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:
1 parent
a54a5f82f8
commit
af318a7d32
51 files changed
+2542
-1357
No files matched your search
+169
-132
@@ -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_)
|
||||
|
||||
Reference in new issue
Block a user