- 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.
983 lines
50 KiB
Lean4
983 lines
50 KiB
Lean4
/-
|
||
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
|
||
Released under Apache 2.0 license as described in the file LICENSE.
|
||
Authors: FormalConflictRange contributors
|
||
-/
|
||
|
||
import FormalConflictRange.CrossedRev
|
||
import FormalConflictRange.CrossedTruncatedGeneral
|
||
|
||
/-!
|
||
# Crossed reversed truncated reads at every positive begin offset
|
||
|
||
This module extends `CrossedRev` from begin offset one to every positive begin offset.
|
||
With `E = end_.key`, `B = begin_.key`, `e = (end_.offset - 1).toNat`,
|
||
`b = (begin.offset - 1).toNat`, and `g` the number of stored keys in `[E, B)`, the
|
||
complete window of a crossed reversed read is the reversed block
|
||
`((above db E).take e).drop (g + b)`.
|
||
-/
|
||
|
||
open FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- Taking `min e |l| - g` after dropping `g` is the same as dropping `g` after
|
||
taking `e`. -/
|
||
theorem take_sub_drop_gen {α : Type*} (l : List α) (e g : Nat) :
|
||
(l.drop g).take (min e l.length - g) = (l.take e).drop g := by
|
||
rw [List.drop_take, List.take_eq_take_iff]
|
||
simp only [List.length_drop]
|
||
omega
|
||
|
||
/-- The complete keys of a crossed reversed read at a positive begin offset are the
|
||
reversed block of the keys at or above `end_.key`, with the gap and the first
|
||
`begin.offset - 1` keys dropped. -/
|
||
theorem completeKeys_crossed_rev_eq_general {db : DB} {r : RangeRead}
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
|
||
RangeRead.completeKeys db r =
|
||
(((above db r.end_.key).take ((r.end_.offset - 1).toNat)).drop
|
||
((between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat)).reverse := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set B : WithTop Key := r.begin.key with hB
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set g : Nat := (between db E B).length with hg
|
||
have hEB : E ≤ B := le_of_lt hcross
|
||
have hfwd : RangeRead.completeKeys db r =
|
||
(((above db B).drop b).take
|
||
(min (cnt db E + e) db.keys.length - (cnt db B + b))).reverse := by
|
||
rw [completeKeys_rev_eq_reverse db r hrev]
|
||
rw [completeKeys_eq_filter_ge_drop_take (db := db)
|
||
(r := { r with reverse := false }) (by simp) hbegin hend]
|
||
have hfilB : db.keys.filter (fun k : Key =>
|
||
decide (({ r with reverse := false } : RangeRead).begin.key ≤
|
||
(k : WithTop Key))) = above db B := rfl
|
||
rw [hfilB]
|
||
simp only [cnt, hE, hB, he, hb]
|
||
have hp : cnt db B = cnt db E + g := by
|
||
rw [hg, hB, hE]
|
||
simpa using cnt_eq_add_between (db := db) hEB
|
||
have hlenE : (above db E).length = db.keys.length - cnt db E := by
|
||
rw [← cnt_add_above_length db E]
|
||
omega
|
||
have hcalc : min (cnt db E + e) db.keys.length - (cnt db B + b) =
|
||
min e (above db E).length - (g + b) := by
|
||
rw [hp, hlenE]
|
||
omega
|
||
rw [hfwd, hcalc, above_eq_drop_between (db := db) hEB, List.drop_drop,
|
||
take_sub_drop_gen]
|
||
|
||
/-- A compatible crossed reversed result has all reported keys at or above
|
||
`begin.key`, at every positive begin offset. -/
|
||
theorem crossed_rev_res_ge_begin_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hc : RangeRead.Compatible db r res) (hbegin : 1 ≤ r.begin.offset) :
|
||
∀ k ∈ res.keys, r.begin.key ≤ (k : WithTop Key) := by
|
||
intro k hk
|
||
have hmem := (RangeRead.compatible_keys_prefix hc).subset hk
|
||
exact le_trans (key_le_resolve_of_one_le (db := db) (s := r.begin) hbegin)
|
||
(RangeRead.mem_completeKeys.mp hmem).2.1
|
||
|
||
/-- A compatible crossed reversed result at a positive begin offset has all reported
|
||
keys at or above `end_.key`. -/
|
||
theorem crossed_rev_res_ge_end_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hc : RangeRead.Compatible db r res)
|
||
(_hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (_hend : 1 ≤ r.end_.offset) :
|
||
∀ k ∈ res.keys, r.end_.key ≤ (k : WithTop Key) := by
|
||
intro k hk
|
||
have hge := crossed_rev_res_ge_begin_general hc hbegin k hk
|
||
exact le_trans (le_of_lt hcross) hge
|
||
|
||
/-- In a crossed reversed result at a positive begin offset every reported key is at
|
||
or above `end_.key`, so the count at or above `end_.key` is the number of reported
|
||
keys. -/
|
||
theorem crossed_rev_count_ge_eq_length_general {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hread : Readable r res) :
|
||
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
|
||
res.keys.length := by
|
||
obtain ⟨db, hc⟩ := hread
|
||
rw [List.countP_eq_length]
|
||
intro k hk
|
||
rw [decide_eq_true_eq]
|
||
exact crossed_rev_res_ge_end_general hc hrev hbegin hcross hend k hk
|
||
|
||
/-- Agreement on the keys at or above `end_.key` fixes the complete keys of a crossed
|
||
reversed read at a positive begin offset. -/
|
||
theorem completeKeys_eq_of_agree_above_crossed_rev_general {db₁ db₂ : DB}
|
||
{r : RangeRead}
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(habove : above db₁ r.end_.key = above db₂ r.end_.key) :
|
||
RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
have hB (db : DB) : above db r.begin.key = (above db E).drop (between db E r.begin.key).length :=
|
||
above_eq_drop_between (le_of_lt hcross)
|
||
have hg_eq : (between db₁ E r.begin.key).length =
|
||
(between db₂ E r.begin.key).length := by
|
||
rw [between_eq_filter_above (db := db₁) E r.begin.key,
|
||
between_eq_filter_above (db := db₂) E r.begin.key, habove]
|
||
have hlen : (above db₁ E).length = (above db₂ E).length := by rw [habove]
|
||
rw [completeKeys_crossed_rev_eq_general (db := db₁) hrev hbegin hcross hend,
|
||
completeKeys_crossed_rev_eq_general (db := db₂) hrev hbegin hcross hend,
|
||
habove, hg_eq]
|
||
|
||
/-- Soundness of the unbounded top crossed reversed branch at a positive begin offset:
|
||
agreement on `[end_.key, ⊤)` fixes the complete keys. -/
|
||
theorem sound_truncatedRevCrossed_top_general {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
|
||
Sound r res ⟨r.end_.key, ⊤⟩ := by
|
||
intro db₁ db₂ hagree
|
||
have habove : above db₁ r.end_.key = above db₂ r.end_.key := by
|
||
have h := hagree
|
||
rw [AgreeOn] at h
|
||
simpa [ConflictRange.keys, above] using h
|
||
have hck := completeKeys_eq_of_agree_above_crossed_rev_general (db₁ := db₁)
|
||
(db₂ := db₂) hrev hbegin hcross hend habove
|
||
constructor
|
||
· intro hc
|
||
simpa [RangeRead.Compatible, hck] using hc
|
||
· intro hc
|
||
simpa [RangeRead.Compatible, hck] using hc
|
||
|
||
/-- In the finite branch `t + (begin.offset - 1) = (end.offset - 1)` of a crossed
|
||
reversed truncated read, the complete keys are exactly the reported keys. -/
|
||
theorem completeKeys_eq_res_of_crossed_rev_finite_general {db : DB} {r : RangeRead}
|
||
{res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (_hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
RangeRead.completeKeys db r = res.keys := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
set g : Nat := (between db E r.begin.key).length with hg
|
||
have hformula : RangeRead.completeKeys db r = ((lE.take e).drop (g + b)).reverse := by
|
||
simpa [E, e, b, lE, g] using
|
||
completeKeys_crossed_rev_eq_general (db := db) (r := r) hrev hbegin hcross hend
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r :=
|
||
RangeRead.compatible_keys_prefix hcomp
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have hlen : (RangeRead.completeKeys db r).length = min e lE.length - (g + b) := by
|
||
rw [hformula, List.length_reverse, List.length_drop, List.length_take]
|
||
have htle : res.keys.length ≤ min e lE.length - (g + b) := by
|
||
rw [← hlen]; exact hpre.length_le
|
||
have htle' : res.keys.length + (g + b) ≤ e := by
|
||
have h1 : min e lE.length ≤ e := Nat.min_le_left _ _
|
||
have h2 : res.keys.length ≤ min e lE.length - (g + b) := htle
|
||
omega
|
||
have hlelen : res.keys.length + b ≤ lE.length := by
|
||
have h1 : min e lE.length ≤ lE.length := Nat.min_le_right _ _
|
||
have h2 := htle
|
||
omega
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
have hg0 : g = 0 := by omega
|
||
have he_le : e ≤ lE.length := by rw [← htb]; exact hlelen
|
||
have hmin : min e lE.length = e := Nat.min_eq_left he_le
|
||
have hlen' : (RangeRead.completeKeys db r).length = res.keys.length := by
|
||
rw [hlen, hg0, hmin]; omega
|
||
exact (hpre.eq_of_length hlen'.symm).symm
|
||
|
||
/-- If a sorted list has exactly `e` elements at or below `H`, its first `e` elements
|
||
are those elements. -/
|
||
theorem take_eq_filter_le_of_length {l : List Key} (hs : l.SortedLT) {H : Key} {e : Nat}
|
||
(h : (l.filter (fun k : Key => decide (k ≤ H))).length = e) :
|
||
l.take e = l.filter (fun k : Key => decide (k ≤ H)) := by
|
||
rw [filter_le_eq_take_countP hs H]
|
||
have hc : l.countP (fun k : Key => decide (k ≤ H)) = e := by
|
||
rw [List.countP_eq_length_filter]; exact h
|
||
rw [hc]
|
||
|
||
/-- In the finite branch, filtering the keys at or above `end_.key` at or below the
|
||
reported head gives the first `e` of them. -/
|
||
theorem crossed_rev_finite_above_filter_eq_take_general {db : DB} {r : RangeRead}
|
||
{res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
(above db r.end_.key).filter
|
||
(fun k : Key => decide (k ≤ res.keys.head hne)) =
|
||
(above db r.end_.key).take ((r.end_.offset - 1).toNat) := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
set g : Nat := (between db E r.begin.key).length with hg
|
||
set H : Key := res.keys.head hne with hHdef
|
||
have hck := completeKeys_eq_res_of_crossed_rev_finite_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
have hformula : RangeRead.completeKeys db r = ((lE.take e).drop (g + b)).reverse := by
|
||
simpa [E, e, b, lE, g] using
|
||
completeKeys_crossed_rev_eq_general (db := db) (r := r) hrev hbegin hcross hend
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r :=
|
||
RangeRead.compatible_keys_prefix hcomp
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have hlen : (RangeRead.completeKeys db r).length = min e lE.length - (g + b) := by
|
||
rw [hformula, List.length_reverse, List.length_drop, List.length_take]
|
||
have htle : res.keys.length ≤ min e lE.length - (g + b) := by
|
||
rw [← hlen]; exact hpre.length_le
|
||
have hlelen : res.keys.length + b ≤ lE.length := by
|
||
have h1 : min e lE.length ≤ lE.length := Nat.min_le_right _ _
|
||
have h2 := htle
|
||
omega
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
have hg0 : g = 0 := by
|
||
have h1 : min e lE.length ≤ e := Nat.min_le_left _ _
|
||
omega
|
||
have he_le : e ≤ lE.length := by rw [← htb]; exact hlelen
|
||
have hmin : min e lE.length = e := Nat.min_eq_left he_le
|
||
have hwin : (lE.take e).drop b = res.keys.reverse := by
|
||
have h := congrArg List.reverse hck
|
||
rw [hformula, hg0, Nat.zero_add] at h
|
||
rw [List.reverse_reverse] at h
|
||
exact h
|
||
have hb_lt_e : b < e := by omega
|
||
have htake_len : (lE.take e).length = e := by rw [List.length_take, hmin]
|
||
have htakene : lE.take e ≠ [] := List.ne_nil_of_length_pos (by rw [htake_len]; omega)
|
||
have hdropne : (lE.take e).drop b ≠ [] := by
|
||
apply List.ne_nil_of_length_pos
|
||
rw [List.length_drop, htake_len]
|
||
omega
|
||
have hHlast : H = (lE.take e).getLast htakene := by
|
||
rw [hHdef]
|
||
have hrevne : res.keys.reverse ≠ [] := by rwa [List.reverse_ne_nil_iff]
|
||
have h1 : res.keys.head hne = (res.keys.reverse).getLast hrevne :=
|
||
(List.getLast_reverse hrevne).symm
|
||
rw [h1]
|
||
exact (List.getLast_congr hrevne hdropne hwin.symm).trans (List.getLast_drop hdropne)
|
||
have hHidx : H = lE[e - 1]'(by omega) := by
|
||
rw [hHlast, List.getLast_take]
|
||
rw [List.getElem?_eq_getElem (by omega)]
|
||
simp
|
||
have hsE : lE.SortedLT := by
|
||
rw [hlE]
|
||
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
|
||
have hfilter := filter_le_getElem_eq_take (A := lE) hsE (b := 0) (t := e)
|
||
(by omega) (by simpa using he_le)
|
||
have hfilter' : lE.filter (fun k : Key => decide (k ≤ H)) = lE.take e := by
|
||
rw [hHidx]
|
||
simpa [Nat.zero_add] using hfilter
|
||
simpa using hfilter'
|
||
|
||
/-- In the finite branch the gap `[end_.key, begin_.key)` stores no key. -/
|
||
theorem crossed_rev_finite_gap_eq_zero_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (_hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
(between db r.end_.key r.begin.key).length = 0 := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set g : Nat := (between db E r.begin.key).length with hg
|
||
set lE : List Key := above db E with hlE
|
||
have hformula : RangeRead.completeKeys db r = ((lE.take e).drop (g + b)).reverse := by
|
||
simpa [E, e, b, lE, g] using
|
||
completeKeys_crossed_rev_eq_general (db := db) (r := r) hrev hbegin hcross hend
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r :=
|
||
RangeRead.compatible_keys_prefix hcomp
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have hlen : (RangeRead.completeKeys db r).length = min e lE.length - (g + b) := by
|
||
rw [hformula, List.length_reverse, List.length_drop, List.length_take]
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
have htle : res.keys.length ≤ min e lE.length - (g + b) := by
|
||
rw [← hlen]; exact hpre.length_le
|
||
have hmin : min e lE.length ≤ e := Nat.min_le_left _ _
|
||
have hkeyle : res.keys.length ≤ e - (g + b) :=
|
||
le_trans htle (Nat.sub_le_sub_right hmin (g + b))
|
||
omega
|
||
|
||
/-- Agreement on `[E, keyAfter H)` is agreement on the keys at or above `E` and at or
|
||
below `H`. -/
|
||
theorem agreeOn_keys_eq_filter_le {E : WithTop Key} {H : Key} {d1 d2 : DB}
|
||
(hag : AgreeOn (⟨E, ((keyAfter H : Key) : WithTop Key)⟩ : ConflictRange) d1 d2) :
|
||
(above d1 E).filter (fun k : Key => decide (k ≤ H)) =
|
||
(above d2 E).filter (fun k : Key => decide (k ≤ H)) := by
|
||
have hmk (d : DB) :
|
||
(⟨E, ((keyAfter H : Key) : WithTop Key)⟩ : ConflictRange).keys d =
|
||
(above d E).filter (fun k : Key => decide (k ≤ H)) := by
|
||
rw [ConflictRange.keys_eq_inRange]
|
||
unfold RangeRead.inRange above
|
||
rw [List.filter_filter]
|
||
apply List.filter_congr
|
||
intro k _
|
||
by_cases hE : E ≤ (k : WithTop Key) <;> by_cases hk : k ≤ H <;>
|
||
simp [hE, hk, WithTop.coe_lt_coe, lt_keyAfter_iff]
|
||
have h := hag
|
||
rw [AgreeOn, hmk d1, hmk d2] at h
|
||
exact h
|
||
|
||
/-- In the finite branch, agreement on `[end_.key, keyAfter (head reported))` fixes the
|
||
complete keys, hence soundness of the finite crossed reversed candidate. -/
|
||
theorem sound_truncatedRevCrossed_finite_general {r : RangeRead} {res : Result}
|
||
(hmore : res.more = true) (hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
Sound r res ⟨r.end_.key, (keyAfter (res.keys.headD ([] : Key)) : WithTop Key)⟩ := by
|
||
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
|
||
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
|
||
rw [hhead]
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set H : Key := res.keys.head hne with hHdef
|
||
have hcr : (⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ : ConflictRange) =
|
||
⟨E, ((keyAfter H : Key) : WithTop Key)⟩ := by simp [E, H]
|
||
rw [hcr]
|
||
have step : ∀ d1 d2 : DB, AgreeOn ⟨E, ((keyAfter H : Key) : WithTop Key)⟩ d1 d2 →
|
||
RangeRead.Compatible d1 r res → RangeRead.Compatible d2 r res := by
|
||
intro d1 d2 hag hc1
|
||
have hck1 : RangeRead.completeKeys d1 r = res.keys :=
|
||
completeKeys_eq_res_of_crossed_rev_finite_general (db := d1) (r := r) (res := res)
|
||
hc1 hmore hrev hbegin hcross hend hne ht
|
||
have hgap1 : (between d1 E r.begin.key).length = 0 :=
|
||
crossed_rev_finite_gap_eq_zero_general (db := d1) (r := r) (res := res)
|
||
hc1 hmore hrev hbegin hcross hend hne ht
|
||
have hfil_eq := agreeOn_keys_eq_filter_le (E := E) (H := H) (d1 := d1) (d2 := d2) hag
|
||
have hfil1 : (above d1 E).filter (fun k : Key => decide (k ≤ H)) =
|
||
(above d1 E).take e := by
|
||
simpa [E, e, H] using crossed_rev_finite_above_filter_eq_take_general (db := d1)
|
||
(r := r) (res := res) hc1 hmore hrev hbegin hcross hend hne ht
|
||
have hformula1 : RangeRead.completeKeys d1 r =
|
||
(((above d1 E).take e).drop
|
||
((between d1 E r.begin.key).length + b)).reverse := by
|
||
simpa [E, e, b] using
|
||
completeKeys_crossed_rev_eq_general (db := d1) (r := r) hrev hbegin hcross hend
|
||
have hlen1 : (RangeRead.completeKeys d1 r).length =
|
||
min e (above d1 E).length -
|
||
((between d1 E r.begin.key).length + b) := by
|
||
rw [hformula1, List.length_reverse, List.length_drop, List.length_take]
|
||
have htle1 : res.keys.length ≤ min e (above d1 E).length -
|
||
((between d1 E r.begin.key).length + b) := by
|
||
rw [← hlen1]
|
||
exact (RangeRead.compatible_keys_prefix hc1).length_le
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have he_le1 : e ≤ (above d1 E).length := by
|
||
have hmin := Nat.min_le_right e (above d1 E).length
|
||
omega
|
||
have htake_len1 : ((above d1 E).take e).length = e := by
|
||
rw [List.length_take, Nat.min_eq_left he_le1]
|
||
have hsE2 : (above d2 E).SortedLT := by
|
||
rw [above_eq_filter]
|
||
exact List.sortedLT_iff_pairwise.mpr (d2.sorted.pairwise.filter _)
|
||
have hfil2 : (above d2 E).filter (fun k : Key => decide (k ≤ H)) =
|
||
(above d2 E).take e := by
|
||
have hlen2 : ((above d2 E).filter (fun k : Key => decide (k ≤ H))).length = e := by
|
||
rw [← hfil_eq, hfil1, htake_len1]
|
||
exact (take_eq_filter_le_of_length hsE2 (H := H) (e := e) hlen2).symm
|
||
have htake_eq : (above d1 E).take e = (above d2 E).take e := by
|
||
rw [← hfil1, hfil_eq, hfil2]
|
||
have hBleH : r.begin.key ≤ (H : WithTop Key) := by
|
||
exact crossed_rev_res_ge_begin_general hc1 hbegin H (List.head_mem hne)
|
||
have hgap2 : (between d2 E r.begin.key).length = 0 := by
|
||
have hsub : between d2 E r.begin.key ⊆ between d1 E r.begin.key := by
|
||
intro k hk
|
||
rw [between_eq_filter_above] at hk ⊢
|
||
rw [List.mem_filter] at hk ⊢
|
||
obtain ⟨hkabove2, hklt⟩ := hk
|
||
have hkH : k ≤ H := by
|
||
have hkB : (k : WithTop Key) < r.begin.key := of_decide_eq_true hklt
|
||
exact WithTop.coe_le_coe.mp (le_trans (le_of_lt hkB) hBleH)
|
||
have hkfil2 : k ∈ (above d2 E).filter (fun k : Key => decide (k ≤ H)) := by
|
||
rw [List.mem_filter]
|
||
exact ⟨hkabove2, decide_eq_true hkH⟩
|
||
rw [hfil2] at hkfil2
|
||
have hktake1 : k ∈ (above d1 E).take e := by
|
||
rw [htake_eq]
|
||
exact hkfil2
|
||
exact ⟨List.mem_of_mem_take hktake1, hklt⟩
|
||
have hnil1 : between d1 E r.begin.key = [] := List.length_eq_zero_iff.mp hgap1
|
||
rw [List.length_eq_zero_iff, List.eq_nil_iff_forall_not_mem]
|
||
intro k hk
|
||
have hk1 : k ∈ between d1 E r.begin.key := hsub hk
|
||
rw [hnil1] at hk1
|
||
exact List.not_mem_nil hk1
|
||
have hck2 : RangeRead.completeKeys d2 r = res.keys := by
|
||
have hformula2 : RangeRead.completeKeys d2 r =
|
||
(((above d2 E).take e).drop
|
||
((between d2 E r.begin.key).length + b)).reverse := by
|
||
simpa [E, e, b] using
|
||
completeKeys_crossed_rev_eq_general (db := d2) (r := r) hrev hbegin hcross hend
|
||
rw [hformula2, hgap2, Nat.zero_add, ← hfil2, ← hfil_eq, hfil1]
|
||
have hf1 := hformula1
|
||
rw [hgap1, Nat.zero_add] at hf1
|
||
rw [← hf1, hck1]
|
||
rw [compatible_iff_truncated_keys_rev hrev hmore hne]
|
||
refine ⟨hc1.1, ?_⟩
|
||
rw [hck2]
|
||
rw [List.filter_eq_self]
|
||
intro k hk
|
||
rw [decide_eq_true_eq]
|
||
exact (RangeRead.compatible_sortedGT hc1 hrev).pairwise.imp le_of_lt |>.rel_getLast hk
|
||
intro d1 d2 hagree
|
||
exact ⟨step d1 d2 hagree, step d2 d1 hagree.symm⟩
|
||
|
||
/-- The keys at or above `E` are the database keys with everything below `E`
|
||
dropped. -/
|
||
theorem above_eq_drop_cnt (db : DB) (E : WithTop Key) :
|
||
above db E = db.keys.drop (cnt db E) := by
|
||
rw [above_eq_filter, cnt]
|
||
have h := filter_not_lt_eq_drop_countP db.sorted E
|
||
convert h using 2
|
||
funext k
|
||
rw [decide_eq_decide]
|
||
show (E ≤ ((k : Key) : WithTop Key)) ↔ ¬ (((k : Key) : WithTop Key) < E)
|
||
constructor
|
||
· intro h; exact not_lt.mpr h
|
||
· intro h; exact le_of_not_gt h
|
||
|
||
/-- In the finite branch, the `b`-shifted first `e` keys at or above `end_.key`
|
||
are exactly the reported keys, reversed, and `e` is within the number of keys at
|
||
or above `end_.key`. -/
|
||
theorem crossed_rev_finite_window_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
((above db r.end_.key).take ((r.end_.offset - 1).toNat)).drop
|
||
((r.begin.offset - 1).toNat) = res.keys.reverse ∧
|
||
(r.end_.offset - 1).toNat ≤ (above db r.end_.key).length := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set g : Nat := (between db E r.begin.key).length with hg
|
||
set lE : List Key := above db E with hlE
|
||
have hck := completeKeys_eq_res_of_crossed_rev_finite_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
have hgap : g = 0 := by
|
||
simpa [g, E] using crossed_rev_finite_gap_eq_zero_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
have hformula : RangeRead.completeKeys db r = ((lE.take e).drop (g + b)).reverse := by
|
||
simpa [E, e, b, lE, g] using
|
||
completeKeys_crossed_rev_eq_general (db := db) (r := r) hrev hbegin hcross hend
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r :=
|
||
RangeRead.compatible_keys_prefix hcomp
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have hlen : (RangeRead.completeKeys db r).length = min e lE.length - (g + b) := by
|
||
rw [hformula, List.length_reverse, List.length_drop, List.length_take]
|
||
have htle : res.keys.length ≤ min e lE.length - (g + b) := by
|
||
rw [← hlen]; exact hpre.length_le
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
have hb_lt_e : b < e := by omega
|
||
have he_le : e ≤ lE.length := by
|
||
have hmin_le : min e lE.length ≤ e := Nat.min_le_left _ _
|
||
omega
|
||
have hwin : (lE.take e).drop b = res.keys.reverse := by
|
||
have h := congrArg List.reverse hck
|
||
rw [hformula, List.reverse_reverse] at h
|
||
rw [hgap, Nat.zero_add] at h
|
||
exact h
|
||
exact ⟨by simpa [E, e, b, lE] using hwin, by simpa [E, e, lE] using he_le⟩
|
||
|
||
/-- In the finite branch, the first `e` keys at or above `end_.key` split into the
|
||
first `b` of them followed by the reversed reported keys. -/
|
||
theorem crossed_rev_finite_take_split_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
(above db r.end_.key).take ((r.end_.offset - 1).toNat) =
|
||
(above db r.end_.key).take ((r.begin.offset - 1).toNat) ++ res.keys.reverse := by
|
||
obtain ⟨hwin, he_le⟩ := crossed_rev_finite_window_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
have hwin' : ((above db E).take e).drop b = res.keys.reverse := by
|
||
simpa [E, e, b] using hwin
|
||
have hb_le_e : b ≤ e := by
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
omega
|
||
rw [← List.take_append_drop b ((above db E).take e), hwin']
|
||
rw [List.take_take, Nat.min_eq_left hb_le_e]
|
||
|
||
/-- In the finite branch, the reported head is the last of the first `e` keys at or
|
||
above `end_.key`. -/
|
||
theorem crossed_rev_finite_head_lookup_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
∃ (hidx : (r.end_.offset - 1).toNat - 1 < (above db r.end_.key).length),
|
||
(above db r.end_.key)[(r.end_.offset - 1).toNat - 1]'hidx = res.keys.head hne := by
|
||
obtain ⟨hwin, he_le⟩ := crossed_rev_finite_window_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
set H : Key := res.keys.head hne with hHdef
|
||
have hwin' : (lE.take e).drop b = res.keys.reverse := by
|
||
simpa [E, e, b, lE] using hwin
|
||
have he_le' : e ≤ lE.length := by simpa [E, e, lE] using he_le
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have hb_lt_e : b < e := by
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
omega
|
||
have htake_len : (lE.take e).length = e := by rw [List.length_take, Nat.min_eq_left he_le']
|
||
have htakene : lE.take e ≠ [] := List.ne_nil_of_length_pos (by rw [htake_len]; omega)
|
||
have hdropne : (lE.take e).drop b ≠ [] := by
|
||
apply List.ne_nil_of_length_pos
|
||
rw [List.length_drop, htake_len]
|
||
omega
|
||
have hHlast : H = (lE.take e).getLast htakene := by
|
||
rw [hHdef]
|
||
have hrevne : res.keys.reverse ≠ [] := by rwa [List.reverse_ne_nil_iff]
|
||
have h1 : res.keys.head hne = (res.keys.reverse).getLast hrevne :=
|
||
(List.getLast_reverse hrevne).symm
|
||
rw [h1]
|
||
exact (List.getLast_congr hrevne hdropne hwin'.symm).trans (List.getLast_drop hdropne)
|
||
have hHidx : H = lE[e - 1]'(by omega) := by
|
||
rw [hHlast, List.getLast_take]
|
||
rw [List.getElem?_eq_getElem (by omega)]
|
||
simp
|
||
refine ⟨by simp only [E, e, lE] at he_le' ⊢; omega, ?_⟩
|
||
simpa [E, e, lE, hHdef] using hHidx.symm
|
||
|
||
/-- In the finite crossed reversed branch at a positive begin offset, inserting an
|
||
unstored key `k` with `end_.key ≤ k < head reported` makes the end selector resolve
|
||
onto the reported head, so the head leaves the complete keys and the truncated
|
||
result can no longer be compatible. -/
|
||
theorem crossed_rev_insert_between_incompatible_general {db : DB} {r : RangeRead}
|
||
{res : Result} {k : Key}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat)
|
||
(hk0 : k ∉ db.keys)
|
||
(hEk : r.end_.key ≤ (k : WithTop Key))
|
||
(hkH : (k : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)) :
|
||
¬ RangeRead.Compatible (db.insert k hk0) r res := by
|
||
let H : Key := res.keys.head hne
|
||
let E : WithTop Key := r.end_.key
|
||
let e : Nat := (r.end_.offset - 1).toNat
|
||
obtain ⟨hidx, hHlookup⟩ := crossed_rev_finite_head_lookup_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
have hHidx : H = (above db E)[e - 1]'hidx := by
|
||
simpa [H, E, e] using hHlookup.symm
|
||
have hdrop : above db E = db.keys.drop (cnt db E) := above_eq_drop_cnt db E
|
||
set j : Nat := cnt db E + (e - 1) with hjdef
|
||
have hjeq? : db.keys[j]? = some H := by
|
||
rw [hjdef, ← List.getElem?_drop (i := cnt db E) (j := e - 1) (xs := db.keys)]
|
||
rw [← hdrop, List.getElem?_eq_getElem hidx]
|
||
exact congrArg some (by simpa [E, e] using hHidx.symm)
|
||
obtain ⟨hjlt, hjeq⟩ := List.getElem?_eq_some_iff.mp hjeq?
|
||
have hcj : db.keys.countP (fun x : Key => decide (x < H)) = j :=
|
||
countP_lt_eq_of_getElem db.sorted hjlt hjeq
|
||
have hHmem : H ∈ res.keys := by dsimp only [H]; exact List.head_mem hne
|
||
have hinskeys : (db.insert k hk0).keys =
|
||
db.keys.insertIdx (db.keys.countP (fun x => decide (x < k))) k := by
|
||
rw [DB.insert_keys, orderedInsert_eq_insertIdx db.sorted hk0]
|
||
have hcountnew : (db.insert k hk0).keys.countP
|
||
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) =
|
||
db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := by
|
||
rw [hinskeys]
|
||
exact countP_insertIdx _ _ _ (by
|
||
rw [decide_eq_false_iff_not]
|
||
exact not_lt.mpr hEk)
|
||
have hanchornew : (r.end_.anchor (db.insert k hk0)).toNat =
|
||
db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e := by
|
||
rw [anchor_toNat_eq (s := r.end_) hend, hcountnew]
|
||
have hJeq : (r.end_.anchor (db.insert k hk0)).toNat = j + 1 := by
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have htb : res.keys.length + (r.begin.offset - 1).toNat = e := by simpa [e] using ht
|
||
have hepos : 0 < e := by omega
|
||
rw [hanchornew, hjdef]
|
||
have hcnt : db.keys.countP
|
||
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = cnt db E := by
|
||
rfl
|
||
rw [hcnt]
|
||
omega
|
||
have hpj : db.keys.countP (fun x : Key => decide (x < k)) ≤ j := by
|
||
rw [← hcj]
|
||
apply countP_le_countP_of_imp
|
||
intro x _ hlt
|
||
rw [decide_eq_true_eq] at hlt ⊢
|
||
have hkH' : k < H := WithTop.coe_lt_coe.mp (by simpa [H] using hkH)
|
||
exact lt_trans hlt hkH'
|
||
have hnewlen : (r.end_.anchor (db.insert k hk0)).toNat <
|
||
(db.insert k hk0).keys.length := by
|
||
rw [hinskeys, hJeq, List.length_insertIdx_of_le_length List.countP_le_length]
|
||
omega
|
||
have hnewget? : (db.insert k hk0).keys[(r.end_.anchor (db.insert k hk0)).toNat]? =
|
||
some H := by
|
||
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 [ite_eq_right hlt, ite_eq_right heq, Nat.add_sub_cancel, List.getElem?_eq_getElem hjlt, hjeq]
|
||
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 hend) hnewlen]
|
||
exact congrArg (fun x : Key => (x : WithTop Key)) hnewget
|
||
intro hcompNew
|
||
have hpre := RangeRead.compatible_keys_prefix hcompNew
|
||
have hHcomp : H ∈ RangeRead.completeKeys (db.insert k hk0) r := hpre.subset hHmem
|
||
have hlt := (RangeRead.mem_completeKeys.mp hHcomp).2.2
|
||
rw [hHresolve] at hlt
|
||
exact (lt_irrefl ((H : Key) : WithTop Key)) hlt
|
||
|
||
/-- In the finite branch every key among the first `b` keys at or above `end_.key`
|
||
lies strictly below the reported last key. -/
|
||
theorem crossed_rev_finite_pad_lt_last_general {db : DB} {r : RangeRead} {res : Result}
|
||
{k : Key}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat)
|
||
(hkP : k ∈ (above db r.end_.key).take ((r.begin.offset - 1).toNat)) :
|
||
k < res.keys.getLast hne := by
|
||
obtain ⟨hwin, he_le⟩ := crossed_rev_finite_window_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
have he_le' : e ≤ lE.length := by simpa [E, e, lE] using he_le
|
||
have hb_le_e : b ≤ e := by
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
omega
|
||
have hsplit : lE.take e = lE.take b ++ res.keys.reverse := by
|
||
have h := crossed_rev_finite_take_split_general (db := db) (r := r) (res := res)
|
||
hcomp hmore hrev hbegin hcross hend hne ht
|
||
simpa [E, e, b, lE] using h
|
||
have hsortedE : (lE.take e).SortedLT :=
|
||
List.sortedLT_iff_pairwise.mpr
|
||
(List.Pairwise.take (i := e) (List.sortedLT_iff_pairwise.mp (by
|
||
rw [hlE]
|
||
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _))))
|
||
have hcrosslt : ∀ a ∈ lE.take b, ∀ c ∈ res.keys.reverse, a < c := by
|
||
rw [hsplit] at hsortedE
|
||
exact (List.sortedLT_append.mp hsortedE).2.2
|
||
have hLmem : res.keys.getLast hne ∈ res.keys.reverse :=
|
||
List.mem_reverse.mpr (List.getLast_mem hne)
|
||
exact hcrosslt k (by simpa [E, b, lE] using hkP) _ hLmem
|
||
|
||
/-- In the finite branch the reported last key is the `b`-th key at or above
|
||
`end_.key`. -/
|
||
theorem crossed_rev_finite_last_lookup_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
∃ (hidx : (r.begin.offset - 1).toNat < (above db r.end_.key).length),
|
||
(above db r.end_.key)[(r.begin.offset - 1).toNat]'hidx = res.keys.getLast hne := by
|
||
obtain ⟨hwin, he_le⟩ := crossed_rev_finite_window_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
have he_le' : e ≤ lE.length := by simpa [E, e, lE] using he_le
|
||
have hb_le_e : b ≤ e := by
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have htb : res.keys.length + b = e := by simpa [e, b] using ht
|
||
omega
|
||
have hsplit : lE.take e = lE.take b ++ res.keys.reverse := by
|
||
have h := crossed_rev_finite_take_split_general (db := db) (r := r) (res := res)
|
||
hcomp hmore hrev hbegin hcross hend hne ht
|
||
simpa [E, e, b, lE] using h
|
||
have hP_len : (lE.take b).length = b := by
|
||
rw [List.length_take, Nat.min_eq_left (le_trans hb_le_e he_le')]
|
||
have hdecomp : lE = lE.take b ++ res.keys.reverse ++ lE.drop e := by
|
||
conv_lhs => rw [← List.take_append_drop e lE]
|
||
rw [hsplit, List.append_assoc]
|
||
have hb_lt : b < lE.length := by
|
||
rw [hdecomp, List.length_append, List.length_append, hP_len, List.length_reverse]
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
omega
|
||
refine ⟨by simp only [E, b, lE] at hb_lt ⊢; exact hb_lt, ?_⟩
|
||
have hgoal? : lE[b]? = some (res.keys.getLast hne) := by
|
||
rw [hdecomp]
|
||
rw [List.getElem?_append]
|
||
rw [ite_eq_left (by
|
||
rw [List.length_append, hP_len, List.length_reverse]
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
omega)]
|
||
rw [List.getElem?_append]
|
||
rw [ite_eq_right (by rw [hP_len]; omega)]
|
||
have hidx : b - (lE.take b).length = 0 := by rw [hP_len]; omega
|
||
rw [hidx]
|
||
have hpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have hrev? := List.getElem?_reverse (l := res.keys) (i := 0) (by simpa using hpos)
|
||
rw [hrev?]
|
||
rw [Nat.sub_zero]
|
||
rw [List.getElem?_eq_getElem (by omega)]
|
||
congr 1
|
||
rw [List.getLast_eq_getElem]
|
||
obtain ⟨_, hval⟩ := List.getElem?_eq_some_iff.mp hgoal?
|
||
exact hval
|
||
|
||
/-- Erasing `k` from the database removes it from the keys at or above `E` when it was
|
||
there. -/
|
||
theorem above_erase_of_mem (db : DB) (E : WithTop Key) {k : Key}
|
||
(_hk : k ∈ above db E) : above (db.erase k) E = (above db E).erase k := by
|
||
rw [above_eq_filter, above_eq_filter, DB.erase_keys, ← List.erase_filter]
|
||
|
||
/-- Erasing `k` from `[E, B)` removes it from the erased database's gap. -/
|
||
theorem between_erase_of_mem (db : DB) (E B : WithTop Key) (k : Key) :
|
||
between (db.erase k) E B = (between db E B).erase k := by
|
||
unfold between
|
||
rw [DB.erase_keys, ← List.erase_filter]
|
||
|
||
/-- If a key `k` lies at or above `E` and strictly below the reported last `L`, it is
|
||
among the first `b` keys at or above `E` in the finite crossed reversed branch. -/
|
||
theorem crossed_rev_finite_mem_take_of_lt_last_general {db : DB} {r : RangeRead}
|
||
{res : Result} {k : Key}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat)
|
||
(hkdb : k ∈ db.keys) (hEk : r.end_.key ≤ (k : WithTop Key))
|
||
(hkL : k < res.keys.getLast hne) :
|
||
k ∈ (above db r.end_.key).take ((r.begin.offset - 1).toNat) := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
obtain ⟨hbL, hLlookup⟩ := crossed_rev_finite_last_lookup_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
have hsE : lE.SortedLT := by
|
||
rw [hlE]
|
||
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
|
||
have hkmem : k ∈ lE := by
|
||
rw [hlE, mem_above]
|
||
exact ⟨hkdb, by simpa [E] using hEk⟩
|
||
obtain ⟨i, hi, hik⟩ := List.mem_iff_getElem.mp hkmem
|
||
have hLlookup' : lE[b]'hbL = res.keys.getLast hne := by
|
||
simpa [E, b, lE] using hLlookup
|
||
have hib : i < b := by
|
||
have hlt : lE[i] < lE[b] := by
|
||
rw [hik, hLlookup']
|
||
exact hkL
|
||
exact (List.SortedLT.getElem_lt_getElem_iff (l := lE) hsE).mp hlt
|
||
rw [List.mem_take_iff_getElem]
|
||
exact ⟨i, Nat.lt_min.mpr ⟨by simpa [b] using hib, hi⟩, by simpa [E, lE] using hik⟩
|
||
|
||
/-- In the finite crossed reversed branch, erasing a reported key makes the result
|
||
incompatible. -/
|
||
theorem crossed_rev_erase_reported_incompatible_general {db : DB} {r : RangeRead}
|
||
{res : Result} {k : Key} (_hcomp : RangeRead.Compatible db r res)
|
||
(hk : k ∈ res.keys) :
|
||
¬ RangeRead.Compatible (db.erase k) r res := by
|
||
intro hc
|
||
have hsub := RangeRead.compatible_keys_subset hc
|
||
exact absurd (hsub hk) (DB.not_mem_erase_self db k)
|
||
|
||
/-- In the finite crossed reversed branch, erasing one of the `b` pad keys makes the
|
||
reported last key leave the complete keys, so the result becomes incompatible. -/
|
||
theorem crossed_rev_finite_erase_pad_incompatible_general {db : DB} {r : RangeRead}
|
||
{res : Result} {k : Key}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat)
|
||
(hkP : k ∈ (above db r.end_.key).take ((r.begin.offset - 1).toNat)) :
|
||
¬ RangeRead.Compatible (db.erase k) r res := by
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db E with hlE
|
||
set L : Key := res.keys.getLast hne with hL
|
||
have hkP' : k ∈ lE.take b := by simpa [E, b, lE] using hkP
|
||
have hklE : k ∈ lE := List.take_subset b lE hkP'
|
||
have hklt : k < L := by
|
||
have h := crossed_rev_finite_pad_lt_last_general (db := db) (r := r) (res := res)
|
||
hcomp hmore hrev hbegin hcross hend hne ht hkP
|
||
simpa [L] using h
|
||
obtain ⟨hbL, hLlookup⟩ := crossed_rev_finite_last_lookup_general (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hbegin hcross hend hne ht
|
||
have hsE : lE.SortedLT := by
|
||
rw [hlE]
|
||
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
|
||
have hsErase : (lE.erase k).SortedLT :=
|
||
List.sortedLT_iff_pairwise.mpr (hsE.pairwise.erase k)
|
||
have hLlookup' : lE[b]'hbL = L := by simpa [E, b, lE, L] using hLlookup
|
||
have hcount : lE.countP (fun x : Key => decide (x < L)) = b :=
|
||
countP_lt_eq_of_getElem hsE hbL hLlookup'
|
||
have hcountErase : (lE.erase k).countP (fun x : Key => decide (x < L)) = b - 1 := by
|
||
rw [List.countP_erase, hcount]
|
||
have hcond : k ∈ lE ∧ decide (k < L) = true := ⟨hklE, by simp [hklt]⟩
|
||
rw [ite_eq_left hcond]
|
||
have hLmemErase : L ∈ lE.erase k := by
|
||
have hLmem : L ∈ lE := hLlookup' ▸ List.getElem_mem hbL
|
||
exact (List.mem_erase_of_ne (ne_of_gt hklt)).mpr hLmem
|
||
have hbpos : 0 < b := by
|
||
obtain ⟨i, hi, _⟩ := List.mem_take_iff_getElem.mp hkP'
|
||
exact Nat.lt_of_le_of_lt (Nat.zero_le i) (Nat.lt_min.mp hi).1
|
||
have hnotdrop : L ∉ (lE.erase k).drop b := by
|
||
intro hmem
|
||
obtain ⟨j, hj, hjeq⟩ := List.mem_drop_iff_getElem.mp hmem
|
||
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hLmemErase
|
||
have hci : (lE.erase k).countP (fun x : Key => decide (x < L)) = i :=
|
||
countP_lt_eq_of_getElem hsErase hi hix
|
||
have hib : i < b := by omega
|
||
have hbj : b + j < (lE.erase k).length := by omega
|
||
have hlt : (lE.erase k)[i] < (lE.erase k)[b + j] :=
|
||
(List.SortedLT.getElem_lt_getElem_iff (l := lE.erase k) hsErase
|
||
(hi := hi) (hj := hbj)).mpr (by omega)
|
||
rw [hix, hjeq] at hlt
|
||
exact lt_irrefl L hlt
|
||
have hgapdb : between db E r.begin.key = [] := by
|
||
have h := crossed_rev_finite_gap_eq_zero_general (db := db) (r := r) (res := res)
|
||
hcomp hmore hrev hbegin hcross hend hne ht
|
||
apply List.eq_nil_of_length_eq_zero
|
||
simpa [E] using h
|
||
have hgapnew : between (db.erase k) E r.begin.key = [] := by
|
||
rw [between_erase_of_mem, hgapdb]
|
||
rfl
|
||
have hformula : RangeRead.completeKeys (db.erase k) r =
|
||
(((above (db.erase k) E).take e).drop
|
||
((between (db.erase k) E r.begin.key).length + b)).reverse :=
|
||
completeKeys_crossed_rev_eq_general (db := db.erase k) (r := r) hrev hbegin hcross hend
|
||
rw [hgapnew] at hformula
|
||
rw [List.length_nil] at hformula
|
||
rw [Nat.zero_add] at hformula
|
||
have habove : above (db.erase k) E = lE.erase k := by
|
||
rw [← above_erase_of_mem db E hklE]
|
||
intro hcompNew
|
||
have hLcomp : L ∈ RangeRead.completeKeys (db.erase k) r := by
|
||
have hpre := RangeRead.compatible_keys_prefix hcompNew
|
||
exact hpre.subset (by rw [hL]; exact List.getLast_mem hne)
|
||
rw [hformula, List.mem_reverse, habove] at hLcomp
|
||
have hdropmem : L ∈ (lE.erase k).drop b :=
|
||
((List.take_sublist e (lE.erase k)).drop b).subset hLcomp
|
||
exact hnotdrop hdropmem
|
||
|
||
/-- **Finite-branch minimality for crossed reversed truncated results at any positive
|
||
begin offset.** -/
|
||
theorem minimal_truncatedRevCrossed_finite_general {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key)
|
||
(hend : 1 ≤ r.end_.offset) (hne : res.keys ≠ [])
|
||
(ht : res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) :
|
||
Minimal r res ⟨r.end_.key, (keyAfter (res.keys.headD ([] : Key)) : WithTop Key)⟩ := by
|
||
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
|
||
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set b : Nat := (r.begin.offset - 1).toNat with hb
|
||
set lE : List Key := above db₀ E with hlE
|
||
set L : Key := res.keys.getLast hne with hL
|
||
set H : Key := res.keys.head hne with hH
|
||
refine (minimal_iff_sound_and_necessary).mpr
|
||
⟨?_, ?_⟩
|
||
· have h := sound_truncatedRevCrossed_finite_general (r := r) (res := res)
|
||
hmore hrev hbegin hcross hend hne ht
|
||
simpa [E, hhead] using h
|
||
· intro k hk
|
||
rw [ConflictRange.mem_iff] at hk
|
||
have hEk : E ≤ (k : WithTop Key) := hk.1
|
||
have hkH : k ≤ H := by
|
||
have h2 : (k : WithTop Key) < (keyAfter (res.keys.headD ([] : Key)) : WithTop Key) := hk.2
|
||
rw [hhead] at h2
|
||
exact (lt_keyAfter_iff k (res.keys.head hne)).mp (WithTop.coe_lt_coe.mp h2)
|
||
by_cases hkL : k < L
|
||
· by_cases hkres : k ∈ res.keys
|
||
· exact necessary_of_mem_result hread' hkres
|
||
· by_cases hkdb : k ∈ db₀.keys
|
||
· have hkP : k ∈ lE.take b := by
|
||
have h := crossed_rev_finite_mem_take_of_lt_last_general (db := db₀) (r := r)
|
||
(res := res) hcomp₀ hmore hrev hbegin hcross hend hne ht hkdb
|
||
(by simpa [E] using hEk) (by simpa [L] using hkL)
|
||
simpa [E, b, lE] using h
|
||
intro cr hs
|
||
by_contra hkcr
|
||
have hins := crossed_rev_finite_erase_pad_incompatible_general (db := db₀) (r := r)
|
||
(res := res) hcomp₀ hmore hrev hbegin hcross hend hne ht
|
||
(by simpa [E, b, lE] using hkP)
|
||
have herase : AgreeOn cr db₀ (db₀.erase k) :=
|
||
(ConflictRange.keys_erase_of_not_mem cr db₀ hkcr).symm
|
||
exact hins ((hs db₀ (db₀.erase k) herase).mp hcomp₀)
|
||
· intro cr hs
|
||
by_contra hkcr
|
||
have hkHlt : (k : WithTop Key) < ((H : Key) : WithTop Key) := by
|
||
have hkL' : (k : WithTop Key) < (L : WithTop Key) := WithTop.coe_lt_coe.mpr hkL
|
||
have hLH : (L : WithTop Key) ≤ (H : WithTop Key) := by
|
||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
|
||
have hLle : ∀ x ∈ res.keys, res.keys.getLast hne ≤ x :=
|
||
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
||
exact WithTop.coe_le_coe.mpr (by
|
||
rw [hL, hH]
|
||
exact hLle _ (List.head_mem hne))
|
||
exact lt_of_lt_of_le hkL' hLH
|
||
have hagree : AgreeOn cr db₀ (db₀.insert k hkdb) :=
|
||
(ConflictRange.keys_insert_of_not_mem cr db₀ hkdb hkcr).symm
|
||
have hcompNew : RangeRead.Compatible (db₀.insert k hkdb) r res :=
|
||
(hs db₀ _ hagree).mp hcomp₀
|
||
exact crossed_rev_insert_between_incompatible_general (db := db₀) hcomp₀ hmore hrev
|
||
hbegin hcross hend hne ht hkdb (by simpa [E] using hEk) hkHlt hcompNew
|
||
· have hLk : L ≤ k := le_of_not_gt hkL
|
||
exact necessary_of_between_result hread' (by rw [hL]; exact List.getLast_mem hne)
|
||
(by rw [hH]; exact List.head_mem hne) hLk hkH
|
||
|
||
/-- A closed form for crossed reversed truncated results at every positive begin offset.
|
||
The finite branch `t + (begin.offset - 1) = (end.offset - 1)` is compact; the remaining
|
||
top branch uses the exact executable algorithm as a fallback. -/
|
||
noncomputable def closedFormCrossedRevGeneral (r : RangeRead) (res : Result) : ConflictRange :=
|
||
if r.end_.key < r.begin.key ∧
|
||
res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat then
|
||
⟨r.end_.key, (keyAfter (res.keys.headD ([] : Key)) : WithTop Key)⟩
|
||
else
|
||
simpleConflictRange r res
|
||
|
||
/-- The partial crossed reversed closed form is minimal on every readable truncated
|
||
result at every positive begin and end offset. -/
|
||
theorem minimal_closedForm_of_crossedRevGeneral {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) :
|
||
Minimal r res (closedFormCrossedRevGeneral r res) := by
|
||
obtain ⟨db, hcomp⟩ := hread
|
||
have hread' : Readable r res := ⟨db, hcomp⟩
|
||
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore
|
||
unfold closedFormCrossedRevGeneral
|
||
by_cases hcond : r.end_.key < r.begin.key ∧
|
||
res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat
|
||
· rw [ite_eq_left hcond]
|
||
exact minimal_truncatedRevCrossed_finite_general hread' hmore hrev hbegin hcond.1 hend
|
||
hne hcond.2
|
||
· rw [ite_eq_right hcond]
|
||
exact simpleConflictRange_minimal hread'
|
||
|
||
attribute [irreducible] closedFormCrossedRevGeneral
|
||
|
||
/-- The partial crossed reversed closed form denotes the general conflict range. -/
|
||
theorem closedFormCrossedRevGeneral_toSet_eq_general {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) :
|
||
(closedFormCrossedRevGeneral r res).toSet = (conflictRangeGeneral r res).toSet :=
|
||
(minimal_closedForm_of_crossedRevGeneral hread hmore hrev hbegin hend).toSet_eq
|
||
(conflictRangeGeneral_minimal hread)
|
||
|
||
/-- The same identification with the executable algorithm. -/
|
||
theorem closedFormCrossedRevGeneral_toSet_eq_simple {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) :
|
||
(closedFormCrossedRevGeneral r res).toSet = (simpleConflictRange r res).toSet :=
|
||
(minimal_closedForm_of_crossedRevGeneral hread hmore hrev hbegin hend).toSet_eq
|
||
(simpleConflictRange_minimal hread)
|
||
|
||
end FormalConflictRange
|