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

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

1121 lines
55 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import FormalConflictRange.CrossedGeneral
/-!
# Forward crossed truncated general cells.
-/
open FormalConflictRange
namespace FormalConflictRange
/-- Slicing a sorted list at `b` and taking `t` elements: the filter up to the last
taken element is exactly the first `b + t` elements. -/
theorem filter_le_getElem_eq_take {A : List Key} (hAs : A.SortedLT) {b t : ℕ}
(ht : 0 < t) (hbt : b + t ≤ A.length) :
A.filter (fun k : Key => decide (k ≤ A[b + t - 1]'(by omega))) = A.take (b + t) := by
have hidx : b + t - 1 < A.length := by omega
have hgne : A.take (b + t) ≠ [] :=
List.ne_nil_of_length_pos (by rw [List.length_take]; omega)
have hglast : (A.take (b + t)).getLast hgne = A[b + t - 1]'hidx := by
rw [List.getLast_eq_getElem, List.getElem_take]
simp only [List.length_take, Nat.min_eq_left hbt]
have h := filter_le_getLast_eq_of_prefix (α := Key) (g := A.take (b + t)) (W := A)
hAs.pairwise (List.take_prefix (b + t) A) hgne
rw [hglast] at h
exact h
theorem completeKeys_eq_filter_ge_drop_take {db : DB} {r : RangeRead}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) :
RangeRead.completeKeys db r =
((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).drop
(r.begin.offset - 1).toNat).take
(min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat) db.keys.length
- (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) +
(r.begin.offset - 1).toNat)) := by
set l := db.keys with hl
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
set b := (r.begin.offset - 1).toNat with hb
have hls : l.SortedLT := by rw [hl]; exact db.sorted
have hAeq : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.drop p := by
rw [hp]
have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key
rw [← hdrop]
apply List.filter_congr
intro k _
rw [decide_eq_decide]
exact not_lt.symm
rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend, ← hl, ← hp, ← hb]
rw [hAeq, List.drop_drop]
/-- The last element of `(A.drop b).take t` is `A[b+t-1]`. -/
theorem getLast_take_drop {A : List Key} {b t : ℕ} {res : List Key}
(ht : 0 < t) (hres : res = (A.drop b).take t) (hbt : b + t ≤ A.length) :
res.getLastD [] = A[b + t - 1]'(by omega) := by
have hne : res ≠ [] := by
rw [hres]
apply List.ne_nil_of_length_pos
rw [List.length_take, Nat.min_eq_left]
· omega
· rw [List.length_drop]; omega
have hlastD : res.getLastD [] = res.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hlastD]
have hne' : (A.drop b).take t ≠ [] := by rw [← hres]; exact hne
calc res.getLast hne
= ((A.drop b).take t).getLast hne' := List.getLast_congr hne hne' hres
_ = A[b + t - 1]'(by omega) := by
rw [List.getLast_eq_getElem, List.getElem_take]
simp only [List.length_take, List.length_drop, Nat.min_eq_left (by omega : t ≤ A.length - b)]
rw [List.getElem_drop]
congr 1
omega
end FormalConflictRange
namespace FormalConflictRange
/-- In the crossed forward truncated B-branch, agreement on the truncated range
forced the reported last to stay strictly below the resolved end. -/
theorem crossed_truncated_hlr_of_drop_gap {db : DB} {r : RangeRead} {res : Result}
(_hrev : r.reverse = false) (_hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
(hcross : r.end_.key < r.begin.key) (hne : res.keys ≠ [])
(hgap : (between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat +
res.keys.length ≤ (r.end_.offset - 1).toNat)
(hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop
(r.begin.offset - 1).toNat = res.keys) :
((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := by
set l := db.keys with hl
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE
set b := (r.begin.offset - 1).toNat with hb
set e := (r.end_.offset - 1).toNat with he
set t := res.keys.length with ht
set last := res.keys.getLast hne with hlast
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hA
set S := A.filter (fun k : Key => decide (k ≤ last)) with hS
have hls : l.SortedLT := by rw [hl]; exact db.sorted
have hAs : A.SortedLT := by
rw [hA]
exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _)
have htrunc : (truncatedRange r last).keys db = S := by
rw [truncatedRange_keys_eq_filter_le]
have hdrop' : S.drop b = res.keys := by
rw [← htrunc]
simpa [hb] using hdrop
have htpos : 0 < t := by rw [ht]; exact List.length_pos_of_ne_nil hne
have hSlen : S.length = b + t := by
have := congrArg List.length hdrop'
rw [List.length_drop, ← ht] at this
omega
have hStake : S = A.take (b + t) := by
rw [hS, filter_le_eq_take_countP hAs last]
congr 1
rw [List.countP_eq_length_filter]
simpa [S] using hSlen
have hAbt : b + t ≤ A.length := by
rw [hStake, List.length_take] at hSlen
omega
have hresdrop : res.keys = (A.drop b).take t := by
rw [← hdrop', hStake, List.drop_take]
congr 1
omega
have hlastD : res.keys.getLastD [] = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hlastA : last = A[b + t - 1]'(by omega) := by
rw [hlast, ← hlastD]
exact getLast_take_drop htpos hresdrop hAbt
set g := (between db r.end_.key r.begin.key).length with hgdef
have hcnt : p = cE + g := by
rw [hp, hcE, hgdef]
simpa [cnt, hl] using cnt_eq_add_between (db := db) (le_of_lt hcross)
have hA_eq : A = l.drop p := by
rw [hA, hp]
have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key
rw [← hdrop]
apply List.filter_congr
intro k _
rw [decide_eq_decide]
exact not_lt.symm
have hjlt : p + (b + t - 1) < l.length := by
have := hAbt
rw [hA_eq, List.length_drop] at this
omega
have hlast_l : last = l[p + (b + t - 1)]'hjlt := by
rw [hlastA]
have hidx : b + t - 1 < A.length := by omega
have h1 : A[b + t - 1]'hidx = (l.drop p)[b + t - 1]'(by rw [List.length_drop]; omega) :=
List.getElem_of_eq hA_eq hidx
rw [h1, List.getElem_drop]
have hgbt : g + (t + b) ≤ e := by
have h := hgap
omega
have hj_anchor : p + (b + t - 1) < (r.end_.anchor db).toNat := by
rw [anchor_toNat_eq (s := r.end_) hend, ← hl, ← hcE, hcnt]
have hble : b + t - 1 < t + b := by omega
omega
have hj_clamp : p + (b + t - 1) < clampIndex db r.end_ := by
unfold clampIndex
exact Nat.lt_min.mpr ⟨hj_anchor, hjlt⟩
rw [hlast_l]
exact (getElem_lt_resolve_iff (db := db) (s := r.end_)
(j := p + (b + t - 1)) hjlt).mpr hj_clamp
end FormalConflictRange
namespace FormalConflictRange
/-- A compatible crossed truncated result bounds the number of stored keys in the
selector gap: `gap + begin-offset-padding + reported-length ≤ end-overshoot`. -/
theorem compatible_gap_bound {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (_hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
(hcross : r.end_.key < r.begin.key)
(hc : RangeRead.Compatible db r res) :
(between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat +
res.keys.length ≤ (r.end_.offset - 1).toNat := by
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc
set l := db.keys with hl
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE
set b := (r.begin.offset - 1).toNat with hb
set e := (r.end_.offset - 1).toNat with he
set t := res.keys.length with ht
set g := (between db r.end_.key r.begin.key).length with hg
have hck := completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend
rw [← hl, ← hp, ← hcE, ← hb, ← he] at hck
have ht_le : t ≤ min (cE + e) l.length - (p + b) := by
have := hpre.length_le
rw [hck, List.length_take, ← ht] at this
exact le_trans this (Nat.min_le_left _ _)
have hcnt : p = cE + g := by
rw [hp, hcE, hg]
simpa [cnt, hl] using cnt_eq_add_between (db := db) (le_of_lt hcross)
have hsub : cE + e - (p + b) = e - g - b := by
rw [hcnt, add_assoc, Nat.add_sub_add_left, Nat.sub_sub]
have hminle : min (cE + e) l.length - (p + b) ≤ e - g - b := by
rw [← hsub]
exact Nat.sub_le_sub_right (Nat.min_le_left _ _) _
have ht_le' : t ≤ e - g - b := le_trans ht_le hminle
have htpos : 0 < t := by rw [ht]; exact List.length_pos_of_ne_nil hne
have hgbe : g + b ≤ e := by
by_contra h
have hz : e - g - b = 0 := by omega
omega
have hfinal : g + b + t ≤ e := by
calc g + b + t = t + (g + b) := by omega
_ ≤ (e - (g + b)) + (g + b) := by
have h1 : t ≤ e - (g + b) := by rwa [Nat.sub_sub] at ht_le'
exact Nat.add_le_add_right h1 _
_ = e := Nat.sub_add_cancel hgbe
simpa [hg, hb, ht, he] using hfinal
end FormalConflictRange
namespace FormalConflictRange
/-- The hcard form of the crossed truncated height lemma, derived from the actual
gap-count form. -/
theorem crossed_truncated_hlr_of_drop {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
(hcross : r.end_.key < r.begin.key) (hne : res.keys ≠ [])
(hcard : intervalCard r.end_.key r.begin.key ≤
(((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞))
(hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop
(r.begin.offset - 1).toNat = res.keys) :
((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := by
refine crossed_truncated_hlr_of_drop_gap hrev hbegin hend hcross hne ?_ hdrop
set g := (between db r.end_.key r.begin.key).length with hg
set t := res.keys.length with ht
set b := (r.begin.offset - 1).toNat with hb
set e := (r.end_.offset - 1).toNat with he
have hgcard : ((g : ℕ) : ℕ∞) ≤ (((e - t - b : ℕ)) : ℕ∞) := by
refine le_trans ?_ (by simpa [e, t, b, g] using hcard)
simpa [g] using between_length_le_intervalCard (db := db) (le_of_lt hcross)
have hgle0 : g ≤ e - t - b := by exact_mod_cast hgcard
have hgle : g ≤ e - (t + b) := by rwa [Nat.sub_sub] at hgle0
have htb : t + b ≤ e := by
by_contra h
have hzero : e - t - b = 0 := by omega
have hle0 : intervalCard r.end_.key r.begin.key ≤ 0 := by simpa [hzero] using hcard
have hzero2 : intervalCard r.end_.key r.begin.key = 0 := le_antisymm hle0 zero_le
exact absurd (intervalCard_eq_zero_iff.mp hzero2) (not_le.mpr hcross)
have hgbt : g + (t + b) ≤ e := by
calc g + (t + b) ≤ (e - (t + b)) + (t + b) := Nat.add_le_add_right hgle _
_ = e := Nat.sub_add_cancel htb
omega
end FormalConflictRange
open FormalConflictRange
namespace FormalConflictRange
/-- General crossed complete keys filtered at or below the last reported key. -/
theorem completeKeys_filter_le_eq_crossed_general {db : DB} {r : RangeRead} {last : Key}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
(hEB : r.end_.key ≤ r.begin.key) (_hBlast : r.begin.key ≤ (last : WithTop Key)) :
(RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) =
(((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).take
(min ((r.end_.offset - 1).toNat - (between db r.end_.key r.begin.key).length)
((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length)).drop
(r.begin.offset - 1).toNat := by
set l := db.keys with hl
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE
set b := (r.begin.offset - 1).toNat with hb
set e := (r.end_.offset - 1).toNat with he
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
set C := A.filter (fun k : Key => decide (k ≤ last)) with hCdef
set q := A.countP (fun k : Key => decide (k ≤ last)) with hqdef
set gap := (between db r.end_.key r.begin.key).length with hgapdef
set K := min (cE + e) l.length - (p + b) with hK
set L := min (e - gap) q with hL
have hls : l.SortedLT := by rw [hl]; exact db.sorted
have hAs : A.SortedLT := by
rw [hAdef]
exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _)
have hA : A = l.drop p := by
rw [hAdef, hp]
have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key
rw [← hdrop]
apply List.filter_congr
intro k _
rw [decide_eq_decide]
exact not_lt.symm
have hCtake : C = A.take q := by
rw [hCdef, hqdef]
exact filter_le_eq_take_countP hAs last
have hqA : q ≤ A.length := by rw [hqdef]; exact List.countP_le_length
have hqC : C.length = q := by
rw [hCtake, List.length_take]
exact Nat.min_eq_left hqA
have hp_le : p ≤ l.length := by rw [hp]; exact List.countP_le_length
have hcB : p = cE + gap := by
rw [hp, hcE, hgapdef]
simpa [cnt, hl] using cnt_eq_add_between (db := db) hEB
have hqN : q + p ≤ l.length := by
have := hqA
rw [hA, List.length_drop] at this
omega
-- filter of a drop of `A`
have hfilter_drop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) =
(A.drop b).take (q - b) := by
have hsplit : A.filter (fun k : Key => decide (k ≤ last)) =
(A.take b).filter (fun k : Key => decide (k ≤ last)) ++
(A.drop b).filter (fun k : Key => decide (k ≤ last)) := by
conv_lhs => rw [← List.take_append_drop b A]
rw [List.filter_append]
have htakeb : (A.take b).filter (fun k : Key => decide (k ≤ last)) =
A.take (min b q) :=
filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hCtake b
have hCtake' : A.filter (fun k : Key => decide (k ≤ last)) = A.take q := hCtake
rw [hCtake', htakeb] at hsplit
have hsplit2 : A.take q = A.take (min b q) ++ (A.take q).drop (min b q) := by
conv_lhs => rw [← List.take_append_drop (min b q) (A.take q)]
rw [List.take_take, Nat.min_eq_left (Nat.min_le_right b q)]
rw [hsplit2] at hsplit
have hdrop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) =
(A.take q).drop (min b q) := (List.append_cancel_left hsplit).symm
have htakeq : (A.take q).drop (min b q) = (A.drop b).take (q - b) := by
by_cases hbq : b ≤ q
· rw [Nat.min_eq_left hbq, List.drop_take]
· have hbq' : q ≤ b := by omega
rw [Nat.min_eq_right hbq', Nat.sub_eq_zero_of_le hbq', List.take_zero]
exact List.drop_eq_nil_of_le (by rw [List.length_take]; exact Nat.min_le_left _ _)
exact hdrop.trans htakeq
have htake_filter : ((A.drop b).take K).filter (fun k : Key => decide (k ≤ last)) =
(A.drop b).take (min K (q - b)) :=
filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hfilter_drop K
have harith : min K (q - b) = L - b := by
rw [hK, hL]
omega
have hAtake : A.take L = C.take L := by
rw [hCtake, List.take_take]
congr 1
exact (Nat.min_eq_left (Nat.min_le_right (e - gap) q)).symm
rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend]
rw [← hl, ← hp, ← hcE, ← hb, ← he]
have hdropA : List.drop (p + b) l = A.drop b := by rw [hA, List.drop_drop]
rw [hdropA, show min (cE + e) l.length - (p + b) = K from rfl]
rw [htake_filter, harith]
rw [← List.drop_take, hAtake, hqC]
end FormalConflictRange
namespace FormalConflictRange
private theorem crossedTrunc_keys_lo_keyAfter_eq_filter_le {db : DB} {lo : WithTop Key} {last :
Key} :
(⟨lo, (keyAfter last : Key)⟩ : ConflictRange).keys db =
(db.keys.filter (fun k : Key => decide (lo ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) := by
unfold ConflictRange.keys
rw [show db.keys.filter (fun (k : Key) => decide (lo ≤ (k : WithTop Key) ∧
(k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) =
db.keys.filter (fun (k : Key) =>
decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) &&
decide (lo ≤ (k : WithTop Key))) from
List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]]
rw [← List.filter_filter]
apply List.filter_congr
intro k _
rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff]
private theorem crossedTrunc_filter_ge_last_eq_filter_of_keys_eq {db : DB} {E B : WithTop Key}
{last : Key}
(hEB : E ≤ B) (_hBlast : B ≤ (last : WithTop Key)) :
(db.keys.filter (fun k : Key => decide (B ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) =
((⟨E, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
(fun k : Key => decide (B ≤ (k : WithTop Key))) := by
rw [crossedTrunc_keys_lo_keyAfter_eq_filter_le]
simp only [List.filter_filter]
apply List.filter_congr
intro k _
simp only [← Bool.decide_and]
rw [decide_eq_decide]
constructor
· rintro ⟨hl, hB⟩
exact ⟨hB, hl, le_trans hEB hB⟩
· rintro ⟨hB, hl, _⟩
exact ⟨hl, hB⟩
private theorem crossedTrunc_between_eq_filter_of_keys_eq {db : DB} {E B : WithTop Key} {last : Key}
(_hEB : E ≤ B) (hBlast : B ≤ (last : WithTop Key)) :
between db E B =
((⟨E, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
(fun k : Key => decide ((k : WithTop Key) < B)) := by
rw [crossedTrunc_keys_lo_keyAfter_eq_filter_le]
simp only [List.filter_filter]
unfold between
rw [show db.keys.filter (fun k : Key => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B)) =
db.keys.filter (fun k : Key => decide ((k : WithTop Key) < B) && decide (E ≤ (k : WithTop
Key))) from
List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]]
apply List.filter_congr
intro k _
simp only [← Bool.decide_and]
rw [decide_eq_decide]
constructor
· rintro ⟨hkB, hE⟩
have hklt : (k : WithTop Key) < (last : WithTop Key) := lt_of_lt_of_le hkB hBlast
exact ⟨hkB, le_of_lt (WithTop.coe_lt_coe.mp hklt), hE⟩
· rintro ⟨hkB, _, hE⟩
exact ⟨hkB, hE⟩
/-- A compatible crossed truncated result reports only keys at or above `begin_.key`,
at any positive begin offset. -/
theorem le_begin_key_of_compatible_crossed_general {db : DB} {r : RangeRead} {res : Result}
(_hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hne : res.keys ≠ [])
(hc : RangeRead.Compatible db r res) :
r.begin.key ≤ (res.keys.getLast hne : WithTop Key) := by
have hmem : res.keys.getLast hne ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hc).subset (List.getLast_mem hne)
exact le_trans (key_le_resolve_of_one_le (db := db) (s := r.begin) hbegin)
(RangeRead.mem_completeKeys.mp hmem).2.1
/-- Agreement on `[r.end_.key, keyAfter last)` fixes the complete keys filtered at or
below `last`, for any positive begin offset on a crossed read with `end_.key ≤
begin_.key`. -/
theorem completeKeys_filter_le_eq_of_agree_crossed_general {r : RangeRead} {last : Key}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
(hEB : r.end_.key ≤ r.begin.key) (hBlast : r.begin.key ≤ (last : WithTop Key))
{db₁ db₂ : DB}
(hagree : (⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db₁ =
(⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db₂) :
(RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last)) =
(RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ last)) := by
let C : DB → List Key := fun db =>
(db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))
let gap : DB → ℕ := fun db => (between db r.end_.key r.begin.key).length
have hC (db : DB) : C db =
((⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
(fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) :=
crossedTrunc_filter_ge_last_eq_filter_of_keys_eq (db := db) hEB hBlast
have hG (db : DB) : between db r.end_.key r.begin.key =
((⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
(fun k : Key => decide ((k : WithTop Key) < r.begin.key)) :=
crossedTrunc_between_eq_filter_of_keys_eq (db := db) hEB hBlast
have hCeq : C db₁ = C db₂ := by
rw [hC db₁, hC db₂, hagree]
have hGeq : gap db₁ = gap db₂ := by
unfold gap
rw [hG db₁, hG db₂, hagree]
have hformula (db : DB) :
(RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) =
((C db).take (min ((r.end_.offset - 1).toNat - gap db) (C db).length)).drop
(r.begin.offset - 1).toNat := by
simpa [C, gap] using completeKeys_filter_le_eq_crossed_general
(db := db) (r := r) (last := last) hrev hbegin hend hEB hBlast
calc
(RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last))
= ((C db₁).take (min ((r.end_.offset - 1).toNat - gap db₁) (C db₁).length)).drop
(r.begin.offset - 1).toNat := hformula db₁
_ = ((C db₂).take (min ((r.end_.offset - 1).toNat - gap db₂) (C db₂).length)).drop
(r.begin.offset - 1).toNat := by rw [hCeq, hGeq]
_ = (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ last)) :=
(hformula db₂).symm
/-- **E-branch soundness for the forward truncated crossed read at any positive begin
offset.** Agreement on `[end_.key, keyAfter (last reported))` fixes the reported prefix
of the complete keys. -/
theorem sound_truncatedRange_of_crossed_E_general {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset) :
Sound r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hlast]
intro db₁ db₂ hagree
constructor
· intro hc₁
have hBlast := le_begin_key_of_compatible_crossed_general (db := db₁) hrev hbegin hne hc₁
have hceq := completeKeys_filter_le_eq_of_agree_crossed_general (r := r)
(last := res.keys.getLast hne) hrev hbegin (by omega) (le_of_lt hcross) hBlast hagree
rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] at hc₁
rw [compatible_iff_truncated_keys (db := db₂) hrev hmore hne]
refine ⟨hc₁.1, ?_⟩
rw [← hceq]
exact hc₁.2
· intro hc₂
have hBlast := le_begin_key_of_compatible_crossed_general (db := db₂) hrev hbegin hne hc₂
have hceq := completeKeys_filter_le_eq_of_agree_crossed_general (r := r)
(last := res.keys.getLast hne) hrev hbegin (by omega) (le_of_lt hcross) hBlast hagree
rw [compatible_iff_truncated_keys (db := db₂) hrev hmore hne] at hc₂
rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne]
refine ⟨hc₂.1, ?_⟩
rw [hceq]
exact hc₂.2
end FormalConflictRange
namespace FormalConflictRange
/-- For a sorted key list, dropping `b` from the prefix at or below `last` is the
same as filtering the dropped tail at or below `last`. -/
theorem filter_drop_eq_drop_filter_le {A : List Key} (hAs : A.SortedLT) (last : Key) (b : ℕ) :
(A.filter (fun k : Key => decide (k ≤ last))).drop b =
(A.drop b).filter (fun k : Key => decide (k ≤ last)) := by
set q := A.countP (fun k : Key => decide (k ≤ last)) with hq
have hqA : q ≤ A.length := by rw [hq]; exact List.countP_le_length
have hC : A.filter (fun k : Key => decide (k ≤ last)) = A.take q := by
rw [hq]; exact filter_le_eq_take_countP hAs last
have hdrop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) =
(A.take q).drop (min b q) := by
have hsplit : A.filter (fun k : Key => decide (k ≤ last)) =
(A.take b).filter (fun k : Key => decide (k ≤ last)) ++
(A.drop b).filter (fun k : Key => decide (k ≤ last)) := by
conv_lhs => rw [← List.take_append_drop b A]
rw [List.filter_append]
have htakeb : (A.take b).filter (fun k : Key => decide (k ≤ last)) =
A.take (min b q) :=
filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hC b
rw [hC, htakeb] at hsplit
have hsplit2 : A.take q = A.take (min b q) ++ (A.take q).drop (min b q) := by
conv_lhs => rw [← List.take_append_drop (min b q) (A.take q)]
rw [List.take_take, Nat.min_eq_left (Nat.min_le_right b q)]
rw [hsplit2] at hsplit
exact (List.append_cancel_left hsplit).symm
rw [hC, hdrop]
by_cases hbq : b ≤ q
· rw [Nat.min_eq_left hbq, List.drop_take]
· have hbq' : q ≤ b := by omega
rw [Nat.min_eq_right hbq']
rw [List.drop_eq_nil_of_le (by rw [List.length_take, Nat.min_eq_left hqA]; exact hbq'),
List.drop_eq_nil_of_le (by rw [List.length_take, Nat.min_eq_left hqA])]
/-- Compatibility with a truncated crossed read is equivalent to the limit and the
begin-offset-dropped truncated range storing exactly the reported keys, provided the
last reported key is strictly below the resolved end. -/
theorem compatible_iff_truncated_drop_of_hlr {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hmore : res.more = true)
(hne : res.keys ≠ [])
(hlr : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_) :
RangeRead.Compatible db r res ↔
RangeRead.withinLimit r res.keys ∧
((truncatedRange r (res.keys.getLast hne)).keys db).drop
(r.begin.offset - 1).toNat = res.keys := by
rw [compatible_iff_truncated_keys (db := db) hrev hmore hne]
have hbridge := completeKeys_filter_le_drop (db := db) (r := r)
(last := res.keys.getLast hne) hrev hbegin hlr
constructor
· rintro ⟨hlim, hfil⟩
exact ⟨hlim, hbridge.symm.trans hfil⟩
· rintro ⟨hlim, hdrop⟩
exact ⟨hlim, hbridge.trans hdrop⟩
/-- **B-branch soundness for the forward truncated crossed read, at any positive begin
offset.** When the gap `[end_.key, begin_.key)` has at least the remaining overshoot
`e - t - (begin.offset - 1)` keys, the truncated range `[begin.key, keyAfter (last
reported))` is sound. -/
theorem sound_truncatedRange_of_crossed_B_general {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.end_.key r.begin.key ≤
(((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞)) :
Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hlast]
set b := (r.begin.offset - 1).toNat with hbdef
intro db₁ db₂ hagree
have keyF (db : DB) (hc : RangeRead.Compatible db r res) :
RangeRead.withinLimit r res.keys ∧
((truncatedRange r (res.keys.getLast hne)).keys db).drop b = res.keys := by
refine ⟨hc.1, ?_⟩
set l := db.keys with hl
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
have hls : l.SortedLT := by rw [hl]; exact db.sorted
have hAs : A.SortedLT := by
rw [hAdef]
exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _)
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc
have hck : RangeRead.completeKeys db r = (A.drop b).take
(min (l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat) l.length
- (l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + b)) := by
simpa [A, b, hl] using completeKeys_eq_filter_ge_drop_take (db := db) (r := r)
hrev hbegin (by omega)
have hpreA : res.keys <+: A.drop b := by
rw [hck] at hpre
exact List.IsPrefix.trans hpre (List.take_prefix _ _)
have hAsDrop : (A.drop b).SortedLT :=
List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := b) hAs.pairwise)
have hfil : (A.drop b).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = res.keys :=
filter_le_getLast_eq_of_prefix hAsDrop.pairwise hpreA hne
have hAeq : db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = A := by
rw [hAdef, hl]
rw [truncatedRange_keys_eq_filter_le, hAeq, filter_drop_eq_drop_filter_le hAs _ b]
exact hfil
have hlrOf (db : DB)
(hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop b = res.keys) :
((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ :=
crossed_truncated_hlr_of_drop hrev hbegin (by omega) hcross hne (by simpa [b] using hcard) hdrop
constructor
· intro hc₁
have hF₁ := keyF db₁ hc₁
have hdrop₂ : ((truncatedRange r (res.keys.getLast hne)).keys db₂).drop b = res.keys := by
rw [← hagree]; exact hF₁.2
exact (compatible_iff_truncated_drop_of_hlr (db := db₂) hrev hbegin hmore hne
(hlrOf db₂ hdrop₂)).mpr ⟨hc₁.1, hdrop₂⟩
· intro hc₂
have hF₂ := keyF db₂ hc₂
have hdrop₁ : ((truncatedRange r (res.keys.getLast hne)).keys db₁).drop b = res.keys := by
rw [hagree]; exact hF₂.2
exact (compatible_iff_truncated_drop_of_hlr (db := db₁) hrev hbegin hmore hne
(hlrOf db₁ hdrop₁)).mpr ⟨hc₂.1, hdrop₁⟩
end FormalConflictRange
namespace FormalConflictRange
/-- Extract the begin-offset padding `P` from a compatible truncated crossed read. -/
theorem crossed_pad_truncated_general {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(_hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ []) (hc : RangeRead.Compatible db r res) :
∃ P : List Key, P.length = (r.begin.offset - 1).toNat ∧ P.SortedLT ∧
(∀ x ∈ P, r.begin.key ≤ (x : WithTop Key)) ∧
(∀ x ∈ P, ∀ y ∈ res.keys, x < y) ∧
(P ++ res.keys).SortedLT := by
set l := db.keys with hl
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
set b := (r.begin.offset - 1).toNat with hb
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
set K := min (l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat) l.length - (p + b) with hK
have hls : l.SortedLT := by rw [hl]; exact db.sorted
have hA : A = l.drop p := by
rw [hAdef]
have hnot : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) =
l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) := by
apply List.filter_congr
intro k _
rw [decide_eq_decide]
exact not_lt.symm
rw [hnot, filter_not_lt_eq_drop_countP hls r.begin.key, ← hp]
have hAs : A.SortedLT := by
rw [hA]
exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise)
have hAge : ∀ x ∈ A, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
rw [hAdef] at hx
exact of_decide_eq_true (List.mem_filter.mp hx).2
have hck : RangeRead.completeKeys db r = (A.drop b).take K := by
rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend]
rw [← hl, ← hp, ← hb, hA, List.drop_drop, hK]
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc
have hpreA : res.keys <+: A.drop b := by
rw [hck] at hpre
exact List.IsPrefix.trans hpre (List.take_prefix _ _)
have hbA : b ≤ A.length := by
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
have := hpreA.length_le
rw [List.length_drop] at this
omega
let P := A.take b
have hPdef : P = A.take b := rfl
have hPlen : P.length = b := by
rw [hPdef, List.length_take, Nat.min_eq_left hbA]
have hPs : P.SortedLT := by
rw [hPdef]
exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := b)
(List.sortedLT_iff_pairwise.mp hAs))
have hPge : ∀ x ∈ P, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
exact hAge x (List.take_subset _ _ (by rw [← hPdef]; exact hx))
have happend : A = P ++ A.drop b := by rw [hPdef, List.take_append_drop]
have hcrossA : ∀ x ∈ P, ∀ y ∈ A.drop b, x < y := by
have := List.sortedLT_append.mp (by rw [← happend]; exact hAs)
exact this.2.2
have hP_lt_res : ∀ x ∈ P, ∀ y ∈ res.keys, x < y := by
intro x hx y hy
exact hcrossA x hx y (hpreA.subset hy)
have hresS : res.keys.SortedLT := RangeRead.compatible_sortedLT hc hrev
refine ⟨P, ?_, hPs, hPge, hP_lt_res, ?_⟩
· rw [hPlen, hb]
· exact List.sortedLT_append.mpr ⟨hPs, hresS, hP_lt_res⟩
end FormalConflictRange
namespace FormalConflictRange
private theorem crossedTrunc_enat_succ_le_of_lt {s : ℕ} {h : ℕ∞} (hs : (s : ℕ∞) < h) :
((s + 1 : ℕ) : ℕ∞) ≤ h := by
cases h with
| top => exact le_top
| coe n =>
rw [ENat.natCast_lt_natCast] at hs
exact_mod_cast Nat.succ_le_of_lt hs
/-- **Gap-key necessity for the forward truncated crossed read at any positive begin
offset.** When the gap is too small to absorb `e - t - b`, every key in
`[end_.key, begin_.key)` is necessary. -/
theorem necessary_of_mem_gap_crossed_truncated_general {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
(hlt : (((r.end_.offset - 1).toNat - res.keys.length -
(r.begin.offset - 1).toNat : ℕ) : ℕ∞) < intervalCard r.end_.key r.begin.key)
(hkE : r.end_.key ≤ (k : WithTop Key))
(hkB : (k : WithTop Key) < r.begin.key) :
Necessary r res k := by
set t : ℕ := res.keys.length with htdef
set eo : ℕ := (r.end_.offset - 1).toNat with heodef
set b : ℕ := (r.begin.offset - 1).toNat with hbdef
set s : ℕ := eo - t - b with hsdef
obtain ⟨db₀, hcomp₀⟩ := hread
have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r :=
RangeRead.compatible_keys_prefix hcomp₀
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
have hmem : x ∈ RangeRead.completeKeys db₀ r := hpre₀.subset hx
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin)
(RangeRead.mem_completeKeys.mp hmem).2.1
have hlast_ge_B : r.begin.key ≤ (res.keys.getLast hne : WithTop Key) :=
hall_ge _ (List.getLast_mem hne)
have hgap : (between db₀ r.end_.key r.begin.key).length + b + t ≤ eo := by
have := compatible_gap_bound (db := db₀) hrev hmore hne hbegin (by omega) hcross hcomp₀
simpa [hbdef, htdef, heodef] using this
have hbt : b + t ≤ eo := by omega
have hse : eo = s + t + b := by rw [hsdef]; omega
have hcard : ((s + 1 : ℕ) : ℕ∞) ≤ intervalCard r.end_.key r.begin.key :=
crossedTrunc_enat_succ_le_of_lt (s := s)
(by simpa [s, htdef, heodef, hbdef] using hlt)
obtain ⟨dbH, hHrange, hkH, hHlen⟩ :=
exists_db_keysIn_avoid (B := r.end_.key) (E := r.begin.key) (k := k) (m := s) hcard
have hHgeE : ∀ x ∈ dbH.keys, r.end_.key ≤ (x : WithTop Key) :=
fun x hx => (hHrange x hx).1
have hHltB : ∀ x ∈ dbH.keys, (x : WithTop Key) < r.begin.key :=
fun x hx => (hHrange x hx).2
obtain ⟨P, hPlen, hPs, hPge, hPlt, hPsortPR⟩ :=
crossed_pad_truncated_general (db := db₀) hrev hbegin hcross (by omega) hne hcomp₀
have hPlen' : P.length = b := by simpa [hbdef] using hPlen
have hPge' : ∀ x ∈ P, r.begin.key ≤ (x : WithTop Key) := by
intro x hx; simpa using hPge x hx
have hH_lt_P : ∀ x ∈ dbH.keys, ∀ y ∈ P, x < y := by
intro x hx y hy
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltB x hx) (hPge' y hy))
obtain ⟨C, hCge, hCnotin⟩ :=
exists_le_not_mem (res.keys ++ dbH.keys) (res.keys.getLast hne)
have hCnotres : C ∉ res.keys := fun h => hCnotin (List.mem_append_left _ h)
have hCnotH : C ∉ dbH.keys := fun h => hCnotin (List.mem_append_right _ h)
have hCgtRes : ∀ a ∈ res.keys, a < C := by
intro a ha
have hle : a ≤ res.keys.getLast hne :=
(hsort.pairwise.imp le_of_lt).rel_getLast ha
exact lt_of_le_of_ne (le_trans hle hCge) (fun h => hCnotres (h ▸ ha))
have hHltC : ∀ a ∈ dbH.keys, a < C := by
intro a ha
have h1 : (a : WithTop Key) < (C : WithTop Key) :=
lt_of_lt_of_le (hHltB a ha)
(le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
exact WithTop.coe_lt_coe.mp h1
have hHP : (dbH.keys ++ P).SortedLT :=
List.sortedLT_append.mpr ⟨dbH.sorted, hPs, hH_lt_P⟩
have hHPres_lt : ∀ x ∈ (dbH.keys ++ P), ∀ y ∈ res.keys, x < y := by
intro x hx y hy
rcases List.mem_append.mp hx with hxH | hxP
· exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltB x hxH) (hall_ge y hy))
· exact hPlt x hxP y hy
have hHPres : (dbH.keys ++ P ++ res.keys).SortedLT :=
List.sortedLT_append.mpr ⟨hHP, hsort, hHPres_lt⟩
have hsingle : ([C] : List Key).SortedLT := by
rw [List.sortedLT_cons]
exact ⟨by simp, List.sortedLT_nil⟩
have hcrossList : ∀ a ∈ (dbH.keys ++ P ++ res.keys), ∀ y ∈ ([C] : List Key), a < y := by
intro a ha y hy
rw [List.mem_singleton] at hy
subst hy
rcases List.mem_append.mp ha with ha' | haR
· rcases List.mem_append.mp ha' with haH | haP
· exact hHltC a haH
· exact lt_of_lt_of_le (hPlt a haP _ (List.getLast_mem hne)) hCge
· exact hCgtRes a haR
have hsort₂ : (dbH.keys ++ P ++ res.keys ++ [C]).SortedLT :=
List.sortedLT_append.mpr ⟨hHPres, hsingle, hcrossList⟩
let db₂ : DB := ⟨dbH.keys ++ P ++ res.keys ++ [C], hsort₂⟩
have hdb₂ : db₂.keys = dbH.keys ++ P ++ res.keys ++ [C] := rfl
have hfil₂ : db₂.keys.filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P ++ res.keys ++ [C] := by
rw [hdb₂, List.filter_append, List.filter_append, List.filter_append]
have hHf : dbH.keys.filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_le.mpr (hHltB x hx)
have hPf : P.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact hPge' x hx
have hresf : res.keys.filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact hall_ge x hx
have hCf : ([C] : List Key).filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = [C] := by
rw [List.filter_eq_self]
intro x hx
rw [List.mem_singleton] at hx
subst hx
rw [decide_eq_true_eq]
exact le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge)
rw [hHf, hPf, hresf, hCf]
simp
have hcE₂ : cnt db₂ r.end_.key = 0 := by
apply cnt_eq_zero_of_forall_ge
intro x hx
rw [hdb₂] at hx
rcases List.mem_append.mp hx with hx' | hxC
· rcases List.mem_append.mp hx' with hx'' | hxR
· rcases List.mem_append.mp hx'' with hxH | hxP
· exact hHgeE x hxH
· exact le_trans (le_of_lt hcross) (hPge' x hxP)
· exact le_trans (le_of_lt hcross) (hall_ge x hxR)
· rw [List.mem_singleton] at hxC
subst hxC
exact le_trans (le_of_lt hcross)
(le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
have hcB₂ : cnt db₂ r.begin.key = s := by
change db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = s
rw [hdb₂, List.countP_append, List.countP_append, List.countP_append]
have hHc : dbH.keys.countP
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = dbH.keys.length :=
cnt_eq_length_of_forall_lt dbH hHltB
have hPc : P.countP
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hPge' x hx)
have hresc : res.keys.countP
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hall_ge x hx)
have hCc : ([C] : List Key).countP
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [List.mem_singleton] at hx
subst hx
rw [decide_eq_true_eq]
exact not_lt.mpr (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
rw [hHc, hPc, hresc, hCc, hHlen]
simp
have hn₂ : db₂.keys.length = s + b + t + 1 := by
rw [hdb₂, List.length_append, List.length_append, List.length_append,
hHlen, hPlen', htdef, List.length_singleton]
have hdropP : (P ++ res.keys ++ [C]).drop b = res.keys ++ [C] := by
have hbP : b = P.length := hPlen'.symm
rw [hbP, List.append_assoc]
rw [List.drop_append_of_le_length le_rfl, List.drop_length]
simp
have hck₂ : RangeRead.completeKeys db₂ r = res.keys := by
rw [completeKeys_eq_filter_ge_drop_take (db := db₂) (r := r) hrev hbegin (by omega),
hfil₂, hdropP]
have hK : min (cnt db₂ r.end_.key + (r.end_.offset - 1).toNat) db₂.keys.length -
(cnt db₂ r.begin.key + b) = t := by
have hE : (r.end_.offset - 1).toNat = eo := heodef.symm
rw [hcE₂, hcB₂, hn₂, hE, hse]
rw [Nat.min_eq_left (by omega)]
omega
have hK' : min (db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat) db₂.keys.length -
(db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) + b) = t := by
simpa [cnt] using hK
rw [hK', List.take_append_of_le_length (le_of_eq htdef), htdef, List.take_length]
have hcomp₂ : RangeRead.Compatible db₂ r res := by
refine ⟨hcomp₀.1, Or.inl ⟨hmore, ?_, hne⟩⟩
rw [hck₂]
have hk_db₂ : k ∉ db₂.keys := by
rw [hdb₂]
intro hmem
rcases List.mem_append.mp hmem with hmem' | hmemC
· rcases List.mem_append.mp hmem' with hmem'' | hmemR
· rcases List.mem_append.mp hmem'' with hmemH | hmemP
· exact hkH hmemH
· exact absurd (hPge' k hmemP) (not_le.mpr hkB)
· exact absurd (hall_ge k hmemR) (not_le.mpr hkB)
· rw [List.mem_singleton] at hmemC
have hkC : k = C := hmemC
have h1 : (k : WithTop Key) < (C : WithTop Key) :=
lt_of_lt_of_le hkB (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
rw [hkC] at h1
exact (lt_irrefl (C : WithTop Key)) h1
let db₁ : DB := db₂.insert k hk_db₂
have hcE₁ : cnt db₁ r.end_.key = 0 := by
rw [show db₁ = db₂.insert k hk_db₂ from rfl,
cnt_insert_not_lt db₂ k hk_db₂ (v := r.end_.key) (not_lt.mpr hkE)]
exact hcE₂
have hcB₁ : cnt db₁ r.begin.key = s + 1 := by
rw [show db₁ = db₂.insert k hk_db₂ from rfl,
cnt_insert_lt db₂ k hk_db₂ (v := r.begin.key) hkB, hcB₂]
have hn₁ : db₁.keys.length = s + b + t + 2 := by
rw [show db₁ = db₂.insert k hk_db₂ from rfl, DB.insert_keys,
List.orderedInsert_length, hn₂]
have hfil₁ : db₁.keys.filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P ++ res.keys ++ [C] := by
have hsingle_filter : List.filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) (k :: db₂.keys) =
db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) := by
rw [List.filter_cons]
have hkf : decide (r.begin.key ≤ (k : WithTop Key)) = false := by
rw [decide_eq_false_iff_not]
exact not_le.mpr hkB
rw [hkf]
rfl
have hperm : List.Perm ((List.orderedInsert (· ≤ ·) k db₂.keys).filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))))
(db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))) := by
have h := (List.perm_orderedInsert (· ≤ ·) k db₂.keys).filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))
rwa [hsingle_filter] at h
have hs₁ : ((List.orderedInsert (· ≤ ·) k db₂.keys).filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))).SortedLT :=
List.sortedLT_iff_pairwise.mpr ((db₂.insert k hk_db₂).sorted.pairwise.filter _)
have hs₂ : (db₂.keys.filter
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _)
rw [show db₁ = db₂.insert k hk_db₂ from rfl, DB.insert_keys]
exact (List.SortedLT.eq_of_mem_iff hs₁ hs₂ (fun x => hperm.mem_iff)).trans hfil₂
have hck₁ : RangeRead.completeKeys db₁ r = res.keys.take (t - 1) := by
rw [completeKeys_eq_filter_ge_drop_take (db := db₁) (r := r) hrev hbegin (by omega),
hfil₁, hdropP]
have hK : min (cnt db₁ r.end_.key + (r.end_.offset - 1).toNat) db₁.keys.length -
(cnt db₁ r.begin.key + b) = t - 1 := by
have hE : (r.end_.offset - 1).toNat = eo := heodef.symm
rw [hcE₁, hcB₁, hn₁, hE, hse]
rw [Nat.min_eq_left (by omega)]
omega
have hK' : min (db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat) db₁.keys.length -
(db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) + b) = t - 1 :=
by
simpa [cnt] using hK
rw [hK', List.take_append_of_le_length (by omega : t - 1 ≤ res.keys.length)]
have hnot₁ : ¬ RangeRead.Compatible db₁ r res := by
intro hc
rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] at hc
rw [hck₁] at hc
have hf : List.filter (fun k : Key => decide (k ≤ res.keys.getLast hne))
(res.keys.take (t - 1)) = res.keys.take (t - 1) := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.mem_of_mem_take hx)
rw [hf] at hc
have heq : res.keys.take (t - 1) = res.keys := hc.2
have hlen := congrArg List.length heq
rw [List.length_take, htdef] at hlen
have htpos : 0 < t := by rw [htdef]; exact List.length_pos_of_ne_nil hne
omega
intro cr hs
by_contra hkcr
have hagree : AgreeOn cr db₂ db₁ :=
(ConflictRange.keys_insert_of_not_mem cr db₂ hk_db₂ hkcr).symm
exact hnot₁ ((hs db₂ db₁ hagree).mp hcomp₂)
end FormalConflictRange
namespace FormalConflictRange
private theorem crossedTrunc_begin_key_exists_coe {r : RangeRead}
(h : r.begin.key ≠ (⊤ : WithTop Key)) :
∃ v : Key, r.begin.key = (↑v : WithTop Key) := by
cases hk : r.begin.key with
| top => exact absurd hk h
| coe v => exact ⟨v, rfl⟩
/-- **Large-gap branch minimality for the forward truncated crossed read at any positive
begin offset.** -/
theorem minimal_truncatedRange_of_crossed_B_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
(hbig : intervalCard r.end_.key r.begin.key ≤
(((r.end_.offset - 1).toNat - res.keys.length -
(r.begin.offset - 1).toNat : ℕ) : ℕ∞)) :
Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hlast]
rw [minimal_iff_sound_and_necessaryRange]
refine ⟨?_, ?_⟩
· have hs := sound_truncatedRange_of_crossed_B_general (r := r) (res := res)
hrev hmore hne hbegin hcross hend hbig
rwa [hlast] at hs
· intro k hkB hklt
have hklast : k ≤ res.keys.getLast hne :=
(lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hklt)
obtain ⟨db₀, hcomp₀⟩ := hread
have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
have hmem : x ∈ RangeRead.completeKeys db₀ r :=
(RangeRead.compatible_keys_prefix hcomp₀).subset hx
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin)
(RangeRead.mem_completeKeys.mp hmem).2.1
have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
obtain ⟨x, hx⟩ : ∃ x, x ∈ res.keys := by
cases h : res.keys with
| nil => exact absurd h hne
| cons a tl => exact ⟨a, by simp⟩
have h1 : r.begin.key ≤ (x : WithTop Key) := hall_ge x hx
intro htop
rw [htop] at h1
exact not_le.mpr (WithTop.coe_lt_top x) h1
obtain ⟨v, hv⟩ := crossedTrunc_begin_key_exists_coe hbk_ne_top
have hbegin_nec : Necessary r res v :=
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv
have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hkB)
have hlast_nec : Necessary r res (res.keys.getLast hne) :=
necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)
exact hbegin_nec.of_between hlast_nec hvk hklast
/-- **Small-gap branch minimality for the forward truncated crossed read at any positive
begin offset.** -/
theorem minimal_truncatedForward_of_crossed_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
(hsmall : (((r.end_.offset - 1).toNat - res.keys.length -
(r.begin.offset - 1).toNat : ℕ) : ℕ∞) < intervalCard r.end_.key r.begin.key) :
Minimal r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hlast]
rw [minimal_iff_sound_and_necessaryRange]
refine ⟨?_, ?_⟩
· have hs := sound_truncatedRange_of_crossed_E_general (r := r) (res := res)
hrev hmore hne hbegin hcross hend
rwa [hlast] at hs
· intro k hkE hklt
have hklast : k ≤ res.keys.getLast hne :=
(lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hklt)
by_cases hkB : (k : WithTop Key) < r.begin.key
· exact necessary_of_mem_gap_crossed_truncated_general hread hmore hrev hne hbegin
hcross hend hsmall hkE hkB
· have hkBle : r.begin.key ≤ (k : WithTop Key) := not_lt.mp hkB
obtain ⟨db₀, hcomp₀⟩ := hread
have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
have hmem : x ∈ RangeRead.completeKeys db₀ r :=
(RangeRead.compatible_keys_prefix hcomp₀).subset hx
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin)
(RangeRead.mem_completeKeys.mp hmem).2.1
have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
obtain ⟨x, hx⟩ : ∃ x, x ∈ res.keys := by
cases h : res.keys with
| nil => exact absurd h hne
| cons a tl => exact ⟨a, by simp⟩
have h1 : r.begin.key ≤ (x : WithTop Key) := hall_ge x hx
intro htop
rw [htop] at h1
exact not_le.mpr (WithTop.coe_lt_top x) h1
obtain ⟨v, hv⟩ := crossedTrunc_begin_key_exists_coe hbk_ne_top
have hbegin_nec : Necessary r res v :=
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv
have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hkBle)
have hlast_nec : Necessary r res (res.keys.getLast hne) :=
necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)
exact hbegin_nec.of_between hlast_nec hvk hklast
/-- The forward truncated crossed closed form at any positive begin offset. -/
noncomputable def truncatedForwardCrossedGeneral (r : RangeRead) (res : Result) : ConflictRange :=
if intervalCard r.end_.key r.begin.key ≤
(((r.end_.offset - 1).toNat - res.keys.length -
(r.begin.offset - 1).toNat : ℕ) : ℕ∞) then
truncatedRange r (res.keys.getLastD ([] : Key))
else
⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
/-- The forward truncated crossed closed form is minimal on the whole region. -/
theorem minimal_truncatedForwardCrossedGeneral {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) :
Minimal r res (truncatedForwardCrossedGeneral r res) := by
unfold truncatedForwardCrossedGeneral
by_cases hbig : intervalCard r.end_.key r.begin.key ≤
(((r.end_.offset - 1).toNat - res.keys.length -
(r.begin.offset - 1).toNat : ℕ) : ℕ∞)
· rw [ite_eq_left hbig]
exact minimal_truncatedRange_of_crossed_B_general hread hmore hrev hne hbegin hcross hend hbig
· rw [ite_eq_right hbig]
exact minimal_truncatedForward_of_crossed_general hread hmore hrev hne hbegin hcross hend
(not_le.mp hbig)
/-- The forward truncated crossed general rule denotes the general conflict range. -/
theorem truncatedForwardCrossedGeneral_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) :
(truncatedForwardCrossedGeneral r res).toSet = (conflictRangeGeneral r res).toSet :=
(minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcross hend).toSet_eq
(conflictRangeGeneral_minimal hread)
/-- The same identification with the executable algorithm. -/
theorem truncatedForwardCrossedGeneral_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) :
(truncatedForwardCrossedGeneral r res).toSet = (simpleConflictRange r res).toSet :=
(minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcross hend).toSet_eq
(simpleConflictRange_minimal hread)
end FormalConflictRange