/- 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