Prove conflict-range closed-form minimality
- Vendor the FormalConflictRange reference library needed by the proof - Add Bridge.lean with simp lemmas connecting the Statement definitions to the reference library - Prove Statement.closedFormMinimal in Proof.lean - Register the new libraries in the Lake config
This commit is contained in:
1 parent
7a0826e873
commit
a54a5f82f8
78 files changed
+91636
-2
No files matched your search
@@ -0,0 +1,982 @@
|
||||
/-
|
||||
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 [if_neg hlt, if_neg 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 [if_pos (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 [if_neg (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 [if_pos 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
|
||||
Reference in new issue
Block a user