Files
conflict-range/Bridge.lean
T
andrew 273ad72f0c Polish release docs and add CI checks
- Correct stale references and headline-path wording in READMEs and Lean docstrings
- Document build steps, comparator requirements, sweep scope, and coverage
- Unify Apache headers across Lean and C++ sources
- Add a bwrap-free axiom audit for the headline theorems
- Add a Gitea workflow running lake build, the axiom audit, C++ tests, and coverage
- Match LLVM coverage tool versions to the compiler and recreate stale build dirs
2026-11-17 21:29:16 -05:00

3621 lines
186 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: FormalConflictRange contributors
-/
import Statement
import FormalConflictRange.SimpleClosedForm
set_option linter.unusedVariables false
set_option linter.unusedSimpArgs false
set_option linter.unreachableTactic false
set_option linter.unusedTactic false
set_option linter.unnecessarySeqFocus false
namespace Statement
open FormalConflictRange
def toRefSelector (s : Selector) : FormalConflictRange.Selector := { key := s.key, offset :=
s.offset }
def toRefRead (r : RangeRead) : FormalConflictRange.RangeRead :=
{ begin := toRefSelector r.begin, end_ := toRefSelector r.end_, limit := none, reverse :=
r.reverse }
def toRefDB (db : DB) : FormalConflictRange.DB := { keys := db.keys, sorted := db.sorted }
def toRefCR (cr : ConflictRange) : FormalConflictRange.ConflictRange := { begin := cr.begin, end_
:= cr.end_ }
def toRefRes (res : Result) : FormalConflictRange.Result := { keys := res.keys, more := res.more }
def ofRefSelector (s : FormalConflictRange.Selector) : Selector := { key := s.key, offset :=
s.offset }
def ofRefRead (r : FormalConflictRange.RangeRead) : RangeRead :=
{ begin := ofRefSelector r.begin, end_ := ofRefSelector r.end_, reverse := r.reverse }
def ofRefDB (db : FormalConflictRange.DB) : DB := { keys := db.keys, sorted := db.sorted }
def ofRefCR (cr : FormalConflictRange.ConflictRange) : ConflictRange := { begin := cr.begin, end_
:= cr.end_ }
def ofRefRes (res : FormalConflictRange.Result) : Result := { keys := res.keys, more := res.more }
@[simp] theorem toRefRead_begin (r : RangeRead) : (toRefRead r).begin = toRefSelector r.begin := rfl
@[simp] theorem toRefRead_end (r : RangeRead) : (toRefRead r).end_ = toRefSelector r.end_ := rfl
@[simp] theorem toRefRead_reverse (r : RangeRead) : (toRefRead r).reverse = r.reverse := rfl
@[simp] theorem toRefRead_limit (r : RangeRead) : (toRefRead r).limit = none := rfl
@[simp] theorem toRefSelector_key (s : Selector) : (toRefSelector s).key = s.key := rfl
@[simp] theorem toRefSelector_offset (s : Selector) : (toRefSelector s).offset = s.offset := rfl
@[simp] theorem toRefDB_keys (db : DB) : (toRefDB db).keys = db.keys := rfl
@[simp] theorem toRefDB_sorted (db : DB) : (toRefDB db).sorted = db.sorted := rfl
@[simp] theorem toRefRes_keys (res : Result) : (toRefRes res).keys = res.keys := rfl
@[simp] theorem toRefRes_more (res : Result) : (toRefRes res).more = res.more := rfl
@[simp] theorem toRefCR_begin (cr : ConflictRange) : (toRefCR cr).begin = cr.begin := rfl
@[simp] theorem toRefCR_end (cr : ConflictRange) : (toRefCR cr).end_ = cr.end_ := rfl
@[simp] theorem toRefCR_mk (a b : WithTop Key) :
toRefCR (⟨a, b⟩ : ConflictRange) = (⟨a, b⟩ : FormalConflictRange.ConflictRange) := rfl
@[simp] theorem toRefCR_ite {c : Prop} [Decidable c] (a b : ConflictRange) :
toRefCR (if c then a else b) =
(if c then toRefCR a else toRefCR b : FormalConflictRange.ConflictRange) := by
split <;> rfl
-- Rewrite reference-side structure literals back into translations of statement
-- literals, so the per-definition bridge lemmas can fire on them.
@[simp] theorem ofRefSelector_toRefSelector (s : Selector) :
ofRefSelector (toRefSelector s) = s := rfl
@[simp] theorem ofRefSelector_lit (k : WithTop Key) (o : Int) :
ofRefSelector (⟨k, o⟩ : FormalConflictRange.Selector) = (⟨k, o⟩ : Selector) := rfl
@[simp] theorem ofRefRes_lit (ks : List Key) (m : Bool) :
ofRefRes (⟨ks, m⟩ : FormalConflictRange.Result) = (⟨ks, m⟩ : Result) := rfl
@[simp] theorem ofRefCR_lit (a b : WithTop Key) :
ofRefCR (⟨a, b⟩ : FormalConflictRange.ConflictRange) = (⟨a, b⟩ : ConflictRange) := rfl
@[simp] theorem toRefRead_mk_lit (b e : FormalConflictRange.Selector) (rev : Bool) :
(⟨b, e, none, rev⟩ : FormalConflictRange.RangeRead) =
toRefRead (⟨ofRefSelector b, ofRefSelector e, rev⟩ : RangeRead) := rfl
@[simp] theorem toRefRes_mk_lit (ks : List Key) (m : Bool) :
(⟨ks, m⟩ : FormalConflictRange.Result) = toRefRes (⟨ks, m⟩ : Result) := rfl
-- inverses
@[simp] theorem ofRefCR_toRefCR (cr : ConflictRange) : ofRefCR (toRefCR cr) = cr := rfl
@[simp] theorem toRefCR_ofRefCR (cr : FormalConflictRange.ConflictRange) : toRefCR (ofRefCR cr) =
cr := rfl
@[simp] theorem ofRefRes_toRefRes (res : Result) : ofRefRes (toRefRes res) = res := rfl
@[simp] theorem toRefRes_ofRefRes (res : FormalConflictRange.Result) : toRefRes (ofRefRes res) =
res := rfl
@[simp] theorem ofRefDB_toRefDB (db : DB) : ofRefDB (toRefDB db) = db := rfl
@[simp] theorem toRefDB_ofRefDB (db : FormalConflictRange.DB) : toRefDB (ofRefDB db) = db := rfl
@[simp] theorem ofRefRead_toRefRead (r : RangeRead) : ofRefRead (toRefRead r) = r := rfl
-- Alias lemmas for reference names that merely duplicate another reference
-- definition (with identical bodies).
@[simp] theorem ref_closedFormZeroCrossEndOne_eq
(r : FormalConflictRange.RangeRead) (res : FormalConflictRange.Result) :
FormalConflictRange.closedFormZeroCrossEndOne r res =
FormalConflictRange.closedFormZeroCrossEndNonpos r res := rfl
@[simp] theorem ref_compactReverseTruncatedZero_eq
(r : FormalConflictRange.RangeRead) (res : FormalConflictRange.Result) :
FormalConflictRange.compactReverseTruncatedZero r res =
FormalConflictRange.closedFormOffsetOneTruncatedRevFullC r res :=
FormalConflictRange.compactReverseTruncatedZero_eq_offsetOne r res
@[simp] theorem ite_or_same {c₁ c₂ : Prop} [Decidable c₁] [Decidable c₂] {α : Type} (a b : α) :
(if c₁ then a else if c₂ then a else b) = if c₁ ∨ c₂ then a else b := by
by_cases h₁ : c₁ <;> by_cases h₂ : c₂ <;> simp [h₁, h₂]
@[simp] theorem normalizeCompleteResult_keys (r : RangeRead) (res : Result) :
(Statement.normalizeCompleteResult r res).keys =
(if r.reverse = true then res.keys.reverse else res.keys) := rfl
theorem normalizeCompleteResult_keys_ne (r : RangeRead) (res : Result) (h : res.keys ≠ []) :
(Statement.normalizeCompleteResult r res).keys ≠ [] := by
unfold Statement.normalizeCompleteResult
split <;> simp_all
attribute [simp] normalizeCompleteResult_keys_ne
@[simp] theorem tr_keyAfterN (n : ℕ) (k : Key) :
FormalConflictRange.keyAfterN n k = Statement.keyAfterN n k := by
induction n generalizing k with
| zero => rfl
| succ n ih => simp [FormalConflictRange.keyAfterN, Statement.keyAfterN, ih] <;> rfl
-- SKIP (no reference) Selector.anchor -> Selector.anchor
@[simp] theorem tr_resolve (db : DB) (s : Selector) :
FormalConflictRange.resolve (toRefDB db) (toRefSelector s) = Statement.resolve (db) (s) := by
unfold FormalConflictRange.resolve Statement.resolve
simp only [toRefDB_keys]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
-- SKIP (no reference) RangeRead.inRange -> RangeRead.inRange
-- SKIP (no reference) RangeRead.completeKeys -> RangeRead.completeKeys
@[simp] theorem tr_keyAfter (k : Key) :
FormalConflictRange.keyAfter (k) = Statement.keyAfter (k) := by
unfold FormalConflictRange.keyAfter Statement.keyAfter
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_beginSlack (r : RangeRead) :
FormalConflictRange.beginSlack (toRefRead r) = Statement.beginSlack (r) := by
unfold FormalConflictRange.beginSlack Statement.beginSlack
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_cELo (oB : ℤ) (oE : ℤ) :
FormalConflictRange.cELo (oB) (oE) = Statement.cELo (oB) (oE) := by
unfold FormalConflictRange.cELo Statement.cELo
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_cEminP (_oB : ℤ) (oE : ℤ) :
FormalConflictRange.cEminP (_oB) (oE) = Statement.cEminP (_oB) (oE) := by
unfold FormalConflictRange.cEminP Statement.cEminP
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_canonicalRange (r : RangeRead) :
FormalConflictRange.canonicalRange (toRefRead r) = toRefCR (Statement.canonicalRange (r)) := by
unfold FormalConflictRange.canonicalRange Statement.canonicalRange
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_intervalCard (b : WithTop Key) (e : WithTop Key) :
FormalConflictRange.intervalCard (b) (e) = Statement.intervalCard (b) (e) := by
unfold FormalConflictRange.intervalCard Statement.intervalCard
simp only [Fin.isValue, List.all_eq_true, beq_iff_eq, ENat.natCast_sub]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampCap (r : RangeRead) :
FormalConflictRange.clampEndOneCap (toRefRead r) = Statement.clampCap (r) := by
unfold FormalConflictRange.clampEndOneCap Statement.clampCap
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_overshoot (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.overshoot (toRefRead r) (toRefRes res) ↔ Statement.overshoot (r) (res) := by
unfold FormalConflictRange.overshoot Statement.overshoot
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_reportedBelowBegin (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.reportedBelowBegin (toRefRead r) (toRefRes res) =
Statement.reportedBelowBegin (r) (res) := by
unfold FormalConflictRange.reportedBelowBegin Statement.reportedBelowBegin
simp only [toRefRead_begin, toRefSelector_key, toRefRes_keys]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampSlack (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampEndOneSlack (toRefRead r) (toRefRes res) = Statement.clampSlack (r)
(res) := by
unfold FormalConflictRange.clampEndOneSlack Statement.clampSlack
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampEndOneUpper (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampEndOneUpper (toRefRead r) (toRefRes res) = Statement.clampEndOneUpper
(r) (res) := by
unfold FormalConflictRange.clampEndOneUpper Statement.clampEndOneUpper
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampHighCap (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampHighCap (toRefRead r) (toRefRes res) = Statement.clampHighCap (r)
(res) := by
unfold FormalConflictRange.clampHighCap Statement.clampHighCap
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampHighThresh (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampHighThresh (toRefRead r) (toRefRes res) = Statement.clampHighThresh
(r) (res) := by
unfold FormalConflictRange.clampHighThresh Statement.clampHighThresh
simp only [toRefRead_end, toRefSelector_key, bottom]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampHighU (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampHighU (toRefRead r) (toRefRes res) = Statement.clampHighU (r) (res)
:= by
unfold FormalConflictRange.clampHighU Statement.clampHighU
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampNonposD (r : RangeRead) :
FormalConflictRange.clampNonposD (toRefRead r) = Statement.clampNonposD (r) := by
unfold FormalConflictRange.clampNonposD Statement.clampNonposD
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampLongC (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampLongC (toRefRead r) (toRefRes res) = Statement.clampLongC (r) (res)
:= by
unfold FormalConflictRange.clampLongC Statement.clampLongC
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampLongUpper (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampLongUpper (toRefRead r) (toRefRes res) = Statement.clampLongUpper (r)
(res) := by
unfold FormalConflictRange.clampLongUpper Statement.clampLongUpper
simp only [ne_eq, hne, not_false_eq_true, tr_clampLongC, toRefRes_keys,
List.headD_eq_head?_getD, toRefRead_end, toRefSelector_key, toRefRead_begin, first, firstKey,
bottom, WithTop.coe_inj]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampNonposBottom (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampNonposBottom (toRefRead r) (toRefRes res) ↔
Statement.clampNonposBottom (r) (res) := by
unfold FormalConflictRange.clampNonposBottom Statement.clampNonposBottom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_leastReported (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.leastReported (toRefRead r) (toRefRes res) = Statement.leastReported (r)
(res) := by
unfold FormalConflictRange.leastReported Statement.leastReported
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampedNonpos (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampedNonpos (toRefRead r) (toRefRes res) ↔ Statement.clampedNonpos (r)
(res) := by
unfold FormalConflictRange.clampedNonpos Statement.clampedNonpos
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_clampsToBottom (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.clampsToBottom (toRefRead r) (toRefRes res) ↔ Statement.clampsToBottom (r)
(res) := by
unfold FormalConflictRange.clampsToBottom Statement.clampsToBottom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_noPinB (KBE : ℕ∞) (oB : ℤ) (oE : ℤ) :
FormalConflictRange.noPinB (KBE) (oB) (oE) = Statement.noPinB (KBE) (oB) (oE) := by
unfold FormalConflictRange.noPinB Statement.noPinB
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossClampEndOne (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormNegCrossClampEndOne (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossClampEndOne (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossClampEndOne Statement.closedFormNegCrossClampEndOne
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossClampEndOne (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossClampEndOne (toRefRead r) (toRefRes res) ↔
Statement.negCrossClampEndOne (r) (res) := by
unfold FormalConflictRange.negCrossClampEndOne Statement.negCrossClampEndOne
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossHeadBottom (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossHeadBottom (toRefRead r) (toRefRes res) ↔
Statement.negCrossHeadBottom (r) (res) := by
unfold FormalConflictRange.negCrossHeadBottom Statement.negCrossHeadBottom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
private abbrev negCrossClampNonposInfiniteLegacy (r : RangeRead) (res : Result) : Prop :=
r.reverse = false ∧
r.begin.offset < 0 ∧
res.more = false ∧
r.end_.offset ≤ 0 ∧
r.begin.key ≤ r.end_.key ∧
intervalCard r.begin.key r.end_.key = ⊤ ∧
first res < r.begin.key ∧
reportedBelowBegin r res ≤ beginSlack r
@[simp] private theorem tr_negCrossClampNonposInfiniteLegacy (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.negCrossClampNonposInfinite (toRefRead r) (toRefRes res) ↔
negCrossClampNonposInfiniteLegacy (r) (res) := by
unfold FormalConflictRange.negCrossClampNonposInfinite
negCrossClampNonposInfiniteLegacy
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossClampNonposLastGe (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossClampNonposLastGe (toRefRead r) (toRefRes res) ↔
Statement.negCrossClampNonposLastGe (r) (res) := by
unfold FormalConflictRange.negCrossClampNonposLastGe Statement.negCrossClampNonposLastGe
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossClampNonposBottom (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossClampNonposBottom (toRefRead r) (toRefRes res) ↔
Statement.negCrossClampNonposBottom (r) (res) := by
unfold FormalConflictRange.negCrossClampNonposBottom Statement.negCrossClampNonposBottom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossClampLongNonpos (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossClampLongNonpos (toRefRead r) (toRefRes res) ↔
Statement.negCrossClampLongNonpos (r) (res) := by
unfold FormalConflictRange.negCrossClampLongNonpos Statement.negCrossClampLongNonpos
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
theorem not_negCrossHeadBottom_of_negCrossClampLongNonpos (r : RangeRead) (res : Result)
(hL : negCrossClampLongNonpos r res) : ¬ negCrossHeadBottom r res := by
intro h
unfold negCrossHeadBottom at h
unfold negCrossClampLongNonpos at hL
obtain ⟨_, _, _, _, hBE, _⟩ := h
obtain ⟨_, _, _, _, _, _, _, hEB⟩ := hL
exact (not_lt_of_ge hBE) hEB
theorem not_negCrossClampNonposInfiniteLegacy_of_negCrossClampLongNonpos (r : RangeRead)
(res : Result) (hL : negCrossClampLongNonpos r res) :
¬ negCrossClampNonposInfiniteLegacy r res := by
intro h
unfold negCrossClampNonposInfiniteLegacy at h
unfold negCrossClampLongNonpos at hL
obtain ⟨_, _, _, _, hBE, _, _, _⟩ := h
obtain ⟨_, _, _, _, _, _, _, hEB⟩ := hL
exact (not_lt_of_ge hBE) hEB
theorem not_negCrossClampNonposBottom_of_negCrossClampLongNonpos (r : RangeRead)
(res : Result) (hL : negCrossClampLongNonpos r res) :
¬ negCrossClampNonposBottom r res := by
intro h
unfold negCrossClampNonposBottom at h
unfold negCrossClampLongNonpos at hL
obtain ⟨_, _, _, _, hBE, _, _⟩ := h
obtain ⟨_, _, _, _, _, _, _, hEB⟩ := hL
exact (not_lt_of_ge hBE) hEB
/-- The legacy priority-table shape of the clamping rule, matching the reference
`closedFormNegCrossClampUnified`. It is kept as one shared expression so the bridge
proof can rewrite to it before applying `closedFormNegCrossClampUnifiedLegacy_eq`. -/
private def closedFormNegCrossClampUnifiedLegacy (r : RangeRead) (res : Result) :
ConflictRange :=
let end_ :=
if negCrossClampEndOne r res then clampEndOneUpper r res
else if
negCrossHeadBottom r res ∨
negCrossClampNonposInfiniteLegacy r res ∨
negCrossClampNonposLastGe r res ∨
negCrossClampNonposBottom r res then
r.end_.key
else if negCrossClampLongNonpos r res then clampLongUpper r res
else r.end_.key
range bottom end_
/-- The legacy clamped-unified rule can drop the three middle cases that simply return
`r.end_.key`: each of them contradicts `negCrossClampLongNonpos` by the ordering of the
two selector keys. `negCrossClampNonposLastGe` has no such key-order field, so it alone
can overlap the long cell and remains as a guard. -/
private theorem closedFormNegCrossClampUnifiedLegacy_eq (r : RangeRead) (res : Result) :
closedFormNegCrossClampUnifiedLegacy r res = closedFormNegCrossClampUnified r res := by
unfold closedFormNegCrossClampUnifiedLegacy closedFormNegCrossClampUnified
dsimp only
by_cases hE : negCrossClampEndOne r res
· rw [ite_eq_left hE, ite_eq_left hE]
· by_cases hL : negCrossClampLongNonpos r res
· have hB1 := not_negCrossHeadBottom_of_negCrossClampLongNonpos r res hL
have hB2 := not_negCrossClampNonposInfiniteLegacy_of_negCrossClampLongNonpos r res hL
have hB4 := not_negCrossClampNonposBottom_of_negCrossClampLongNonpos r res hL
by_cases hB3 : negCrossClampNonposLastGe r res <;>
simp [hE, hL, hB1, hB2, hB3, hB4]
· simp [hE, hL]
/-- The legacy shape is the reference shape, so this is the original bridge lemma. -/
private theorem tr_closedFormNegCrossClampUnifiedLegacy (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossClampUnified (toRefRead r) (toRefRes res) =
toRefCR (closedFormNegCrossClampUnifiedLegacy r res) := by
unfold FormalConflictRange.closedFormNegCrossClampUnified
closedFormNegCrossClampUnifiedLegacy
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossClampUnified (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormNegCrossClampUnified (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossClampUnified (r) (res)) := by
rw [tr_closedFormNegCrossClampUnifiedLegacy r res hne]
exact congrArg toRefCR (closedFormNegCrossClampUnifiedLegacy_eq r res)
@[simp] theorem tr_negCrossCompleteHighM (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossCompleteHighM (toRefRead r) (toRefRes res) =
Statement.negCrossCompleteHighM (r) (res) := by
unfold FormalConflictRange.negCrossCompleteHighM Statement.negCrossCompleteHighM
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossHighD (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossHighD (toRefRead r) (toRefRes res) = Statement.negCrossHighD (r)
(res) := by
unfold FormalConflictRange.negCrossHighD Statement.negCrossHighD
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossHighGapCap (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossHighGapCap (toRefRead r) (toRefRes res) =
Statement.negCrossHighGapCap (r) (res) := by
unfold FormalConflictRange.negCrossHighGapCap Statement.negCrossHighGapCap
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossHighUsesEnd (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossHighUsesEnd (toRefRead r) (toRefRes res) ↔
Statement.negCrossHighUsesEnd (r) (res) := by
unfold FormalConflictRange.negCrossHighUsesEnd Statement.negCrossHighUsesEnd
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossCompleteHigh (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormNegCrossCompleteHigh (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossCompleteHigh (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossCompleteHigh Statement.closedFormNegCrossCompleteHigh
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossCompleteHigh (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossCompleteHigh (toRefRead r) (toRefRes res) ↔
Statement.negCrossCompleteHigh (r) (res) := by
unfold FormalConflictRange.negCrossCompleteHigh Statement.negCrossCompleteHigh
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormDeficit (r : RangeRead) :
FormalConflictRange.compactDeficit (toRefRead r) = Statement.closedFormDeficit (r) := by
unfold FormalConflictRange.compactDeficit Statement.closedFormDeficit
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_completeResidualReduced (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.completeResidualReduced (toRefRead r) (toRefRes res) = toRefRead
(Statement.completeResidualReduced (r) (res)) := by
unfold FormalConflictRange.completeResidualReduced Statement.completeResidualReduced
simp only [toRefRead_begin, toRefRes_keys, List.getLastD_eq_getLast?, tr_keyAfter,
toRefRead_end, toRefSelector_offset, toRefRead_limit, toRefRead_reverse, toRefRead_mk_lit,
ofRefSelector_toRefSelector, ofRefSelector_lit, afterLast, lastKey, residualT]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_topOfLast (last : Key) :
FormalConflictRange.topOfLast (last) = toRefCR (Statement.topOfLast (last)) := by
unfold FormalConflictRange.topOfLast Statement.topOfLast
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossOvershoot (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormNegCrossOvershoot (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossOvershoot (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossOvershoot Statement.closedFormNegCrossOvershoot
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossEndOne (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossEndOne (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossEndOne (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossEndOne Statement.closedFormNegCrossEndOne
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossEndOneLong (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossEndOneLong (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossEndOneLong (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossEndOneLong Statement.closedFormNegCrossEndOneLong
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossCompleteResidual (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossCompleteResidual (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossCompleteResidual (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossCompleteResidual
Statement.closedFormNegCrossCompleteResidual
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossCompleteHighResidual (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossCompleteHighResidual (toRefRead r) (toRefRes res) =
toRefCR (Statement.closedFormNegCrossCompleteHighResidual (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossCompleteHighResidual
Statement.closedFormNegCrossCompleteHighResidual
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossNonclampUnified (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossNonclampUnified (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossNonclampUnified (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossNonclampUnified
Statement.closedFormNegCrossNonclampUnified
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossTopUnified (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormNegCrossTopUnified (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossTopUnified (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTopUnified Statement.closedFormNegCrossTopUnified
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncNonposGap (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncNonposGap (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncNonposGap (r) (res) := by
unfold FormalConflictRange.negCrossTruncNonposGap Statement.negCrossTruncNonposGap
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncNonposGapA2aBottom (r : RangeRead) (res : Result) (hne : res.keys
≠ []) :
FormalConflictRange.negCrossTruncNonposGapA2aBottom (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncNonposGapA2aBottom (r) (res) := by
unfold FormalConflictRange.negCrossTruncNonposGapA2aBottom
Statement.negCrossTruncNonposGapA2aBottom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncNonposGapA2aBottomHigh (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.negCrossTruncNonposGapA2aBottomHigh (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncNonposGapA2aBottomHigh (r) (res) := by
unfold FormalConflictRange.negCrossTruncNonposGapA2aBottomHigh
Statement.negCrossTruncNonposGapA2aBottomHigh
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossTruncNonposGapA2aBottom (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncNonposGapA2aBottom (toRefRead r) (toRefRes res) =
toRefCR (Statement.closedFormNegCrossTruncNonposGapA2aBottom (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncNonposGapA2aBottom
Statement.closedFormNegCrossTruncNonposGapA2aBottom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_finiteUnderCond (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.finiteUnderCond (toRefRead r) (toRefRes res) ↔ Statement.finiteUnderCond
(r) (res) := by
unfold FormalConflictRange.finiteUnderCond Statement.finiteUnderCond
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualFiniteOver (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevResidualFiniteOver (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualFiniteOver (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualFiniteOver
Statement.negCrossTruncRevResidualFiniteOver
simp only [toRefRes_more, toRefRead_reverse, toRefRead_begin, toRefSelector_offset,
toRefRes_keys, ne_eq, hne, not_false_eq_true, toRefRead_end, toRefSelector_key,
List.getLastD_eq_getLast?, Int.pred_toNat, true_and, last, lastKey, residualT, residualE,
and_congr_right_iff]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossTruncRevResidualFiniteUnified (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevResidualFiniteUnified (toRefRead r) (toRefRes
res) = toRefCR (Statement.closedFormNegCrossTruncRevResidualFiniteUnified (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevResidualFiniteUnified
FormalConflictRange.closedFormNegCrossTruncRevResidualFiniteUnder
Statement.closedFormNegCrossTruncRevResidualFiniteUnified
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_sentinelLargeTight (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.sentinelLargeTight (toRefRead r) (toRefRes res) ↔
Statement.sentinelLargeTight (r) (res) := by
unfold FormalConflictRange.sentinelLargeTight Statement.sentinelLargeTight
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualTopLarge (r : RangeRead) (res : Result) (hne : res.keys
≠ []) :
FormalConflictRange.negCrossTruncRevResidualTopLarge (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualTopLarge (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualTopLarge
Statement.negCrossTruncRevResidualTopLarge
simp only [toRefRes_more, toRefRead_reverse, toRefRead_begin, toRefSelector_offset,
toRefRes_keys, ne_eq, hne, not_false_eq_true, toRefRead_end, toRefSelector_key,
List.getLastD_eq_getLast?, Int.pred_toNat, ENat.natCast_sub, Nat.cast_one, tr_intervalCard,
tsub_le_iff_right, true_and, last, lastKey, residualT, residualE, and_congr_right_iff,
and_congr_left_iff]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualTopLargeSentinel (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevResidualTopLargeSentinel (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualTopLargeSentinel (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualTopLargeSentinel
Statement.negCrossTruncRevResidualTopLargeSentinel
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormNegCrossTruncRevResidualTopLargeUnified (r : RangeRead) (res :
Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevResidualTopLargeUnified (toRefRead r) (toRefRes
res) = toRefCR (Statement.closedFormNegCrossTruncRevResidualTopLargeUnified (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevResidualTopLargeUnified
FormalConflictRange.closedFormNegCrossTruncRevResidualTopLargeSentinel
Statement.closedFormNegCrossTruncRevResidualTopLargeUnified
have hS := tr_negCrossTruncRevResidualTopLargeSentinel r res hne
have hT := tr_sentinelLargeTight r res hne
simp only [hS, hT, Statement.last]
split_ifs <;> simp_all
@[simp] theorem tr_truncatedRangeRev (r : RangeRead) (last : Key) :
FormalConflictRange.truncatedRangeRev (toRefRead r) (last) = toRefCR
(Statement.truncatedRangeRev (r) (last)) := by
unfold FormalConflictRange.truncatedRangeRev Statement.truncatedRangeRev
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormReverseTruncatedZero (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormOffsetOneTruncatedRevFullC (toRefRead r) (toRefRes res) =
toRefCR (Statement.closedFormReverseTruncatedZero (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOneTruncatedRevFullC
Statement.closedFormReverseTruncatedZero
simp only [toRefRead_end, toRefSelector_offset, toRefRes_keys, List.getLastD_eq_getLast?,
tr_truncatedRangeRev, toRefSelector_key, Int.pred_toNat, List.headD_eq_head?_getD,
tr_keyAfter, tr_keyAfterN, lastKey, residualT, residualE, range, last, afterFirst, firstKey,
toRefCR_ite, toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all only [not_le]))
all_goals (try (split_ifs <;> simp_all only [not_le]))
all_goals (try (split <;> simp_all only [ne_eq, toRefCR_ite, toRefCR_mk,
FormalConflictRange.ConflictRange.mk.injEq, WithTop.coe_ne_top, WithTop.top_ne_coe,
and_false]))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_truncatedRange (r : RangeRead) (last : Key) :
FormalConflictRange.truncatedRange (toRefRead r) (last) = toRefCR (Statement.truncatedRange
(r) (last)) := by
unfold FormalConflictRange.truncatedRange Statement.truncatedRange
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_truncatedForwardClosed (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.truncatedForwardClosed (toRefRead r) (toRefRes res) = toRefCR
(Statement.truncatedForwardClosed (r) (res)) := by
unfold FormalConflictRange.truncatedForwardClosed Statement.truncatedForwardClosed
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_gapOvershoot (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.gapOvershoot (toRefRead r) (toRefRes res) = Statement.gapOvershoot (r)
(res) := by
unfold FormalConflictRange.gapOvershoot Statement.gapOvershoot
simp only [endOvershoot, toRefRead_end, toRefSelector_offset, Int.pred_toNat, reportedAtEnd,
toRefSelector_key, toRefRes_keys, residualE, residualT]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_completeReversedClosed (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.completeReversedClosed (toRefRead r) (toRefRes res) = toRefCR
(Statement.completeReversedClosed (r) (res)) := by
unfold FormalConflictRange.completeReversedClosed Statement.completeReversedClosed
simp only [toRefRead_end, toRefSelector_offset, tr_canonicalRange, reportedAtEnd,
toRefSelector_key, toRefRes_keys, endOvershoot, Int.pred_toNat, toRefRead_begin, ne_eq, hne,
not_false_eq_true, tr_gapOvershoot, tr_intervalCard, List.headD_eq_head?_getD, tr_keyAfter,
completeClosedWith, residualT, residualE, range, afterFirst, firstKey, toRefCR_ite, toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_completeForwardClosed (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.completeForwardClosed (toRefRead r) (toRefRes res) = toRefCR
(Statement.completeForwardClosed (r) (res)) := by
unfold FormalConflictRange.completeForwardClosed Statement.completeForwardClosed
simp only [toRefRead_end, toRefSelector_offset, tr_canonicalRange, reportedAtEnd,
toRefSelector_key, toRefRes_keys, endOvershoot, Int.pred_toNat, toRefRead_begin, ne_eq, hne,
not_false_eq_true, tr_gapOvershoot, tr_intervalCard, List.getLastD_eq_getLast?, tr_keyAfter,
completeClosedWith, residualT, residualE, range, afterLast, lastKey, toRefCR_ite, toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_completeClosed (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.completeClosed (toRefRead r) (toRefRes res) = toRefCR
(Statement.completeClosed (r) (res)) := by
unfold FormalConflictRange.completeClosed Statement.completeClosed
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormOffsetOneTruncated (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormOffsetOneTruncated (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormOffsetOneTruncated (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOneTruncated Statement.closedFormOffsetOneTruncated
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_topRange (r : RangeRead) :
FormalConflictRange.topRange (toRefRead r) = toRefCR (Statement.topRange (r)) := by
unfold FormalConflictRange.topRange Statement.topRange
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormOffsetOneRev (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormOffsetOneRev (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormOffsetOneRev (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOneRev Statement.closedFormOffsetOneRev
simp only [toRefRead_end, toRefSelector_offset, tr_canonicalRange, toRefSelector_key,
toRefRes_keys, Int.pred_toNat, List.headD_eq_head?_getD, tr_truncatedRange, tr_topRange,
closedFormOffsetOneWith, residualT, residualE, firstKey, toRefCR_ite]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormOffsetOne (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormOffsetOne (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormOffsetOne (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOne Statement.closedFormOffsetOne
simp only [toRefRead_end, toRefSelector_offset, tr_canonicalRange, toRefSelector_key,
toRefRes_keys, Int.pred_toNat, List.getLastD_eq_getLast?, tr_truncatedRange, tr_topRange,
closedFormOffsetOneWith, residualT, residualE, lastKey, toRefCR_ite]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormOffsetOneAny (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormOffsetOneAny (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormOffsetOneAny (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOneAny Statement.closedFormOffsetOneAny
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormOffsetOneUniversal (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormOffsetOneUniversal (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormOffsetOneUniversal (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOneUniversal Statement.closedFormOffsetOneUniversal
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormOffsetOneTotal (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormOffsetOneTotal (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormOffsetOneTotal (r) (res)) := by
unfold FormalConflictRange.closedFormOffsetOneTotal Statement.closedFormOffsetOneTotal
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossEndOneLong (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormZeroCrossEndOneLong (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossEndOneLong (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossEndOneLong Statement.closedFormZeroCrossEndOneLong
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossEnd (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormZeroCrossEndNonpos (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossEnd (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossEndNonpos Statement.closedFormZeroCrossEnd
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_crossedOvershootGeneral (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.crossedOvershootGeneral (toRefRead r) (toRefRes res) =
Statement.crossedOvershootGeneral (r) (res) := by
unfold FormalConflictRange.crossedOvershootGeneral Statement.crossedOvershootGeneral
simp only [endOvershoot, toRefRead_end, toRefSelector_offset, Int.pred_toNat, reportedAtEnd,
toRefSelector_key, toRefRes_keys, toRefRead_begin, residualE, residualT, residualB]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_completeForwardCrossedGeneral (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.completeForwardCrossedGeneral (toRefRead r) (toRefRes res) = toRefCR
(Statement.completeForwardCrossedGeneral (r) (res)) := by
unfold FormalConflictRange.completeForwardCrossedGeneral Statement.completeForwardCrossedGeneral
simp only [toRefRead_end, toRefSelector_offset, tr_canonicalRange, reportedAtEnd,
toRefSelector_key, toRefRes_keys, toRefRead_begin, Int.pred_toNat, endOvershoot,
List.getLastD_eq_getLast?, tr_keyAfter, ne_eq, hne, not_false_eq_true,
tr_crossedOvershootGeneral, tr_intervalCard, residualT, residualB, residualE, range,
afterLast, lastKey, crossedBegin, toRefCR_ite, toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_zeroBeginAnchor (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroBeginAnchor (toRefRead r) (toRefRes res) = toRefRead
(Statement.zeroBeginAnchor (r) (res)) := by
unfold FormalConflictRange.zeroBeginAnchor Statement.zeroBeginAnchor
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_zeroCrossLongAnchor (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroCrossLongAnchor (toRefRead r) (toRefRes res) = toRefCR
(Statement.zeroCrossLongAnchor (r) (res)) := by
unfold FormalConflictRange.zeroCrossLongAnchor Statement.zeroCrossLongAnchor
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossLong (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormZeroCrossLong (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossLong (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossLong Statement.closedFormZeroCrossLong
simp only [toRefRead_begin, toRefSelector_key, toRefRead_end, toRefRes_keys,
List.headD_eq_head?_getD, toRefSelector_offset, Int.pred_toNat, ENat.natCast_sub,
Nat.cast_one, tr_intervalCard, ne_eq, hne, not_false_eq_true, tr_zeroCrossLongAnchor,
toRefCR_begin, toRefCR_end, range, first, firstKey, residualE, residualT, toRefCR_ite,
toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossUnderEnd (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormZeroCrossUnderEnd (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossUnderEnd (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossUnderEnd Statement.closedFormZeroCrossUnderEnd
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossComplete (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormZeroCrossComplete (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossComplete (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossComplete Statement.closedFormZeroCrossComplete
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossCompleteRev (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormZeroCrossCompleteRev (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossCompleteRev (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossCompleteRev Statement.closedFormZeroCrossCompleteRev
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_zeroCrossUnderEnd (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroCrossUnderEnd (toRefRead r) (toRefRes res) ↔
Statement.zeroCrossUnderEnd (r) (res) := by
unfold FormalConflictRange.zeroCrossUnderEnd Statement.zeroCrossUnderEnd
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossResidual (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormZeroCrossResidual (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossResidual (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossResidual Statement.closedFormZeroCrossResidual
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormZeroCrossTruncRevCrossed (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.closedFormZeroCrossTruncRevCrossed (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormZeroCrossTruncRevCrossed (r) (res)) := by
unfold FormalConflictRange.closedFormZeroCrossTruncRevCrossed
Statement.closedFormZeroCrossTruncRevCrossed
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_AlwaysEmpty (r : RangeRead) :
FormalConflictRange.AlwaysEmpty (toRefRead r) ↔ Statement.AlwaysEmpty (r) := by
rw [FormalConflictRange.alwaysEmpty_iff_not_countFeasible,
FormalConflictRange.countFeasible_iff_int,
FormalConflictRange.countFeasibleInt_iff_closedForm]
simp [FormalConflictRange.closedForm, Statement.AlwaysEmpty, Statement.bottom]
@[simp] theorem tr_emptyRange (r : RangeRead) :
FormalConflictRange.emptyRange (toRefRead r) = toRefCR (Statement.emptyRange (r)) := by
unfold FormalConflictRange.emptyRange Statement.emptyRange
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_crossedRangeGeneral (r : RangeRead) :
FormalConflictRange.crossedRangeGeneral (toRefRead r) = toRefCR (Statement.crossedRangeGeneral
(r)) := by
unfold FormalConflictRange.crossedRangeGeneral Statement.crossedRangeGeneral
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
private def emptyValueLegacy (r : RangeRead) : ConflictRange :=
if AlwaysEmpty r then emptyRange r
else if r.begin.offset ≤ 0 then
if 2 ≤ r.end_.offset then range bottom ⊤
else if r.begin.key ≤ r.end_.key then range bottom r.end_.key
else if intervalCard r.end_.key r.begin.key < ↑(r.end_.offset - r.begin.offset).toNat then
range bottom r.end_.key
else range bottom (max r.begin.key r.end_.key)
else if r.end_.offset ≤ 1 then canonicalRange r
else if r.begin.key ≤ r.end_.key then topRange r else crossedRangeGeneral r
/-- The explicit `begin.key ≤ end_.key` branch is redundant: when it holds, the
capacity test below returns the same bottom-to-`end_.key` range on both sides, and when
the capacity test fails the fallback's `max` is just `end_.key`. -/
private theorem emptyValueLegacy_eq (r : RangeRead) : emptyValueLegacy r = emptyValue r := by
rw [emptyValueLegacy, emptyValue]
by_cases hA : AlwaysEmpty r
· rw [ite_eq_left hA, ite_eq_left hA]
· rw [ite_eq_right hA, ite_eq_right hA]
by_cases hb : r.begin.offset ≤ 0
· by_cases h2 : 2 ≤ r.end_.offset
· simp [hb, h2]
· by_cases hle : r.begin.key ≤ r.end_.key
· by_cases hcap : intervalCard r.end_.key r.begin.key <
↑(r.end_.offset - r.begin.offset).toNat
· simp [hb, h2, hle, hcap]
· simp [hb, h2, hle, hcap, max_eq_right hle]
· simp [hb, h2, hle]
· simp [hb]
private theorem tr_emptyValueLegacy (r : RangeRead) :
FormalConflictRange.emptyValue (toRefRead r) = toRefCR (emptyValueLegacy r) := by
unfold FormalConflictRange.emptyValue emptyValueLegacy
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_emptyValue (r : RangeRead) :
FormalConflictRange.emptyValue (toRefRead r) = toRefCR (Statement.emptyValue (r)) := by
rw [tr_emptyValueLegacy r]
exact congrArg toRefCR (emptyValueLegacy_eq r)
@[simp] theorem tr_closedFormBegin (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactBegin (toRefRead r) (toRefRes res) = Statement.closedFormBegin (r)
(res) := by
unfold FormalConflictRange.compactBegin Statement.closedFormBegin
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormFinite (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactFinite (toRefRead r) (toRefRes res) ↔ Statement.closedFormFinite
(r) (res) := by
unfold FormalConflictRange.compactFinite Statement.closedFormFinite
simp only [tr_closedFormDeficit, FormalConflictRange.residualT, toRefRead_end,
toRefSelector_key, toRefRes_keys, FormalConflictRange.residualE, toRefSelector_offset,
Int.pred_toNat, residualT, residualE]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormCompleteForward (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactCompleteForward (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormCompleteForward (r) (res)) := by
unfold FormalConflictRange.compactCompleteForward Statement.closedFormCompleteForward
simp only [toRefRead_end, toRefSelector_offset, ne_eq, hne, not_false_eq_true,
tr_closedFormBegin, toRefSelector_key, tr_clampsToBottom, toRefRead_begin,
FormalConflictRange.residualT, toRefRes_keys, FormalConflictRange.residualE, Int.pred_toNat,
List.getLastD_eq_getLast?, tr_keyAfter, tr_closedFormFinite, tr_crossedOvershootGeneral,
tr_intervalCard, range, residualT, residualE, afterLast, lastKey, crossedBegin, toRefCR_ite,
toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_normalizeCompleteResult (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.normalizeCompleteResult (toRefRead r) (toRefRes res) = toRefRes
(Statement.normalizeCompleteResult (r) (res)) := by
unfold FormalConflictRange.normalizeCompleteResult Statement.normalizeCompleteResult
simp only [toRefRead_reverse, toRefRes_keys, toRefRes_mk_lit]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormComplete (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactComplete (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormComplete (r) (res)) := by
unfold FormalConflictRange.compactComplete Statement.closedFormComplete
have hne' : (Statement.normalizeCompleteResult r res).keys ≠ [] :=
normalizeCompleteResult_keys_ne r res hne
exact tr_closedFormCompleteForward (Statement.forwardRead r) (Statement.normalizeCompleteResult
r res) hne'
@[simp] theorem tr_closedFormForwardCapacity (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactForwardCapacity (toRefRead r) (toRefRes res) =
Statement.closedFormForwardCapacity (r) (res) := by
unfold FormalConflictRange.compactForwardCapacity Statement.closedFormForwardCapacity
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormForwardTruncated (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactForwardTruncated (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormForwardTruncated (r) (res)) := by
unfold FormalConflictRange.compactForwardTruncated Statement.closedFormForwardTruncated
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormReverseCount (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactReverseCount (toRefRead r) (toRefRes res) =
Statement.closedFormReverseCount (r) (res) := by
unfold FormalConflictRange.compactReverseCount Statement.closedFormReverseCount
simp only [toRefRead_end, toRefSelector_key, toRefRead_begin, toRefRes_keys,
FormalConflictRange.residualT, residualT]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormReverseFinite (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactReverseFinite (toRefRead r) (toRefRes res) ↔
Statement.closedFormReverseFinite (r) (res) := by
unfold FormalConflictRange.compactReverseFinite Statement.closedFormReverseFinite
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormCrossedRoom (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactCrossedRoom (toRefRead r) (toRefRes res) ↔
Statement.closedFormCrossedRoom (r) (res) := by
unfold FormalConflictRange.compactCrossedRoom Statement.closedFormCrossedRoom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormReverseTruncatedSkip (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.compactReverseTruncatedSkip (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormReverseTruncatedSkip (r) (res)) := by
unfold FormalConflictRange.compactReverseTruncatedSkip Statement.closedFormReverseTruncatedSkip
simp only [toRefRead_end, toRefSelector_offset, tr_canonicalRange, toRefRes_keys,
toRefSelector_key, tr_topRange, ne_eq, hne, not_false_eq_true, tr_closedFormReverseFinite,
toRefRead_begin, List.headD_eq_head?_getD, tr_keyAfter, tr_closedFormCrossedRoom, ge_iff_le,
residualE, Int.pred_toNat, ENat.natCast_sub, Nat.cast_one, last, lastKey,
List.getLastD_eq_getLast?, tsub_le_iff_right, range, afterFirst, firstKey, toRefCR_ite,
toRefCR_mk]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormReverseTruncated (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactReverseTruncated (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormReverseTruncated (r) (res)) := by
unfold FormalConflictRange.compactReverseTruncated Statement.closedFormReverseTruncated
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormPositive (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactPositive (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormPositive (r) (res)) := by
unfold FormalConflictRange.compactPositive Statement.closedFormPositive
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_zeroCrossOvershootComplete (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroCrossOvershootComplete (toRefRead r) (toRefRes res) ↔
Statement.zeroCrossOvershootComplete (r) (res) := by
unfold FormalConflictRange.zeroCrossOvershootComplete Statement.zeroCrossOvershootComplete
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossOvershoot (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossOvershoot (toRefRead r) (toRefRes res) ↔
Statement.negCrossOvershoot (r) (res) := by
unfold FormalConflictRange.negCrossOvershoot Statement.negCrossOvershoot
unfold Statement.overshoot
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne, and_assoc]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_crossedCompleteOvershoot (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.crossedCompleteOvershoot (toRefRead r) (toRefRes res) ↔
Statement.crossedCompleteOvershoot (r) (res) := by
unfold FormalConflictRange.crossedCompleteOvershoot Statement.crossedCompleteOvershoot
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_crossedCompleteEndLeOne (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.crossedCompleteEndLeOne (toRefRead r) (toRefRes res) ↔
Statement.crossedCompleteEndLeOne (r) (res) := by
unfold FormalConflictRange.crossedCompleteEndLeOne Statement.crossedCompleteEndLeOne
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_zeroCrossLongTop (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroCrossLongTop (toRefRead r) (toRefRes res) ↔ Statement.zeroCrossLongTop
(r) (res) := by
unfold FormalConflictRange.zeroCrossLongTop Statement.zeroCrossLongTop
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_zeroCrossLongFinite (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroCrossLongFinite (toRefRead r) (toRefRes res) ↔
Statement.zeroCrossLongFinite (r) (res) := by
unfold FormalConflictRange.zeroCrossLongFinite Statement.zeroCrossLongFinite
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_crossedCompleteBeginZero (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.crossedCompleteBeginZero (toRefRead r) (toRefRes res) ↔
Statement.crossedCompleteBeginZero (r) (res) := by
unfold FormalConflictRange.crossedCompleteBeginZero Statement.crossedCompleteBeginZero
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
/-- The head-bottom, infinite and bottom predicates each imply `begin.key ≤ end_.key`,
while the long nonpositive cell requires `end_.key < begin.key`. Hence the infinite
cell is covered by either the earlier `crossedCompleteEndLeOne` branch or by the bottom
cell. -/
private theorem infinite_subsumed_of_not_endLeOne (r : RangeRead) (res : Result)
(hE : ¬ crossedCompleteEndLeOne r res)
(h : negCrossClampNonposInfiniteLegacy r res) : negCrossClampNonposBottom r res := by
unfold negCrossClampNonposInfiniteLegacy at h
obtain ⟨hr, hb, hm, hend, hBE, _hcap, hfb, _hrep⟩ := h
refine ⟨hr, hb, hm, hend, hBE, hfb, ?_⟩
by_contra hbot
exact hE ⟨hr, hm, by omega, hfb, Or.inr ⟨hend, by
rintro ⟨_, hb'⟩
exact hbot hb'⟩⟩
/-- The last-ge clamp cell is covered by the earlier end-le-one branch unless the
bottom clamp holds; in that case `begin.key ≤ end_.key` gives the bottom cell and
`end_.key < begin.key` gives the long nonpositive cell. -/
private theorem lastGe_subsumed_of_not_endLeOne (r : RangeRead) (res : Result)
(hE : ¬ crossedCompleteEndLeOne r res)
(h : negCrossClampNonposLastGe r res) :
negCrossClampNonposBottom r res ∨ negCrossClampLongNonpos r res := by
unfold negCrossClampNonposLastGe at h
obtain ⟨hr, hb, hm, hend, hfb, _hlast, hrep⟩ := h
have hbot : clampNonposBottom r res := by
by_contra hbot
exact hE ⟨hr, hm, by omega, hfb, Or.inr ⟨hend, by
rintro ⟨_, hb'⟩
exact hbot hb'⟩⟩
by_cases hBE : r.begin.key ≤ r.end_.key
· exact Or.inl ⟨hr, hb, hm, hend, hBE, hfb, hbot⟩
· exact Or.inr ⟨hr, hb, hm, hend, hfb, hrep, hbot, not_le.mp hBE⟩
/-- The legacy six-way clamping predicate used by the reference dispatcher. -/
private abbrev crossedCompleteClampLegacy (r : RangeRead) (res : Result) : Prop :=
negCrossClampEndOne r res ∨
negCrossHeadBottom r res ∨
negCrossClampNonposInfiniteLegacy r res ∨
negCrossClampNonposLastGe r res ∨
negCrossClampNonposBottom r res ∨ negCrossClampLongNonpos r res
private theorem tr_crossedCompleteClampLegacy (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.crossedCompleteClamp (toRefRead r) (toRefRes res) ↔
crossedCompleteClampLegacy r res := by
unfold FormalConflictRange.crossedCompleteClamp crossedCompleteClampLegacy
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
set_option synthInstance.maxSize 10000 in
private def closedFormCrossedCompleteLegacy (r : RangeRead) (res : Result) : ConflictRange :=
if crossedCompleteOvershoot r res then closedFormNegCrossTopUnified r res
else if crossedCompleteEndLeOne r res then
closedFormNegCrossNonclampUnified r res
else if crossedCompleteBeginZero r res then closedFormZeroCrossResidual r res
else if crossedCompleteClampLegacy r res then closedFormNegCrossClampUnified r res
else closedFormNegCrossCompleteHighResidual r res
/-- Removing the two clamp cells covered by the earlier end-le-one branch does not
change the crossed-complete dispatcher. -/
private theorem closedFormCrossedCompleteLegacy_eq (r : RangeRead) (res : Result) :
closedFormCrossedCompleteLegacy r res = closedFormCrossedComplete r res := by
unfold closedFormCrossedCompleteLegacy closedFormCrossedComplete
by_cases hO : crossedCompleteOvershoot r res
· rw [ite_eq_left hO, ite_eq_left hO]
· rw [ite_eq_right hO, ite_eq_right hO]
by_cases hE : crossedCompleteEndLeOne r res
· rw [ite_eq_left hE, ite_eq_left hE]
· rw [ite_eq_right hE, ite_eq_right hE]
by_cases hB : crossedCompleteBeginZero r res
· rw [ite_eq_left hB, ite_eq_left hB]
· rw [ite_eq_right hB, ite_eq_right hB]
have hclamp : crossedCompleteClampLegacy r res ↔ crossedCompleteClamp r res := by
constructor
· intro hL
unfold crossedCompleteClampLegacy at hL
unfold crossedCompleteClamp
rcases hL with h | h | h | h | h | h
· exact Or.inl h
· exact Or.inr (Or.inl h)
· exact Or.inr (Or.inr (Or.inl
(infinite_subsumed_of_not_endLeOne r res hE h)))
· rcases lastGe_subsumed_of_not_endLeOne r res hE h with h' | h'
· exact Or.inr (Or.inr (Or.inl h'))
· exact Or.inr (Or.inr (Or.inr h'))
· exact Or.inr (Or.inr (Or.inl h))
· exact Or.inr (Or.inr (Or.inr h))
· intro hC
unfold crossedCompleteClampLegacy
unfold crossedCompleteClamp at hC
rcases hC with h | h | h | h
· exact Or.inl h
· exact Or.inr (Or.inl h)
· exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inl h))))
· exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr h))))
by_cases hC : crossedCompleteClamp r res
· have hCL : crossedCompleteClampLegacy r res := hclamp.mpr hC
simp [hO, hE, hB, hC, hCL]
· have hCL : ¬ crossedCompleteClampLegacy r res := fun h => hC (hclamp.mp h)
simp [hO, hE, hB, hC, hCL]
private theorem tr_closedFormCrossedCompleteLegacy (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.compactCrossedComplete (toRefRead r) (toRefRes res) =
toRefCR (closedFormCrossedCompleteLegacy r res) := by
unfold FormalConflictRange.compactCrossedComplete closedFormCrossedCompleteLegacy
simp [tr_crossedCompleteClampLegacy r res hne,
Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormCrossedComplete (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactCrossedComplete (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormCrossedComplete (r) (res)) := by
rw [tr_closedFormCrossedCompleteLegacy r res hne]
exact congrArg toRefCR (closedFormCrossedCompleteLegacy_eq r res)
@[simp] theorem tr_zeroCrossTruncRevCrossed (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.zeroCrossTruncRevCrossed (toRefRead r) (toRefRes res) ↔
Statement.zeroCrossTruncRevCrossed (r) (res) := by
unfold FormalConflictRange.zeroCrossTruncRevCrossed Statement.zeroCrossTruncRevCrossed
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevUnder (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevUnder (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevUnder (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevUnder Statement.negCrossTruncRevUnder
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
private abbrev negCrossTruncRevCrossedNonposSmallLegacy (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧
r.reverse = true ∧
r.begin.offset < 0 ∧
last res < r.begin.key ∧
r.end_.key < r.begin.key ∧
r.end_.offset ≤ 0 ∧
intervalCard r.end_.key r.begin.key + ↑res.keys.length +
↑(1 - r.end_.offset).toNat ≤
↑(beginSlack r) + 1
private abbrev negCrossTruncRevCrossedSmallLegacy (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧
r.reverse = true ∧
r.begin.offset < 0 ∧
last res < r.begin.key ∧
r.end_.key < r.begin.key ∧
r.end_.offset = 1 ∧
intervalCard r.end_.key r.begin.key + ↑res.keys.length ≤
↑(beginSlack r) + 1
@[simp] private theorem tr_negCrossTruncRevCrossedNonposSmallLegacy (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevCrossedNonposSmall (toRefRead r) (toRefRes res) ↔
negCrossTruncRevCrossedNonposSmallLegacy (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevCrossedNonposSmall
negCrossTruncRevCrossedNonposSmallLegacy
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] private theorem tr_negCrossTruncRevCrossedSmallLegacy (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevCrossedSmall (toRefRead r) (toRefRes res) ↔
negCrossTruncRevCrossedSmallLegacy (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevCrossedSmall
negCrossTruncRevCrossedSmallLegacy
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
private theorem negCrossTruncRevCrossedLowLegacy_iff (r : RangeRead) (res : Result) :
(negCrossTruncRevCrossedNonposSmallLegacy r res ∨
negCrossTruncRevCrossedSmallLegacy r res) ↔
negCrossTruncRevCrossedLow r res := by
unfold negCrossTruncRevCrossedNonposSmallLegacy negCrossTruncRevCrossedSmallLegacy
negCrossTruncRevCrossedLow
constructor
· rintro (⟨hm, hr, hb, hl, he, h0, hcap⟩ | ⟨hm, hr, hb, hl, he, h1, hcap⟩)
· exact ⟨hm, hr, hb, hl, he, by omega, hcap⟩
· exact ⟨hm, hr, hb, hl, he, by omega, by simpa [h1] using hcap⟩
· rintro ⟨hm, hr, hb, hl, he, hle, hcap⟩
by_cases h0 : r.end_.offset ≤ 0
· exact Or.inl ⟨hm, hr, hb, hl, he, h0, hcap⟩
· have h1 : r.end_.offset = 1 := by omega
exact Or.inr ⟨hm, hr, hb, hl, he, h1, by simpa [h1] using hcap⟩
@[simp] theorem tr_revTruncLeOneLow (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.revTruncLeOneLow (toRefRead r) (toRefRes res) ↔ Statement.revTruncLeOneLow
(r) (res) := by
unfold FormalConflictRange.revTruncLeOneLow Statement.revTruncLeOneLow
simp [negCrossTruncRevCrossedLowLegacy_iff r res, Statement.firstKey, Statement.lastKey,
Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevBelowEnd (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevBelowEnd (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevBelowEnd (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevBelowEnd Statement.negCrossTruncRevBelowEnd
unfold Statement.overshoot
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne, and_assoc]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualRoom (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.negCrossTruncRevResidualRoom (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualRoom (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualRoom Statement.negCrossTruncRevResidualRoom
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualTopCrossedSmallGap (r : RangeRead) (res : Result) (hne
: res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevResidualTopCrossedSmallGap (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualTopCrossedSmallGap (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualTopCrossedSmallGap
Statement.negCrossTruncRevResidualTopCrossedSmallGap
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualTopCrossed (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevResidualTopCrossed (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualTopCrossed (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualTopCrossed
Statement.negCrossTruncRevResidualTopCrossed
simp only [toRefRes_more, toRefRead_reverse, toRefRead_begin, toRefSelector_offset,
toRefRes_keys, ne_eq, hne, not_false_eq_true, toRefRead_end, List.getLastD_eq_getLast?,
toRefSelector_key, Int.pred_toNat, true_and, last, lastKey, residualT, residualE,
and_congr_right_iff]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_revTruncGeTwoTop (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.revTruncGeTwoTop (toRefRead r) (toRefRes res) ↔ Statement.revTruncGeTwoTop
(r) (res) := by
unfold FormalConflictRange.revTruncGeTwoTop Statement.revTruncGeTwoTop
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncRevResidualTopLargeCrossed (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevResidualTopLargeCrossed (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevResidualTopLargeCrossed (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevResidualTopLargeCrossed
Statement.negCrossTruncRevResidualTopLargeCrossed
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_revTruncGeTwoLarge (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.revTruncGeTwoLarge (toRefRead r) (toRefRes res) ↔
Statement.revTruncGeTwoLarge (r) (res) := by
unfold FormalConflictRange.revTruncGeTwoLarge Statement.revTruncGeTwoLarge
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncTopTop (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncTopTop (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncTopTop (r) (res) := by
unfold FormalConflictRange.negCrossTruncTopTop Statement.negCrossTruncTopTop
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_negCrossTruncTopTopEq (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.negCrossTruncTopTopEq (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncTopTopEq (r) (res) := by
unfold FormalConflictRange.negCrossTruncTopTopEq Statement.negCrossTruncTopTopEq
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormClampSlack (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactClampSlack (toRefRead r) (toRefRes res) =
Statement.closedFormClampSlack (r) (res) := by
unfold FormalConflictRange.compactClampSlack Statement.closedFormClampSlack
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormClampGapSmall (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactClampGapSmall (toRefRead r) (toRefRes res) ↔
Statement.closedFormClampGapSmall (r) (res) := by
unfold FormalConflictRange.compactClampGapSmall Statement.closedFormClampGapSmall
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormClampGapExactSaturated (r : RangeRead) (res : Result) (hne : res.keys
≠ []) :
FormalConflictRange.compactClampGapExactSaturated (toRefRead r) (toRefRes res) ↔
Statement.closedFormClampGapExactSaturated (r) (res) := by
unfold FormalConflictRange.compactClampGapExactSaturated
Statement.closedFormClampGapExactSaturated
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormClampGapLow (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactClampGapLow (toRefRead r) (toRefRes res) ↔
Statement.closedFormClampGapLow (r) (res) := by
unfold FormalConflictRange.compactClampGapLow Statement.closedFormClampGapLow
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormClampUpper (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactClampUpper (toRefRead r) (toRefRes res) =
Statement.closedFormClampUpper (r) (res) := by
unfold FormalConflictRange.compactClampUpper Statement.closedFormClampUpper
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormForwardSaturated (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactForwardSaturated (toRefRead r) (toRefRes res) ↔
Statement.closedFormForwardSaturated (r) (res) := by
unfold FormalConflictRange.compactForwardSaturated Statement.closedFormForwardSaturated
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormForwardTruncatedNonpos (r : RangeRead) (res : Result) (hne : res.keys
≠ []) :
FormalConflictRange.compactForwardTruncatedNonpos (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormForwardTruncatedNonpos (r) (res)) := by
unfold FormalConflictRange.compactForwardTruncatedNonpos
FormalConflictRange.closedFormNegCrossTruncTopTopEq
Statement.closedFormForwardTruncatedNonpos
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
@[simp] theorem tr_closedFormCrossed (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactCrossed (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormCrossed (r) (res)) := by
unfold FormalConflictRange.compactCrossed
FormalConflictRange.closedFormNegCrossTruncRevUnder
FormalConflictRange.closedFormNegCrossTruncRevCrossedNonposLarge
FormalConflictRange.closedFormNegCrossTruncRevBelowEnd
Statement.closedFormCrossed
simp [Statement.firstKey, Statement.lastKey, Statement.first, Statement.last,
Statement.afterFirst, Statement.afterLast, Statement.bottom, Statement.range,
Statement.forwardRead, Statement.reversedResult, Statement.crossedBegin,
Statement.completeClosedWith, Statement.closedFormOffsetOneWith, Statement.closedFormSplit,
Statement.residualE, Statement.residualT, Statement.residualB, Statement.residualD,
FormalConflictRange.compactSplit, FormalConflictRange.residualE,
FormalConflictRange.residualT, FormalConflictRange.residualB, FormalConflictRange.residualD,
FormalConflictRange.endOvershoot, FormalConflictRange.reportedAtEnd, hne]
all_goals (try rfl)
all_goals (try (intros; rfl))
all_goals (try (intros; exact Iff.rfl))
all_goals (try (intros; simp_all))
all_goals (try (split_ifs <;> simp_all))
all_goals (try (split <;> simp_all))
all_goals (try order)
all_goals (try omega)
all_goals (try contradiction)
all_goals (try (exfalso; order))
all_goals (try (exfalso; omega))
all_goals (try rfl)
end Statement