Files
conflict-range/FormalConflictRange/CrossedRevGeneral.lean
T

981 lines
50 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
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