/- 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.NegCrossTruncRevResidualLargeSentinel import FormalConflictRange.NegCrossTruncRevFinite /-! # The finite branch of the reversed crossed negative-begin truncated residual This module closes the *under* part of the finite branch of the last reversed crossed negative-begin truncated residual. The setting is * `res.more = true`, `r.reverse = true`, `r.begin.offset < 0`, `res.keys ≠ []`; * `2 ≤ r.end_.offset`; * the reported last `L` lies at or below `end_.key` (`last ≤ end_.key`); * the finite count `#reported ≥ end_.key = end_.offset - 1`; * the crossed selectors `L < begin.key`. Writing `H` for the reported head, `L` for the reported last and `cond` for the capacity condition `(reportedBelowBegin - 1) + intervalCard (keyAfter H) begin.key ≤ beginSlack`, the minimal range is `[L, if cond then keyAfter H else begin.key)`. The finite branch makes the end resolution the least stored key strictly above the reported head. Hence compatibility with `r` is the same as compatibility with the read whose end selector is `(keyAfter H, 1)`, and minimality transfers from the offset-one crossed cells. The complementary *over* part (`end_.key < last`) is not covered here. -/ namespace FormalConflictRange /-- The finite under cell of the reversed crossed negative-begin truncated residual: the finite branch on the region `last ≤ end_.key < begin.key`. -/ abbrev negCrossTruncRevResidualFiniteUnder (r : RangeRead) (res : Result) : Prop := res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧ 2 ≤ r.end_.offset ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧ res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat /-- The capacity condition of the finite under cell: after accounting for the reported keys below the begin selector, the gap `[keyAfter head, begin.key)` still fits in the begin slack. -/ noncomputable def finiteUnderCond (r : RangeRead) (res : Result) : Prop := ((reportedBelowBegin r res - 1 : ℕ) : ℕ∞) + intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) r.begin.key ≤ (beginSlack r : ℕ∞) /-- The closed form of the finite under cell: `[last reported, if cond then keyAfter head else begin.key)`. -/ noncomputable def closedFormNegCrossTruncRevResidualFiniteUnder (r : RangeRead) (res : Result) : ConflictRange := by classical let L : WithTop Key := ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) let U : WithTop Key := if finiteUnderCond r res then (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) else r.begin.key exact ⟨L, U⟩ /-! ### The end resolution is the least stored key above the reported head -/ /-- **Under compatibility the end resolution is the least stored key strictly above the reported head.** The reported keys are the stored keys in `[last, resolve end_)` read backwards, so the head is stored, the resolution lies strictly above it, and no stored key lies between them. -/ theorem resolve_end_eq_resolve_keyAfter_head {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) : resolve db r.end_ = resolve db (selAt (((keyAfter (res.keys.head hne)) : Key) : WithTop Key)) := by set H : Key := res.keys.head hne with hHdef set K : Key := keyAfter H with hKdef set L : Key := res.keys.getLast hne with hLdef set R : WithTop Key := resolve db r.end_ with hRdef have hHK : H < K := by rw [hKdef]; exact keyAfter_self_lt H have hHKcoe : ((H : Key) : WithTop Key) < ((K : Key) : WithTop Key) := WithTop.coe_lt_coe.mpr hHK have hbetween : between db ((L : Key) : WithTop Key) R = res.keys.reverse := by have h := res_keys_eq_reverse_between_resolve_end hcomp hmore hrev hne have h' : between db ((res.keys.getLast hne : Key) : WithTop Key) (resolve db r.end_) = res.keys.reverse := by have h2 := congrArg List.reverse h rw [List.reverse_reverse] at h2 exact h2.symm simpa [hLdef, hRdef] using h' have hHmem : H ∈ res.keys := by rw [hHdef]; exact List.head_mem hne have hHbetween : H ∈ between db ((L : Key) : WithTop Key) R := by rw [hbetween]; exact List.mem_reverse.mpr hHmem have hLH : ((L : Key) : WithTop Key) ≤ ((H : Key) : WithTop Key) := (of_decide_eq_true (List.mem_filter.mp hHbetween).2).1 have hHR : ((H : Key) : WithTop Key) < R := (of_decide_eq_true (List.mem_filter.mp hHbetween).2).2 have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev have hhead_le : ∀ x ∈ res.keys, x ≤ H := by intro x hx rw [hHdef] exact (hsort.pairwise.imp (fun h => le_of_lt h)).rel_head hx -- Every stored key at or above `keyAfter H` is at or above the resolution. have hclaim : ∀ k ∈ db.keys, ((K : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) → R ≤ ((k : Key) : WithTop Key) := by intro k hk hKk by_contra hkR push Not at hkR have hLk : ((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) := le_trans hLH (le_trans (le_of_lt hHKcoe) hKk) have hkbetween : k ∈ between db ((L : Key) : WithTop Key) R := by unfold between exact List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq] exact ⟨hLk, hkR⟩⟩ have hkres : k ∈ res.keys := by rw [hbetween] at hkbetween exact List.mem_reverse.mp hkbetween have hkH : k ≤ H := hhead_le k hkres exact absurd (le_trans hKk (WithTop.coe_le_coe.mpr hkH)) (not_le.mpr hHKcoe) refine le_antisymm ?_ ?_ · -- `R ≤ resolve (selAt K)` rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := selAt (((K : Key) : WithTop Key))) with hnil | htop | ⟨x, hxmem, hxeq⟩ · -- `resolve (selAt K) = ↑nil`, impossible since `↑K ≤ resolve` have hKle : ((K : Key) : WithTop Key) ≤ (([] : Key) : WithTop Key) := by rw [← hnil]; exact coe_le_resolve_selAt db K have hKnil : K = [] := by rw [WithTop.coe_le_coe] at hKle exact le_antisymm hKle (nil_le_key K) rw [hKnil] at hHK exact absurd hHK (not_lt.mpr (nil_le_key H)) · rw [htop]; exact le_top · have hKx : ((K : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := by rw [← hxeq]; exact coe_le_resolve_selAt db K rw [hxeq] exact hclaim x hxmem hKx · -- `resolve (selAt K) ≤ R` rcases eq_or_ne R (⊤ : WithTop Key) with hRtop | hRne · rw [hRtop]; exact le_top · rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hnil | htop | ⟨r, hrmem, hRr⟩ · rw [← hRdef] at hnil rw [hnil] at hHR exact absurd hHR (by simp) · rw [← hRdef] at htop exact absurd htop hRne · rw [← hRdef] at hRr have hKr : ((K : Key) : WithTop Key) ≤ ((r : Key) : WithTop Key) := by rw [hRr] at hHR exact keyAfter_le_of_lt hHR rw [hRr] exact resolve_selAt_le_of_mem hrmem (WithTop.coe_le_coe.mp hKr) /-- **A finite resolution of an offset-one selector keyed at a genuine key is a stored key.** -/ theorem mem_keys_of_resolve_selAt_eq_coe {db : DB} {b v : Key} (h : resolve db (selAt (↑b : WithTop Key)) = (↑v : WithTop Key)) : v ∈ db.keys := by rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := selAt (↑b : WithTop Key)) with hnil | htop | ⟨x, hxmem, hxeq⟩ · have hv : v = [] := WithTop.coe_eq_coe.mp (h.symm.trans hnil) have hnonneg := anchor_selAt_coe_nonneg db b have hempty : ([] : Key) ∈ db.keys := by rw [resolve_eq_ite] at hnil rw [ite_eq_right (not_lt.mpr hnonneg)] at hnil cases hk : db.keys[(selAt (↑b : WithTop Key)).anchor db |>.toNat]? with | none => rw [hk] at hnil; simp at hnil | some k => rw [hk] at hnil have hknil : k = [] := WithTop.coe_eq_coe.mp hnil rw [← hknil] exact List.mem_of_getElem? hk rw [hv] exact hempty · rw [htop] at h exact absurd h (by simp) · have hvx : v = x := WithTop.coe_eq_coe.mp (h.symm.trans hxeq) rw [hvx] exact hxmem /-- **The finite under cell reduces to the read with end selector `(keyAfter head, 1)`.** Compatibility is unchanged by replacing the end selector with the immediate successor of the reported head at offset one. -/ theorem compatible_iff_finiteUnder_reduce {r : RangeRead} {res : Result} (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hend : 2 ≤ r.end_.offset) (hLE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key) (hcount : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db { r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) } res := by intro db have hH : res.keys.headD ([] : Key) = res.keys.head hne := headD_eq_head_of_ne hne have hL : res.keys.getLastD ([] : Key) = res.keys.getLast hne := getLastD_eq_getLast_of_ne hne set r' : RangeRead := { r with end_ := selAt (((keyAfter (res.keys.head hne) : Key)) : WithTop Key) } with hr'def have hr'end : r'.end_ = selAt (((keyAfter (res.keys.head hne) : Key)) : WithTop Key) := rfl have hr'lim : r'.limit = r.limit := rfl have hr'rev : r'.reverse = r.reverse := rfl have hr'target : r' = { r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) } := by rw [hr'def, hH] -- forward direction have hfwd : RangeRead.Compatible db r res → RangeRead.Compatible db r' res := by intro hcomp have hres := resolve_end_eq_resolve_keyAfter_head (db := db) hcomp hmore hrev hne have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db r' := by unfold RangeRead.completeKeys rw [hr'rev, hrev] simp only rw [hres, hr'end] exact (compatible_congr_completeKeys hck hr'lim).mp hcomp -- backward direction have hbwd : RangeRead.Compatible db r' res → RangeRead.Compatible db r res := by intro hcomp' have hres' := resolve_end_eq_resolve_keyAfter_head (db := db) (r := r') hcomp' hmore (by rw [hr'rev, hrev]) hne -- `resolve (r'.end_) = least stored key above H` have hR' : resolve db r'.end_ = resolve db (selAt (((keyAfter (res.keys.head hne)) : Key) : WithTop Key)) := hres' -- the reported keys are the stored keys in `[L, resolve r'.end_)` read backwards have hbetween' : between db ((res.keys.getLast hne : Key) : WithTop Key) (resolve db r'.end_) = res.keys.reverse := by have h := res_keys_eq_reverse_between_resolve_end hcomp' hmore (by rw [hr'rev, hrev]) hne have h2 := congrArg List.reverse h rw [List.reverse_reverse] at h2 exact h2.symm -- We show that `resolve db r.end_` also lands on the least stored key above `H`. -- Write `R' := resolve db r'.end_`. set R' : WithTop Key := resolve db r'.end_ with hR'def set H : Key := res.keys.head hne with hHdef set L : Key := res.keys.getLast hne with hLdef have hHmem : H ∈ res.keys := by rw [hHdef]; exact List.head_mem hne have hHbetween : H ∈ between db ((L : Key) : WithTop Key) R' := by rw [hbetween'] exact List.mem_reverse.mpr hHmem have hLH : ((L : Key) : WithTop Key) ≤ ((H : Key) : WithTop Key) := (of_decide_eq_true (List.mem_filter.mp hHbetween).2).1 have hHR' : ((H : Key) : WithTop Key) < R' := (of_decide_eq_true (List.mem_filter.mp hHbetween).2).2 have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp' (by rw [hr'rev, hrev]) have hhead_le : ∀ x ∈ res.keys, x ≤ H := by intro x hx rw [hHdef] exact (hsort.pairwise.imp (fun h => le_of_lt h)).rel_head hx -- stored keys in `[L, R')` are exactly the reported keys have hstoredLe : ∀ k ∈ db.keys, ((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) → ((k : Key) : WithTop Key) < R' → k ∈ res.keys := by intro k hk hLk hkR have hkb : k ∈ between db ((L : Key) : WithTop Key) R' := by unfold between exact List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq]; exact ⟨hLk, hkR⟩⟩ rw [hbetween'] at hkb exact List.mem_reverse.mp hkb -- `end_.key ≤ head`: if `head < end_.key`, no reported key is at or above it have hEH : r.end_.key ≤ ((H : Key) : WithTop Key) := by by_contra hcon push Not at hcon have hzero : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = 0 := by apply List.countP_eq_zero.mpr intro k hk simpa using decide_eq_false (not_le.mpr (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hhead_le k hk)) hcon)) rw [hcount] at hzero have : 1 ≤ (r.end_.offset - 1).toNat := by omega omega -- the first `e` stored keys at or above `end_.key` are the reported ones have hbetweenE : between db r.end_.key R' = res.keys.reverse.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by have hLE' : ((L : Key) : WithTop Key) ≤ r.end_.key := by rw [← hL] exact hLE have hfil := between_filter_ge_eq (db := db) (L := ((L : Key) : WithTop Key)) (E := r.end_.key) (B := R') hLE' rw [← hfil, hbetween'] have hlenE : (between db r.end_.key R').length = (r.end_.offset - 1).toNat := by rw [hbetweenE, ← List.countP_eq_length_filter, List.countP_reverse, hcount] -- the stored keys at or above `end_.key` split as the reported ones plus those -- at or above `R'` have hsplit : db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = between db r.end_.key R' ++ db.keys.filter (fun k : Key => decide (R' ≤ (k : WithTop Key))) := by have hdecomp : db.keys = db.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) < R')) ++ db.keys.filter (fun k : Key => decide (¬ ((k : Key) : WithTop Key) < R')) := by have h1 := filter_lt_eq_take_countP db.sorted R' have h2 := filter_not_lt_eq_drop_countP db.sorted R' rw [h1, h2] exact (List.take_append_drop _ _).symm have hEB : r.end_.key ≤ R' := le_trans hEH (le_of_lt hHR') rw [hdecomp, List.filter_append, List.filter_append] have hK1nil : (db.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) < R'))).filter (fun k : Key => decide (R' ≤ ((k : Key) : WithTop Key))) = [] := by rw [List.filter_eq_nil_iff] intro k hk have hklt : ((k : Key) : WithTop Key) < R' := of_decide_eq_true (List.mem_filter.mp hk).2 simpa using decide_eq_false (not_le.mpr hklt) rw [hK1nil, List.nil_append] congr 1 · rw [List.filter_filter] unfold between apply List.filter_congr intro k _ by_cases hE : r.end_.key ≤ ((k : Key) : WithTop Key) <;> by_cases hB : ((k : Key) : WithTop Key) < R' <;> simp [hE, hB] · apply List.filter_congr intro k hk have hklt : ¬ ((k : Key) : WithTop Key) < R' := of_decide_eq_true (List.mem_filter.mp hk).2 have hkge : R' ≤ ((k : Key) : WithTop Key) := not_lt.mp hklt have hE : r.end_.key ≤ ((k : Key) : WithTop Key) := le_trans hEB hkge simp [hE, hkge] have hresolve : resolve db r.end_ = R' := by rw [resolve_eq_filter_getElem? (db := db) (s := r.end_) (by omega)] rw [hsplit] have hlen : (between db r.end_.key R').length = (r.end_.offset - 1).toNat := hlenE rw [List.getElem?_append_right (le_of_eq hlen)] rw [show (r.end_.offset - 1).toNat - (between db r.end_.key R').length = 0 by omega] cases hR'eq : R' with | top => have hnil : db.keys.filter (fun k : Key => decide ((⊤ : WithTop Key) ≤ ((k : Key) : WithTop Key))) = [] := by rw [List.filter_eq_nil_iff] intro k _ simp rw [hnil, List.getElem?_nil] | coe r => have hrmem : r ∈ db.keys := by apply mem_keys_of_resolve_selAt_eq_coe (b := keyAfter (res.keys.head hne)) rw [← hr'end] exact hR'def.symm.trans hR'eq have hfilt : (db.keys.filter (fun k : Key => decide ((↑r : WithTop Key) ≤ ((k : Key) : WithTop Key))))[0]? = some r := by have hsel : resolve db (selAt (↑r : WithTop Key)) = (↑r : WithTop Key) := resolve_selAt_self hrmem rw [resolve_eq_filter_getElem? (db := db) (s := selAt (↑r : WithTop Key)) (by norm_num : (1 : Int) ≤ (selAt (↑r : WithTop Key)).offset)] at hsel have hidx : ((selAt (↑r : WithTop Key)).offset - 1).toNat = 0 := by simp [selAt] rw [hidx, selAt_key] at hsel cases hq : (db.keys.filter (fun k : Key => decide ((↑r : WithTop Key) ≤ ((k : Key) : WithTop Key))))[0]? with | none => rw [hq] at hsel; simp at hsel | some k => rw [hq] at hsel; simpa using hsel rw [hfilt] have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db r' := by unfold RangeRead.completeKeys rw [hr'rev, hrev] simp only rw [hresolve, hr'end] exact (compatible_congr_completeKeys hck hr'lim).mpr hcomp' constructor · intro h rw [← hr'target] exact hfwd h · intro h rw [← hr'target] at h exact hbwd h /-- **Elementary `ℕ∞` arithmetic for the finite under cell.** For `t ≥ 1`, subtracting one from `t` on the left of a sum costs exactly one unit of slack. -/ theorem enat_natCast_sub_one_add_le_iff {I : ℕ∞} {q t : ℕ} (ht : 1 ≤ t) : (((t - 1 : ℕ) : ℕ∞) + I ≤ (q : ℕ∞)) ↔ (I + (t : ℕ∞) ≤ (q : ℕ∞) + 1) := by have hts : ((t : ℕ) : ℕ∞) = ((t - 1 : ℕ) : ℕ∞) + 1 := by rw [← ENat.natCast_one, ← ENat.natCast_add] congr 1 omega rw [hts] rw [show I + (((t - 1 : ℕ) : ℕ∞) + 1) = (((t - 1 : ℕ) : ℕ∞) + I) + 1 by rw [add_comm I]; ac_rfl] set m : ℕ∞ := ((t - 1 : ℕ) : ℕ∞) + I by_cases hm : m = ⊤ · rw [hm]; simp · rw [ENat.add_one_le_iff hm, ENat.lt_add_one_iff (ENat.natCast_ne_top q)] /-! ### A general bound on the reported keys below the begin selector At a negative begin offset the begin anchor sits either `beginSlack + 1` places below `begin.key` (when it is nonnegative) or before the start of the database, so the stored keys in `[resolve begin, begin.key)` occupy at most `beginSlack + 1` slots. The reported keys below `begin.key` are a subcollection of those slots. -/ /-- At a negative begin offset the stored keys in `[resolve begin, begin.key)` fit in `beginSlack + 1` slots. -/ theorem between_resolve_begin_length_le_beginSlack_succ {db : DB} {r : RangeRead} (hbegin : r.begin.offset < 0) : (between db (resolve db r.begin) r.begin.key).length ≤ beginSlack r + 1 := by set d : ℕ := (between db (resolve db r.begin) r.begin.key).length with hd have hoff : r.begin.offset ≤ 0 := le_of_lt hbegin have hEB : resolve db r.begin ≤ r.begin.key := resolve_le_key_of_offset_nonpos hoff have hdec : cnt db r.begin.key = cnt db (resolve db r.begin) + d := cnt_eq_add_between db hEB have hcntEmin : cnt db (resolve db r.begin) = min (r.begin.anchor db).toNat db.keys.length := by rw [cnt, countP_lt_resolve] have hcntB : (cnt db r.begin.key : ℤ) = r.begin.anchor db + (beginSlack r : ℤ) + 1 := by have hanc := anchor_eq_count_sub_slack db r hoff have hc : ((List.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) db.keys : ℕ) : ℤ) = (cnt db r.begin.key : ℤ) := rfl rw [hc] at hanc linarith rcases lt_or_ge (r.begin.anchor db) 0 with hneg | hpos · have hres : resolve db r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hneg rw [hres, cnt_nil, Nat.zero_add] at hdec have hcntd : (cnt db r.begin.key : ℤ) = (d : ℤ) := by rw [hdec] have hd_int : (d : ℤ) ≤ (beginSlack r : ℤ) := by linarith have hd_nat : d ≤ beginSlack r := by exact_mod_cast hd_int omega · have hcast : ((r.begin.anchor db).toNat : ℤ) = r.begin.anchor db := Int.toNat_of_nonneg hpos have hcnat : cnt db r.begin.key = (r.begin.anchor db).toNat + beginSlack r + 1 := by have h : (cnt db r.begin.key : ℤ) = ((r.begin.anchor db).toNat : ℤ) + (beginSlack r : ℤ) + 1 := by rw [hcast]; linarith exact_mod_cast h have hlt : (r.begin.anchor db).toNat < db.keys.length := by have hle : cnt db r.begin.key ≤ db.keys.length := cnt_le_length db _ omega rw [hcntEmin, Nat.min_eq_left (le_of_lt hlt)] at hdec omega /-- The reported keys below the begin selector are stored in `[resolve begin, begin.key)`. -/ theorem reportedBelowBegin_le_between_resolve_begin {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (_hbegin : r.begin.offset < 0) : reportedBelowBegin r res ≤ (between db (resolve db r.begin) r.begin.key).length := by have hstep1 := List.Sublist.countP_le (p := fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) (RangeRead.compatible_keys_prefix hcomp).sublist have hstep2 : (RangeRead.completeKeys db r).countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := (RangeRead.completeKeys_perm_inRange db r).countP_eq _ have hstep3 : (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) ≤ (between db (resolve db r.begin) r.begin.key).length := by have hin : RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < resolve db r.end_)) := rfl rw [hin, List.countP_filter] unfold between rw [← List.countP_eq_length_filter] apply countP_le_countP_of_imp intro k _ hk rw [Bool.and_eq_true] at hk rw [decide_eq_true_eq] exact ⟨(of_decide_eq_true hk.2).1, of_decide_eq_true hk.1⟩ calc reportedBelowBegin r res = res.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := rfl _ ≤ (RangeRead.completeKeys db r).countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := hstep1 _ = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := hstep2 _ ≤ (between db (resolve db r.begin) r.begin.key).length := hstep3 /-- **The reported-below-begin bound.** At a negative begin offset, the reported keys below `begin.key` number at most `beginSlack + 1`. -/ theorem reportedBelowBegin_le_beginSlack_succ {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hbegin : r.begin.offset < 0) : reportedBelowBegin r res ≤ beginSlack r + 1 := le_trans (reportedBelowBegin_le_between_resolve_begin hcomp hbegin) (between_resolve_begin_length_le_beginSlack_succ hbegin) /-- Under the crossed finite under cell every reported key lies strictly below `begin.key`, so all of them are counted by `reportedBelowBegin`. -/ theorem reportedBelowBegin_eq_length_of_crossed {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key) : reportedBelowBegin r res = res.keys.length := by obtain ⟨db, hcomp⟩ := hread have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev have hH : res.keys.headD ([] : Key) = res.keys.head hne := headD_eq_head_of_ne hne rw [hH] at hcross have hHK : res.keys.head hne < keyAfter (res.keys.head hne) := keyAfter_self_lt _ unfold reportedBelowBegin rw [List.countP_eq_length] intro k hk rw [decide_eq_true_eq] have hkH : k ≤ res.keys.head hne := (hsort.pairwise.imp (fun h => le_of_lt h)).rel_head hk exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkH) (lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hHK) (le_of_lt hcross)) /-- The finite under capacity condition is the small-gap condition of the reduced offset-one read, on the crossed region. -/ theorem finiteUnderCond_iff_crossedSmall {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key) : finiteUnderCond r res ↔ intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) r.begin.key + (res.keys.length : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1 := by have hrep := reportedBelowBegin_eq_length_of_crossed hread hrev hne hcross have ht : 1 ≤ res.keys.length := List.length_pos_iff.mpr hne unfold finiteUnderCond rw [hrep] exact enat_natCast_sub_one_add_le_iff ht /-- When the finite under capacity condition fails on the crossed region, the large-gap condition of the reduced offset-one read holds. -/ theorem crossedLarge_of_not_finiteUnderCond {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key) (hnot : ¬ finiteUnderCond r res) : (beginSlack r : ℕ∞) + 2 ≤ intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) r.begin.key + (res.keys.length : ℕ∞) := by rw [finiteUnderCond_iff_crossedSmall hread hrev hne hcross] at hnot have hgt : (beginSlack r : ℕ∞) + 1 < intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) r.begin.key + (res.keys.length : ℕ∞) := not_le.mp hnot have hone : ((beginSlack r : ℕ∞) + 1) ≠ ⊤ := WithTop.add_ne_top.mpr ⟨ENat.natCast_ne_top _, ENat.one_ne_top⟩ have := (ENat.add_one_le_iff hone).mpr hgt simpa [show ((beginSlack r : ℕ∞) + 1) + 1 = (beginSlack r : ℕ∞) + 2 by rw [add_assoc]; norm_num] using this /-- The crossed finite under cell of the reversed crossed negative-begin truncated residual: the finite under cell with the crossed selectors `keyAfter head < begin.key`. -/ abbrev negCrossTruncRevResidualFiniteUnderCrossed (r : RangeRead) (res : Result) : Prop := negCrossTruncRevResidualFiniteUnder r res ∧ (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key /-- **The crossed finite under cell of the residual is minimal.** The crossed case makes the end resolution the least stored key above the reported head, so the cell has the same compatible databases as the offset-one read with end selector `(keyAfter head, 1)`, and minimality transfers from the small- or large-gap offset-one cells. -/ theorem minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_crossed {r : RangeRead} {res : Result} (hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteUnderCrossed r res) : Minimal r res (closedFormNegCrossTruncRevResidualFiniteUnder r res) := by obtain ⟨hbase, hcrossK⟩ := hcell obtain ⟨hmore, hrev, hbeg, hne, hend, hLE, hcrossL, hcount⟩ := hbase let r' : RangeRead := { r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) } have hcompat : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res := fun db => compatible_iff_finiteUnder_reduce hmore hrev hne hend hLE hcount db have hread' : Readable r' res := by obtain ⟨db, hdb⟩ := hread exact ⟨db, (hcompat db).mp hdb⟩ have hr'end : r'.end_ = selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl have hr'key : r'.end_.key = (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl have hr'off : r'.end_.offset = 1 := rfl have hr'beg : r'.begin = r.begin := rfl have hr'begoff : r'.begin.offset < 0 := hbeg have hr'rev : r'.reverse = true := hrev have hr'crossK : r'.end_.key < r'.begin.key := by rw [hr'key, hr'beg]; exact hcrossK have hr'crossL : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r'.begin.key := by rw [hr'beg]; exact hcrossL by_cases hcond : finiteUnderCond r res · -- small-gap branch have hcap : intervalCard r'.end_.key r'.begin.key + (res.keys.length : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1 := by rw [hr'key, hr'beg] exact (finiteUnderCond_iff_crossedSmall hread hrev hne hcrossK).mp hcond have hcell' : negCrossTruncRevCrossedSmall r' res := by refine ⟨hmore, hr'rev, hr'begoff, hne, hr'crossL, hr'crossK, hr'off, hcap⟩ have hmin' : Minimal r' res (truncatedRangeRev r' (res.keys.getLastD ([] : Key))) := minimal_closedForm_of_negCross_trunc_rev_crossedSmall hread' hcell' have hcr : closedFormNegCrossTruncRevResidualFiniteUnder r res = truncatedRangeRev r' (res.keys.getLastD ([] : Key)) := by simp [closedFormNegCrossTruncRevResidualFiniteUnder, truncatedRangeRev, hcond, hr'end] rw [hcr] exact (minimal_congr_of_compatible_iff hcompat).mpr hmin' · -- large-gap branch have hcap : (beginSlack r : ℕ∞) + 2 ≤ intervalCard r'.end_.key r'.begin.key + (res.keys.length : ℕ∞) := by rw [hr'key, hr'beg] exact crossedLarge_of_not_finiteUnderCond hread hrev hne hcrossK hcond have hcell' : negCrossTruncRevCrossedLarge r' res := by refine ⟨hmore, hr'rev, hr'begoff, hne, hr'crossL, hr'crossK, hr'off, hcap⟩ have hmin' : Minimal r' res (closedFormNegCrossTruncRevCrossedLarge r' res) := minimal_closedForm_of_negCross_trunc_rev_crossedLarge hread' hcell' have hcr : closedFormNegCrossTruncRevResidualFiniteUnder r res = closedFormNegCrossTruncRevCrossedLarge r' res := by simp [closedFormNegCrossTruncRevResidualFiniteUnder, closedFormNegCrossTruncRevCrossedLarge, hcond, hr'beg] rw [hcr] exact (minimal_congr_of_compatible_iff hcompat).mpr hmin' /-- On the complementary, non-crossed part of the finite under cell, the capacity condition holds automatically: the interval `[keyAfter head, begin.key)` is empty, and the reported keys below `begin.key` fit in `beginSlack + 1` slots. -/ theorem finiteUnderCond_of_not_crossed {r : RangeRead} {res : Result} (hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteUnder r res) (hnotcross : ¬ (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key) : finiteUnderCond r res := by obtain ⟨db, hcomp⟩ := hread obtain ⟨hmore, hrev, hbeg, hne, hend, hLE, hcrossL, hcount⟩ := hcell have hbound := reportedBelowBegin_le_beginSlack_succ hcomp hbeg have hcard : intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) r.begin.key = 0 := intervalCard_eq_zero_of_le (le_of_not_gt hnotcross) unfold finiteUnderCond rw [hcard, add_zero, ENat.natCast_le_natCast] omega /-- The non-crossed finite under cell of the reversed crossed negative-begin truncated residual: the finite under cell with `begin.key ≤ keyAfter head`. -/ abbrev negCrossTruncRevResidualFiniteUnderNotCrossed (r : RangeRead) (res : Result) : Prop := negCrossTruncRevResidualFiniteUnder r res ∧ ¬ (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key /-- **The non-crossed finite under cell of the residual is minimal.** Here the interval `[keyAfter head, begin.key)` is empty, so the capacity condition holds and the closed form is `[last reported, keyAfter head)`. The reduced offset-one read has its begin key at or below its end key, so minimality transfers from the reversed under-end cell. -/ theorem minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_notCrossed {r : RangeRead} {res : Result} (hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteUnderNotCrossed r res) : Minimal r res (closedFormNegCrossTruncRevResidualFiniteUnder r res) := by obtain ⟨hbase, hnotcross⟩ := hcell have hbase0 : negCrossTruncRevResidualFiniteUnder r res := hbase obtain ⟨hmore, hrev, hbeg, hne, hend, hLE, hcrossL, hcount⟩ := hbase let r' : RangeRead := { r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) } have hcompat : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res := fun db => compatible_iff_finiteUnder_reduce hmore hrev hne hend hLE hcount db have hread' : Readable r' res := by obtain ⟨db, hdb⟩ := hread exact ⟨db, (hcompat db).mp hdb⟩ have hr'end : r'.end_ = selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl have hr'key : r'.end_.key = (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl have hr'off : r'.end_.offset = 1 := rfl have hr'beg : r'.begin = r.begin := rfl have hr'rev : r'.reverse = true := hrev have hr'crossL : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r'.begin.key := by rw [hr'beg]; exact hcrossL have hr'under : r'.begin.key ≤ r'.end_.key := by rw [hr'key]; exact le_of_not_gt hnotcross have hcond : finiteUnderCond r res := finiteUnderCond_of_not_crossed hread hbase0 hnotcross have hcell' : negCrossTruncRevUnder r' res := ⟨hmore, hr'rev, hbeg, hne, hr'crossL, hr'under, by rw [hr'off]⟩ have hmin' : Minimal r' res (closedFormNegCrossTruncRevUnder r' res) := minimal_closedForm_of_negCross_trunc_rev_under hread' hcell' have hcr : closedFormNegCrossTruncRevResidualFiniteUnder r res = closedFormNegCrossTruncRevUnder r' res := by simp [closedFormNegCrossTruncRevResidualFiniteUnder, closedFormNegCrossTruncRevUnder, truncatedRangeRev, hcond, hr'end] rw [hcr] exact (minimal_congr_of_compatible_iff hcompat).mpr hmin' end FormalConflictRange