/- 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.Empty import FormalConflictRange.General import FormalConflictRange.ComputableAlgorithm /-! # The residual complete-result cell The complete-result closed form has one cross-free cell not given by the earlier fixed offset rules: `begin.offset ≥ 2`, `end.offset ≥ 2`, `0 < t < e`, a reported key at or above `end.key`, and `begin.key < end.key`. This file closes it with the corrected capacity criterion. Writing `b = begin.offset - 1`, `e = end.offset - 1`, `t` for the reported keys at or above `end.key`, and `g = intervalCard begin.key end.key`, the minimal range is the truncated range when `(b - g) + t = e` and the top range when `(b - g) + t < e`. The finite branch rests on the exact count identity `completeKeys_count_ge_eq_general`: the number of complete keys at or above `end.key` is `min e A_E - (b - N)`, where `N` is the number of stored keys in `[begin.key, end.key)`. Since `N ≤ g`, the finite-branch identity forces `N = g` and `e ≤ A_E`: every compatible database fills the whole selector gap. Then the complete window is the first `e` stored keys at or above `end.key`, shifted past `b - g` of them, and agreement on `[begin.key, keyAfter last)` fixes exactly that window. The top branch is witnessed by a compatible database that prepends `b` keys below the reported head to the reported keys, so its resolved end is `⊤` while its stored count stays strictly below `c_E + e`. Every key above the reported last is then necessary, since inserting it breaks compatibility. `residual_dt_le_e` proves the two branches exhaustive, and `closedFormResidual` assembles the rule. -/ namespace FormalConflictRange /-- The begin overshoot `b = begin.offset - 1`. -/ def residualB (r : RangeRead) : ℕ := (r.begin.offset - 1).toNat /-- The end offset `e = end.offset - 1`. -/ def residualE (r : RangeRead) : ℕ := (r.end_.offset - 1).toNat /-- The number `t` of reported keys at or above `end.key`. -/ def residualT (r : RangeRead) (res : Result) : ℕ := res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) /-- **The finite branch fills the selector gap.** In a compatible database of the residual cell, if `(b - g) + t = e` with `0 < t < e` and `intervalCard begin.key end.key = g`, then the database stores all `g` keys of the gap and at least `e` keys at or above `end.key`, and the begin overshoot exceeds the gap (`g < b`). -/ theorem residual_finite_counts {db : DB} {r : RangeRead} {res : Result} {g : ℕ} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) (hdt : (residualB r - g) + residualT r res = residualE r) : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) = g ∧ g < residualB r ∧ residualE r ≤ db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := 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 := residualB r with hb set e := residualE r with he set t := residualT r res with ht set N := cE - p with hN set A := l.length - cE with hA have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hcount := completeKeys_count_ge_eq_general (db := db) (r := r) hrev hbegin hcross hend rw [← hres] at hcount have hbto : b = r.begin.offset.toNat - 1 := by rw [hb, residualB]; exact toNat_sub_one hbegin have heto : e = r.end_.offset.toNat - 1 := by rw [he, residualE]; exact toNat_sub_one hend have hcount' : t = min e A - (b - N) := by rw [hbto, heto] simpa [residualT, l, p, cE, t, N, A, ht, hl, hp, hcE, hN, hA] using hcount have hNle : N ≤ g := by have h := cnt_sub_le_intervalCard (db := db) (w₁ := r.begin.key) (w₂ := r.end_.key) hcross rw [hcard] at h have hcast := ENat.natCast_le_natCast.mp h simpa [N, p, cE, cnt, hl, hp, hcE, hN] using hcast have hbg : g < b := by have : 0 < b - g := by omega omega have hbNpos : 0 < b - N := by omega have hmin : min e A = e := by have hminge : b - N ≤ min e A := by by_contra hlt have hzero : min e A - (b - N) = 0 := Nat.sub_eq_zero_of_le (le_of_not_ge hlt) omega have hbge : b - g ≤ b - N := Nat.sub_le_sub_left hNle b omega refine ⟨?_, hbg, by omega⟩ omega /-! ### The finite-branch window and its list decompositions The complete window of a compatible database in the finite branch is the first `e` stored keys at or above `end.key`, with the begin overshoot `b - g` dropped. To compare two databases that agree on `[begin.key, keyAfter last)`, split the stored keys of that range at `end.key` and split the keys at or above `end.key` at the reported last. Both decompositions are proved by sortedness and membership. -/ private def rD (r : RangeRead) (last : Key) (db : DB) : List Key := (truncatedRange r last).keys db private def rG (r : RangeRead) (db : DB) : List Key := db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) private def rA (r : RangeRead) (last : Key) (db : DB) : List Key := db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) private def rW (r : RangeRead) (db : DB) : List Key := db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) private def rAbove (last : Key) (db : DB) : List Key := db.keys.filter (fun k : Key => decide (last < k)) private theorem mem_rD {r : RangeRead} {last : Key} {db : DB} {k : Key} : k ∈ rD r last db ↔ k ∈ db.keys ∧ r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ↑last := by rw [rD, truncatedRange_keys_eq_filter_le, List.mem_filter, List.mem_filter, decide_eq_true_eq, decide_eq_true_eq, WithTop.coe_le_coe] tauto private theorem mem_rG {r : RangeRead} {db : DB} {k : Key} : k ∈ rG r db ↔ k ∈ db.keys ∧ r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key := by simp [rG] private theorem mem_rA {r : RangeRead} {last : Key} {db : DB} {k : Key} : k ∈ rA r last db ↔ k ∈ db.keys ∧ r.end_.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ↑last := by simp [rA] private theorem mem_rW {r : RangeRead} {db : DB} {k : Key} : k ∈ rW r db ↔ k ∈ db.keys ∧ r.end_.key ≤ (k : WithTop Key) := by simp [rW] private theorem mem_rAbove {last : Key} {db : DB} {k : Key} : k ∈ rAbove last db ↔ k ∈ db.keys ∧ ↑last < (k : WithTop Key) := by simp [rAbove] private theorem sorted_rD {r : RangeRead} {last : Key} {db : DB} : (rD r last db).SortedLT := by rw [rD, truncatedRange_keys_eq_filter_le] exact List.sortedLT_iff_pairwise.mpr ((db.sorted.pairwise.filter _).filter _) private theorem sorted_rG {r : RangeRead} {db : DB} : (rG r db).SortedLT := List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) private theorem sorted_rA {r : RangeRead} {last : Key} {db : DB} : (rA r last db).SortedLT := List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) private theorem sorted_rW {r : RangeRead} {db : DB} : (rW r db).SortedLT := List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) private theorem sorted_rAbove {last : Key} {db : DB} : (rAbove last db).SortedLT := List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) private theorem rD_eq_rG_append_rA {r : RangeRead} {last : Key} {db : DB} (hBE : r.begin.key ≤ r.end_.key) (hElast : r.end_.key ≤ (↑last : WithTop Key)) : rD r last db = rG r db ++ rA r last db := by refine List.SortedLT.eq_of_mem_iff (sorted_rD) ?_ ?_ · rw [List.sortedLT_append] refine ⟨sorted_rG, sorted_rA, ?_⟩ intro x hx y hy have hx' := (mem_rG.mp hx).2.2 have hy' := (mem_rA.mp hy).2.1 exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le hx' hy') · intro k rw [mem_rD, List.mem_append, mem_rG, mem_rA] constructor · rintro ⟨hmem, hB, hklast⟩ by_cases hk : (k : WithTop Key) < r.end_.key · exact Or.inl ⟨hmem, hB, hk⟩ · exact Or.inr ⟨hmem, le_of_not_gt hk, hklast⟩ · rintro (⟨hmem, hB, hk⟩ | ⟨hmem, hE, hklast⟩) · exact ⟨hmem, hB, le_trans (le_of_lt hk) hElast⟩ · exact ⟨hmem, le_trans hBE hE, hklast⟩ private theorem rW_eq_rA_append_rAbove {r : RangeRead} {last : Key} {db : DB} (hElast : r.end_.key ≤ (↑last : WithTop Key)) : rW r db = rA r last db ++ rAbove last db := by refine List.SortedLT.eq_of_mem_iff (sorted_rW) ?_ ?_ · rw [List.sortedLT_append] refine ⟨sorted_rA, sorted_rAbove, ?_⟩ intro x hx y hy have hx' := (mem_rA.mp hx).2.2 have hy' := (mem_rAbove.mp hy).2 exact WithTop.coe_lt_coe.mp (lt_of_le_of_lt hx' hy') · intro k rw [mem_rW, List.mem_append, mem_rA, mem_rAbove] constructor · rintro ⟨hmem, hE⟩ by_cases hk : (k : WithTop Key) ≤ ↑last · exact Or.inl ⟨hmem, hE, hk⟩ · exact Or.inr ⟨hmem, lt_of_not_ge hk⟩ · rintro (⟨hmem, hE, -⟩ | ⟨hmem, hlt⟩) · exact ⟨hmem, hE⟩ · exact ⟨hmem, le_trans hElast (le_of_lt hlt)⟩ /-- **The finite-branch window.** In the finite branch the complete keys of any compatible database are the first `e` stored keys at or above `end.key`, with the begin overshoot `b - g` dropped. -/ theorem residual_window {db : DB} {r : RangeRead} {res : Result} {g : ℕ} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) (hdt : (residualB r - g) + residualT r res = residualE r) : RangeRead.completeKeys db r = ((rW r db).take (residualE r)).drop (residualB r - g) := by obtain ⟨hN, hbg, hAle⟩ := residual_finite_counts hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt have hbN : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤ (r.begin.offset - 1).toNat := by rw [show (r.begin.offset - 1).toNat = residualB r from rfl] calc db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) = g := hN _ ≤ residualB r := le_of_lt hbg have hAle' : (r.end_.offset - 1).toNat ≤ db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := hAle have h := completeKeys_eq_above_take_drop (db := db) (r := r) hrev hbegin hcross hend hbN hAle' simpa [rW, residualB, residualE, hN] using h /-- The reported last is at or above `end.key` whenever some reported key is. -/ theorem last_ge_end_of_count_pos {r : RangeRead} {res : Result} (hsort : res.keys.SortedLT) (hne : res.keys ≠ []) (htpos : 0 < res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))) : r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by obtain ⟨k, hk, hkge⟩ := List.countP_pos_iff.mp htpos rw [decide_eq_true_eq] at hkge exact le_trans hkge (WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hk)) /-- The keys in `[begin.key, end.key)` number the difference of the counts below the two endpoints. -/ private theorem rG_length_eq_cnt {r : RangeRead} {db : DB} (hBE : r.begin.key ≤ r.end_.key) : (rG r db).length = cnt db r.end_.key - cnt db r.begin.key := by have h := cnt_eq_add_between db hBE have hr : rG r db = between db r.begin.key r.end_.key := rfl rw [hr] omega /-- The keys in `[end.key, last]` number `e` in the finite branch. The complete window is the reported result; filtering it at or below the reported last removes nothing, and the general drop identity turns that filter into the truncated range with the begin overshoot removed. Splitting the truncated range at `end.key` leaves `[end.key, last]`, whose length is `e`. -/ private theorem rA_length_eq {db : DB} {r : RangeRead} {res : Result} {g : ℕ} {last : Key} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (hlast : last = res.keys.getLast hne) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) (hdt : (residualB r - g) + residualT r res = residualE r) : (rA r last db).length = residualE r := by have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hlast_mem : last ∈ res.keys := by rw [hlast]; exact List.getLast_mem hne have hmemck : last ∈ RangeRead.completeKeys db r := by rw [← hres]; exact hlast_mem have hlr : (last : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hmemck).2.2 have hfilt : (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) = res.keys := by rw [← hres, hlast] exact filter_le_getLast_eq_of_prefix hsort.pairwise (List.prefix_refl _) hne have hdrop := completeKeys_filter_le_drop (db := db) (r := r) (last := last) hrev hbegin hlr rw [hfilt] at hdrop obtain ⟨hN, hbg, hAle⟩ := residual_finite_counts hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt have hElast : r.end_.key ≤ (↑last : WithTop Key) := by rw [hlast] exact last_ge_end_of_count_pos hsort hne htpos have hGg : (rG r db).length = g := by rw [rG_length_eq_cnt hcross] simpa [cnt] using hN have hDdrop : (rD r last db).drop (residualB r) = res.keys := by rw [rD] simpa [residualB] using hdrop.symm have hD := rD_eq_rG_append_rA (r := r) (last := last) (db := db) hcross hElast have hb_eq : residualB r = g + (residualB r - g) := by omega have hA_drop : (rA r last db).drop (residualB r - g) = res.keys := by have hstep : (rD r last db).drop (residualB r) = ((rG r db) ++ (rA r last db)).drop (g + (residualB r - g)) := by conv_lhs => rw [hD] rw [hb_eq] rw [hstep, List.drop_append] at hDdrop rw [List.drop_eq_nil_of_le (by omega : (rG r db).length ≤ g + (residualB r - g)), List.nil_append] at hDdrop have hsub : g + (residualB r - g) - (rG r db).length = residualB r - g := by rw [hGg]; omega rwa [hsub] at hDdrop have hresmem : ∀ k ∈ res.keys, r.end_.key ≤ (k : WithTop Key) := by intro k hk have hkA : k ∈ rA r last db := by apply List.mem_of_mem_drop rw [hA_drop] exact hk exact (mem_rA.mp hkA).2.1 have htlen : residualT r res = res.keys.length := by rw [residualT] exact List.countP_eq_length.mpr fun k hk => by rw [decide_eq_true_eq]; exact hresmem k hk have hlen := congrArg List.length hA_drop rw [List.length_drop] at hlen omega /-- `[begin.key, end.key)` is the part of `[begin.key, last]` below `end.key`, when `end.key ≤ last`. -/ private theorem rG_eq_rD_filter_lt {r : RangeRead} {last : Key} {db : DB} (hElast : r.end_.key ≤ (↑last : WithTop Key)) : rG r db = (rD r last db).filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by refine List.SortedLT.eq_of_mem_iff sorted_rG ?_ ?_ · exact List.sortedLT_iff_pairwise.mpr (sorted_rD.pairwise.filter _) · intro k rw [mem_rG, List.mem_filter, mem_rD] constructor · rintro ⟨hmem, hB, hkE⟩ exact ⟨⟨hmem, hB, le_trans (le_of_lt hkE) hElast⟩, by rw [decide_eq_true_eq]; exact hkE⟩ · rintro ⟨⟨hmem, hB, -⟩, hkE⟩ exact ⟨hmem, hB, of_decide_eq_true hkE⟩ /-- `[end.key, last]` is the part of `[begin.key, last]` at or above `end.key`, when `begin.key ≤ end.key`. -/ private theorem rA_eq_rD_filter_ge {r : RangeRead} {last : Key} {db : DB} (hBE : r.begin.key ≤ r.end_.key) : rA r last db = (rD r last db).filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by refine List.SortedLT.eq_of_mem_iff sorted_rA ?_ ?_ · exact List.sortedLT_iff_pairwise.mpr (sorted_rD.pairwise.filter _) · intro k rw [mem_rA, List.mem_filter, mem_rD] constructor · rintro ⟨hmem, hE, hklast⟩ exact ⟨⟨hmem, le_trans hBE hE, hklast⟩, by rw [decide_eq_true_eq]; exact hE⟩ · rintro ⟨⟨hmem, -, hklast⟩, hE⟩ exact ⟨hmem, of_decide_eq_true hE, hklast⟩ /-- **Finite-branch completeness from agreement.** If a database agrees on the truncated range `[begin.key, keyAfter last)` with a finite-branch compatible database, then it is itself complete: the shared gap `[begin.key, end.key)` fills the begin overshoot, and the first `e` stored keys at or above `end.key` reach the reported last. -/ private theorem completeKeys_eq_of_truncated_eq_finite {db₁ db₂ : DB} {r : RangeRead} {res : Result} {g : ℕ} {last : Key} (hcomp : RangeRead.Compatible db₁ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (hlast : last = res.keys.getLast hne) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) (hdt : (residualB r - g) + residualT r res = residualE r) (hT : (truncatedRange r last).keys db₂ = (truncatedRange r last).keys db₁) : RangeRead.completeKeys db₂ r = res.keys := by have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev obtain ⟨hN₁, hbg, hAle₁⟩ := residual_finite_counts hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt have hElast : r.end_.key ≤ (↑last : WithTop Key) := by rw [hlast] exact last_ge_end_of_count_pos hsort hne htpos have hres₁ : res.keys = RangeRead.completeKeys db₁ r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq -- Agreement splits into the gap and the above-`end` parts. have hT' : rD r last db₂ = rD r last db₁ := by simpa [rD] using hT have hG₂ : rG r db₂ = rG r db₁ := by rw [rG_eq_rD_filter_lt (db := db₂) hElast, rG_eq_rD_filter_lt (db := db₁) hElast, hT'] have hA₂ : rA r last db₂ = rA r last db₁ := by rw [rA_eq_rD_filter_ge (db := db₂) hcross, rA_eq_rD_filter_ge (db := db₁) hcross, hT'] have hGlen₂ : (rG r db₂).length = g := by rw [hG₂, rG_length_eq_cnt (db := db₁) hcross] simpa [cnt] using hN₁ have hAlen₁ : (rA r last db₁).length = residualE r := rA_length_eq hcomp hmore hrev hne hbegin hcross hend hcard hlast htpos htlt hdt have hAlen₂ : (rA r last db₂).length = residualE r := by rw [hA₂, hAlen₁] -- The reference database's window. have hW₁ := residual_window (db := db₁) hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt have hW₁dec := rW_eq_rA_append_rAbove (r := r) (last := last) (db := db₁) hElast have htake₁ : (rW r db₁).take (residualE r) = rA r last db₁ := by rw [hW₁dec, List.take_append_of_le_length (le_of_eq hAlen₁.symm), List.take_of_length_le (le_of_eq hAlen₁)] have hresA : (rA r last db₁).drop (residualB r - g) = res.keys := by rw [← htake₁, ← hW₁, ← hres₁] -- The shared decomposition supplies the count bounds for `db₂`. have hgap₂ : db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) = g := by have h := rG_length_eq_cnt (db := db₂) hcross rw [← hGlen₂] simpa [cnt] using h.symm have hbN₂ : db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤ (r.begin.offset - 1).toNat := by rw [hgap₂] exact le_of_lt hbg have hAle₂ : (r.end_.offset - 1).toNat ≤ db₂.keys.length - db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by have h := cnt_add_above_length db₂ r.end_.key have hsub : db₂.keys.length - db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = (above db₂ r.end_.key).length := by have hcnt : db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cnt db₂ r.end_.key := rfl omega rw [hsub] have hdec := rW_eq_rA_append_rAbove (r := r) (last := last) (db := db₂) hElast have : above db₂ r.end_.key = rW r db₂ := rfl rw [this, hdec, List.length_append] have heq : (r.end_.offset - 1).toNat = residualE r := rfl rw [heq, hAlen₂] omega -- The general window formula plus the shared gap/`end` split. have hformula := completeKeys_eq_above_take_drop (db := db₂) (r := r) hrev hbegin hcross hend hbN₂ hAle₂ rw [hgap₂] at hformula have hrW₂ : db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = rW r db₂ := rfl rw [hrW₂] at hformula have hW₂dec := rW_eq_rA_append_rAbove (r := r) (last := last) (db := db₂) hElast have htake₂ : (rW r db₂).take (residualE r) = rA r last db₂ := by rw [hW₂dec, List.take_append_of_le_length (le_of_eq hAlen₂.symm), List.take_of_length_le (le_of_eq hAlen₂)] change RangeRead.completeKeys db₂ r = ((rW r db₂).take (residualE r)).drop (residualB r - g) at hformula rw [htake₂, hA₂, hresA] at hformula exact hformula /-- **Finite-branch soundness in the residual cell.** Agreement on `[begin.key, keyAfter last)` fixes compatibility for a complete result whose finite branch is `(b - g) + t = e`. -/ theorem sound_truncatedRange_of_residual_finite {r : RangeRead} {res : Result} {g : ℕ} (hmore : res.more = false) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) (hdt : (residualB r - g) + residualT r res = residualE r) : Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by have hne : res.keys ≠ [] := by intro hnil rw [residualT, hnil] at htpos simp at htpos 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 have hcomp : ∀ db : DB, RangeRead.Compatible db r res → RangeRead.withinLimit r res.keys ∧ RangeRead.completeKeys db r = res.keys := by intro db hc refine ⟨hc.1, ?_⟩ rcases hc.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq.symm constructor · intro hc₁ obtain ⟨hlim, hck₁⟩ := hcomp db₁ hc₁ have hT : (truncatedRange r (res.keys.getLast hne)).keys db₂ = (truncatedRange r (res.keys.getLast hne)).keys db₁ := hagree.symm have hck₂ := completeKeys_eq_of_truncated_eq_finite (db₁ := db₁) (db₂ := db₂) (g := g) ⟨hlim, Or.inr ⟨hmore, hck₁.symm⟩⟩ hmore hrev hne hbegin hcross hend hcard rfl htpos htlt hdt hT exact ⟨hlim, Or.inr ⟨hmore, hck₂.symm⟩⟩ · intro hc₂ obtain ⟨hlim, hck₂⟩ := hcomp db₂ hc₂ have hT : (truncatedRange r (res.keys.getLast hne)).keys db₁ = (truncatedRange r (res.keys.getLast hne)).keys db₂ := hagree have hck₁ := completeKeys_eq_of_truncated_eq_finite (db₁ := db₂) (db₂ := db₁) (g := g) ⟨hlim, Or.inr ⟨hmore, hck₂.symm⟩⟩ hmore hrev hne hbegin hcross hend hcard rfl htpos htlt hdt hT exact ⟨hlim, Or.inr ⟨hmore, hck₁.symm⟩⟩ /-- **Finite-branch minimality in the residual cell.** The truncated range `[begin.key, keyAfter last)` is minimal for a complete result in the finite branch `(b - g) + t = e`. -/ theorem minimal_truncatedRange_of_residual_finite {r : RangeRead} {res : Result} {g : ℕ} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) (hdt : (residualB r - g) + residualT r res = residualE r) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp₀⟩ := hread have hne : res.keys ≠ [] := by intro hnil rw [residualT, hnil] at htpos simp at htpos have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp₀ refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · rw [← hgetLast] exact sound_truncatedRange_of_residual_finite hmore hrev hbegin hcross hend hcard htpos htlt hdt · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne) have hBtop : r.begin.key ≠ (⊤ : WithTop Key) := by obtain ⟨m, _, hmge⟩ := List.countP_pos_iff.mp htpos rw [decide_eq_true_eq] at hmge intro htop rw [htop] at hcross exact absurd (le_trans hcross hmge) (not_le_of_gt (WithTop.coe_lt_top m)) obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hBtop have hvB : r.begin.key = (↑v : WithTop Key) := hv.symm have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hvB have hvk : v ≤ k := WithTop.coe_le_coe.mp (hvB ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs private theorem residual_between_begin_head {db₀ : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) : (between db₀ r.begin.key ((res.keys.head hne : Key) : WithTop Key)).length = (r.begin.offset - 1).toNat := by set H : Key := res.keys.head hne with hH have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hneCK : RangeRead.completeKeys db₀ r ≠ [] := by rw [← hres]; exact hne have hpos : 0 ≤ r.begin.anchor db₀ := anchor_nonneg_of_one_le hbegin obtain ⟨a, ha_mem, ha_res, ha_head⟩ := RangeRead.completeKeys_head_resolve (db := db₀) (r := r) hrev hneCK hpos have hHhead? : res.keys.head? = some H := by rw [hH, List.head?_eq_some_head hne] have hahead? : (RangeRead.completeKeys db₀ r).head? = some a := by rw [← ha_head, List.head?_eq_some_head hneCK] have hsome : some H = some a := by rw [← hHhead?, ← hahead?] exact congrArg List.head? hres have ha : a = H := (Option.some.inj hsome.symm) have hresolveB : resolve db₀ r.begin = (↑H : WithTop Key) := by rw [← ha, ha_res] -- anchor < length have hlt : (r.begin.anchor db₀).toNat < db₀.keys.length := by by_contra h have htop : resolve db₀ r.begin = (⊤ : WithTop Key) := resolve_eq_top hpos (le_of_not_gt h) rw [htop] at hresolveB exact absurd hresolveB.symm (by simp) have hget : db₀.keys[(r.begin.anchor db₀).toNat] = H := by have h := resolve_eq_getElem (db := db₀) (s := r.begin) hpos hlt rw [h] at hresolveB exact WithTop.coe_eq_coe.mp hresolveB have hcnt : cnt db₀ (↑H : WithTop Key) = (r.begin.anchor db₀).toNat := by rw [cnt_coe] exact countP_lt_eq_of_getElem db₀.sorted hlt hget have hanchor : (r.begin.anchor db₀).toNat = cnt db₀ r.begin.key + (r.begin.offset - 1).toNat := by rw [anchor_toNat_eq hbegin] rfl have hBH : r.begin.key ≤ (↑H : WithTop Key) := by have h := begin_key_le_head_of_one_le_offset (r := r) (res := res) ⟨db₀, hcomp⟩ hne hbegin rwa [hH] have hadd := cnt_eq_add_between db₀ hBH omega private theorem residual_topWitness_of_D {db₀ : DB} {r : RangeRead} {res : Result} {g n : ℕ} {H : Key} (hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hHle : ∀ k ∈ res.keys, (↑H : WithTop Key) ≤ (↑k : WithTop Key)) (hBH : r.begin.key ≤ (↑H : WithTop Key)) (D : List Key) (hDlen : D.length = residualB r) (hDsorted : D.SortedLT) (hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key)) (hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key)) (hDcntE : (D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n) (hbn : residualB r - n = residualB r - g) (htop : (residualB r - g) + residualT r res < residualE r) : ∃ w : DB, RangeRead.Compatible w r res ∧ (∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((res.keys.getLast hne : Key) : WithTop Key)) ∧ resolve w r.end_ = (⊤ : WithTop Key) ∧ w.keys.length < w.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by have hRsorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hwsorted : (D ++ res.keys).SortedLT := by rw [List.sortedLT_append] refine ⟨hDsorted, hRsorted, ?_⟩ intro a ha b hb exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hDH a ha) (hHle b hb)) let w : DB := { keys := D ++ res.keys, sorted := hwsorted } have hwkeys : w.keys = D ++ res.keys := rfl have hDBw : ∀ k ∈ w.keys, r.begin.key ≤ (↑k : WithTop Key) := by intro k hk rw [hwkeys] at hk rcases List.mem_append.mp hk with hkD | hkR · exact hDB k hkD · exact le_trans hBH (hHle k hkR) have htopKeys : (topRange r).keys w = w.keys := by unfold topRange ConflictRange.keys rw [List.filter_eq_self] intro k hk rw [decide_eq_true_eq] exact ⟨hDBw k hk, WithTop.coe_lt_top k⟩ have hwlen : w.keys.length = residualB r + res.keys.length := by rw [hwkeys, List.length_append, hDlen] have hwcnt : w.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = n + res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by rw [hwkeys, List.countP_append] have hDcnt : D.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = n := by rw [List.countP_eq_length_filter, hDcntE] rw [hDcnt] have hres_split : res.keys.length = (res.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length + residualT r res := by have h := List.length_eq_countP_add_countP (l := res.keys) (p := fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) have hc : List.countP (fun a : Key => decide ¬(decide (r.end_.key ≤ (a : WithTop Key))) = true) res.keys = res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by apply List.countP_congr intro k hk simp only [decide_eq_true_eq] exact not_le rw [hc] at h have h2 : res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = (res.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length := List.countP_eq_length_filter rw [h2] at h rw [residualT] omega have hlen_lt : w.keys.length < w.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by rw [hwlen, hwcnt, List.countP_eq_length_filter] rw [hres_split] have hee : residualE r = (r.end_.offset - 1).toNat := rfl rw [← hee] omega have hEtop : resolve w r.end_ = (⊤ : WithTop Key) := by refine resolve_eq_top (anchor_nonneg_of_one_le (by omega)) ?_ rw [anchor_toNat_eq (s := r.end_) (by omega)] omega have hckW : RangeRead.completeKeys w r = res.keys := by rw [completeKeys_eq_topRange_keys_drop (db := w) (r := r) hrev hbegin hEtop, htopKeys] rw [hwkeys] change List.drop (residualB r) (D ++ res.keys) = res.keys rw [List.drop_append_of_le_length (i := residualB r) (le_of_eq hDlen.symm), List.drop_eq_nil_of_le (le_of_eq hDlen), List.nil_append] have hwcomp : RangeRead.Compatible w r res := by refine ⟨hcomp.1, Or.inr ⟨hmore, hckW.symm⟩⟩ have hwsub : ∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by intro k hk rw [hwkeys] at hk rcases List.mem_append.mp hk with hkD | hkR · exact le_trans (le_of_lt (hDH k hkD)) (hHle _ (List.getLast_mem hne)) · exact WithTop.coe_le_coe.mpr ((hRsorted.pairwise.imp le_of_lt).rel_getLast hkR) exact ⟨w, hwcomp, hwsub, hEtop, hlen_lt⟩ private theorem residual_exists_topWitness {db₀ : DB} {r : RangeRead} {res : Result} {g : ℕ} (hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htop : (residualB r - g) + residualT r res < residualE r) : ∃ w : DB, RangeRead.Compatible w r res ∧ (∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((res.keys.getLast hne : Key) : WithTop Key)) ∧ resolve w r.end_ = (⊤ : WithTop Key) ∧ w.keys.length < w.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq set H : Key := res.keys.head hne with hH have hHmem : H ∈ res.keys := by rw [hH]; exact List.head_mem hne have hRsorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hHle : ∀ k ∈ res.keys, (↑H : WithTop Key) ≤ (↑k : WithTop Key) := by intro k hk rw [hH] exact WithTop.coe_le_coe.mpr ((hRsorted.pairwise.imp le_of_lt).rel_head hk) have hBH : r.begin.key ≤ (↑H : WithTop Key) := by have h := begin_key_le_head_of_one_le_offset (r := r) (res := res) ⟨db₀, hcomp⟩ hne hbegin rwa [hH] have hB_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by intro htop' have hle : (⊤ : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [htop'] at hBH exact absurd hle (not_le.mpr (WithTop.coe_lt_top H)) obtain ⟨v, hvB⟩ := WithTop.ne_top_iff_exists.mp hB_ne_top have hvB' : r.begin.key = (↑v : WithTop Key) := hvB.symm have hE_ne_top : r.end_.key ≠ (⊤ : WithTop Key) := by intro htop' rw [htop', intervalCard_top_right hB_ne_top] at hcard exact absurd hcard (by simp) obtain ⟨e, heE'⟩ := WithTop.ne_top_iff_exists.mp hE_ne_top have heE : r.end_.key = (↑e : WithTop Key) := heE'.symm have hcard' : intervalCard (↑v : WithTop Key) (↑e : WithTop Key) = (g : ℕ∞) := by simpa [hvB', heE] using hcard have hve : (↑v : WithTop Key) ≤ (↑e : WithTop Key) := by rw [← hvB', ← heE]; exact hcross have hBH' : (↑v : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [hvB'] at hBH have hlenBH : (between db₀ (↑v) (↑H)).length = residualB r := by have h := residual_between_begin_head (db₀ := db₀) (r := r) (res := res) hcomp hmore hrev hne hbegin have hh : ((res.keys.head hne : Key) : WithTop Key) = (↑H : WithTop Key) := by rw [hH] rw [hvB', hh] at h simpa [residualB] using h have hleBE : (between db₀ (↑v) (↑e)).length ≤ g := by have h := between_length_le_intervalCard (db := db₀) hve rw [hcard'] at h exact_mod_cast h by_cases hEH : r.end_.key ≤ (↑H : WithTop Key) · -- Case `end.key ≤ H`: fill `min b g` chain keys below `end.key`, -- then take the remaining `b - min b g` database keys in `[end.key, H)`. have hEH' : (↑e : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [heE] at hEH have hsplit : (between db₀ (↑v) (↑H)).length = (between db₀ (↑v) (↑e)).length + (between db₀ (↑e) (↑H)).length := by have h1 := cnt_eq_add_between db₀ hve have h2 := cnt_eq_add_between db₀ hBH' have h3 := cnt_eq_add_between db₀ hEH' omega have hleBE_b : (between db₀ (↑v) (↑e)).length ≤ residualB r := by omega have hleBE_n : (between db₀ (↑v) (↑e)).length ≤ min (residualB r) g := le_min hleBE_b hleBE have hd_le : residualB r - min (residualB r) g ≤ (between db₀ (↑e) (↑H)).length := by omega set n : ℕ := min (residualB r) g with hn set D : List Key := ((List.range n).map (chain v)) ++ (between db₀ (↑e) (↑H)).take (residualB r - n) with hD have hDlen : D.length = residualB r := by simp only [hD, List.length_append, List.length_map, List.length_range, List.length_take] omega have hbtsorted : (between db₀ (↑e) (↑H)).SortedLT := List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _) have hD2sorted : ((between db₀ (↑e) (↑H)).take (residualB r - n)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (R := (· < ·)) (List.sortedLT_iff_pairwise.mp hbtsorted)) have hDsorted : D.SortedLT := by rw [hD, List.sortedLT_append] refine ⟨sortedLT_map_chain v n, hD2sorted, ?_⟩ intro a ha b hb rw [List.mem_map] at ha obtain ⟨i, hi, rfl⟩ := ha have hi_lt : i < g := lt_of_lt_of_le (List.mem_range.mp hi) (min_le_right _ _) have hae : chain v i < e := by rw [chain_lt_iff] rw [hcard'] exact_mod_cast hi_lt have hbmem := List.mem_of_mem_take hb rw [between, List.mem_filter] at hbmem exact lt_of_lt_of_le hae (WithTop.coe_le_coe.mp (of_decide_eq_true hbmem.2).1) have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by intro k hk rw [hD, List.mem_append] at hk rcases hk with hk1 | hk2 · rw [List.mem_map] at hk1 obtain ⟨i, hi, rfl⟩ := hk1 rw [hvB'] exact WithTop.coe_le_coe.mpr (chain_le v i) · have hbmem := List.mem_of_mem_take hk2 rw [between, List.mem_filter] at hbmem rw [hvB'] exact le_trans hve (of_decide_eq_true hbmem.2).1 have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by intro k hk rw [hD, List.mem_append] at hk rcases hk with hk1 | hk2 · rw [List.mem_map] at hk1 obtain ⟨i, hi, rfl⟩ := hk1 have hi_lt : i < g := lt_of_lt_of_le (List.mem_range.mp hi) (min_le_right _ _) have hae : chain v i < e := by rw [chain_lt_iff] rw [hcard'] exact_mod_cast hi_lt exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hae) hEH' · have hbmem := List.mem_of_mem_take hk2 rw [between, List.mem_filter] at hbmem exact (of_decide_eq_true hbmem.2).2 have hDcntE : (D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by rw [hD, List.filter_append] have h1 : (List.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) ((List.range n).map (chain v))) = (List.range n).map (chain v) := by rw [List.filter_eq_self] intro k hk rw [List.mem_map] at hk obtain ⟨i, hi, rfl⟩ := hk rw [decide_eq_true_eq, heE] have hi_lt : i < g := lt_of_lt_of_le (List.mem_range.mp hi) (min_le_right _ _) have hae : chain v i < e := by rw [chain_lt_iff] rw [hcard'] exact_mod_cast hi_lt exact WithTop.coe_lt_coe.mpr hae have h2 : (List.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) ((between db₀ (↑e) (↑H)).take (residualB r - n))) = [] := by rw [List.filter_eq_nil_iff] intro k hk rw [decide_eq_true_eq] have hbmem := List.mem_of_mem_take hk rw [between, List.mem_filter] at hbmem have hEk : (↑e : WithTop Key) ≤ (↑k : WithTop Key) := (of_decide_eq_true hbmem.2).1 intro hklt rw [heE] at hklt exact absurd hklt (not_lt.mpr hEk) rw [h1, h2, List.length_append, List.length_map, List.length_range, List.length_nil] omega have hbn : residualB r - n = residualB r - g := by simp only [hn] by_cases hbg : residualB r ≤ g · rw [min_eq_left hbg] have hz : residualB r - g = 0 := by omega rw [Nat.sub_self, hz] · rw [min_eq_right (le_of_not_ge hbg)] exact residual_topWitness_of_D (g := g) (n := n) (H := H) hcomp hmore hrev hne hbegin hend hHle hBH D hDlen hDsorted hDB hDH hDcntE hbn htop · -- Case `H < end.key`: there are only `b` keys in `[B, H)`, and -- `b ≤ g`, so use them all. have hHE : (↑H : WithTop Key) < r.end_.key := lt_of_not_ge hEH have hHE' : (↑H : WithTop Key) < (↑e : WithTop Key) := by rwa [heE] at hHE have hb_le_g : residualB r ≤ g := by have h1 := cnt_eq_add_between db₀ hBH' have h2 := cnt_eq_add_between db₀ hve have h3 := cnt_le_cnt_of_le db₀ (le_of_lt hHE') omega set n : ℕ := residualB r with hn set D : List Key := between db₀ (↑v) (↑H) with hD have hDlen : D.length = residualB r := by rw [hD]; exact hlenBH have hD2sorted : D.SortedLT := List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _) have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by intro k hk rw [hD, between, List.mem_filter] at hk rw [hvB'] exact (of_decide_eq_true hk.2).1 have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by intro k hk rw [hD, between, List.mem_filter] at hk exact (of_decide_eq_true hk.2).2 have hDcntE : (D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by rw [show D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = D from by rw [List.filter_eq_self] intro k hk rw [decide_eq_true_eq, heE] exact lt_trans (hDH k hk) hHE'] exact hDlen have hbn : residualB r - n = residualB r - g := by simp only [hn, Nat.sub_self] omega exact residual_topWitness_of_D (g := g) (n := n) (H := H) hcomp hmore hrev hne hbegin hend hHle hBH D hDlen hD2sorted hDB hDH hDcntE hbn htop private theorem residual_necessary_above_last_top {db₀ : DB} {r : RangeRead} {res : Result} {g : ℕ} (hread : Readable r res) (hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htop : (residualB r - g) + residualT r res < residualE r) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by by_cases hx : x ∈ res.keys · exact necessary_of_mem_result hread hx · intro cr hs by_contra hcr obtain ⟨w, hwcomp, hwsub, hwtop, hwlt⟩ := residual_exists_topWitness (db₀ := db₀) (r := r) (res := res) (g := g) hcomp hmore hrev hne hbegin hcross hend hcard htop have hx0 : x ∉ w.keys := by intro hxw have hxle : x ≤ res.keys.getLast hne := WithTop.coe_le_coe.mp (hwsub x hxw) have hxeq : x = res.keys.getLast hne := le_antisymm hxle hlo exact hx (hxeq ▸ List.getLast_mem hne) have hsub : ∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := fun k hk => le_trans (hwsub k hk) (WithTop.coe_le_coe.mpr hlo) have hEins : resolve (w.insert x hx0) r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_insert_top hx0 hwlt hend exact hx (mem_result_of_insert (db₀ := w) hwcomp hs hcr hmore hne hx0 hsub hEins) /-- **Top-branch minimality in the residual cell.** When `(b - g) + t < e`, the unbounded top range `[begin.key, ⊤)` is the minimal sound conflict range. Soundness is `sound_topRange_of_one_le_le`; keys up to the reported last are necessary by the begin key, the reported last, and convexity, while keys above it are `necessary_above_last_of_residual_top`. -/ theorem minimal_topRange_of_residual_top {r : RangeRead} {res : Result} {g : ℕ} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htop : (residualB r - g) + residualT r res < residualE r) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp₀⟩ := hread refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · exact sound_topRange_of_one_le_le (by omega) (by omega) hcross · intro k hk cr hs obtain ⟨hBk, -⟩ := hk by_cases hklast : k ≤ res.keys.getLast hne · have hBtop : r.begin.key ≠ (⊤ : WithTop Key) := by obtain ⟨m, _, hmge⟩ := List.countP_pos_iff.mp htpos rw [decide_eq_true_eq] at hmge intro htop' rw [htop'] at hcross exact absurd (le_trans hcross hmge) (not_le_of_gt (WithTop.coe_lt_top m)) obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hBtop have hvB : r.begin.key = (↑v : WithTop Key) := hv.symm have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hvB have hvk : v ≤ k := by change r.begin.key ≤ (↑k : WithTop Key) at hBk exact WithTop.coe_le_coe.mp (by rwa [hvB] at hBk) 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) cr hs · have hklast' : res.keys.getLast hne < k := lt_of_not_ge hklast exact residual_necessary_above_last_top ⟨db₀, hcomp₀⟩ hcomp₀ hmore hrev hne hbegin hcross hend hcard htop hklast'.le cr hs /-- **The capacity criterion never overruns the end offset.** In the residual complete-result cell the two branches are exhaustive: `(b - g) + t ≤ e`. The proof reads the exact count identity `completeKeys_count_ge_eq_general`: at most `g` stored keys lie in `[begin.key, end.key)`, and a positive count of reported keys at or above `end.key` makes the top window long enough. -/ theorem residual_dt_le_e {db : DB} {r : RangeRead} {res : Result} {g : ℕ} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) : (residualB r - g) + residualT r res ≤ residualE r := by have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hEq := completeKeys_count_ge_eq_general (db := db) (r := r) hrev hbegin hcross hend have ht : residualT r res = (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by rw [residualT, hres] rw [ht, hEq] have hNle : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤ g := by have h := cnt_sub_le_intervalCard db hcross rw [hcard] at h exact_mod_cast h set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he set A := db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hA set N := db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hN have htpos' : 0 < min e A - (b - N) := by rw [residualT, hres] at htpos rw [hEq] at htpos simpa [b, e, A, N] using htpos have hmain : (b - g) + (min e A - (b - N)) ≤ e := by by_cases hbg : b ≤ g · have hz : b - g = 0 := by omega rw [hz, Nat.zero_add] exact le_trans (Nat.sub_le _ _) (min_le_left _ _) · have hgb : g < b := lt_of_not_ge hbg have hNb : N ≤ g := hNle omega simpa [residualB, residualE, b, e, A, N] using hmain /-- **The residual complete-result closed form.** It is the truncated range `[begin.key, keyAfter (last reported))` in the finite branch `(b - g) + t = e`, and the unbounded top range `[begin.key, ⊤)` in the complementary branch. -/ noncomputable def closedFormResidual (r : RangeRead) (res : Result) (g : ℕ) : ConflictRange := if (residualB r - g) + residualT r res = residualE r then truncatedRange r (res.keys.getLastD ([] : Key)) else topRange r /-- **The residual closed form is minimal.** The dispatch is exhaustive by `residual_dt_le_e`; the finite branch is `minimal_truncatedRange_of_residual_finite` and the strict branch is `minimal_topRange_of_residual_top`. -/ theorem minimal_closedForm_of_residual {r : RangeRead} {res : Result} {g : ℕ} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : Minimal r res (closedFormResidual r res g) := by obtain ⟨db₀, hcomp₀⟩ := hread have hdtle := residual_dt_le_e (db := db₀) hcomp₀ hmore hrev hbegin hcross (by omega) hcard htpos unfold closedFormResidual by_cases hdt : (residualB r - g) + residualT r res = residualE r · rw [ite_eq_left hdt] exact minimal_truncatedRange_of_residual_finite ⟨db₀, hcomp₀⟩ hmore hrev hbegin hcross (by omega) hcard htpos htlt hdt · rw [ite_eq_right hdt] have htop : (residualB r - g) + residualT r res < residualE r := lt_of_le_of_ne hdtle hdt exact minimal_topRange_of_residual_top ⟨db₀, hcomp₀⟩ hmore hrev hne hbegin hcross hend hcard htpos htop /-- The residual closed form denotes the same key set as the general conflict range. -/ theorem closedFormResidual_toSet_eq_general {r : RangeRead} {res : Result} {g : ℕ} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : (closedFormResidual r res g).toSet = (conflictRangeGeneral r res).toSet := (minimal_closedForm_of_residual hread hmore hrev hne hbegin hcross hend hcard htpos htlt).toSet_eq (conflictRangeGeneral_minimal hread) /-- The residual closed form denotes the same key set as the executable algorithm. -/ theorem closedFormResidual_toSet_eq_simple {r : RangeRead} {res : Result} {g : ℕ} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞)) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : (closedFormResidual r res g).toSet = (simpleConflictRange r res).toSet := (minimal_closedForm_of_residual hread hmore hrev hne hbegin hcross hend hcard htpos htlt).toSet_eq (simpleConflictRange_minimal hread) /-! ## The infinite-gap case When `intervalCard begin.key end.key = ⊤`, there are arbitrarily many chain keys between the selector keys, so the witness for the top branch can use `b` chain keys without any finite capacity hypothesis. The finite branch `d + t = e` is impossible there (it would require the finite database to fill an infinite gap), so the top branch is the only outcome. This removes the last finiteness restriction from the residual criterion. -/ private theorem residual_exists_topWitness_infinite {db₀ : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hinf : intervalCard r.begin.key r.end_.key = ⊤) (htpos : 0 < residualT r res) (htop : residualT r res < residualE r) : ∃ w : DB, RangeRead.Compatible w r res ∧ (∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((res.keys.getLast hne : Key) : WithTop Key)) ∧ resolve w r.end_ = (⊤ : WithTop Key) ∧ w.keys.length < w.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq set H : Key := res.keys.head hne with hH have hRsorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hHle : ∀ k ∈ res.keys, (↑H : WithTop Key) ≤ (↑k : WithTop Key) := by intro k hk rw [hH] exact WithTop.coe_le_coe.mpr ((hRsorted.pairwise.imp le_of_lt).rel_head hk) have hBH : r.begin.key ≤ (↑H : WithTop Key) := by have h := begin_key_le_head_of_one_le_offset (r := r) (res := res) ⟨db₀, hcomp⟩ hne hbegin rwa [hH] have hB_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by intro htop' have hle : (⊤ : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [htop'] at hBH exact absurd hle (not_le.mpr (WithTop.coe_lt_top H)) obtain ⟨v, hvB⟩ := WithTop.ne_top_iff_exists.mp hB_ne_top have hvB' : r.begin.key = (↑v : WithTop Key) := hvB.symm have hE_ne_top : r.end_.key ≠ (⊤ : WithTop Key) := by intro htop' simp [residualT, htop'] at htpos obtain ⟨e, heE'⟩ := WithTop.ne_top_iff_exists.mp hE_ne_top have heE : r.end_.key = (↑e : WithTop Key) := heE'.symm have hinf' : intervalCard (↑v : WithTop Key) (↑e : WithTop Key) = ⊤ := by simpa [hvB', heE] using hinf have hve : (↑v : WithTop Key) ≤ (↑e : WithTop Key) := by rw [← hvB', ← heE]; exact hcross have hBH' : (↑v : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [hvB'] at hBH have hlenBH : (between db₀ (↑v) (↑H)).length = residualB r := by have h := residual_between_begin_head (db₀ := db₀) (r := r) (res := res) hcomp hmore hrev hne hbegin have hh : ((res.keys.head hne : Key) : WithTop Key) = (↑H : WithTop Key) := by rw [hH] rw [hvB', hh] at h simpa [residualB] using h by_cases hEH : r.end_.key ≤ (↑H : WithTop Key) · have hEH' : (↑e : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [heE] at hEH set n : ℕ := residualB r with hn set D : List Key := (List.range n).map (chain v) with hD have hDlen : D.length = residualB r := by simp [hD, hn] have hDsorted : D.SortedLT := by rw [hD]; exact sortedLT_map_chain v n have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by intro k hk rw [hD, List.mem_map] at hk obtain ⟨i, hi, rfl⟩ := hk rw [hvB'] exact WithTop.coe_le_coe.mpr (chain_le v i) have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by intro k hk rw [hD, List.mem_map] at hk obtain ⟨i, hi, rfl⟩ := hk exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (chain_lt_of_intervalCard_eq_top hinf' i)) hEH' have hDcntE : (D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by rw [hD] have hfilter : (List.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) ((List.range n).map (chain v))) = (List.range n).map (chain v) := by rw [List.filter_eq_self] intro k hk rw [List.mem_map] at hk obtain ⟨i, hi, rfl⟩ := hk rw [decide_eq_true_eq, heE] exact WithTop.coe_lt_coe.mpr (chain_lt_of_intervalCard_eq_top hinf' i) rw [hfilter, List.length_map, List.length_range] exact residual_topWitness_of_D (g := residualB r) (n := n) (H := H) hcomp hmore hrev hne hbegin hend hHle hBH D hDlen hDsorted hDB hDH hDcntE (by simp [hn]) (by simpa [hn] using htop) · have hHE : (↑H : WithTop Key) < r.end_.key := lt_of_not_ge hEH have hHE' : (↑H : WithTop Key) < (↑e : WithTop Key) := by rwa [heE] at hHE set n : ℕ := residualB r with hn set D : List Key := between db₀ (↑v) (↑H) with hD have hDlen : D.length = residualB r := by rw [hD]; exact hlenBH have hDsorted : D.SortedLT := by rw [hD]; exact List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _) have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by intro k hk rw [hD, between, List.mem_filter] at hk rw [hvB'] exact (of_decide_eq_true hk.2).1 have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by intro k hk rw [hD, between, List.mem_filter] at hk exact (of_decide_eq_true hk.2).2 have hDcntE : (D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by rw [show D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = D from by rw [List.filter_eq_self] intro k hk rw [decide_eq_true_eq, heE] exact lt_trans (hDH k hk) hHE'] exact hDlen exact residual_topWitness_of_D (g := residualB r) (n := n) (H := H) hcomp hmore hrev hne hbegin hend hHle hBH D hDlen hDsorted hDB hDH hDcntE (by simp [hn]) (by simpa [hn] using htop) private theorem residual_necessary_above_last_top_infinite {db₀ : DB} {r : RangeRead} {res : Result} (hread : Readable r res) (hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hinf : intervalCard r.begin.key r.end_.key = ⊤) (htpos : 0 < residualT r res) (htop : residualT r res < residualE r) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by by_cases hx : x ∈ res.keys · exact necessary_of_mem_result hread hx · intro cr hs by_contra hcr obtain ⟨w, hwcomp, hwsub, hwtop, hwlt⟩ := residual_exists_topWitness_infinite (db₀ := db₀) (r := r) (res := res) hcomp hmore hrev hne hbegin hcross hend hinf htpos htop have hx0 : x ∉ w.keys := by intro hxw have hxle : x ≤ res.keys.getLast hne := WithTop.coe_le_coe.mp (hwsub x hxw) have hxeq : x = res.keys.getLast hne := le_antisymm hxle hlo exact hx (hxeq ▸ List.getLast_mem hne) have hsub : ∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := fun k hk => le_trans (hwsub k hk) (WithTop.coe_le_coe.mpr hlo) have hEins : resolve (w.insert x hx0) r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_insert_top hx0 hwlt hend exact hx (mem_result_of_insert (db₀ := w) hwcomp hs hcr hmore hne hx0 hsub hEins) /-- **Top-branch minimality with an infinite selector gap.** When `intervalCard begin.key end.key = ⊤`, the finite branch is impossible and the unbounded top range is minimal as soon as `t < e`. -/ theorem minimal_topRange_of_residual_top_infinite {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hinf : intervalCard r.begin.key r.end_.key = ⊤) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp₀⟩ := hread refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · exact sound_topRange_of_one_le_le (by omega) (by omega) hcross · intro k hk cr hs obtain ⟨hBk, -⟩ := hk by_cases hklast : k ≤ res.keys.getLast hne · have hBtop : r.begin.key ≠ (⊤ : WithTop Key) := by obtain ⟨m, _, hmge⟩ := List.countP_pos_iff.mp htpos rw [decide_eq_true_eq] at hmge intro htop' rw [htop'] at hcross exact absurd (le_trans hcross hmge) (not_le_of_gt (WithTop.coe_lt_top m)) obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hBtop have hvB : r.begin.key = (↑v : WithTop Key) := hv.symm have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hvB have hvk : v ≤ k := by change r.begin.key ≤ (↑k : WithTop Key) at hBk exact WithTop.coe_le_coe.mp (by rwa [hvB] at hBk) 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) cr hs · have hklast' : res.keys.getLast hne < k := lt_of_not_ge hklast exact residual_necessary_above_last_top_infinite ⟨db₀, hcomp₀⟩ hcomp₀ hmore hrev hne hbegin hcross hend hinf htpos htlt hklast'.le cr hs /-- The capacity deficit `d = max 0 (b - g)`, with `g : ℕ∞`; an infinite gap leaves nothing to fill. -/ def residualD (r : RangeRead) (g : ℕ∞) : ℕ := if g = ⊤ then 0 else residualB r - g.toNat /-- For a finite gap the deficit is ordinary truncated subtraction. -/ theorem residualD_coe (r : RangeRead) (n : ℕ) : residualD r (n : ℕ∞) = residualB r - n := by unfold residualD rw [ite_eq_right (by simp)] rfl /-- **The residual complete-result closed form with an infinite gap parameter.** It is the truncated range in the finite branch `d + t = e` and the top range otherwise, where `d = max 0 (b - g)` and `g` is the full interval cardinality, possibly `⊤`. -/ noncomputable def closedFormResidualGeneral (r : RangeRead) (res : Result) (g : ℕ∞) : ConflictRange := if residualD r g + residualT r res = residualE r then truncatedRange r (res.keys.getLastD ([] : Key)) else topRange r /-- **The infinite-gap residual closed form is minimal.** The finite branch is impossible, and `minimal_topRange_of_residual_top_infinite` gives the top range. -/ theorem minimal_closedForm_of_residual_general {r : RangeRead} {res : Result} {g : ℕ∞} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = g) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : Minimal r res (closedFormResidualGeneral r res g) := by by_cases hg : g = ⊤ · have hinf : intervalCard r.begin.key r.end_.key = ⊤ := by rw [hcard, hg] have hne' : residualD r g + residualT r res ≠ residualE r := by simp [residualD, hg] omega unfold closedFormResidualGeneral rw [ite_eq_right hne'] exact minimal_topRange_of_residual_top_infinite hread hmore hrev hne hbegin hcross hend hinf htpos htlt · obtain ⟨n, rfl⟩ := ENat.ne_top_iff_exists.mp hg have hcardn : intervalCard r.begin.key r.end_.key = (n : ℕ∞) := hcard unfold closedFormResidualGeneral rw [residualD_coe] by_cases hdt : (residualB r - n) + residualT r res = residualE r · rw [ite_eq_left hdt] exact minimal_truncatedRange_of_residual_finite hread hmore hrev hbegin hcross (by omega) hcardn htpos htlt hdt · rw [ite_eq_right hdt] have hle := residual_dt_le_e (db := Classical.choose hread) (Classical.choose_spec hread) hmore hrev hbegin hcross (by omega) hcardn htpos have htop : (residualB r - n) + residualT r res < residualE r := lt_of_le_of_ne hle hdt exact minimal_topRange_of_residual_top hread hmore hrev hne hbegin hcross hend hcardn htpos htop /-- The general residual closed form denotes the general conflict range. -/ theorem closedFormResidualGeneral_toSet_eq_general {r : RangeRead} {res : Result} {g : ℕ∞} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = g) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : (closedFormResidualGeneral r res g).toSet = (conflictRangeGeneral r res).toSet := (minimal_closedForm_of_residual_general hread hmore hrev hne hbegin hcross hend hcard htpos htlt).toSet_eq (conflictRangeGeneral_minimal hread) /-- The general residual closed form denotes the executable algorithm. -/ theorem closedFormResidualGeneral_toSet_eq_simple {r : RangeRead} {res : Result} {g : ℕ∞} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hcard : intervalCard r.begin.key r.end_.key = g) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) : (closedFormResidualGeneral r res g).toSet = (simpleConflictRange r res).toSet := (minimal_closedForm_of_residual_general hread hmore hrev hne hbegin hcross hend hcard htpos htlt).toSet_eq (simpleConflictRange_minimal hread) /-- **The total cross-free complete-result closed form.** On a complete result with `begin.offset ≥ 1` and `begin.key ≤ end_.key`, the automatic three-branch rule covers `end.offset ≤ 1`, the finite branch `t = e`, and the below-`end_.key` branch; the equal-selector rule covers `begin.key = end_.key`; and `closedFormResidualGeneral` covers the remaining strict cell `begin.key < end_.key`, `0 < t < e`. The gap parameter is the full interval cardinality, so the infinite-gap case is included. -/ noncomputable def closedFormCompleteCrossFree (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 1 then closedFormOffsetOne r res else if residualT r res = residualE r ∨ (∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) then closedFormOffsetOne r res else if r.begin.key = r.end_.key then closedFormKeyEqComplete r res else closedFormResidualGeneral r res (intervalCard r.begin.key r.end_.key) /-- **The total cross-free complete-result rule is minimal at every positive begin offset.** -/ theorem minimal_closedForm_of_complete_crossFree {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormCompleteCrossFree r res) := by obtain ⟨db₀, hcomp₀⟩ := hread have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp₀.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq unfold closedFormCompleteCrossFree by_cases hend1 : r.end_.offset ≤ 1 · rw [ite_eq_left hend1] exact minimal_closedForm_of_complete_general ⟨db₀, hcomp₀⟩ hmore hne hrev hbegin hcross (Or.inl hend1) · rw [ite_eq_right hend1] by_cases hcase : residualT r res = residualE r ∨ (∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) · rw [ite_eq_left hcase] exact minimal_closedForm_of_complete_general ⟨db₀, hcomp₀⟩ hmore hne hrev hbegin hcross (Or.inr hcase) · rw [ite_eq_right hcase] have htne : residualT r res ≠ residualE r := fun h => hcase (Or.inl h) have hbelow : ¬ (∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) := fun h => hcase (Or.inr h) have ht0 : residualT r res ≠ 0 := by intro h0 apply hbelow intro k hk have hk' := List.countP_eq_zero.mp h0 k hk rw [decide_eq_true_eq] at hk' exact not_le.mp hk' have htpos : 0 < residualT r res := Nat.pos_of_ne_zero ht0 have htle' := completeKeys_count_ge_le_general (db := db₀) hrev hbegin hcross (by omega : 1 ≤ r.end_.offset) have htle : residualT r res ≤ residualE r := by simpa [residualT, residualE, hres] using htle' have htlt : residualT r res < residualE r := lt_of_le_of_ne htle htne have hend2 : 2 ≤ r.end_.offset := by omega by_cases hkey : r.begin.key = r.end_.key · rw [ite_eq_left hkey] exact minimal_closedForm_of_key_eq_complete_general ⟨db₀, hcomp₀⟩ hmore hrev hne hbegin hkey hend2 · rw [ite_eq_right hkey] have hltkey : r.begin.key < r.end_.key := lt_of_le_of_ne hcross hkey exact minimal_closedForm_of_residual_general (g := intervalCard r.begin.key r.end_.key) ⟨db₀, hcomp₀⟩ hmore hrev hne hbegin hcross hend2 rfl htpos htlt /-- The total cross-free complete rule denotes the general conflict range. -/ theorem closedFormCompleteCrossFree_toSet_eq_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) : (closedFormCompleteCrossFree r res).toSet = (conflictRangeGeneral r res).toSet := (minimal_closedForm_of_complete_crossFree hread hmore hrev hne hbegin hcross).toSet_eq (conflictRangeGeneral_minimal hread) /-- The total cross-free complete rule denotes the executable algorithm. -/ theorem closedFormCompleteCrossFree_toSet_eq_simple {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) : (closedFormCompleteCrossFree r res).toSet = (simpleConflictRange r res).toSet := (minimal_closedForm_of_complete_crossFree hread hmore hrev hne hbegin hcross).toSet_eq (simpleConflictRange_minimal hread) end FormalConflictRange