Fix all Lean build warnings

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

`lake build` now completes with zero warnings.
This commit is contained in:
andrew committed 2026-11-17 10:04:35 -05:00
1 parent a54a5f82f8
commit af318a7d32
51 files changed
+2542 -1357

No files matched your search

+169 -132
View File
@@ -5066,7 +5066,7 @@ theorem completeKeys_count_ge_le_end_offset {db : DB} {r : RangeRead}
`(end_.offset - 1).toNat`, for a truncated result and any read whose end offset is
positive. -/
theorem reported_count_ge_le_end_offset {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hne : res.keys ≠ [])
(hread : Readable r res) (_hmore : res.more = true) (_hne : res.keys ≠ [])
(hend : 1 ≤ r.end_.offset) :
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤
(r.end_.offset - 1).toNat := by
@@ -7393,8 +7393,8 @@ The end resolution is the `(end_.offset)`-th stored key at or above `end_.key`,
window contains at most the first `(end_.offset - 1)` such keys; a higher begin
resolution only removes more of them. -/
theorem completeKeys_count_ge_le_general {db : DB} {r : RangeRead}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) :
(hrev : r.reverse = false) (_hbegin : 1 ≤ r.begin.offset)
(_hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) :
(RangeRead.completeKeys db r).countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤
(r.end_.offset - 1).toNat := by
@@ -7562,7 +7562,8 @@ theorem completeKeys_eq_above_take_drop {db : DB} {r : RangeRead}
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤
(r.begin.offset - 1).toNat)
(hAle : (r.end_.offset - 1).toNat ≤
db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) :
db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) <
r.end_.key))) :
RangeRead.completeKeys db r =
((db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).take
(r.end_.offset - 1).toNat).drop
@@ -7613,7 +7614,8 @@ theorem completeKeys_eq_above_take_drop {db : DB} {r : RangeRead}
countP_drop_eq hls (resolve db r.end_) (p + b), ← hd, nat_sub_min_right]
have hAE : l.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = l.drop cE := by
have h := filter_not_lt_eq_drop_countP hls r.end_.key
rw [show l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE from hcE.symm] at h
rw [show l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE from hcE.symm]
at h
rw [← h]
apply List.filter_congr
intro k _
@@ -7810,7 +7812,7 @@ theorem minimal_truncatedRange_of_finite_general {r : RangeRead} {res : Result}
/-- At begin offset one, the keys of the truncated range `[begin.key, keyAfter last)`
are the stored keys at or above `begin.key` followed by those at or below `last`. -/
theorem truncatedRange_keys_eq_filter_take {db : DB} {r : RangeRead} {last : Key}
(hrev : r.reverse = false) (hbegin : r.begin.offset = 1)
(_hrev : r.reverse = false) (_hbegin : r.begin.offset = 1)
(hBlelast : r.begin.key ≤ (last : WithTop Key)) :
(truncatedRange r last).keys db =
(db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).take
@@ -7840,7 +7842,8 @@ theorem truncatedRange_keys_eq_filter_take {db : DB} {r : RangeRead} {last : Key
unfold truncatedRange ConflictRange.keys
rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) =
l.filter (fun (k : Key) => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) &&
l.filter (fun (k : Key) => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop
Key)) &&
decide (r.begin.key ≤ (k : WithTop Key))) from
List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]]
rw [← List.filter_filter, ← hAdef]
@@ -7849,13 +7852,15 @@ theorem truncatedRange_keys_eq_filter_take {db : DB} {r : RangeRead} {last : Key
rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff]
have hK : A.countP (fun k : Key => decide (k ≤ last)) =
l.countP (fun k : Key => decide (k ≤ last)) - p := by
have hcongr : (fun k : Key => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) =
have hcongr : (fun k : Key => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop
Key))) =
(fun k : Key => decide (k ≤ last)) := by
funext k
rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff]
rw [← hcongr]
rw [hA_eq, countP_drop_eq hls ((keyAfter last : Key) : WithTop Key) p]
have hpK : p ≤ l.countP (fun k : Key => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) := by
have hpK : p ≤ l.countP (fun k : Key => decide ((k : WithTop Key) < ((keyAfter last : Key) :
WithTop Key))) := by
rw [hp]
apply countP_le_countP_of_imp
intro k _ hk
@@ -7870,7 +7875,7 @@ theorem truncatedRange_keys_eq_filter_take {db : DB} {r : RangeRead} {last : Key
private theorem exists_of_countP_pos {l : List Key} {p : Key → Bool}
(h : 0 < l.countP p) : ∃ a ∈ l, p a = true := by
by_contra hcon
push_neg at hcon
push Not at hcon
have hzero : l.countP p = 0 := by
rw [List.countP_eq_zero]
intro a ha
@@ -8392,7 +8397,8 @@ private theorem completeKeys_count_ge_eq_min {db : DB} {r : RangeRead}
(RangeRead.completeKeys db r).countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
min ((r.end_.offset - 1).toNat)
(db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) := by
(db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)))
:= by
set l := db.keys with hl
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
set p := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp
@@ -8478,7 +8484,7 @@ database is the sentinel `⊤`: otherwise the complete window would contain exac
inequality defining the branch. -/
private theorem resolve_end_eq_top_of_top_branch {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hrev : r.reverse = false) (_hne : res.keys ≠ [])
(hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(ht : res.keys.countP
@@ -8504,8 +8510,8 @@ private theorem countP_lt_insert {db : DB} {x : Key} (hx : x ∉ db.keys) (E : W
rw [DB.insert_keys, List.Perm.countP_eq _
(List.perm_orderedInsert (· ≤ ·) x db.keys)]
by_cases h : ((x : Key) : WithTop Key) < E
· rw [List.countP_cons_of_pos (by simpa using h), if_pos h]
· rw [List.countP_cons_of_neg (by simpa using h), if_neg h, Nat.add_zero]
· rw [List.countP_cons_of_pos (by simpa using h), ite_eq_left h]
· rw [List.countP_cons_of_neg (by simpa using h), ite_eq_right h, Nat.add_zero]
/-- Inserting a fresh key into a database increases its key count by one. -/
private theorem insert_keys_length {db : DB} {x : Key} (hx : x ∉ db.keys) :
@@ -8527,8 +8533,8 @@ theorem resolve_end_eq_top_of_insert_top {db₀ : DB} {r : RangeRead} {x : Key}
rw [anchor_toNat_eq (s := r.end_) (by omega), countP_lt_insert hx0 r.end_.key]
rw [insert_keys_length hx0]
by_cases h : ((x : Key) : WithTop Key) < r.end_.key
· rw [if_pos h]; omega
· rw [if_neg h]; omega
· rw [ite_eq_left h]; omega
· rw [ite_eq_right h]; omega
/-- **Top-branch necessity above the reported last.** In the top branch of the
offset-one closed form, every key at or above the last reported key is necessary.
@@ -8678,16 +8684,16 @@ theorem minimal_closedForm_of_offset_one {r : RangeRead} {res : Result}
Minimal r res (closedFormOffsetOne r res) := by
unfold closedFormOffsetOne
by_cases hend1 : r.end_.offset ≤ 1
· rw [if_pos hend1]
· rw [ite_eq_left hend1]
exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne (by omega) hend1
· rw [if_neg hend1]
· rw [ite_eq_right hend1]
have hend : 2 ≤ r.end_.offset := by omega
by_cases ht : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat
· rw [if_pos ht]
· rw [ite_eq_left ht]
exact minimal_truncatedRange_of_finite hread hmore hne hrev hbegin hcross hend ht
· rw [if_neg ht]
· rw [ite_eq_right ht]
obtain ⟨db₀, hcomp⟩ := hread
have hres : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩
@@ -8762,9 +8768,9 @@ theorem minimal_closedForm_of_offset_one_any {r : RangeRead} {res : Result}
Minimal r res (closedFormOffsetOneAny r res) := by
unfold closedFormOffsetOneAny
by_cases h : r.reverse = true
· rw [if_pos h]
· rw [ite_eq_left h]
exact minimal_closedForm_of_offset_one_rev hread hmore hne h hbegin hcross
· rw [if_neg h]
· rw [ite_eq_right h]
have hf : r.reverse = false := by
cases hr : r.reverse <;> simp_all
exact minimal_closedForm_of_offset_one hread hmore hne hf hbegin hcross
@@ -8779,13 +8785,13 @@ theorem minimal_closedForm_of_end_le_one {r : RangeRead} {res : Result}
Minimal r res (closedFormOffsetOneAny r res) := by
unfold closedFormOffsetOneAny
by_cases h : r.reverse = true
· rw [if_pos h]
· rw [ite_eq_left h]
unfold closedFormOffsetOneRev
rw [if_pos hend]
rw [ite_eq_left hend]
exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend
· rw [if_neg h]
· rw [ite_eq_right h]
unfold closedFormOffsetOne
rw [if_pos hend]
rw [ite_eq_left hend]
exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend
/-- **The overshoot region whose reported keys lie below `end_.key`.** For a complete
@@ -8806,15 +8812,15 @@ theorem minimal_closedForm_of_reported_below {r : RangeRead} {res : Result}
have hepos : 0 < (r.end_.offset - 1).toNat := by omega
unfold closedFormOffsetOneAny
by_cases h : r.reverse = true
· rw [if_pos h]
· rw [ite_eq_left h]
unfold closedFormOffsetOneRev
rw [if_neg (by omega : ¬ r.end_.offset ≤ 1), ht0,
if_neg (by omega : ¬ (0 = (r.end_.offset - 1).toNat))]
rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ht0,
ite_eq_right (by omega : ¬ (0 = (r.end_.offset - 1).toNat))]
exact minimal_topRange_of_end_offset_ge_two_rev_general hread hmore h hne hbegin hend hhi
· rw [if_neg h]
· rw [ite_eq_right h]
unfold closedFormOffsetOne
rw [if_neg (by omega : ¬ r.end_.offset ≤ 1), ht0,
if_neg (by omega : ¬ (0 = (r.end_.offset - 1).toNat))]
rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ht0,
ite_eq_right (by omega : ¬ (0 = (r.end_.offset - 1).toNat))]
have hf : r.reverse = false := by
cases hr : r.reverse <;> simp_all
exact minimal_topRange_of_end_offset_ge_two_general hread hmore hf hne hbegin hend hhi
@@ -8837,17 +8843,17 @@ theorem minimal_closedForm_of_complete_general {r : RangeRead} {res : Result}
Minimal r res (closedFormOffsetOne r res) := by
unfold closedFormOffsetOne
by_cases hend1 : r.end_.offset ≤ 1
· rw [if_pos hend1]
· rw [ite_eq_left hend1]
exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend1
· rw [if_neg hend1]
· rw [ite_eq_right hend1]
have hend : 2 ≤ r.end_.offset := by omega
by_cases ht : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat
· rw [if_pos ht]
· rw [ite_eq_left ht]
exact minimal_truncatedRange_of_finite_general hread hmore hne hrev hbegin hcross
hend ht
· rw [if_neg ht]
· rw [ite_eq_right ht]
have hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by
rcases hcase with h | h | h
· exact absurd h hend1
@@ -8856,10 +8862,10 @@ theorem minimal_closedForm_of_complete_general {r : RangeRead} {res : Result}
have h := minimal_closedForm_of_reported_below hread hmore hne hbegin hend hhi
have h' : Minimal r res (topRange r) := by
unfold closedFormOffsetOneAny at h
rw [if_neg (by simp [hrev])] at h
rw [ite_eq_right (by simp [hrev])] at h
unfold closedFormOffsetOne at h
rw [if_neg hend1] at h
rw [if_neg (by
rw [ite_eq_right hend1] at h
rw [ite_eq_right (by
intro hc
exact ht (by rw [hc]))] at h
exact h
@@ -8880,10 +8886,10 @@ theorem minimal_closedForm_of_offset_one_truncated {r : RangeRead} {res : Result
Minimal r res (closedFormOffsetOneTruncated r res) := by
unfold closedFormOffsetOneTruncated
by_cases hle : r.end_.offset ≤ 0
· rw [if_pos hle]
· rw [ite_eq_left hle]
exact minimal_canonicalRange_of_truncated_end_offset_nonpos hread hmore hrev
(by omega) hle
· rw [if_neg hle]
· rw [ite_eq_right hle]
exact minimal_truncatedRange_of_offset_one_of_more hread hmore hrev hbegin hcross
(by omega)
@@ -8904,9 +8910,9 @@ theorem minimal_closedForm_of_truncated_general {r : RangeRead} {res : Result}
Minimal r res (closedFormTruncatedGeneral r res) := by
unfold closedFormTruncatedGeneral
by_cases hle : r.end_.offset ≤ 0
· rw [if_pos hle]
· rw [ite_eq_left hle]
exact minimal_canonicalRange_of_truncated_end_offset_nonpos hread hmore hrev hbegin hle
· rw [if_neg hle]
· rw [ite_eq_right hle]
exact minimal_truncatedRange_of_more_general hread hmore hrev hbegin (by omega) hcross
/-- **A compact closed form for every result at begin offset one.** For a non-reversed
@@ -8926,9 +8932,9 @@ theorem minimal_closedForm_of_offset_one_result {r : RangeRead} {res : Result}
Minimal r res (closedFormOffsetOneResult r res) := by
unfold closedFormOffsetOneResult
by_cases hmore : res.more = true
· rw [if_pos hmore]
· rw [ite_eq_left hmore]
exact minimal_closedForm_of_offset_one_truncated hread hmore hrev hbegin hcross
· rw [if_neg hmore]
· rw [ite_eq_right hmore]
have hfalse : res.more = false := by
cases hm : res.more <;> simp_all
exact minimal_closedForm_of_offset_one hread hfalse hne hrev hbegin hcross
@@ -8952,12 +8958,12 @@ theorem minimal_closedForm_of_offset_one_truncated_rev {r : RangeRead} {res : Re
Minimal r res (closedFormOffsetOneTruncatedRev r res) := by
unfold closedFormOffsetOneTruncatedRev
rcases hcase with hle | ⟨hge, hhi⟩
· rw [if_pos hle]
· rw [ite_eq_left hle]
by_cases h1 : r.end_.offset = 1
· exact minimal_truncatedRangeRev_of_offset_one hread hmore hrev hbegin h1
· exact minimal_truncatedRangeRev_of_end_offset_nonpos hread hmore hrev hbegin
(by omega)
· rw [if_neg (by omega)]
· rw [ite_eq_right (by omega)]
exact minimal_topOfLast_of_end_offset_ge_two_rev hread hmore hrev hbegin hge hhi
/-- **The earlier full reversed truncated rule at begin offset one.** Read off the
@@ -9066,15 +9072,15 @@ theorem filter_sublist_filter_of_imp {α : Type*} {l : List α} {p q : α → Bo
| cons a l ih =>
rw [List.filter_cons, List.filter_cons]
by_cases hp : p a = true
· rw [if_pos hp]
· rw [ite_eq_left hp]
have hq : q a = true := h a hp
rw [if_pos hq]
exact ih.cons₂ a
· rw [if_neg hp]
rw [ite_eq_left hq]
exact ih.cons_cons a
· rw [ite_eq_right hp]
by_cases hq : q a = true
· rw [if_pos hq]
· rw [ite_eq_left hq]
exact ih.cons a
· rw [if_neg hq]
· rw [ite_eq_right hq]
exact ih
/-- If `L ≤ keyAfterN n E`, then a database stores at most `n` keys in `[E, L)`. -/
@@ -9147,13 +9153,13 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_full {r : RangeRead} {res
(hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne)
unfold closedFormOffsetOneTruncatedRevFull
by_cases hle : r.end_.offset ≤ 1
· rw [if_pos hle]
· rw [ite_eq_left hle]
by_cases h1 : r.end_.offset = 1
· exact minimal_truncatedRangeRev_of_offset_one ⟨db₀, hcomp₀⟩ hmore hrev hbegin h1
· exact minimal_truncatedRangeRev_of_end_offset_nonpos ⟨db₀, hcomp₀⟩ hmore hrev hbegin
(by omega)
· have hge : 2 ≤ r.end_.offset := by omega
rw [if_neg hle]
rw [ite_eq_right hle]
have hHlt : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.end_.key := by
rcases hcase with h | h
· exact absurd h hle
@@ -9171,7 +9177,7 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_full {r : RangeRead} {res
have hepos : 0 < (r.end_.offset - 1).toNat := by omega
dsimp only
rw [ht0]
rw [if_neg (by omega : ¬ (0 = (r.end_.offset - 1).toNat))]
rw [ite_eq_right (by omega : ¬ (0 = (r.end_.offset - 1).toNat))]
have hheadLt : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key := by
rw [← hhead]; exact hHlt
have hLE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key := by
@@ -9195,7 +9201,8 @@ private theorem completeKeys_count_ge_eq_min_rev {db : DB} {r : RangeRead}
(RangeRead.completeKeys db r).countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
min ((r.end_.offset - 1).toNat)
(db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) := by
(db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)))
:= by
have h := completeKeys_count_ge_eq_min (db := db) (r := {r with reverse := false})
(by simp) hbegin hcross hend
have hck : RangeRead.completeKeys db {r with reverse := false} =
@@ -9208,7 +9215,7 @@ private theorem completeKeys_count_ge_eq_min_rev {db : DB} {r : RangeRead}
/-- The number of reported keys at or above `end_.key` is at most
`(end_.offset - 1)` for a readable truncated reversed result at begin offset one. -/
private theorem reported_count_ge_le_offset_sub_one_rev {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hread : Readable r res) (_hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset) :
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤
@@ -9287,7 +9294,7 @@ prefix of the descending complete keys; if a complete key sat below the last rep
key but at or above `end_.key`, the complete keys would contain strictly more keys at
or above `end_.key` than the count bound allows. -/
private theorem rev_truncated_no_key_between {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hcomp : RangeRead.Compatible db r res) (_hmore : res.more = true)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset)
(hne : res.keys ≠ [])
@@ -9362,9 +9369,9 @@ private theorem rev_truncated_finite_keys_eq {db : DB} {r : RangeRead} {res : Re
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hbase := rev_truncated_filter_between (db := db) hcomp hmore hrev hne
unfold closedFormOffsetOneTruncatedRevFull
rw [if_neg (by omega : ¬ r.end_.offset ≤ 1)]
rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1)]
dsimp only
rw [if_pos ht]
rw [ite_eq_left ht]
rw [hlast, hhead, ← hbase]
unfold ConflictRange.keys
apply List.filter_congr
@@ -9391,7 +9398,7 @@ private theorem rev_truncated_finite_keys_eq {db : DB} {r : RangeRead} {res : Re
/-- In the finite reversed-truncated branch, the candidate equality fixes the
complete keys at or above the reported last key, hence compatibility. -/
private theorem rev_finite_filter_eq {db : DB} {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true)
(hread : Readable r res) (_hmore : res.more = true)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset)
(hne : res.keys ≠ [])
@@ -9409,12 +9416,14 @@ private theorem rev_finite_filter_eq {db : DB} {r : RangeRead} {res : Result}
let H : Key := res.keys.head hne
let E : WithTop Key := r.end_.key
let e : Nat := (r.end_.offset - 1).toNat
let P : Key → Bool := fun k => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ((H : Key) : WithTop Key))
let P : Key → Bool := fun k => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ((H : Key) :
WithTop Key))
let Q : Key → Bool := fun k => decide (E ≤ (k : WithTop Key))
let BT : Key → Bool := fun k => decide (min ((L : Key) : WithTop Key) E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < ((keyAfter H : Key) : WithTop Key))
let BT : Key → Bool := fun k => decide (min ((L : Key) : WithTop Key) E ≤ (k : WithTop Key) ∧ (k
: WithTop Key) < ((keyAfter H : Key) : WithTop Key))
have hT' : db.keys.filter BT = res.keys.reverse := by
simpa only [closedFormOffsetOneTruncatedRevFull, if_neg (by omega : ¬ r.end_.offset ≤ 1),
if_pos ht, hlast, hhead, BT, L, H, E, ConflictRange.keys] using hT
simpa only [closedFormOffsetOneTruncatedRevFull, ite_eq_right (by omega : ¬ r.end_.offset ≤ 1),
ite_eq_left ht, hlast, hhead, BT, L, H, E, ConflictRange.keys] using hT
have hresnodup : res.keys.Nodup := by
have h := db.nodup.filter BT
rw [hT'] at h
@@ -9659,7 +9668,6 @@ private theorem rev_finite_filter_eq {db : DB} {r : RangeRead} {res : Result}
have hkres : k ∈ res.keys := List.mem_reverse.mp hkC
have hLk : L ≤ k := (hsort.pairwise.imp le_of_lt).rel_getLast hkres
exact absurd (WithTop.coe_le_coe.mpr hLk) (not_le.mpr hkL)
-- The complete keys at or above `L` are exactly the reported keys.
have hfilter : (RangeRead.completeKeys db r).filter
(fun k : Key => decide ((L : Key) ≤ k)) = res.keys := by
@@ -9667,7 +9675,7 @@ private theorem rev_finite_filter_eq {db : DB} {r : RangeRead} {res : Result}
(k : WithTop Key) < resolve db r.end_)
have hW : RangeRead.completeKeys db r = (db.keys.filter W).reverse := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [if_pos hrev]
rw [ite_eq_left hrev]
have hstep : (db.keys.filter W).filter (fun k : Key => decide ((L : Key) ≤ k)) =
res.keys.reverse := by
rw [List.filter_filter, ← hT']
@@ -9733,8 +9741,8 @@ private theorem rev_insert_between_incompatible {db : DB} {r : RangeRead} {res :
have hT : (closedFormOffsetOneTruncatedRevFull r res).keys db = res.keys.reverse :=
rev_truncated_finite_keys_eq (db := db) hcomp hmore hrev hbegin hcross hend hne ht
have hT' : db.keys.filter BT = res.keys.reverse := by
simpa only [closedFormOffsetOneTruncatedRevFull, if_neg (by omega : ¬ r.end_.offset ≤ 1),
if_pos ht, hlast, hhead, BT, L, H, E, ConflictRange.keys] using hT
simpa only [closedFormOffsetOneTruncatedRevFull, ite_eq_right (by omega : ¬ r.end_.offset ≤ 1),
ite_eq_left ht, hlast, hhead, BT, L, H, E, ConflictRange.keys] using hT
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
have hLH : L ≤ H := by
dsimp only [L, H]
@@ -9876,7 +9884,7 @@ private theorem rev_insert_between_incompatible {db : DB} {r : RangeRead} {res :
rw [hinskeys, hJeq, List.getElem?_insertIdx]
have hlt : ¬ j + 1 < db.keys.countP (fun x => decide (x < k)) := by omega
have heq : ¬ j + 1 = db.keys.countP (fun x => decide (x < k)) := by omega
rw [if_neg hlt, if_neg heq, Nat.add_sub_cancel, List.getElem?_eq_getElem hjlt, hj]
rw [ite_eq_right hlt, ite_eq_right heq, Nat.add_sub_cancel, List.getElem?_eq_getElem hjlt, hj]
obtain ⟨_, hnewget⟩ := List.getElem?_eq_some_iff.mp hnewget?
have hHresolve : resolve (db.insert k hk0) r.end_ = ((H : Key) : WithTop Key) := by
rw [resolve_eq_getElem (anchor_nonneg_of_one_le (by omega)) hnewlen]
@@ -9960,7 +9968,7 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_full_finite {r : RangeRea
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
unfold closedFormOffsetOneTruncatedRevFull at hk
rw [if_neg (by omega : ¬ r.end_.offset ≤ 1), if_pos ht] at hk
rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ite_eq_left ht] at hk
rw [hlast, hhead] at hk
have hkH : k ≤ res.keys.head hne :=
(lt_keyAfter_iff k (res.keys.head hne)).mp (WithTop.coe_lt_coe.mp hk.2)
@@ -10217,7 +10225,8 @@ private theorem necessary_pad_top_rev {r : RangeRead} {res : Result}
have hP_sorted : P.SortedLT := by
rw [hPdef]
exact List.sortedLT_iff_pairwise.mpr
(List.Pairwise.take (i := n) (List.Pairwise.erase k (List.sortedLT_iff_pairwise.mp hS_sorted)))
(List.Pairwise.take (i := n) (List.Pairwise.erase k (List.sortedLT_iff_pairwise.mp
hS_sorted)))
have hP_sub : P ⊆ S := by
intro x hx
rw [hPdef] at hx
@@ -10300,7 +10309,7 @@ private theorem necessary_pad_top_rev {r : RangeRead} {res : Result}
have hck_a : RangeRead.completeKeys db_a r = aList.reverse := by
unfold RangeRead.completeKeys
rw [hrev]
simp only [if_true]
simp only [ite_true]
change (RangeRead.inRange aList (resolve db_a r.begin) (resolve db_a r.end_)).reverse =
aList.reverse
rw [hin_a]
@@ -10565,7 +10574,7 @@ theorem necessary_above_head_top_rev {r : RangeRead} {res : Result}
WithTop.coe_lt_top x⟩
unfold RangeRead.completeKeys
rw [hrev]
simp only [if_true]
simp only [ite_true]
rw [hin, hdb₁_keys, List.reverse_reverse]
have hcomp₁ : RangeRead.Compatible db₁ r res := by
refine (compatible_iff_truncated_keys_rev (db := db₁) hrev hmore hne).mpr
@@ -10634,7 +10643,8 @@ theorem necessary_above_head_top_rev {r : RangeRead} {res : Result}
= (db₁.keys ++ [k])[0] := List.getElem_of_eq hkeys₂ hpos'
_ = db₁.keys[0] := List.getElem_append_left (i := 0) hlen₁
_ = L := hbase
have hkey : (db₁.insert k hk_notin).keys[(r.begin.anchor (db₁.insert k hk_notin)).toNat] = L := by
have hkey : (db₁.insert k hk_notin).keys[(r.begin.anchor (db₁.insert k hk_notin)).toNat] = L
:= by
rw [List.getElem_eq_iff hidx, hanc, List.getElem?_eq_getElem hpos, hget0₂]
rw [resolve_eq_getElem h0 hidx, hkey]
have hcount₁₂ : db₁.keys.countP
@@ -10686,7 +10696,7 @@ theorem necessary_above_head_top_rev {r : RangeRead} {res : Result}
exact WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hLH hkH))
unfold RangeRead.completeKeys
rw [hrev]
simp only [if_true]
simp only [ite_true]
rw [hin, hkeys₂, List.reverse_append, List.reverse_singleton, hdb₁_keys,
List.reverse_reverse]
rfl
@@ -10732,7 +10742,7 @@ private theorem completeKeys_filter_length_le {db : DB} {r : RangeRead}
rw [hqf] at ha
simp at ha
rw [RangeRead.completeKeys, hrev]
simp only [if_true]
simp only [ite_true]
rw [List.filter_reverse, List.length_reverse]
exact hwin.length_le
@@ -10870,8 +10880,8 @@ the same keys at or above the last; the strict top-branch inequality then bounds
keys at or above `end_.key` by `e - 1`, so its end is also unbounded. -/
private theorem resolve_end_eq_top_of_agree_begin_last {db db' : DB} {r : RangeRead}
{res : Result} {E L : Key} {n : Nat}
(hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ [])
(hmore : res.more = true) (hrev : r.reverse = true) (_hbegin : r.begin.offset = 1)
(_hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ [])
(hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne)
(hn : n = (r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1)
@@ -11181,9 +11191,9 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_fullC {r : RangeRead} {re
· have h := minimal_closedForm_of_offset_one_truncated_rev_full hread' hmore hrev hbegin
(Or.inl hle)
unfold closedFormOffsetOneTruncatedRevFull at h
rw [if_pos hle] at h
rw [ite_eq_left hle] at h
unfold closedFormOffsetOneTruncatedRevFullC
rw [if_pos hle]
rw [ite_eq_left hle]
exact h
· have hcount_le : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤
@@ -11196,11 +11206,11 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_fullC {r : RangeRead} {re
· have h := minimal_closedForm_of_offset_one_truncated_rev_full_finite hread' hmore hrev
hbegin hcross (by omega : 2 ≤ r.end_.offset) ht
unfold closedFormOffsetOneTruncatedRevFull at h
rw [if_neg hle, if_pos ht] at h
rw [ite_eq_right hle, ite_eq_left ht] at h
unfold closedFormOffsetOneTruncatedRevFullC
rw [if_neg hle]
rw [ite_eq_right hle]
dsimp only
rw [if_pos ht]
rw [ite_eq_left ht]
simpa only [hlast, hhead] using h
· have hlt : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) <
@@ -11212,9 +11222,9 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_fullC {r : RangeRead} {re
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1 :=
hn_def
unfold closedFormOffsetOneTruncatedRevFullC
rw [if_neg hle]
rw [ite_eq_right hle]
dsimp only
rw [if_neg ht]
rw [ite_eq_right ht]
by_cases htop : r.end_.key = (⊤ : WithTop Key)
· rw [htop]
have h := minimal_topOfLast_of_end_offset_ge_two_rev hread' hmore hrev hbegin
@@ -11236,14 +11246,14 @@ theorem minimal_closedForm_of_offset_one_truncated_rev_fullC {r : RangeRead} {re
rw [← hlast]; exact hroom
have h := minimal_topRev_begin_end hread' hmore hrev hbegin hcross
(by omega : 2 ≤ r.end_.offset) hne hE.symm rfl hn hlt hroom'
rw [if_pos hroom]
rw [ite_eq_left hroom]
exact h
· have hge : res.keys.getLast hne ≤ keyAfterN n E := by
rw [← hlast]
exact le_of_not_gt hroom
have h := minimal_topRev_begin_last hread' hmore hrev hbegin hcross
(by omega : 2 ≤ r.end_.offset) hE.symm hne rfl hn hlt (Or.inr hge)
rw [if_neg hroom]
rw [ite_eq_right hroom]
simpa only [← hlast] using h
/-- **One compact rule for every result at begin offset one.** Dispatch on `res.more`
@@ -11264,16 +11274,16 @@ theorem minimal_closedForm_of_offset_one_universal {r : RangeRead} {res : Result
Minimal r res (closedFormOffsetOneUniversal r res) := by
unfold closedFormOffsetOneUniversal
by_cases hmore : res.more = true
· rw [if_pos hmore]
· rw [ite_eq_left hmore]
by_cases hrev : r.reverse = true
· rw [if_pos hrev]
· rw [ite_eq_left hrev]
exact minimal_closedForm_of_offset_one_truncated_rev_fullC hread hmore hrev
hbegin hcross
· rw [if_neg hrev]
· rw [ite_eq_right hrev]
have hfalse : r.reverse = false := by
cases hr : r.reverse <;> simp_all
exact minimal_closedForm_of_offset_one_truncated hread hmore hfalse hbegin hcross
· rw [if_neg hmore]
· rw [ite_eq_right hmore]
have hfalse : res.more = false := by
cases hm : res.more <;> simp_all
exact minimal_closedForm_of_offset_one_any hread hfalse hne hbegin hcross
@@ -11283,7 +11293,7 @@ hypothesis is retained for compatibility with earlier statements. -/
theorem minimal_closedForm_of_offset_one_universal_of_auto {r : RangeRead} {res : Result}
(hread : Readable r res) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key)
(hauto : r.reverse = false ∨ res.more = false ∨ r.end_.offset ≤ 1 ∨
(_hauto : r.reverse = false ∨ res.more = false ∨ r.end_.offset ≤ 1 ∨
r.end_.key = (⊤ : WithTop Key)) :
Minimal r res (closedFormOffsetOneUniversal r res) :=
minimal_closedForm_of_offset_one_universal hread hne hbegin hcross
@@ -11294,7 +11304,7 @@ theorem minimal_closedForm_of_offset_one_universal_of_not_cell {r : RangeRead}
{res : Result}
(hread : Readable r res) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key)
(hcell : ¬ (r.reverse = true ∧ res.more = true ∧ 2 ≤ r.end_.offset ∧
(_hcell : ¬ (r.reverse = true ∧ res.more = true ∧ 2 ≤ r.end_.offset ∧
r.end_.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key))) :
Minimal r res (closedFormOffsetOneUniversal r res) :=
minimal_closedForm_of_offset_one_universal hread hne hbegin hcross
@@ -11492,8 +11502,8 @@ theorem completeKeys_eq_drop_take_general {db : DB} {r : RangeRead}
/-- **In the crossed case every complete key lies at or above `end_.key` at any
positive begin offset.** -/
theorem completeKeys_count_ge_eq_length_of_crossed_general {db : DB} {r : RangeRead}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
(_hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (_hend : 1 ≤ r.end_.offset) :
(RangeRead.completeKeys db r).countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(RangeRead.completeKeys db r).length := by
@@ -11688,7 +11698,8 @@ theorem compatible_crossed_iff_crossFree {r : RangeRead} {res : Result}
unfold Selector.anchor crossFreeAnchor
simp only
omega
have hresolve : resolve db r.begin = resolve db ({ key := r.end_.key, offset := 1 } : Selector) := by
have hresolve : resolve db r.begin = resolve db ({ key := r.end_.key, offset := 1 } :
Selector) := by
unfold resolve
rw [hanchor]
rfl
@@ -11726,7 +11737,8 @@ theorem compatible_crossed_iff_crossFree {r : RangeRead} {res : Result}
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) (by omega))
(RangeRead.mem_completeKeys.mp hk₀).2.1
-- show no stored key lies in [E, B)
have hno : ∀ k ∈ db.keys, ¬ (r.end_.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key) := by
have hno : ∀ k ∈ db.keys, ¬ (r.end_.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)
:= by
intro k hk hkb
have hkwin : k ∈ RangeRead.completeKeys db (crossFreeAnchor r) := by
refine RangeRead.mem_completeKeys.mpr ⟨hk, ?_, ?_⟩
@@ -11758,13 +11770,13 @@ theorem compatible_crossed_iff_crossFree {r : RangeRead} {res : Result}
unfold Selector.anchor crossFreeAnchor
simp only
omega
have hresolve : resolve db r.begin = resolve db ({ key := r.end_.key, offset := 1 } : Selector) := by
have hresolve : resolve db r.begin = resolve db ({ key := r.end_.key, offset := 1 } :
Selector) := by
unfold resolve
rw [hanchor]
rfl
refine ⟨?_, ?_⟩
· change r.withinLimit res.keys
exact hcomp.1
· exact hcomp.1
· right
refine ⟨by simp [hmore], ?_⟩
have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db (crossFreeAnchor r) := by
@@ -11933,7 +11945,8 @@ private theorem completeKeys_eq_drop_take_of_key_eq {db : DB} {r : RangeRead}
have hAlen : (l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length =
l.length - c := by rw [hA, List.length_drop]
have hle : c + e ≤ l.length := by
have hlen' : e ≤ (l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length := by
have hlen' : e ≤ (l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length
:= by
simpa [hl] using hlen
rw [hAlen] at hlen'
have hc_le : c ≤ l.length := by
@@ -12081,7 +12094,8 @@ private theorem sound_truncatedRange_of_key_eq_finite_general {r : RangeRead} {r
rw [← truncatedRange_keys_eq_filter_le (db := db₂) (r := r) (last := last), hTlen₂]
have hfil := filter_le_eq_take_countP hAsort₂ last
rw [hq] at hfil
exact hfil.symm.trans (truncatedRange_keys_eq_filter_le (db := db₂) (r := r) (last := last)).symm
exact hfil.symm.trans (truncatedRange_keys_eq_filter_le (db := db₂) (r := r) (last :=
last)).symm
-- Assemble the complete window of `db₂`.
have hck₂ : RangeRead.completeKeys db₂ r = res.keys := by
rw [completeKeys_eq_drop_take_of_key_eq (db := db₂) hrev hbegin hkey (by omega) hlenA₂]
@@ -12134,7 +12148,7 @@ database is the sentinel. Otherwise the complete window would be the rank interv
would number exactly `e - b`. -/
private theorem resolve_end_eq_top_of_key_eq_top_general {db : DB} {r : RangeRead}
{res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hrev : r.reverse = false) (_hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key)
(hend : 2 ≤ r.end_.offset)
(ht : res.keys.countP
@@ -12520,10 +12534,10 @@ theorem minimal_closedForm_of_key_eq_complete_general {r : RangeRead} {res : Res
by_cases ht : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) +
(r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat
· rw [if_pos ht]
· rw [ite_eq_left ht]
exact minimal_truncatedRange_of_key_eq_finite_general hread' hmore hne hrev hbegin
hkey hend ht
· rw [if_neg ht]
· rw [ite_eq_right ht]
have hle := key_eq_count_add_le (db := db₀) hcomp hmore hrev hne hbegin hkey
(by omega)
exact minimal_topRange_of_key_eq_top_general hread' hmore hrev hne hbegin hkey hend
@@ -12557,7 +12571,8 @@ theorem resolve_eq_filter_lt_reverse {db : DB} {s : Selector} (hoff : s.offset
set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) with hc
have hanchor : s.anchor db = (c : ℤ) - (m : ℤ) - 1 := by
unfold Selector.anchor; rw [← hc, hoff']; ring
have hflen : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).length = c := by
have hflen : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).length = c
:= by
rw [← List.countP_eq_length_filter, ← hc]
have hclen : c ≤ db.keys.length := by rw [hc]; exact List.countP_le_length
by_cases hmc : m < c
@@ -12573,7 +12588,8 @@ theorem resolve_eq_filter_lt_reverse {db : DB} {s : Selector} (hoff : s.offset
rw [resolve_eq_getElem h0 hlen]
apply WithTop.coe_inj.mp
simp only [hidx]
have hsome : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[m]? =
have hsome : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) <
s.key))).reverse[m]? =
some (db.keys[c - 1 - m]'(by omega)) := by
rw [List.getElem?_reverse (by rw [hflen]; omega)]
rw [hflen]
@@ -12583,7 +12599,8 @@ theorem resolve_eq_filter_lt_reverse {db : DB} {s : Selector} (hoff : s.offset
· have hle : c ≤ m := by omega
have hneg : s.anchor db < 0 := by rw [hanchor]; omega
rw [resolve_eq_nil hneg]
have hnone : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[m]? = none :=
have hnone : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) <
s.key))).reverse[m]? = none :=
List.getElem?_eq_none (by rw [List.length_reverse, hflen]; exact hle)
rw [hnone]
@@ -12608,34 +12625,44 @@ theorem filter_lt_eq_filter_lt_append_between {l : List Key} (hs : l.SortedLT)
List.filter_cons_of_pos (p := fun k : Key => decide ((↑k : WithTop Key) < E)) (a := x)
(decide_eq_true hxE)
by_cases hxa : ((x : Key) : WithTop Key) < ((a : Key) : WithTop Key)
· have hFa_pos : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) =
· have hFa_pos : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop
Key))) =
x :: xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) :=
List.filter_cons_of_pos (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) (a := x)
List.filter_cons_of_pos (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop
Key))) (a := x)
(decide_eq_true hxa)
have hG_neg : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
have hG_neg : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop
Key) ∧
(↑k : WithTop Key) < E)) =
xs.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
(↑k : WithTop Key) < E)) :=
List.filter_cons_of_neg (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
List.filter_cons_of_neg (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop
Key) ∧
(↑k : WithTop Key) < E)) (a := x) (by simp [not_le.mpr hxa])
rw [hFE_pos, hFa_pos, hG_neg, hih]
rfl
· have hax : ((a : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := le_of_not_gt hxa
have hFa_nil : xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) = [] := by
have hFa_nil : xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key)))
= [] := by
rw [List.filter_eq_nil_iff]
intro k hk
have hxk : ((x : Key) : WithTop Key) < (k : WithTop Key) := WithTop.coe_lt_coe.mpr (hx_le k hk)
have hxk : ((x : Key) : WithTop Key) < (k : WithTop Key) := WithTop.coe_lt_coe.mpr
(hx_le k hk)
simp only [decide_eq_true_eq]
exact not_lt.mpr (le_trans hax (le_of_lt hxk))
have hFa_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) =
have hFa_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop
Key))) =
xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) :=
List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) (a := x)
List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop
Key))) (a := x)
(by simp [hxa])
have hG_pos : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
have hG_pos : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop
Key) ∧
(↑k : WithTop Key) < E)) =
x :: xs.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
(↑k : WithTop Key) < E)) :=
List.filter_cons_of_pos (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
List.filter_cons_of_pos (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop
Key) ∧
(↑k : WithTop Key) < E)) (a := x) (decide_eq_true ⟨hax, hxE⟩)
rw [hFE_pos, hFa_neg, hG_pos, hFa_nil, List.nil_append, hih, hFa_nil, List.nil_append]
· have hEx : E ≤ ((x : Key) : WithTop Key) := le_of_not_gt hxE
@@ -12647,15 +12674,19 @@ theorem filter_lt_eq_filter_lt_append_between {l : List Key} (hs : l.SortedLT)
xs.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) :=
List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < E)) (a := x)
(by simp [hxE])
have hFa_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) =
have hFa_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop
Key))) =
xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) :=
List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) (a := x)
List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop
Key))) (a := x)
(by simp [hnot_a])
have hG_neg : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
have hG_neg : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop
Key) ∧
(↑k : WithTop Key) < E)) =
xs.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
(↑k : WithTop Key) < E)) :=
List.filter_cons_of_neg (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
List.filter_cons_of_neg (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop
Key) ∧
(↑k : WithTop Key) < E)) (a := x) (by simp [hxE])
rw [hFE_neg, hFa_neg, hG_neg, hih]
@@ -12674,7 +12705,8 @@ theorem resolve_eq_of_agree_between {db₁ db₂ : DB} {s : Selector}
(hqa : (a : WithTop Key) ≤ ((q : Key) : WithTop Key)) :
resolve db₂ s = ((q : Key) : WithTop Key) := by
set m := (-s.offset).toNat with hm
set A₁ := db₁.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) with hA₁
set A₁ := db₁.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) with
hA₁
set B₁ := db₁.keys.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
(↑k : WithTop Key) < E)) with hB₁
set F₁ := db₁.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) with hF₁
@@ -12707,7 +12739,8 @@ theorem resolve_eq_of_agree_between {db₁ db₂ : DB} {s : Selector}
exact List.getElem?_append_left (l₁ := B₁.reverse) (l₂ := A₁.reverse) (i := m)
(by rwa [List.length_reverse])
rwa [hleft] at hq
set A₂ := db₂.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) with hA₂
set A₂ := db₂.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) with
hA₂
set B₂ := db₂.keys.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧
(↑k : WithTop Key) < E)) with hB₂
set F₂ := db₂.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) with hF₂
@@ -12808,14 +12841,16 @@ theorem minimal_headToEnd_of_zero_begin_crossed_endNonpos {r : RangeRead} {res :
have hB_le_E : r.begin.key ≤ r.end_.key := by
by_contra hcon
have hEB : r.end_.key < r.begin.key := lt_of_not_ge hcon
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hn | ht | ⟨k, hkdb, hkres⟩
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hn | ht | ⟨k, hkdb,
hkres⟩
· rw [hn] at hhead_lt_res
exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le _))
· exact absurd ht (resolve_ne_top_of_offset_nonpos hend)
· have hk_lt_B : (k : WithTop Key) < r.begin.key :=
lt_of_le_of_lt (by rw [← hkres]; exact hres_le_E) hEB
have hk_le_head : (k : WithTop Key) ≤ ((res.keys.head hne : Key) : WithTop Key) := by
have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k hkdb hk_lt_B
have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k
hkdb hk_lt_B
rwa [hL] at hb
have hhead_lt_k : ((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) := by
rw [← hkres]; exact hhead_lt_res
@@ -12853,7 +12888,8 @@ theorem minimal_headToEnd_of_zero_begin_crossed_endNonpos {r : RangeRead} {res :
exact hno k (List.mem_of_mem_filter hk_in) hheadk hkB
have hL' : resolve db' r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
apply le_antisymm
· rcases resolve_eq_nil_or_eq_top_or_mem (db := db') (s := r.begin) with hn | ht | ⟨k, hkdb', hkres⟩
· rcases resolve_eq_nil_or_eq_top_or_mem (db := db') (s := r.begin) with hn | ht | ⟨k,
hkdb', hkres⟩
· rw [hn]; exact coe_nil_le _
· exact absurd ht (resolve_ne_top_of_offset_nonpos (by rw [hbegin]))
· rw [hkres]
@@ -13032,7 +13068,7 @@ theorem compatible_zero_crossed_iff_anchor {r : RangeRead} {res : Result}
rw [hL]
congr 1
funext k
show decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
change decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db r.end_) =
decide (resolve db (zeroBeginAnchor r res).begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db r.end_)
@@ -13065,7 +13101,8 @@ theorem compatible_zero_crossed_iff_anchor {r : RangeRead} {res : Result}
exact hres_avoid k hkck hkb
have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
apply le_antisymm
· rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with hn | ht | ⟨q, hq, hqeq⟩
· rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with hn | ht | ⟨q, hq,
hqeq⟩
· rw [hn]
exact coe_nil_le _
· exact absurd ht (resolve_ne_top_of_offset_nonpos (by rw [hbegin]))
@@ -13091,7 +13128,7 @@ theorem compatible_zero_crossed_iff_anchor {r : RangeRead} {res : Result}
rw [hL]
congr 1
funext k
show decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
change decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db r.end_) =
decide (resolve db (zeroBeginAnchor r res).begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db r.end_)