/- 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.CrossedGeneral /-! # Forward crossed truncated general cells. -/ open FormalConflictRange namespace FormalConflictRange /-- Slicing a sorted list at `b` and taking `t` elements: the filter up to the last taken element is exactly the first `b + t` elements. -/ theorem filter_le_getElem_eq_take {A : List Key} (hAs : A.SortedLT) {b t : ℕ} (ht : 0 < t) (hbt : b + t ≤ A.length) : A.filter (fun k : Key => decide (k ≤ A[b + t - 1]'(by omega))) = A.take (b + t) := by have hidx : b + t - 1 < A.length := by omega have hgne : A.take (b + t) ≠ [] := List.ne_nil_of_length_pos (by rw [List.length_take]; omega) have hglast : (A.take (b + t)).getLast hgne = A[b + t - 1]'hidx := by rw [List.getLast_eq_getElem, List.getElem_take] simp only [List.length_take, Nat.min_eq_left hbt] have h := filter_le_getLast_eq_of_prefix (α := Key) (g := A.take (b + t)) (W := A) hAs.pairwise (List.take_prefix (b + t) A) hgne rw [hglast] at h exact h theorem completeKeys_eq_filter_ge_drop_take {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) : RangeRead.completeKeys db r = ((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).drop (r.begin.offset - 1).toNat).take (min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db.keys.length - (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + (r.begin.offset - 1).toNat)) := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set b := (r.begin.offset - 1).toNat with hb have hls : l.SortedLT := by rw [hl]; exact db.sorted have hAeq : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.drop p := by rw [hp] have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend, ← hl, ← hp, ← hb] rw [hAeq, List.drop_drop] /-- The last element of `(A.drop b).take t` is `A[b+t-1]`. -/ theorem getLast_take_drop {A : List Key} {b t : ℕ} {res : List Key} (ht : 0 < t) (hres : res = (A.drop b).take t) (hbt : b + t ≤ A.length) : res.getLastD [] = A[b + t - 1]'(by omega) := by have hne : res ≠ [] := by rw [hres] apply List.ne_nil_of_length_pos rw [List.length_take, Nat.min_eq_left] · omega · rw [List.length_drop]; omega have hlastD : res.getLastD [] = res.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlastD] have hne' : (A.drop b).take t ≠ [] := by rw [← hres]; exact hne calc res.getLast hne = ((A.drop b).take t).getLast hne' := List.getLast_congr hne hne' hres _ = A[b + t - 1]'(by omega) := by rw [List.getLast_eq_getElem, List.getElem_take] simp only [List.length_take, List.length_drop, Nat.min_eq_left (by omega : t ≤ A.length - b)] rw [List.getElem_drop] congr 1 omega end FormalConflictRange namespace FormalConflictRange /-- In the crossed forward truncated B-branch, agreement on the truncated range forced the reported last to stay strictly below the resolved end. -/ theorem crossed_truncated_hlr_of_drop_gap {db : DB} {r : RangeRead} {res : Result} (_hrev : r.reverse = false) (_hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hcross : r.end_.key < r.begin.key) (hne : res.keys ≠ []) (hgap : (between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat + res.keys.length ≤ (r.end_.offset - 1).toNat) (hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop (r.begin.offset - 1).toNat = res.keys) : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he set t := res.keys.length with ht set last := res.keys.getLast hne with hlast set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hA set S := A.filter (fun k : Key => decide (k ≤ last)) with hS have hls : l.SortedLT := by rw [hl]; exact db.sorted have hAs : A.SortedLT := by rw [hA] exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _) have htrunc : (truncatedRange r last).keys db = S := by rw [truncatedRange_keys_eq_filter_le] have hdrop' : S.drop b = res.keys := by rw [← htrunc] simpa [hb] using hdrop have htpos : 0 < t := by rw [ht]; exact List.length_pos_of_ne_nil hne have hSlen : S.length = b + t := by have := congrArg List.length hdrop' rw [List.length_drop, ← ht] at this omega have hStake : S = A.take (b + t) := by rw [hS, filter_le_eq_take_countP hAs last] congr 1 rw [List.countP_eq_length_filter] simpa [S] using hSlen have hAbt : b + t ≤ A.length := by rw [hStake, List.length_take] at hSlen omega have hresdrop : res.keys = (A.drop b).take t := by rw [← hdrop', hStake, List.drop_take] congr 1 omega have hlastD : res.keys.getLastD [] = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hlastA : last = A[b + t - 1]'(by omega) := by rw [hlast, ← hlastD] exact getLast_take_drop htpos hresdrop hAbt set g := (between db r.end_.key r.begin.key).length with hgdef have hcnt : p = cE + g := by rw [hp, hcE, hgdef] simpa [cnt, hl] using cnt_eq_add_between (db := db) (le_of_lt hcross) have hA_eq : A = l.drop p := by rw [hA, hp] have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hjlt : p + (b + t - 1) < l.length := by have := hAbt rw [hA_eq, List.length_drop] at this omega have hlast_l : last = l[p + (b + t - 1)]'hjlt := by rw [hlastA] have hidx : b + t - 1 < A.length := by omega have h1 : A[b + t - 1]'hidx = (l.drop p)[b + t - 1]'(by rw [List.length_drop]; omega) := List.getElem_of_eq hA_eq hidx rw [h1, List.getElem_drop] have hgbt : g + (t + b) ≤ e := by have h := hgap omega have hj_anchor : p + (b + t - 1) < (r.end_.anchor db).toNat := by rw [anchor_toNat_eq (s := r.end_) hend, ← hl, ← hcE, hcnt] have hble : b + t - 1 < t + b := by omega omega have hj_clamp : p + (b + t - 1) < clampIndex db r.end_ := by unfold clampIndex exact Nat.lt_min.mpr ⟨hj_anchor, hjlt⟩ rw [hlast_l] exact (getElem_lt_resolve_iff (db := db) (s := r.end_) (j := p + (b + t - 1)) hjlt).mpr hj_clamp end FormalConflictRange namespace FormalConflictRange /-- A compatible crossed truncated result bounds the number of stored keys in the selector gap: `gap + begin-offset-padding + reported-length ≤ end-overshoot`. -/ theorem compatible_gap_bound {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (_hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hcross : r.end_.key < r.begin.key) (hc : RangeRead.Compatible db r res) : (between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat + res.keys.length ≤ (r.end_.offset - 1).toNat := by have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he set t := res.keys.length with ht set g := (between db r.end_.key r.begin.key).length with hg have hck := completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend rw [← hl, ← hp, ← hcE, ← hb, ← he] at hck have ht_le : t ≤ min (cE + e) l.length - (p + b) := by have := hpre.length_le rw [hck, List.length_take, ← ht] at this exact le_trans this (Nat.min_le_left _ _) have hcnt : p = cE + g := by rw [hp, hcE, hg] simpa [cnt, hl] using cnt_eq_add_between (db := db) (le_of_lt hcross) have hsub : cE + e - (p + b) = e - g - b := by rw [hcnt, add_assoc, Nat.add_sub_add_left, Nat.sub_sub] have hminle : min (cE + e) l.length - (p + b) ≤ e - g - b := by rw [← hsub] exact Nat.sub_le_sub_right (Nat.min_le_left _ _) _ have ht_le' : t ≤ e - g - b := le_trans ht_le hminle have htpos : 0 < t := by rw [ht]; exact List.length_pos_of_ne_nil hne have hgbe : g + b ≤ e := by by_contra h have hz : e - g - b = 0 := by omega omega have hfinal : g + b + t ≤ e := by calc g + b + t = t + (g + b) := by omega _ ≤ (e - (g + b)) + (g + b) := by have h1 : t ≤ e - (g + b) := by rwa [Nat.sub_sub] at ht_le' exact Nat.add_le_add_right h1 _ _ = e := Nat.sub_add_cancel hgbe simpa [hg, hb, ht, he] using hfinal end FormalConflictRange namespace FormalConflictRange /-- The hcard form of the crossed truncated height lemma, derived from the actual gap-count form. -/ theorem crossed_truncated_hlr_of_drop {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hcross : r.end_.key < r.begin.key) (hne : res.keys ≠ []) (hcard : intervalCard r.end_.key r.begin.key ≤ (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞)) (hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop (r.begin.offset - 1).toNat = res.keys) : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := by refine crossed_truncated_hlr_of_drop_gap hrev hbegin hend hcross hne ?_ hdrop set g := (between db r.end_.key r.begin.key).length with hg set t := res.keys.length with ht set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hgcard : ((g : ℕ) : ℕ∞) ≤ (((e - t - b : ℕ)) : ℕ∞) := by refine le_trans ?_ (by simpa [e, t, b, g] using hcard) simpa [g] using between_length_le_intervalCard (db := db) (le_of_lt hcross) have hgle0 : g ≤ e - t - b := by exact_mod_cast hgcard have hgle : g ≤ e - (t + b) := by rwa [Nat.sub_sub] at hgle0 have htb : t + b ≤ e := by by_contra h have hzero : e - t - b = 0 := by omega have hle0 : intervalCard r.end_.key r.begin.key ≤ 0 := by simpa [hzero] using hcard have hzero2 : intervalCard r.end_.key r.begin.key = 0 := le_antisymm hle0 zero_le exact absurd (intervalCard_eq_zero_iff.mp hzero2) (not_le.mpr hcross) have hgbt : g + (t + b) ≤ e := by calc g + (t + b) ≤ (e - (t + b)) + (t + b) := Nat.add_le_add_right hgle _ _ = e := Nat.sub_add_cancel htb omega end FormalConflictRange open FormalConflictRange namespace FormalConflictRange /-- General crossed complete keys filtered at or below the last reported key. -/ theorem completeKeys_filter_le_eq_crossed_general {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hEB : r.end_.key ≤ r.begin.key) (_hBlast : r.begin.key ≤ (last : WithTop Key)) : (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) = (((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).take (min ((r.end_.offset - 1).toNat - (between db r.end_.key r.begin.key).length) ((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length)).drop (r.begin.offset - 1).toNat := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef set C := A.filter (fun k : Key => decide (k ≤ last)) with hCdef set q := A.countP (fun k : Key => decide (k ≤ last)) with hqdef set gap := (between db r.end_.key r.begin.key).length with hgapdef set K := min (cE + e) l.length - (p + b) with hK set L := min (e - gap) q with hL have hls : l.SortedLT := by rw [hl]; exact db.sorted have hAs : A.SortedLT := by rw [hAdef] exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _) have hA : A = l.drop p := by rw [hAdef, hp] have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hCtake : C = A.take q := by rw [hCdef, hqdef] exact filter_le_eq_take_countP hAs last have hqA : q ≤ A.length := by rw [hqdef]; exact List.countP_le_length have hqC : C.length = q := by rw [hCtake, List.length_take] exact Nat.min_eq_left hqA have hp_le : p ≤ l.length := by rw [hp]; exact List.countP_le_length have hcB : p = cE + gap := by rw [hp, hcE, hgapdef] simpa [cnt, hl] using cnt_eq_add_between (db := db) hEB have hqN : q + p ≤ l.length := by have := hqA rw [hA, List.length_drop] at this omega -- filter of a drop of `A` have hfilter_drop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) = (A.drop b).take (q - b) := by have hsplit : A.filter (fun k : Key => decide (k ≤ last)) = (A.take b).filter (fun k : Key => decide (k ≤ last)) ++ (A.drop b).filter (fun k : Key => decide (k ≤ last)) := by conv_lhs => rw [← List.take_append_drop b A] rw [List.filter_append] have htakeb : (A.take b).filter (fun k : Key => decide (k ≤ last)) = A.take (min b q) := filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hCtake b have hCtake' : A.filter (fun k : Key => decide (k ≤ last)) = A.take q := hCtake rw [hCtake', htakeb] at hsplit have hsplit2 : A.take q = A.take (min b q) ++ (A.take q).drop (min b q) := by conv_lhs => rw [← List.take_append_drop (min b q) (A.take q)] rw [List.take_take, Nat.min_eq_left (Nat.min_le_right b q)] rw [hsplit2] at hsplit have hdrop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) = (A.take q).drop (min b q) := (List.append_cancel_left hsplit).symm have htakeq : (A.take q).drop (min b q) = (A.drop b).take (q - b) := by by_cases hbq : b ≤ q · rw [Nat.min_eq_left hbq, List.drop_take] · have hbq' : q ≤ b := by omega rw [Nat.min_eq_right hbq', Nat.sub_eq_zero_of_le hbq', List.take_zero] exact List.drop_eq_nil_of_le (by rw [List.length_take]; exact Nat.min_le_left _ _) exact hdrop.trans htakeq have htake_filter : ((A.drop b).take K).filter (fun k : Key => decide (k ≤ last)) = (A.drop b).take (min K (q - b)) := filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hfilter_drop K have harith : min K (q - b) = L - b := by rw [hK, hL] omega have hAtake : A.take L = C.take L := by rw [hCtake, List.take_take] congr 1 exact (Nat.min_eq_left (Nat.min_le_right (e - gap) q)).symm rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend] rw [← hl, ← hp, ← hcE, ← hb, ← he] have hdropA : List.drop (p + b) l = A.drop b := by rw [hA, List.drop_drop] rw [hdropA, show min (cE + e) l.length - (p + b) = K from rfl] rw [htake_filter, harith] rw [← List.drop_take, hAtake, hqC] end FormalConflictRange namespace FormalConflictRange private theorem crossedTrunc_keys_lo_keyAfter_eq_filter_le {db : DB} {lo : WithTop Key} {last : Key} : (⟨lo, (keyAfter last : Key)⟩ : ConflictRange).keys db = (db.keys.filter (fun k : Key => decide (lo ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) := by unfold ConflictRange.keys rw [show db.keys.filter (fun (k : Key) => decide (lo ≤ (k : WithTop Key) ∧ (k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) = db.keys.filter (fun (k : Key) => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) && decide (lo ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter] apply List.filter_congr intro k _ rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] private theorem crossedTrunc_filter_ge_last_eq_filter_of_keys_eq {db : DB} {E B : WithTop Key} {last : Key} (hEB : E ≤ B) (_hBlast : B ≤ (last : WithTop Key)) : (db.keys.filter (fun k : Key => decide (B ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) = ((⟨E, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter (fun k : Key => decide (B ≤ (k : WithTop Key))) := by rw [crossedTrunc_keys_lo_keyAfter_eq_filter_le] simp only [List.filter_filter] apply List.filter_congr intro k _ simp only [← Bool.decide_and] rw [decide_eq_decide] constructor · rintro ⟨hl, hB⟩ exact ⟨hB, hl, le_trans hEB hB⟩ · rintro ⟨hB, hl, _⟩ exact ⟨hl, hB⟩ private theorem crossedTrunc_between_eq_filter_of_keys_eq {db : DB} {E B : WithTop Key} {last : Key} (_hEB : E ≤ B) (hBlast : B ≤ (last : WithTop Key)) : between db E B = ((⟨E, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter (fun k : Key => decide ((k : WithTop Key) < B)) := by rw [crossedTrunc_keys_lo_keyAfter_eq_filter_le] simp only [List.filter_filter] unfold between rw [show db.keys.filter (fun k : Key => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B)) = db.keys.filter (fun k : Key => decide ((k : WithTop Key) < B) && decide (E ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] apply List.filter_congr intro k _ simp only [← Bool.decide_and] rw [decide_eq_decide] constructor · rintro ⟨hkB, hE⟩ have hklt : (k : WithTop Key) < (last : WithTop Key) := lt_of_lt_of_le hkB hBlast exact ⟨hkB, le_of_lt (WithTop.coe_lt_coe.mp hklt), hE⟩ · rintro ⟨hkB, _, hE⟩ exact ⟨hkB, hE⟩ /-- A compatible crossed truncated result reports only keys at or above `begin_.key`, at any positive begin offset. -/ theorem le_begin_key_of_compatible_crossed_general {db : DB} {r : RangeRead} {res : Result} (_hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hne : res.keys ≠ []) (hc : RangeRead.Compatible db r res) : r.begin.key ≤ (res.keys.getLast hne : WithTop Key) := by have hmem : res.keys.getLast hne ∈ RangeRead.completeKeys db r := (RangeRead.compatible_keys_prefix hc).subset (List.getLast_mem hne) exact le_trans (key_le_resolve_of_one_le (db := db) (s := r.begin) hbegin) (RangeRead.mem_completeKeys.mp hmem).2.1 /-- Agreement on `[r.end_.key, keyAfter last)` fixes the complete keys filtered at or below `last`, for any positive begin offset on a crossed read with `end_.key ≤ begin_.key`. -/ theorem completeKeys_filter_le_eq_of_agree_crossed_general {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hEB : r.end_.key ≤ r.begin.key) (hBlast : r.begin.key ≤ (last : WithTop Key)) {db₁ db₂ : DB} (hagree : (⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db₁ = (⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db₂) : (RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last)) = (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ last)) := by let C : DB → List Key := fun db => (db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) let gap : DB → ℕ := fun db => (between db r.end_.key r.begin.key).length have hC (db : DB) : C db = ((⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) := crossedTrunc_filter_ge_last_eq_filter_of_keys_eq (db := db) hEB hBlast have hG (db : DB) : between db r.end_.key r.begin.key = ((⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) := crossedTrunc_between_eq_filter_of_keys_eq (db := db) hEB hBlast have hCeq : C db₁ = C db₂ := by rw [hC db₁, hC db₂, hagree] have hGeq : gap db₁ = gap db₂ := by unfold gap rw [hG db₁, hG db₂, hagree] have hformula (db : DB) : (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) = ((C db).take (min ((r.end_.offset - 1).toNat - gap db) (C db).length)).drop (r.begin.offset - 1).toNat := by simpa [C, gap] using completeKeys_filter_le_eq_crossed_general (db := db) (r := r) (last := last) hrev hbegin hend hEB hBlast calc (RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last)) = ((C db₁).take (min ((r.end_.offset - 1).toNat - gap db₁) (C db₁).length)).drop (r.begin.offset - 1).toNat := hformula db₁ _ = ((C db₂).take (min ((r.end_.offset - 1).toNat - gap db₂) (C db₂).length)).drop (r.begin.offset - 1).toNat := by rw [hCeq, hGeq] _ = (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ last)) := (hformula db₂).symm /-- **E-branch soundness for the forward truncated crossed read at any positive begin offset.** Agreement on `[end_.key, keyAfter (last reported))` fixes the reported prefix of the complete keys. -/ theorem sound_truncatedRange_of_crossed_E_general {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) : Sound r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] intro db₁ db₂ hagree constructor · intro hc₁ have hBlast := le_begin_key_of_compatible_crossed_general (db := db₁) hrev hbegin hne hc₁ have hceq := completeKeys_filter_le_eq_of_agree_crossed_general (r := r) (last := res.keys.getLast hne) hrev hbegin (by omega) (le_of_lt hcross) hBlast hagree rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] at hc₁ rw [compatible_iff_truncated_keys (db := db₂) hrev hmore hne] refine ⟨hc₁.1, ?_⟩ rw [← hceq] exact hc₁.2 · intro hc₂ have hBlast := le_begin_key_of_compatible_crossed_general (db := db₂) hrev hbegin hne hc₂ have hceq := completeKeys_filter_le_eq_of_agree_crossed_general (r := r) (last := res.keys.getLast hne) hrev hbegin (by omega) (le_of_lt hcross) hBlast hagree rw [compatible_iff_truncated_keys (db := db₂) hrev hmore hne] at hc₂ rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] refine ⟨hc₂.1, ?_⟩ rw [hceq] exact hc₂.2 end FormalConflictRange namespace FormalConflictRange /-- For a sorted key list, dropping `b` from the prefix at or below `last` is the same as filtering the dropped tail at or below `last`. -/ theorem filter_drop_eq_drop_filter_le {A : List Key} (hAs : A.SortedLT) (last : Key) (b : ℕ) : (A.filter (fun k : Key => decide (k ≤ last))).drop b = (A.drop b).filter (fun k : Key => decide (k ≤ last)) := by set q := A.countP (fun k : Key => decide (k ≤ last)) with hq have hqA : q ≤ A.length := by rw [hq]; exact List.countP_le_length have hC : A.filter (fun k : Key => decide (k ≤ last)) = A.take q := by rw [hq]; exact filter_le_eq_take_countP hAs last have hdrop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) = (A.take q).drop (min b q) := by have hsplit : A.filter (fun k : Key => decide (k ≤ last)) = (A.take b).filter (fun k : Key => decide (k ≤ last)) ++ (A.drop b).filter (fun k : Key => decide (k ≤ last)) := by conv_lhs => rw [← List.take_append_drop b A] rw [List.filter_append] have htakeb : (A.take b).filter (fun k : Key => decide (k ≤ last)) = A.take (min b q) := filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hC b rw [hC, htakeb] at hsplit have hsplit2 : A.take q = A.take (min b q) ++ (A.take q).drop (min b q) := by conv_lhs => rw [← List.take_append_drop (min b q) (A.take q)] rw [List.take_take, Nat.min_eq_left (Nat.min_le_right b q)] rw [hsplit2] at hsplit exact (List.append_cancel_left hsplit).symm rw [hC, hdrop] by_cases hbq : b ≤ q · rw [Nat.min_eq_left hbq, List.drop_take] · have hbq' : q ≤ b := by omega rw [Nat.min_eq_right hbq'] rw [List.drop_eq_nil_of_le (by rw [List.length_take, Nat.min_eq_left hqA]; exact hbq'), List.drop_eq_nil_of_le (by rw [List.length_take, Nat.min_eq_left hqA])] /-- Compatibility with a truncated crossed read is equivalent to the limit and the begin-offset-dropped truncated range storing exactly the reported keys, provided the last reported key is strictly below the resolved end. -/ theorem compatible_iff_truncated_drop_of_hlr {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hmore : res.more = true) (hne : res.keys ≠ []) (hlr : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ ((truncatedRange r (res.keys.getLast hne)).keys db).drop (r.begin.offset - 1).toNat = res.keys := by rw [compatible_iff_truncated_keys (db := db) hrev hmore hne] have hbridge := completeKeys_filter_le_drop (db := db) (r := r) (last := res.keys.getLast hne) hrev hbegin hlr constructor · rintro ⟨hlim, hfil⟩ exact ⟨hlim, hbridge.symm.trans hfil⟩ · rintro ⟨hlim, hdrop⟩ exact ⟨hlim, hbridge.trans hdrop⟩ /-- **B-branch soundness for the forward truncated crossed read, at any positive begin offset.** When the gap `[end_.key, begin_.key)` has at least the remaining overshoot `e - t - (begin.offset - 1)` keys, the truncated range `[begin.key, keyAfter (last reported))` is sound. -/ theorem sound_truncatedRange_of_crossed_B_general {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.end_.key r.begin.key ≤ (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞)) : Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] set b := (r.begin.offset - 1).toNat with hbdef intro db₁ db₂ hagree have keyF (db : DB) (hc : RangeRead.Compatible db r res) : RangeRead.withinLimit r res.keys ∧ ((truncatedRange r (res.keys.getLast hne)).keys db).drop b = res.keys := by refine ⟨hc.1, ?_⟩ set l := db.keys with hl set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef have hls : l.SortedLT := by rw [hl]; exact db.sorted have hAs : A.SortedLT := by rw [hAdef] exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _) have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc have hck : RangeRead.completeKeys db r = (A.drop b).take (min (l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) l.length - (l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + b)) := by simpa [A, b, hl] using completeKeys_eq_filter_ge_drop_take (db := db) (r := r) hrev hbegin (by omega) have hpreA : res.keys <+: A.drop b := by rw [hck] at hpre exact List.IsPrefix.trans hpre (List.take_prefix _ _) have hAsDrop : (A.drop b).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := b) hAs.pairwise) have hfil : (A.drop b).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = res.keys := filter_le_getLast_eq_of_prefix hAsDrop.pairwise hpreA hne have hAeq : db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = A := by rw [hAdef, hl] rw [truncatedRange_keys_eq_filter_le, hAeq, filter_drop_eq_drop_filter_le hAs _ b] exact hfil have hlrOf (db : DB) (hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop b = res.keys) : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := crossed_truncated_hlr_of_drop hrev hbegin (by omega) hcross hne (by simpa [b] using hcard) hdrop constructor · intro hc₁ have hF₁ := keyF db₁ hc₁ have hdrop₂ : ((truncatedRange r (res.keys.getLast hne)).keys db₂).drop b = res.keys := by rw [← hagree]; exact hF₁.2 exact (compatible_iff_truncated_drop_of_hlr (db := db₂) hrev hbegin hmore hne (hlrOf db₂ hdrop₂)).mpr ⟨hc₁.1, hdrop₂⟩ · intro hc₂ have hF₂ := keyF db₂ hc₂ have hdrop₁ : ((truncatedRange r (res.keys.getLast hne)).keys db₁).drop b = res.keys := by rw [hagree]; exact hF₂.2 exact (compatible_iff_truncated_drop_of_hlr (db := db₁) hrev hbegin hmore hne (hlrOf db₁ hdrop₁)).mpr ⟨hc₂.1, hdrop₁⟩ end FormalConflictRange namespace FormalConflictRange /-- Extract the begin-offset padding `P` from a compatible truncated crossed read. -/ theorem crossed_pad_truncated_general {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (_hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) (hne : res.keys ≠ []) (hc : RangeRead.Compatible db r res) : ∃ P : List Key, P.length = (r.begin.offset - 1).toNat ∧ P.SortedLT ∧ (∀ x ∈ P, r.begin.key ≤ (x : WithTop Key)) ∧ (∀ x ∈ P, ∀ y ∈ res.keys, x < y) ∧ (P ++ res.keys).SortedLT := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set b := (r.begin.offset - 1).toNat with hb set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef set K := min (l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) l.length - (p + b) with hK have hls : l.SortedLT := by rw [hl]; exact db.sorted have hA : A = l.drop p := by rw [hAdef] have hnot : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) := by apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm rw [hnot, filter_not_lt_eq_drop_countP hls r.begin.key, ← hp] have hAs : A.SortedLT := by rw [hA] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) have hAge : ∀ x ∈ A, r.begin.key ≤ (x : WithTop Key) := by intro x hx rw [hAdef] at hx exact of_decide_eq_true (List.mem_filter.mp hx).2 have hck : RangeRead.completeKeys db r = (A.drop b).take K := by rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend] rw [← hl, ← hp, ← hb, hA, List.drop_drop, hK] have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc have hpreA : res.keys <+: A.drop b := by rw [hck] at hpre exact List.IsPrefix.trans hpre (List.take_prefix _ _) have hbA : b ≤ A.length := by have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne have := hpreA.length_le rw [List.length_drop] at this omega let P := A.take b have hPdef : P = A.take b := rfl have hPlen : P.length = b := by rw [hPdef, List.length_take, Nat.min_eq_left hbA] have hPs : P.SortedLT := by rw [hPdef] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := b) (List.sortedLT_iff_pairwise.mp hAs)) have hPge : ∀ x ∈ P, r.begin.key ≤ (x : WithTop Key) := by intro x hx exact hAge x (List.take_subset _ _ (by rw [← hPdef]; exact hx)) have happend : A = P ++ A.drop b := by rw [hPdef, List.take_append_drop] have hcrossA : ∀ x ∈ P, ∀ y ∈ A.drop b, x < y := by have := List.sortedLT_append.mp (by rw [← happend]; exact hAs) exact this.2.2 have hP_lt_res : ∀ x ∈ P, ∀ y ∈ res.keys, x < y := by intro x hx y hy exact hcrossA x hx y (hpreA.subset hy) have hresS : res.keys.SortedLT := RangeRead.compatible_sortedLT hc hrev refine ⟨P, ?_, hPs, hPge, hP_lt_res, ?_⟩ · rw [hPlen, hb] · exact List.sortedLT_append.mpr ⟨hPs, hresS, hP_lt_res⟩ end FormalConflictRange namespace FormalConflictRange private theorem crossedTrunc_enat_succ_le_of_lt {s : ℕ} {h : ℕ∞} (hs : (s : ℕ∞) < h) : ((s + 1 : ℕ) : ℕ∞) ≤ h := by cases h with | top => exact le_top | coe n => rw [ENat.natCast_lt_natCast] at hs exact_mod_cast Nat.succ_le_of_lt hs /-- **Gap-key necessity for the forward truncated crossed read at any positive begin offset.** When the gap is too small to absorb `e - t - b`, every key in `[end_.key, begin_.key)` is necessary. -/ theorem necessary_of_mem_gap_crossed_truncated_general {r : RangeRead} {res : Result} {k : Key} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (hlt : (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞) < intervalCard r.end_.key r.begin.key) (hkE : r.end_.key ≤ (k : WithTop Key)) (hkB : (k : WithTop Key) < r.begin.key) : Necessary r res k := by set t : ℕ := res.keys.length with htdef set eo : ℕ := (r.end_.offset - 1).toNat with heodef set b : ℕ := (r.begin.offset - 1).toNat with hbdef set s : ℕ := eo - t - b with hsdef obtain ⟨db₀, hcomp₀⟩ := hread have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp₀ have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by intro x hx have hmem : x ∈ RangeRead.completeKeys db₀ r := hpre₀.subset hx exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin) (RangeRead.mem_completeKeys.mp hmem).2.1 have hlast_ge_B : r.begin.key ≤ (res.keys.getLast hne : WithTop Key) := hall_ge _ (List.getLast_mem hne) have hgap : (between db₀ r.end_.key r.begin.key).length + b + t ≤ eo := by have := compatible_gap_bound (db := db₀) hrev hmore hne hbegin (by omega) hcross hcomp₀ simpa [hbdef, htdef, heodef] using this have hbt : b + t ≤ eo := by omega have hse : eo = s + t + b := by rw [hsdef]; omega have hcard : ((s + 1 : ℕ) : ℕ∞) ≤ intervalCard r.end_.key r.begin.key := crossedTrunc_enat_succ_le_of_lt (s := s) (by simpa [s, htdef, heodef, hbdef] using hlt) obtain ⟨dbH, hHrange, hkH, hHlen⟩ := exists_db_keysIn_avoid (B := r.end_.key) (E := r.begin.key) (k := k) (m := s) hcard have hHgeE : ∀ x ∈ dbH.keys, r.end_.key ≤ (x : WithTop Key) := fun x hx => (hHrange x hx).1 have hHltB : ∀ x ∈ dbH.keys, (x : WithTop Key) < r.begin.key := fun x hx => (hHrange x hx).2 obtain ⟨P, hPlen, hPs, hPge, hPlt, hPsortPR⟩ := crossed_pad_truncated_general (db := db₀) hrev hbegin hcross (by omega) hne hcomp₀ have hPlen' : P.length = b := by simpa [hbdef] using hPlen have hPge' : ∀ x ∈ P, r.begin.key ≤ (x : WithTop Key) := by intro x hx; simpa using hPge x hx have hH_lt_P : ∀ x ∈ dbH.keys, ∀ y ∈ P, x < y := by intro x hx y hy exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltB x hx) (hPge' y hy)) obtain ⟨C, hCge, hCnotin⟩ := exists_le_not_mem (res.keys ++ dbH.keys) (res.keys.getLast hne) have hCnotres : C ∉ res.keys := fun h => hCnotin (List.mem_append_left _ h) have hCnotH : C ∉ dbH.keys := fun h => hCnotin (List.mem_append_right _ h) have hCgtRes : ∀ a ∈ res.keys, a < C := by intro a ha have hle : a ≤ res.keys.getLast hne := (hsort.pairwise.imp le_of_lt).rel_getLast ha exact lt_of_le_of_ne (le_trans hle hCge) (fun h => hCnotres (h ▸ ha)) have hHltC : ∀ a ∈ dbH.keys, a < C := by intro a ha have h1 : (a : WithTop Key) < (C : WithTop Key) := lt_of_lt_of_le (hHltB a ha) (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge)) exact WithTop.coe_lt_coe.mp h1 have hHP : (dbH.keys ++ P).SortedLT := List.sortedLT_append.mpr ⟨dbH.sorted, hPs, hH_lt_P⟩ have hHPres_lt : ∀ x ∈ (dbH.keys ++ P), ∀ y ∈ res.keys, x < y := by intro x hx y hy rcases List.mem_append.mp hx with hxH | hxP · exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltB x hxH) (hall_ge y hy)) · exact hPlt x hxP y hy have hHPres : (dbH.keys ++ P ++ res.keys).SortedLT := List.sortedLT_append.mpr ⟨hHP, hsort, hHPres_lt⟩ have hsingle : ([C] : List Key).SortedLT := by rw [List.sortedLT_cons] exact ⟨by simp, List.sortedLT_nil⟩ have hcrossList : ∀ a ∈ (dbH.keys ++ P ++ res.keys), ∀ y ∈ ([C] : List Key), a < y := by intro a ha y hy rw [List.mem_singleton] at hy subst hy rcases List.mem_append.mp ha with ha' | haR · rcases List.mem_append.mp ha' with haH | haP · exact hHltC a haH · exact lt_of_lt_of_le (hPlt a haP _ (List.getLast_mem hne)) hCge · exact hCgtRes a haR have hsort₂ : (dbH.keys ++ P ++ res.keys ++ [C]).SortedLT := List.sortedLT_append.mpr ⟨hHPres, hsingle, hcrossList⟩ let db₂ : DB := ⟨dbH.keys ++ P ++ res.keys ++ [C], hsort₂⟩ have hdb₂ : db₂.keys = dbH.keys ++ P ++ res.keys ++ [C] := rfl have hfil₂ : db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P ++ res.keys ++ [C] := by rw [hdb₂, List.filter_append, List.filter_append, List.filter_append] have hHf : dbH.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = [] := by rw [List.filter_eq_nil_iff] intro x hx rw [decide_eq_true_eq] exact not_le.mpr (hHltB x hx) have hPf : P.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P := by rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact hPge' x hx have hresf : res.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = res.keys := by rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact hall_ge x hx have hCf : ([C] : List Key).filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = [C] := by rw [List.filter_eq_self] intro x hx rw [List.mem_singleton] at hx subst hx rw [decide_eq_true_eq] exact le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge) rw [hHf, hPf, hresf, hCf] simp have hcE₂ : cnt db₂ r.end_.key = 0 := by apply cnt_eq_zero_of_forall_ge intro x hx rw [hdb₂] at hx rcases List.mem_append.mp hx with hx' | hxC · rcases List.mem_append.mp hx' with hx'' | hxR · rcases List.mem_append.mp hx'' with hxH | hxP · exact hHgeE x hxH · exact le_trans (le_of_lt hcross) (hPge' x hxP) · exact le_trans (le_of_lt hcross) (hall_ge x hxR) · rw [List.mem_singleton] at hxC subst hxC exact le_trans (le_of_lt hcross) (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge)) have hcB₂ : cnt db₂ r.begin.key = s := by change db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = s rw [hdb₂, List.countP_append, List.countP_append, List.countP_append] have hHc : dbH.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = dbH.keys.length := cnt_eq_length_of_forall_lt dbH hHltB have hPc : P.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by rw [List.countP_eq_zero] intro x hx rw [decide_eq_true_eq] exact not_lt.mpr (hPge' x hx) have hresc : res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by rw [List.countP_eq_zero] intro x hx rw [decide_eq_true_eq] exact not_lt.mpr (hall_ge x hx) have hCc : ([C] : List Key).countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by rw [List.countP_eq_zero] intro x hx rw [List.mem_singleton] at hx subst hx rw [decide_eq_true_eq] exact not_lt.mpr (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge)) rw [hHc, hPc, hresc, hCc, hHlen] simp have hn₂ : db₂.keys.length = s + b + t + 1 := by rw [hdb₂, List.length_append, List.length_append, List.length_append, hHlen, hPlen', htdef, List.length_singleton] have hdropP : (P ++ res.keys ++ [C]).drop b = res.keys ++ [C] := by have hbP : b = P.length := hPlen'.symm rw [hbP, List.append_assoc] rw [List.drop_append_of_le_length le_rfl, List.drop_length] simp have hck₂ : RangeRead.completeKeys db₂ r = res.keys := by rw [completeKeys_eq_filter_ge_drop_take (db := db₂) (r := r) hrev hbegin (by omega), hfil₂, hdropP] have hK : min (cnt db₂ r.end_.key + (r.end_.offset - 1).toNat) db₂.keys.length - (cnt db₂ r.begin.key + b) = t := by have hE : (r.end_.offset - 1).toNat = eo := heodef.symm rw [hcE₂, hcB₂, hn₂, hE, hse] rw [Nat.min_eq_left (by omega)] omega have hK' : min (db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db₂.keys.length - (db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) + b) = t := by simpa [cnt] using hK rw [hK', List.take_append_of_le_length (le_of_eq htdef), htdef, List.take_length] have hcomp₂ : RangeRead.Compatible db₂ r res := by refine ⟨hcomp₀.1, Or.inl ⟨hmore, ?_, hne⟩⟩ rw [hck₂] have hk_db₂ : k ∉ db₂.keys := by rw [hdb₂] intro hmem rcases List.mem_append.mp hmem with hmem' | hmemC · rcases List.mem_append.mp hmem' with hmem'' | hmemR · rcases List.mem_append.mp hmem'' with hmemH | hmemP · exact hkH hmemH · exact absurd (hPge' k hmemP) (not_le.mpr hkB) · exact absurd (hall_ge k hmemR) (not_le.mpr hkB) · rw [List.mem_singleton] at hmemC have hkC : k = C := hmemC have h1 : (k : WithTop Key) < (C : WithTop Key) := lt_of_lt_of_le hkB (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge)) rw [hkC] at h1 exact (lt_irrefl (C : WithTop Key)) h1 let db₁ : DB := db₂.insert k hk_db₂ have hcE₁ : cnt db₁ r.end_.key = 0 := by rw [show db₁ = db₂.insert k hk_db₂ from rfl, cnt_insert_not_lt db₂ k hk_db₂ (v := r.end_.key) (not_lt.mpr hkE)] exact hcE₂ have hcB₁ : cnt db₁ r.begin.key = s + 1 := by rw [show db₁ = db₂.insert k hk_db₂ from rfl, cnt_insert_lt db₂ k hk_db₂ (v := r.begin.key) hkB, hcB₂] have hn₁ : db₁.keys.length = s + b + t + 2 := by rw [show db₁ = db₂.insert k hk_db₂ from rfl, DB.insert_keys, List.orderedInsert_length, hn₂] have hfil₁ : db₁.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P ++ res.keys ++ [C] := by have hsingle_filter : List.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) (k :: db₂.keys) = db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) := by rw [List.filter_cons] have hkf : decide (r.begin.key ≤ (k : WithTop Key)) = false := by rw [decide_eq_false_iff_not] exact not_le.mpr hkB rw [hkf] rfl have hperm : List.Perm ((List.orderedInsert (· ≤ ·) k db₂.keys).filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))) (db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))) := by have h := (List.perm_orderedInsert (· ≤ ·) k db₂.keys).filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) rwa [hsingle_filter] at h have hs₁ : ((List.orderedInsert (· ≤ ·) k db₂.keys).filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))).SortedLT := List.sortedLT_iff_pairwise.mpr ((db₂.insert k hk_db₂).sorted.pairwise.filter _) have hs₂ : (db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))).SortedLT := List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _) rw [show db₁ = db₂.insert k hk_db₂ from rfl, DB.insert_keys] exact (List.SortedLT.eq_of_mem_iff hs₁ hs₂ (fun x => hperm.mem_iff)).trans hfil₂ have hck₁ : RangeRead.completeKeys db₁ r = res.keys.take (t - 1) := by rw [completeKeys_eq_filter_ge_drop_take (db := db₁) (r := r) hrev hbegin (by omega), hfil₁, hdropP] have hK : min (cnt db₁ r.end_.key + (r.end_.offset - 1).toNat) db₁.keys.length - (cnt db₁ r.begin.key + b) = t - 1 := by have hE : (r.end_.offset - 1).toNat = eo := heodef.symm rw [hcE₁, hcB₁, hn₁, hE, hse] rw [Nat.min_eq_left (by omega)] omega have hK' : min (db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db₁.keys.length - (db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) + b) = t - 1 := by simpa [cnt] using hK rw [hK', List.take_append_of_le_length (by omega : t - 1 ≤ res.keys.length)] have hnot₁ : ¬ RangeRead.Compatible db₁ r res := by intro hc rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] at hc rw [hck₁] at hc have hf : List.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) (res.keys.take (t - 1)) = res.keys.take (t - 1) := by rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.mem_of_mem_take hx) rw [hf] at hc have heq : res.keys.take (t - 1) = res.keys := hc.2 have hlen := congrArg List.length heq rw [List.length_take, htdef] at hlen have htpos : 0 < t := by rw [htdef]; exact List.length_pos_of_ne_nil hne omega intro cr hs by_contra hkcr have hagree : AgreeOn cr db₂ db₁ := (ConflictRange.keys_insert_of_not_mem cr db₂ hk_db₂ hkcr).symm exact hnot₁ ((hs db₂ db₁ hagree).mp hcomp₂) end FormalConflictRange namespace FormalConflictRange private theorem crossedTrunc_begin_key_exists_coe {r : RangeRead} (h : r.begin.key ≠ (⊤ : WithTop Key)) : ∃ v : Key, r.begin.key = (↑v : WithTop Key) := by cases hk : r.begin.key with | top => exact absurd hk h | coe v => exact ⟨v, rfl⟩ /-- **Large-gap branch minimality for the forward truncated crossed read at any positive begin offset.** -/ theorem minimal_truncatedRange_of_crossed_B_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (hbig : intervalCard r.end_.key r.begin.key ≤ (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞)) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] rw [minimal_iff_sound_and_necessaryRange] refine ⟨?_, ?_⟩ · have hs := sound_truncatedRange_of_crossed_B_general (r := r) (res := res) hrev hmore hne hbegin hcross hend hbig rwa [hlast] at hs · intro k hkB hklt have hklast : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hklt) obtain ⟨db₀, hcomp₀⟩ := hread have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by intro x hx have hmem : x ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp₀).subset hx exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin) (RangeRead.mem_completeKeys.mp hmem).2.1 have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by obtain ⟨x, hx⟩ : ∃ x, x ∈ res.keys := by cases h : res.keys with | nil => exact absurd h hne | cons a tl => exact ⟨a, by simp⟩ have h1 : r.begin.key ≤ (x : WithTop Key) := hall_ge x hx intro htop rw [htop] at h1 exact not_le.mpr (WithTop.coe_lt_top x) h1 obtain ⟨v, hv⟩ := crossedTrunc_begin_key_exists_coe hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hkB) have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne) exact hbegin_nec.of_between hlast_nec hvk hklast /-- **Small-gap branch minimality for the forward truncated crossed read at any positive begin offset.** -/ theorem minimal_truncatedForward_of_crossed_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (hsmall : (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞) < intervalCard r.end_.key r.begin.key) : Minimal r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] rw [minimal_iff_sound_and_necessaryRange] refine ⟨?_, ?_⟩ · have hs := sound_truncatedRange_of_crossed_E_general (r := r) (res := res) hrev hmore hne hbegin hcross hend rwa [hlast] at hs · intro k hkE hklt have hklast : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hklt) by_cases hkB : (k : WithTop Key) < r.begin.key · exact necessary_of_mem_gap_crossed_truncated_general hread hmore hrev hne hbegin hcross hend hsmall hkE hkB · have hkBle : r.begin.key ≤ (k : WithTop Key) := not_lt.mp hkB obtain ⟨db₀, hcomp₀⟩ := hread have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by intro x hx have hmem : x ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp₀).subset hx exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin) (RangeRead.mem_completeKeys.mp hmem).2.1 have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by obtain ⟨x, hx⟩ : ∃ x, x ∈ res.keys := by cases h : res.keys with | nil => exact absurd h hne | cons a tl => exact ⟨a, by simp⟩ have h1 : r.begin.key ≤ (x : WithTop Key) := hall_ge x hx intro htop rw [htop] at h1 exact not_le.mpr (WithTop.coe_lt_top x) h1 obtain ⟨v, hv⟩ := crossedTrunc_begin_key_exists_coe hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hkBle) have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne) exact hbegin_nec.of_between hlast_nec hvk hklast /-- The forward truncated crossed closed form at any positive begin offset. -/ noncomputable def truncatedForwardCrossedGeneral (r : RangeRead) (res : Result) : ConflictRange := if intervalCard r.end_.key r.begin.key ≤ (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞) then truncatedRange r (res.keys.getLastD ([] : Key)) else ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ /-- The forward truncated crossed closed form is minimal on the whole region. -/ theorem minimal_truncatedForwardCrossedGeneral {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) : Minimal r res (truncatedForwardCrossedGeneral r res) := by unfold truncatedForwardCrossedGeneral by_cases hbig : intervalCard r.end_.key r.begin.key ≤ (((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞) · rw [ite_eq_left hbig] exact minimal_truncatedRange_of_crossed_B_general hread hmore hrev hne hbegin hcross hend hbig · rw [ite_eq_right hbig] exact minimal_truncatedForward_of_crossed_general hread hmore hrev hne hbegin hcross hend (not_le.mp hbig) /-- The forward truncated crossed general rule denotes the general conflict range. -/ theorem truncatedForwardCrossedGeneral_toSet_eq_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) : (truncatedForwardCrossedGeneral r res).toSet = (conflictRangeGeneral r res).toSet := (minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcross hend).toSet_eq (conflictRangeGeneral_minimal hread) /-- The same identification with the executable algorithm. -/ theorem truncatedForwardCrossedGeneral_toSet_eq_simple {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) : (truncatedForwardCrossedGeneral r res).toSet = (simpleConflictRange r res).toSet := (minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcross hend).toSet_eq (simpleConflictRange_minimal hread) end FormalConflictRange