- 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.
3600 lines
187 KiB
Lean4
3600 lines
187 KiB
Lean4
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
|