Files
conflict-range/Bridge.lean
T
andrew af318a7d32 Fix all Lean build warnings
- Update deprecated lemmas (ite_eq_left/right, ENat casts, List.Sublist, ...)
- Replace push_neg with push Not and resolve unused-variable warnings
- Convert flexible simp/simp_all calls to explicit simp only lists
- Remove unscoped maxHeartbeats options, open scoped Classical, and unused tactics
- Add missing module docstrings and clean up style linter hits
- Wrap over-long lines and flatten the deeply nested
  minimal_conflictRangeClosedForm_total proof

`lake build` now completes with zero warnings.
2026-11-17 10:04:35 -05:00

3600 lines
187 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.
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)
@[simp] theorem tr_negCrossClampNonposInfinite (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.negCrossClampNonposInfinite (toRefRead r) (toRefRes res) ↔
Statement.negCrossClampNonposInfinite (r) (res) := by
unfold FormalConflictRange.negCrossClampNonposInfinite Statement.negCrossClampNonposInfinite
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)
@[simp] theorem tr_closedFormNegCrossClampUnified (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.closedFormNegCrossClampUnified (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossClampUnified (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossClampUnified Statement.closedFormNegCrossClampUnified
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_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_closedFormNegCrossTruncRevBelowEnd (_r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevBelowEnd (toRefRead _r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossTruncRevBelowEnd (_r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevBelowEnd
Statement.closedFormNegCrossTruncRevBelowEnd
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_closedFormNegCrossTruncRevCrossedNonposLarge (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevCrossedNonposLarge (toRefRead r) (toRefRes res)
= toRefCR (Statement.closedFormNegCrossTruncRevCrossedNonposLarge (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevCrossedNonposLarge
Statement.closedFormNegCrossTruncRevCrossedNonposLarge
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_closedFormNegCrossTruncRevResidualFiniteUnder (r : RangeRead) (res : Result)
(hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevResidualFiniteUnder (toRefRead r) (toRefRes res)
= toRefCR (Statement.closedFormNegCrossTruncRevResidualFiniteUnder (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevResidualFiniteUnder
Statement.closedFormNegCrossTruncRevResidualFiniteUnder
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
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_closedFormNegCrossTruncRevResidualTopLargeSentinel (r : RangeRead) (res :
Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevResidualTopLargeSentinel (toRefRead r) (toRefRes
res) = toRefCR (Statement.closedFormNegCrossTruncRevResidualTopLargeSentinel (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevResidualTopLargeSentinel
Statement.closedFormNegCrossTruncRevResidualTopLargeSentinel
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
Statement.closedFormNegCrossTruncRevResidualTopLargeUnified
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_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_closedFormNegCrossTruncRevUnder (r : RangeRead) (res : Result) (hne : res.keys
≠ []) :
FormalConflictRange.closedFormNegCrossTruncRevUnder (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossTruncRevUnder (r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncRevUnder
Statement.closedFormNegCrossTruncRevUnder
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_closedFormNegCrossTruncTopTopEq (_r : RangeRead) (res : Result) (hne : res.keys
≠ []) :
FormalConflictRange.closedFormNegCrossTruncTopTopEq (toRefRead _r) (toRefRes res) = toRefCR
(Statement.closedFormNegCrossTruncTopTopEq (_r) (res)) := by
unfold FormalConflictRange.closedFormNegCrossTruncTopTopEq
Statement.closedFormNegCrossTruncTopTopEq
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_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_nonposRevReduced (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.nonposRevReduced (toRefRead r) (toRefRes res) = toRefRead
(Statement.nonposRevReduced (r) (res)) := by
unfold FormalConflictRange.nonposRevReduced Statement.nonposRevReduced
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_closedFormNonposRevTrunc (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.closedFormNonposRevTrunc (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormNonposRevTrunc (r) (res)) := by
unfold FormalConflictRange.closedFormNonposRevTrunc Statement.closedFormNonposRevTrunc
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)
@[simp] theorem tr_emptyValue (r : RangeRead) :
FormalConflictRange.emptyValue (toRefRead r) = toRefCR (Statement.emptyValue (r)) := by
unfold FormalConflictRange.emptyValue Statement.emptyValue
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_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_closedFormClamped (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactClamped (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormClamped (r) (res)) := by
unfold FormalConflictRange.compactClamped Statement.closedFormClamped
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
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_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)
@[simp] theorem tr_crossedCompleteClamp (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.crossedCompleteClamp (toRefRead r) (toRefRes res) ↔
Statement.crossedCompleteClamp (r) (res) := by
unfold FormalConflictRange.crossedCompleteClamp Statement.crossedCompleteClamp
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_closedFormCrossedComplete (r : RangeRead) (res : Result) (hne : res.keys ≠ []) :
FormalConflictRange.compactCrossedComplete (toRefRead r) (toRefRes res) = toRefCR
(Statement.closedFormCrossedComplete (r) (res)) := by
unfold FormalConflictRange.compactCrossedComplete Statement.closedFormCrossedComplete
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_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)
@[simp] theorem tr_negCrossTruncRevCrossedNonposSmall (r : RangeRead) (res : Result) (hne :
res.keys ≠ []) :
FormalConflictRange.negCrossTruncRevCrossedNonposSmall (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevCrossedNonposSmall (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevCrossedNonposSmall
Statement.negCrossTruncRevCrossedNonposSmall
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_negCrossTruncRevCrossedSmall (r : RangeRead) (res : Result) (hne : res.keys ≠
[]) :
FormalConflictRange.negCrossTruncRevCrossedSmall (toRefRead r) (toRefRes res) ↔
Statement.negCrossTruncRevCrossedSmall (r) (res) := by
unfold FormalConflictRange.negCrossTruncRevCrossedSmall Statement.negCrossTruncRevCrossedSmall
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_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 [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
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_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
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 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