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:
andrew committed 2026-11-16 21:53:59 -05:00
1 parent 7a0826e873
commit a54a5f82f8
78 files changed
+91636 -2

No files matched your search

+982
View File
@@ -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