/- 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.Residual import FormalConflictRange.Nonpos /-! # The cross-free nonpositive-begin complete closed form At a nonpositive begin offset the resolved begin can clamp below `begin.key`, so the empty key can be forced into every sound range. This module closes the cross-free complete-result cell there: `begin.offset ≤ 0`, `begin.key ≤` the reported head, `begin.key ≤ end_.key`, and a nonempty complete result. Writing `t` for the number of reported keys at or above `end_.key` and `e = end_.offset - 1`, the minimal range is * `[⊥, end_.key)` when `end_.offset ≤ 1`; * `[⊥, keyAfter (last reported))` when `t = e` (the finite branch); * `[⊥, ⊤)` when `t < e` (the top branch). The finite branch fixes the complete keys below `keyAfter (last reported)`; the top branch forces the end selector to resolve to `⊤`, and inserting a key above the reported last then keeps that sentinel and adds the key to the complete window. -/ open FormalConflictRange namespace FormalConflictRange /-- The empty key is at or below every `WithTop Key` bound. -/ theorem coe_nil_le_key_withTop (t : WithTop Key) : ((([] : Key) : WithTop Key)) ≤ t := by cases t with | top => exact le_top | coe k => exact WithTop.coe_le_coe.mpr (nil_le_key k) /-- At a nonpositive offset, a resolution that is not the empty key lies strictly below the selector's own key. -/ theorem resolve_lt_key_of_offset_nonpos_of_ne_nil {db : DB} {s : Selector} (hoff : s.offset ≤ 0) (hne : resolve db s ≠ (([] : Key) : WithTop Key)) : resolve db s < s.key := by rcases lt_or_ge (s.anchor db) 0 with hneg | hpos · rw [resolve_eq_nil hneg] at hne exact absurd rfl hne · have hcnt : (s.anchor db).toNat < db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := (Int.toNat_lt hpos).mpr (by simp only [Selector.anchor]; omega) have hlt : (s.anchor db).toNat < db.keys.length := lt_of_lt_of_le hcnt (List.countP_le_length) rw [resolve_eq_getElem hpos hlt] exact getElem_lt_of_lt_countP_top db.sorted hlt hcnt /-- In a complete nonempty result at a nonpositive begin offset with `begin.key` at or below the reported head, the begin selector clamps to the empty key. -/ theorem resolve_eq_nil_of_complete_begin_le_head {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : resolve db r.begin = (([] : Key) : WithTop Key) := by have hres_eq : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq set head : Key := res.keys.head hne with hhead have hhead_ck : head ∈ RangeRead.completeKeys db r := by rw [← hres_eq]; exact List.head_mem hne have hhead_lo : resolve db r.begin ≤ (head : WithTop Key) := (RangeRead.mem_completeKeys.mp hhead_ck).2.1 have hhead_hi : (head : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hhead_ck).2.2 by_contra hne0 have hlt : resolve db r.begin < r.begin.key := resolve_lt_key_of_offset_nonpos_of_ne_nil hbegin hne0 have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by intro ht rw [ht] at hhead_lo exact absurd hhead_lo (not_le.mpr (WithTop.coe_lt_top head)) rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with h | h | ⟨k, hkdb, hkres⟩ · exact hne0 h · exact hnot_top h · have hk_le : (k : WithTop Key) ≤ (head : WithTop Key) := by rw [← hkres]; exact hhead_lo have hk_lt_end : (k : WithTop Key) < resolve db r.end_ := lt_of_le_of_lt hk_le hhead_hi have hk_ck : k ∈ RangeRead.completeKeys db r := RangeRead.mem_completeKeys.mpr ⟨hkdb, by rw [hkres], hk_lt_end⟩ have hk_res : k ∈ res.keys := by rw [hres_eq]; exact hk_ck have hhead_le_k : head ≤ k := (RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hk_res have hhead_le_res : (head : WithTop Key) ≤ resolve db r.begin := by rw [hkres]; exact WithTop.coe_le_coe.mpr hhead_le_k have hkeq : resolve db r.begin = (head : WithTop Key) := le_antisymm hhead_lo hhead_le_res rw [hkeq] at hlt exact absurd hlo (not_le.mpr hlt) /-- For a compatible *complete* result, the complete keys are exactly the stored keys in `[resolve begin, last reported]`. -/ theorem completeKeys_eq_filter_le_last {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) : RangeRead.completeKeys db r = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ k ≤ res.keys.getLast hne)) := by have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hlast : res.keys.getLast hne ∈ RangeRead.completeKeys db r := by rw [← hres]; exact List.getLast_mem hne have hlt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hlast).2.2 have hf := completeKeys_filter_le_eq (db := db) (r := r) (last := res.keys.getLast hne) hrev hlt have hpair : (RangeRead.completeKeys db r).Pairwise (· < ·) := by have h := RangeRead.completeKeys_pairwise (db := db) (r := r) rw [hrev] at h exact h have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp have hfiltr : (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = RangeRead.completeKeys db r := by have h := filter_le_getLast_eq_of_prefix hpair hpre hne exact h.trans hres rw [← hf, hfiltr] /-- The complete keys at or above `end_.key` are the stored keys at or above `end_.key` and at or below the reported last, in a complete cross-free nonpositive read. -/ theorem completeKeys_filter_ge_eq_db_filter {db : DB} {r : RangeRead} {res : Result} {last : Key} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hlast : last = res.keys.getLast hne) (_hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) : (RangeRead.completeKeys db r).filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) := by have hmain := completeKeys_eq_filter_le_last (db := db) (r := r) (res := res) hcomp hrev hmore hne rw [hmain, ← hlast] rw [List.filter_filter, List.filter_filter] apply List.filter_congr intro k _ rw [← Bool.decide_and, ← Bool.decide_and, decide_eq_decide] constructor · rintro ⟨hE, hs, hl⟩ exact ⟨hl, hE⟩ · rintro ⟨hl, hE⟩ exact ⟨hE, le_trans hstart hE, hl⟩ /-- The number of reported keys at or above `end_.key` is the length of the stored keys in `[end_.key, last]`, in a complete cross-free nonpositive read. -/ theorem residualT_eq_filter_length {db : DB} {r : RangeRead} {res : Result} {last : Key} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hlast : last = res.keys.getLast hne) (hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) : residualT r res = ((db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length := by have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hc := completeKeys_filter_ge_eq_db_filter (db := db) (r := r) (res := res) (last := last) hcomp hrev hmore hne hlast hbegin hstart unfold residualT rw [List.countP_eq_length_filter, hres, hc] /-- The reported over-count never exceeds the end offset, in a complete cross-free nonpositive read with `end_.offset ≥ 2`. -/ theorem residualT_le_residualE_nonpos {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) : 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 hlast : res.keys.getLast hne ∈ RangeRead.completeKeys db r := by rw [← hres]; exact List.getLast_mem hne have hlt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hlast).2.2 have h := filter_length_le_offset_of_resolve_end_gt (db := db) (r := r) (last := res.keys.getLast hne) (by omega) hlt rw [residualT_eq_filter_length hcomp hrev hmore hne rfl hbegin hstart] simpa [residualE] using h /-- A stronger Boolean filter is strictly shorter when it misses a member of the weaker filter. -/ theorem length_filter_lt_of_mem_not {L : List Key} {p q : Key → Bool} (himp : ∀ a, p a = true → q a = true) {x : Key} (hxq : x ∈ L.filter q) (hxp : x ∉ L.filter p) : (L.filter p).length < (L.filter q).length := by have hsub := filter_sublist_filter_of_imp (l := L) himp rcases lt_or_eq_of_le hsub.length_le with h | h · exact h · exfalso have heq := hsub.eq_of_length h rw [← heq] at hxq exact hxp hxq end FormalConflictRange /-- **Finite-branch completeness from agreement (nonpositive cross-free complete).** If a database agrees on the bottom truncated range with a compatible finite-branch database, then it is itself complete. -/ theorem completeKeys_eq_res_of_agree_nonpos_complete {db₁ db₂ : DB} {r : RangeRead} {res : Result} {last : Key} (hcomp : RangeRead.Compatible db₁ r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hstart : resolve db₁ r.begin ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hlast : last = res.keys.getLast hne) (hte : residualT r res = residualE r) (hT : (truncatedRangeBottom last).keys db₁ = (truncatedRangeBottom last).keys db₂) : RangeRead.completeKeys db₂ r = res.keys := 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 he1 : 0 < residualE r := by unfold residualE; omega have htpos : 0 < residualT r res := by rw [hte]; exact he1 have hElast : r.end_.key ≤ (last : WithTop Key) := by rw [hlast] exact last_ge_end_of_count_pos hsort hne htpos -- Agreement on `[⊥, keyAfter last)` is equality of the keys at or below `last`. have hbE : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter last : WithTop Key))) = db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter last : WithTop Key))) := by have h : (truncatedRangeBottom last).keys db₁ = (truncatedRangeBottom last).keys db₂ := hT unfold truncatedRangeBottom at h rwa [keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h have hb : db₁.keys.filter (fun k : Key => decide (k ≤ last)) = db₂.keys.filter (fun k : Key => decide (k ≤ last)) := by have hc : ∀ db : DB, db.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter last : WithTop Key))) = db.keys.filter (fun k : Key => decide (k ≤ last)) := by intro db apply List.filter_congr intro k _ rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] rwa [hc db₁, hc db₂] at hbE have hhead_le_last : res.keys.head hne ≤ last := by rw [hlast] exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne) have hkey_ka : r.begin.key ≤ (keyAfter last : WithTop Key) := le_trans (le_trans hlo (WithTop.coe_le_coe.mpr hhead_le_last)) (WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt last))) have hbegineq : resolve db₂ r.begin = resolve db₁ r.begin := by symm exact resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) hbegin hkey_ka hbE -- The reference count is `e`. have hM₁len : ((db₁.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length = residualE r := by have h := residualT_eq_filter_length (db := db₁) (r := r) (res := res) (last := last) hcomp hrev hmore hne hlast hbegin hstart rw [← h] exact hte have hM₂ : ((db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))) = ((db₁.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))) := by apply eq_of_forall_mem_iff_of_pairwise · exact db₂.sorted.pairwise.sublist (List.filter_sublist.trans List.filter_sublist) · exact db₁.sorted.pairwise.sublist (List.filter_sublist.trans List.filter_sublist) · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨⟨hk₂, hEk⟩, hkl⟩ have hmem : k ∈ db₁.keys.filter (fun k : Key => decide (k ≤ last)) := by rw [hb] exact List.mem_filter.mpr ⟨hk₂, decide_eq_true hkl⟩ exact ⟨⟨(List.mem_filter.mp hmem).1, hEk⟩, hkl⟩ · rintro ⟨⟨hk₁, hEk⟩, hkl⟩ have hmem : k ∈ db₂.keys.filter (fun k : Key => decide (k ≤ last)) := by rw [← hb] exact List.mem_filter.mpr ⟨hk₁, decide_eq_true hkl⟩ exact ⟨⟨(List.mem_filter.mp hmem).1, hEk⟩, hkl⟩ have hM₂len : ((db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length = residualE r := by rw [hM₂, hM₁len] have hlt₂ : (last : WithTop Key) < resolve db₂ r.end_ := resolve_end_gt_of_filter_length_le (db := db₂) (r := r) (last := last) (by omega) (le_of_eq hM₂len) -- The complete keys of `db₂` are the stored keys in `[start, last]`. have hck₂ : RangeRead.completeKeys db₂ r = db₂.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ k ≤ last)) := by unfold RangeRead.completeKeys RangeRead.inRange rw [hrev] rw [hbegineq] apply List.filter_congr intro k hk rw [decide_eq_decide] constructor · rintro ⟨hs, hkt⟩ refine ⟨hs, ?_⟩ by_contra hnk have hklast : last < k := lt_of_not_ge hnk have hEk : r.end_.key ≤ (k : WithTop Key) := le_trans hElast (WithTop.coe_le_coe.mpr (le_of_lt hklast)) have hkL : k ∈ (db₂.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter (fun x : Key => decide (x ≤ k)) := by rw [List.mem_filter, List.mem_filter] exact ⟨⟨hk, decide_eq_true hEk⟩, decide_eq_true le_rfl⟩ have hknot : k ∉ (db₂.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter (fun x : Key => decide (x ≤ last)) := by rw [List.mem_filter, List.mem_filter] rintro ⟨⟨-, -⟩, hle⟩ rw [decide_eq_true_eq] at hle exact absurd hle (not_le.mpr hklast) have himp : ∀ a : Key, decide (a ≤ last) = true → decide (a ≤ k) = true := by intro a ha rw [decide_eq_true_eq] at ha ⊢ exact le_trans ha (le_of_lt hklast) have hstrict := length_filter_lt_of_mem_not (L := db₂.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))) (p := fun x : Key => decide (x ≤ last)) (q := fun x : Key => decide (x ≤ k)) himp hkL hknot have hbound := filter_length_le_offset_of_resolve_end_gt (db := db₂) (r := r) (last := k) (by omega) hkt unfold residualE at hM₂len omega · rintro ⟨hs, hkl⟩ exact ⟨hs, lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkl) hlt₂⟩ -- Agreement on `[start, last]` is exactly the reported keys. have hfilter_eq : db₂.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ k ≤ last)) = db₁.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ k ≤ last)) := by apply eq_of_forall_mem_iff_of_pairwise · exact db₂.sorted.pairwise.sublist List.filter_sublist · exact db₁.sorted.pairwise.sublist List.filter_sublist · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨hk₂, hs, hl⟩ have hmem : k ∈ db₁.keys.filter (fun k : Key => decide (k ≤ last)) := by rw [hb] exact List.mem_filter.mpr ⟨hk₂, decide_eq_true hl⟩ exact ⟨(List.mem_filter.mp hmem).1, hs, hl⟩ · rintro ⟨hk₁, hs, hl⟩ have hmem : k ∈ db₂.keys.filter (fun k : Key => decide (k ≤ last)) := by rw [← hb] exact List.mem_filter.mpr ⟨hk₁, decide_eq_true hl⟩ exact ⟨(List.mem_filter.mp hmem).1, hs, hl⟩ have hck₁ : RangeRead.completeKeys db₁ r = db₁.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ k ≤ last)) := by have h := completeKeys_eq_filter_le_last (db := db₁) (r := r) (res := res) hcomp hrev hmore hne rwa [← hlast] at h rw [hck₂, hfilter_eq, ← hck₁, ← hres] /-- **A finite end resolution fills the reported count.** In a complete cross-free nonpositive read with `end.offset ≥ 2`, if the end selector resolves to a genuine key, then the number of reported keys at or above `end_.key` is exactly `end.offset - 1`. -/ theorem residualT_eq_residualE_of_resolve_end_ne_top {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (_hne : res.keys ≠ []) (_hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (htop : resolve db r.end_ ≠ (⊤ : WithTop Key)) : 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 set Q := db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hQ set e := (r.end_.offset - 1).toNat with he have hQs : Q.SortedLT := by rw [hQ] exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) have hend1 : 1 ≤ r.end_.offset := by omega have hQres := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend1 have heQ : e < Q.length := by by_contra hge rw [List.getElem?_eq_none (le_of_not_gt hge)] at hQres exact htop hQres have htopq : resolve db r.end_ = ((Q[e] : Key) : WithTop Key) := by rw [hQres, List.getElem?_eq_getElem heQ] have hloE : resolve db r.begin ≤ r.end_.key := hstart -- The reported keys at or above `end_.key` are the first `e` stored keys there. have hck : (RangeRead.completeKeys db r).filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) := by unfold RangeRead.completeKeys RangeRead.inRange rw [ite_eq_right (by simp [hrev])] rw [hQ] apply eq_of_forall_mem_iff_of_pairwise · exact db.sorted.pairwise.sublist (List.filter_sublist.trans List.filter_sublist) · exact db.sorted.pairwise.sublist (List.filter_sublist.trans List.filter_sublist) · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨⟨hk, hlo, hhi⟩, hE⟩ exact ⟨⟨hk, hE⟩, hhi⟩ · rintro ⟨⟨hk, hE⟩, hhi⟩ exact ⟨⟨hk, le_trans hloE hE, hhi⟩, hE⟩ have htake : Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) = Q.take e := by rw [htopq, filter_lt_eq_take_countP hQs ((Q[e] : Key) : WithTop Key)] congr 1 rw [show Q.countP (fun k : Key => decide ((k : WithTop Key) < ((Q[e] : Key) : WithTop Key))) = Q.countP (fun k : Key => decide (k < Q[e])) from by apply List.countP_congr intro k _ rw [decide_eq_true_eq, decide_eq_true_eq, WithTop.coe_lt_coe]] exact countP_lt_eq_of_getElem hQs heQ rfl unfold residualT residualE rw [hres, List.countP_eq_length_filter, hck, htake, List.length_take, Nat.min_eq_left (le_of_lt heQ)] /-- **The top branch forces an unbounded end.** In a complete cross-free nonpositive read with `end.offset ≥ 2`, if the reported count at or above `end_.key` is below `end.offset - 1`, then the end selector resolves to `⊤`. -/ theorem resolve_end_eq_top_of_residualT_lt_residualE {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (htlt : residualT r res < residualE r) : resolve db r.end_ = (⊤ : WithTop Key) := by by_contra htop have h := residualT_eq_residualE_of_resolve_end_ne_top hcomp hrev hmore hne hbegin hstart hend htop omega /-- **Finite-branch soundness (nonpositive cross-free complete).** Agreement on the bottom truncated range fixes the complete keys, so a complete result stays complete. -/ theorem sound_truncatedRangeBottom_of_nonpos_complete {r : RangeRead} {res : Result} {last : Key} (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hend : 2 ≤ r.end_.offset) (hlast : last = res.keys.getLast hne) (hte : residualT r res = residualE r) : Sound r res (truncatedRangeBottom last) := by intro db₁ db₂ hagree have hiff : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ res.keys = RangeRead.completeKeys db r := by intro db constructor · rintro ⟨hlim, hm | ⟨-, heq⟩⟩ · simp [hmore] at hm · exact ⟨hlim, heq⟩ · rintro ⟨hlim, hck⟩ exact ⟨hlim, Or.inr ⟨hmore, hck⟩⟩ rw [hiff db₁, hiff db₂] constructor · rintro ⟨hlim, hck₁⟩ have hcomp₁ : RangeRead.Compatible db₁ r res := (hiff db₁).mpr ⟨hlim, hck₁⟩ have hstart₁ : resolve db₁ r.begin ≤ r.end_.key := by rw [resolve_eq_nil_of_complete_begin_le_head hcomp₁ hrev hmore hne hbegin hlo] exact coe_nil_le_key_withTop r.end_.key exact ⟨hlim, (completeKeys_eq_res_of_agree_nonpos_complete hcomp₁ hrev hmore hne hbegin hlo hstart₁ hend hlast hte hagree).symm⟩ · rintro ⟨hlim, hck₂⟩ have hcomp₂ : RangeRead.Compatible db₂ r res := (hiff db₂).mpr ⟨hlim, hck₂⟩ have hstart₂ : resolve db₂ r.begin ≤ r.end_.key := by rw [resolve_eq_nil_of_complete_begin_le_head hcomp₂ hrev hmore hne hbegin hlo] exact coe_nil_le_key_withTop r.end_.key exact ⟨hlim, (completeKeys_eq_res_of_agree_nonpos_complete (db₁ := db₂) (db₂ := db₁) hcomp₂ hrev hmore hne hbegin hlo hstart₂ hend hlast hte hagree.symm).symm⟩ /-- **Finite-branch minimality (nonpositive cross-free complete).** When `t = e`, the minimal range is `[⊥, keyAfter last)`. -/ theorem minimal_truncatedRangeBottom_of_nonpos_complete_finite {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hend : 2 ≤ r.end_.offset) (hte : residualT r res = residualE r) : Minimal r res (truncatedRangeBottom (res.keys.getLast hne)) := by obtain ⟨db₀, hcomp₀⟩ := hread refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_truncatedRangeBottom_of_nonpos_complete hrev hmore hne hbegin hlo hend rfl hte, ?_⟩ intro k _ hk have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk) exact (necessary_nil_of_begin_offset_nonpos ⟨db₀, hcomp₀⟩ hrev hne hbegin hlo).of_between (necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)) (nil_le_key k) hkle /-- **Top-branch necessity above the reported last (nonpositive cross-free complete).** Every key above the reported last is necessary: inserting it keeps the unbounded end and adds it to the complete window. -/ theorem necessary_above_last_of_nonpos_top {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hBhead : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hend : 2 ≤ r.end_.offset) (htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hcomp⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hcomp⟩ hx cr hs · by_contra hcr 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 hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hstart₀ : resolve db₀ r.begin ≤ r.end_.key := by rw [resolve_eq_nil_of_complete_begin_le_head hcomp hrev hmore hne hbegin hBhead] exact coe_nil_le_key_withTop r.end_.key have hE₀ : resolve db₀ r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_residualT_lt_residualE hcomp hrev hmore hne hbegin hstart₀ hend htlt have hElast : r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := last_ge_end_of_count_pos hsort hne htpos have hhead_le_last : res.keys.head hne ≤ res.keys.getLast hne := (hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne) have hbegin_last : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := le_trans hBhead (WithTop.coe_le_coe.mpr hhead_le_last) have hx0 : x ∉ db₀.keys := by intro hxk have hge : resolve db₀ r.begin ≤ ((x : Key) : WithTop Key) := le_trans (resolve_le_key_of_offset_nonpos hbegin) (le_trans hbegin_last (WithTop.coe_le_coe.mpr hlo)) have hmem : x ∈ RangeRead.completeKeys db₀ r := by rw [RangeRead.mem_completeKeys] exact ⟨hxk, hge, by rw [hE₀]; exact WithTop.coe_lt_top x⟩ rw [← hres] at hmem exact hx hmem have hall : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := by intro k hk by_cases hkb : resolve db₀ r.begin ≤ ((k : Key) : WithTop Key) · have hmem : k ∈ RangeRead.completeKeys db₀ r := by rw [RangeRead.mem_completeKeys] exact ⟨hk, hkb, by rw [hE₀]; exact WithTop.coe_lt_top k⟩ have hkres : k ∈ res.keys := by rw [← hres] at hmem; exact hmem exact le_trans (WithTop.coe_le_coe.mpr (hmaxres k hkres)) (WithTop.coe_le_coe.mpr hlo) · have hklt : ((k : Key) : WithTop Key) < resolve db₀ r.begin := lt_of_not_ge hkb have hk_lt_last : ((k : Key) : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key) := lt_of_lt_of_le (lt_of_lt_of_le hklt (resolve_le_key_of_offset_nonpos hbegin)) hbegin_last exact le_trans (WithTop.coe_le_coe.mpr (le_of_lt (WithTop.coe_lt_coe.mp hk_lt_last))) (WithTop.coe_le_coe.mpr hlo) have hL_lt : db₀.keys.length < db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by set Q := db₀.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hQ have hQlelast : ∀ k ∈ Q, k ≤ res.keys.getLast hne := by intro k hk rw [hQ] at hk obtain ⟨hkdb, hkE⟩ := (List.mem_filter.mp hk) rw [decide_eq_true_eq] at hkE have hmem : k ∈ RangeRead.completeKeys db₀ r := by rw [RangeRead.mem_completeKeys] exact ⟨hkdb, le_trans hstart₀ hkE, by rw [hE₀]; exact WithTop.coe_lt_top k⟩ have hkres : k ∈ res.keys := by rw [← hres] at hmem; exact hmem exact hmaxres k hkres have hfilter : Q.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = Q := by rw [List.filter_eq_self] intro k hk rw [decide_eq_true_eq] exact hQlelast k hk have hTQ : residualT r res = Q.length := by have h := residualT_eq_filter_length (db := db₀) (r := r) (res := res) (last := res.keys.getLast hne) hcomp hrev hmore hne rfl hbegin hstart₀ rw [h, hfilter] have hQlen : Q.length = db₀.keys.length - db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by have hsum := countP_ge_add_countP_lt (l := db₀.keys) r.end_.key rw [hQ, ← List.countP_eq_length_filter] omega have htlt' : Q.length < (r.end_.offset - 1).toNat := by rw [← hTQ]; exact htlt rw [hQlen] at htlt' omega have hEins := resolve_end_eq_top_of_insert_top hx0 hL_lt hend exact hx (mem_result_of_insert hcomp hs hcr hmore hne hx0 hall hEins) /-- **Top-branch minimality (nonpositive cross-free complete).** When `t < e`, the minimal range is the full range `[⊥, ⊤)`. -/ theorem minimal_fullRange_of_nonpos_complete_top {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hend : 2 ≤ r.end_.offset) (htlt : residualT r res < residualE r) : Minimal r res ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by obtain ⟨db₀, hcomp₀⟩ := hread by_cases htpos : 0 < residualT r res · refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_fullRange r res, ?_⟩ intro k _ _ by_cases hkle : k ≤ res.keys.getLast hne · exact (necessary_nil_of_begin_offset_nonpos ⟨db₀, hcomp₀⟩ hrev hne hbegin hlo).of_between (necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)) (nil_le_key k) hkle · exact necessary_above_last_of_nonpos_top ⟨db₀, hcomp₀⟩ hrev hmore hne hbegin hlo hend htpos htlt (le_of_lt (lt_of_not_ge hkle)) · have hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_contra hge have hpos : 0 < residualT r res := by unfold residualT rw [List.countP_pos_iff] exact ⟨k, hk, by rw [decide_eq_true_eq]; exact le_of_not_gt hge⟩ omega exact minimal_fullRange_of_nonpos_overshoot_nonempty ⟨db₀, hcomp₀⟩ hrev hmore hne hbegin hend hhi hlo /-- The cross-free nonpositive-begin complete closed form. -/ noncomputable def completeNonposCrossFree (r : RangeRead) (res : Result) : ConflictRange := if res.keys = [] then ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ else if r.end_.offset ≤ 1 then ⟨(([] : Key) : WithTop Key), r.end_.key⟩ else if residualT r res = residualE r then truncatedRangeBottom (res.keys.getLastD ([] : Key)) else ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ /-- **The cross-free nonpositive-begin complete closed form.** For `begin.offset ≤ 0`, `begin.key ≤ head`, and a complete nonempty result, the minimal range is `[⊥, end_.key)` when `end_.offset ≤ 1`, `[⊥, keyAfter last)` in the finite branch `t = e`, and `[⊥, ⊤)` otherwise. -/ theorem minimal_completeNonposCrossFree {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : Minimal r res (completeNonposCrossFree r res) := by unfold completeNonposCrossFree rw [ite_eq_right hne] by_cases hend1 : r.end_.offset ≤ 1 · rw [ite_eq_left hend1] exact minimal_bottomRange_of_nonpos_underEnd_nonempty hread hrev hmore hne hbegin hend1 hlo · rw [ite_eq_right hend1] have hend : 2 ≤ r.end_.offset := by omega by_cases hte : residualT r res = residualE r · rw [ite_eq_left hte] 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] exact minimal_truncatedRangeBottom_of_nonpos_complete_finite hread hrev hmore hne hbegin hlo hend hte · rw [ite_eq_right hte] obtain ⟨db₀, hcomp₀⟩ := hread have hstart₀ : resolve db₀ r.begin ≤ r.end_.key := by rw [resolve_eq_nil_of_complete_begin_le_head hcomp₀ hrev hmore hne hbegin hlo] exact coe_nil_le_key_withTop r.end_.key have htle : residualT r res ≤ residualE r := residualT_le_residualE_nonpos hcomp₀ hrev hmore hne hbegin hstart₀ hend have htlt : residualT r res < residualE r := lt_of_le_of_ne htle hte exact minimal_fullRange_of_nonpos_complete_top ⟨db₀, hcomp₀⟩ hrev hmore hne hbegin hlo hend htlt /-- The reversed-traversal cross-free nonpositive-begin complete closed form. -/ noncomputable def completeNonposCrossFreeRev (r : RangeRead) (res : Result) : ConflictRange := completeNonposCrossFree { r with reverse := false } { keys := res.keys.reverse, more := false } /-- The reversed cross-free nonpositive-begin complete rule is minimal. -/ theorem minimal_completeNonposCrossFree_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : Minimal r res (completeNonposCrossFreeRev r res) := by let r' : RangeRead := { r with reverse := false } let res' : Result := { keys := res.keys.reverse, more := false } have hread' : Readable r' res' := by obtain ⟨db, hcomp⟩ := hread exact ⟨db, (compatible_flip (b := true) hrev hmore).mpr hcomp⟩ have hne' : res'.keys ≠ [] := by simpa [res'] using hne have hlo' : r'.begin.key ≤ ((res'.keys.head hne' : Key) : WithTop Key) := by simpa [r', res'] using hlo have hmin' : Minimal r' res' (completeNonposCrossFree r' res') := minimal_completeNonposCrossFree hread' rfl rfl hne' hbegin hlo' have hflip := (minimal_flip (r := r) (res := res) (cr := completeNonposCrossFree r' res') (b := true) hrev hmore) exact hflip.mp hmin' /-- A nonempty *complete* result at a nonpositive begin offset, cross-free, with the begin key at or below the least reported key. This is the cross-free nonpositive-begin complete cell, in either traversal. -/ abbrev nonposCompleteCrossFree (r : RangeRead) (res : Result) : Prop := res.more = false ∧ res.keys ≠ [] ∧ r.begin.offset ≤ 0 ∧ r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) /-- The cross-free nonpositive-begin complete closed form, in either traversal. -/ noncomputable def closedFormCompleteNonposCrossFree (r : RangeRead) (res : Result) : ConflictRange := if r.reverse = true then completeNonposCrossFreeRev r res else completeNonposCrossFree r res /-- **The cross-free nonpositive-begin complete closed form is minimal.** -/ theorem minimal_closedForm_of_complete_nonpos_crossFree {r : RangeRead} {res : Result} (hread : Readable r res) (h : nonposCompleteCrossFree r res) : Minimal r res (closedFormCompleteNonposCrossFree r res) := by obtain ⟨hmore, hne, hbegin, hloD⟩ := h unfold closedFormCompleteNonposCrossFree cases hrev : r.reverse with | false => rw [ite_eq_right (by simp [])] have hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by have hloD' : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by simpa [leastReported, hrev] using hloD have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl rwa [← hhead] exact minimal_completeNonposCrossFree hread hrev hmore hne hbegin hlo | true => rw [ite_eq_left (by simp [])] have hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by have hloD' : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by simpa [leastReported, hrev] using hloD have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rwa [← hlast] exact minimal_completeNonposCrossFree_rev hread hrev hmore hne hbegin hlo namespace FormalConflictRange /-- Agreement on keys at or below `last` fixes the `end_.key`-filtered keys at or below `last`. -/ theorem filter_end_le_swap (db : DB) (r : RangeRead) (last : Key) : (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) = (db.keys.filter (fun k : Key => decide (k ≤ last))).filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by rw [List.filter_filter, List.filter_filter] apply List.filter_congr intro k _ exact Bool.and_comm _ _ /-- Agreement on keys at or below `last` transfers the end-resolution cut at `last`. -/ theorem lt_resolve_end_iff_of_agree_bottom {db₁ db₂ : DB} {r : RangeRead} {last : Key} (hend : 1 ≤ r.end_.offset) (hb : db₁.keys.filter (fun k : Key => decide (k ≤ last)) = db₂.keys.filter (fun k : Key => decide (k ≤ last))) : ((last : Key) : WithTop Key) < resolve db₁ r.end_ ↔ ((last : Key) : WithTop Key) < resolve db₂ r.end_ := by have hQ : (db₁.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) = (db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) := by rw [filter_end_le_swap, filter_end_le_swap, hb] constructor · intro h1 have hc1 := filter_length_le_offset_of_resolve_end_gt (db := db₁) hend h1 have hc2 : ((db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by rw [← hQ] exact hc1 exact resolve_end_gt_of_filter_length_le (db := db₂) hend hc2 · intro h2 have hc2 := filter_length_le_offset_of_resolve_end_gt (db := db₂) hend h2 have hc1 : ((db₁.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by rw [hQ] exact hc2 exact resolve_end_gt_of_filter_length_le (db := db₁) hend hc1 /-- **Soundness of `[⊥, keyAfter last)` for a nonpositive-begin truncated forward result, with no pinning hypothesis.** Agreement fixes the stored keys at or below the reported last and the begin resolution. If the end key lies at or below the reported last, the same agreement fixes the end resolution cut at the reported last; otherwise the reported last lies below the end key and `end_.key ≤ resolve end_` fixes the cut for every database. -/ theorem sound_truncatedRangeBottom_of_nonpos_more {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : r.begin.offset ≤ 0) (hmore : res.more = true) (hne : res.keys ≠ []) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) (hge : 1 ≤ r.end_.offset) : Sound r res (truncatedRangeBottom (res.keys.getLast hne)) := by intro db₁ db₂ hagree have hbE : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter (res.keys.getLast hne) : WithTop Key))) = db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter (res.keys.getLast hne) : WithTop Key))) := by have h : (truncatedRangeBottom (res.keys.getLast hne)).keys db₁ = (truncatedRangeBottom (res.keys.getLast hne)).keys db₂ := hagree unfold truncatedRangeBottom at h rwa [keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h have hb : db₁.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = db₂.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by have hc : ∀ db : DB, db.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter (res.keys.getLast hne) : WithTop Key))) = db.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by intro db apply List.filter_congr intro k _ rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] rwa [hc db₁, hc db₂] at hbE have hkey_ka : r.begin.key ≤ (keyAfter (res.keys.getLast hne) : WithTop Key) := le_trans hlo (WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt (res.keys.getLast hne)))) have hres : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_keys_below hbegin hkey_ka hbE have hA : ∀ db : DB, db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ k ≤ res.keys.getLast hne)) = (db.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne))).filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) := by intro db rw [List.filter_filter] apply List.filter_congr intro k _ rw [Bool.decide_and] have hck_of_lt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₁ r.end_ → ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₂ r.end_ → (RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by intro hlt₁ hlt₂ rw [completeKeys_filter_le_eq (db := db₁) hrev hlt₁, completeKeys_filter_le_eq (db := db₂) hrev hlt₂, hA db₁, hA db₂, hres, hb] rw [compatible_iff_truncated_keys hrev hmore hne, compatible_iff_truncated_keys (db := db₂) hrev hmore hne] by_cases hE : r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) · -- Non-overshoot: the end key lies at or below the reported last. constructor · rintro ⟨hlim, hck₁⟩ have hmem : res.keys.getLast hne ∈ (RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by rw [hck₁] exact List.getLast_mem hne have hlt₁ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₁ r.end_ := (RangeRead.mem_completeKeys.mp (List.mem_of_mem_filter hmem)).2.2 have hlt₂ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₂ r.end_ := (lt_resolve_end_iff_of_agree_bottom (db₁ := db₁) (db₂ := db₂) hge hb).mp hlt₁ exact ⟨hlim, hck_of_lt hlt₁ hlt₂ ▸ hck₁⟩ · rintro ⟨hlim, hck₂⟩ have hmem : res.keys.getLast hne ∈ (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by rw [hck₂] exact List.getLast_mem hne have hlt₂ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₂ r.end_ := (RangeRead.mem_completeKeys.mp (List.mem_of_mem_filter hmem)).2.2 have hlt₁ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₁ r.end_ := (lt_resolve_end_iff_of_agree_bottom (db₁ := db₂) (db₂ := db₁) hge hb.symm).mp hlt₂ exact ⟨hlim, (hck_of_lt hlt₁ hlt₂).symm ▸ hck₂⟩ · -- The reported last lies below the end key, so every database cuts above it. have hlast_lt : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key := lt_of_not_ge hE have hlt : ∀ db : DB, ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := fun db => lt_of_lt_of_le hlast_lt (key_le_resolve_of_one_le (db := db) (s := r.end_) hge) constructor · rintro ⟨hlim, hck₁⟩ exact ⟨hlim, hck_of_lt (hlt db₁) (hlt db₂) ▸ hck₁⟩ · rintro ⟨hlim, hck₂⟩ exact ⟨hlim, (hck_of_lt (hlt db₁) (hlt db₂)).symm ▸ hck₂⟩ /-- **The nonpositive-begin truncated forward case is minimal with no pinning.** -/ theorem minimal_truncatedRangeBottom_of_nonpos_more {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hge : 1 ≤ r.end_.offset) : Minimal r res (truncatedRangeBottom (res.keys.getLast hne)) := by obtain ⟨db₀, hcomp₀⟩ := hread have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev have hhead_last : res.keys.head hne ≤ res.keys.getLast hne := (hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne) have hlo' : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := le_trans hlo (WithTop.coe_le_coe.mpr hhead_last) refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_truncatedRangeBottom_of_nonpos_more hrev hbegin hmore hne hlo' hge, ?_⟩ intro k _ hk have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk) exact (necessary_nil_of_begin_offset_nonpos ⟨db₀, hcomp₀⟩ hrev hne hbegin hlo).of_between (necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)) (nil_le_key k) hkle /-- A nonempty *truncated forward* result at a nonpositive begin offset, cross-free, with `1 ≤ end_.offset`. This removes the pinning hypothesis from `nonposFwdTruncPinned`: the minimal range is still `[⊥, keyAfter last)`. -/ abbrev nonposFwdTrunc (r : RangeRead) (res : Result) : Prop := res.more = true ∧ r.reverse = false ∧ r.begin.offset ≤ 0 ∧ r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) ∧ 1 ≤ r.end_.offset /-- The cross-free nonpositive-begin forward truncated closed form. -/ noncomputable def closedFormNonposFwdTrunc (_r : RangeRead) (res : Result) : ConflictRange := truncatedRangeBottom (res.keys.getLastD ([] : Key)) /-- **The cross-free nonpositive-begin forward truncated closed form is minimal.** -/ theorem minimal_closedForm_of_nonpos_fwdTrunc {r : RangeRead} {res : Result} (hread : Readable r res) (h : nonposFwdTrunc r res) : Minimal r res (closedFormNonposFwdTrunc r res) := by obtain ⟨hmore, hrev, hbegin, hloD, hge⟩ := h obtain ⟨db₀, hcomp₀⟩ := hread have hread' : Readable r res := ⟨db₀, hcomp₀⟩ have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl unfold closedFormNonposFwdTrunc rw [hlast] have hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by have hloD' : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by simpa [leastReported, hrev] using hloD have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl rwa [← hhead] exact minimal_truncatedRangeBottom_of_nonpos_more hread' hrev hmore hne hbegin hlo hge /-- Splitting a count below `b` at a threshold `a < b`. -/ theorem countP_lt_split {l : List Key} {a b : WithTop Key} (hab : a < b) : l.countP (fun (k : Key) => decide ((k : WithTop Key) < b)) = l.countP (fun (k : Key) => decide ((k : WithTop Key) ≤ a)) + l.countP (fun (k : Key) => decide (a < (k : WithTop Key)) && decide ((k : WithTop Key) < b)) := by induction l with | nil => rfl | cons x rest ih => simp only [List.countP_cons] rw [ih] by_cases hb : ((x : WithTop Key) < b) · by_cases hle : ((x : WithTop Key) ≤ a) · have hnb : ¬ (a < (x : WithTop Key)) := not_lt.mpr hle simp [hb, hle, hnb] omega · have hgt : a < (x : WithTop Key) := lt_of_not_ge hle simp [hb, hle, hgt] omega · have hle : ¬ ((x : WithTop Key) ≤ a) := fun h => hb (lt_of_le_of_lt h hab) simp [hb, hle] /-- In the compatible nonpositive-begin, nonpositive-end forward truncated case, there are at least `(1 - end_.offset)` stored keys strictly between the reported last and `end_.key`. -/ theorem filler_count_nonpos_more_nonpos_end {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (_hrev : r.reverse = false) (_hmore : res.more = true) (hne : res.keys ≠ []) (_hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) : (1 - r.end_.offset).toNat ≤ (db.keys.filter (fun (k : Key) => decide (res.keys.getLast hne < k ∧ ((k : WithTop Key) < r.end_.key)))).length := by set last := res.keys.getLast hne with hlast set o := r.end_.offset with ho set c := db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key)) with hc set d := db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) ≤ (↑last : WithTop Key))) with hd set n := (db.keys.filter (fun (k : Key) => decide (last < k ∧ ((k : WithTop Key) < r.end_.key)))).length with hn have hlastmem : last ∈ db.keys := (RangeRead.mem_completeKeys.mp ((RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne))).1 have hlast_res : ((last : Key) : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp ((RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne))).2.2 have hlastE : ((last : Key) : WithTop Key) < r.end_.key := lt_end_key_of_lt_resolve_end_nonpos hend hlastmem hlast_res have hsplit : c = d + n := by rw [hc, hd, hn] have hs := countP_lt_split (l := db.keys) (a := (↑last : WithTop Key)) (b := r.end_.key) hlastE have hn' : (db.keys.filter (fun (k : Key) => decide (last < k ∧ ((k : WithTop Key) < r.end_.key)))).length = db.keys.countP (fun (k : Key) => decide ((↑last : WithTop Key) < (k : WithTop Key)) && decide ((k : WithTop Key) < r.end_.key)) := by rw [List.countP_eq_length_filter] congr 1 rw [hn', ← hs] have hanchor_nonneg : 0 ≤ r.end_.anchor db := by by_contra hneg have hnil : resolve db r.end_ = (↑([] : Key) : WithTop Key) := resolve_eq_nil (lt_of_not_ge hneg) rw [hnil] at hlast_res exact absurd hlast_res (not_lt.mpr (WithTop.coe_le_coe.mpr (nil_le_key last))) have hanchor_eq : r.end_.anchor db = (c : Int) + o - 1 := by rw [hc, ho] cases hE : r.end_.key with | top => rw [anchor_of_top (s := r.end_) hE, countP_lt_top] | coe e => rw [anchor_of_coe (s := r.end_) hE, countP_lt_coe] have hd_le : d ≤ db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_)) := by rw [hd] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_le_of_lt hk hlast_res have hres_count : db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_)) = min (r.end_.anchor db).toNat db.keys.length := countP_lt_resolve have hd_le_min : d ≤ min ((c : Int) + o - 1).toNat db.keys.length := by rw [hres_count, hanchor_eq] at hd_le exact hd_le have hanchor_nonneg' : 0 ≤ (c : Int) + o - 1 := by rw [← hanchor_eq]; exact hanchor_nonneg have hnat : (((c : Int) + o - 1).toNat : Int) = (c : Int) + o - 1 := Int.toNat_of_nonneg hanchor_nonneg' have hd_lt : (d : Int) < (c : Int) + o := by have h1 : d ≤ ((c : Int) + o - 1).toNat := le_trans hd_le_min (Nat.min_le_left _ _) have h1' : (d : Int) ≤ (c : Int) + o - 1 := by rw [← hnat] exact_mod_cast h1 omega have hc_eq : (c : Int) = (d : Int) + (n : Int) := by rw [hsplit]; push_cast; ring have hn_gt : (n : Int) > -(o : Int) := by omega have hni : (((1 - o).toNat : ℕ) : Int) ≤ (n : Int) := by have htoNat : (((1 - o).toNat : ℕ) : Int) = (1 : Int) - o := by rw [Int.toNat_of_nonneg]; omega rw [htoNat] omega exact_mod_cast hni /-- At a nonpositive end offset, if the begin selector resolves to `⊥` and the end selector to a genuine key `w`, the complete keys are exactly the stored keys below `w`. -/ theorem completeKeys_eq_of_resolve_nil_coe {db : DB} {r : RangeRead} {w : Key} (hrev : r.reverse = false) (hend : r.end_.offset ≤ 0) (hb : resolve db r.begin = ((↑([] : Key) : WithTop Key))) (he : resolve db r.end_ = (↑w : WithTop Key)) : RangeRead.completeKeys db r = db.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (↑w : WithTop Key))) := by have hwle : (↑w : WithTop Key) ≤ r.end_.key := by rw [← he]; exact resolve_le_key_of_offset_nonpos hend rw [completeKeys_eq_filter_of_end_nonpos hrev hend, hb, he, List.filter_filter] apply List.filter_congr intro k _ by_cases h : ((↑k : WithTop Key) < (↑w : WithTop Key)) · have hlt : ((↑k : WithTop Key)) < r.end_.key := lt_of_lt_of_le h hwle have hbot : ((↑([] : Key) : WithTop Key)) ≤ (↑k : WithTop Key) := WithTop.coe_le_coe.mpr (nil_le_key k) simp [h, hlt, hbot] · simp [h] /-- **The witness for a key above the reported last, in the nonpositive forward-truncated nonpositive-end case.** We build a database consisting of the reported keys followed by exactly `m = (1 - end_.offset)` filler keys in `(last, end_.key)`, one of which is the target key `k`. The begin selector resolves to `⊥`, the end selector resolves just above the reported last, so the complete keys are exactly the reported keys; erasing the target lowers the end resolution to the reported last and drops the last reported key, breaking compatibility. -/ theorem exists_witness_nonpos_more_nonpos_end {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) {k : Key} (hkgt : res.keys.getLast hne < k) (hklt : (k : WithTop Key) < r.end_.key) : ∃ dbw : DB, RangeRead.Compatible dbw r res ∧ k ∈ dbw.keys ∧ ¬ RangeRead.Compatible (dbw.erase k) r res := by have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db r := (RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne) obtain ⟨hlast_mem, -, hlast_res⟩ := RangeRead.mem_completeKeys.mp hlast_ck have hlastE : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key := lt_end_key_of_lt_resolve_end_nonpos hend hlast_mem hlast_res have hfill := filler_count_nonpos_more_nonpos_end hcomp hrev hmore hne hbegin hend set last := res.keys.getLast hne with hlast set m := (1 - r.end_.offset).toNat with hm have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx have hm1 : 1 ≤ m := by rw [hm]; omega set G : List Key := db.keys.filter (fun x : Key => decide (last < x ∧ (x : WithTop Key) < r.end_.key)) with hG have hGlen : m ≤ G.length := hfill have hGnodup : G.Nodup := by rw [hG]; exact db.sorted.pairwise.nodup.filter _ have hGmem : ∀ x ∈ G, last < x ∧ (x : WithTop Key) < r.end_.key := by intro x hx rw [hG] at hx exact of_decide_eq_true (List.mem_filter.mp hx).2 -- the raw filler list starts with `k` and then the reservoir without `k` set raw : List Key := (k :: G.erase k).take m with hraw have hrawNodup : raw.Nodup := by rw [hraw] refine (List.take_sublist m (k :: G.erase k)).nodup ?_ exact List.nodup_cons.mpr ⟨hGnodup.not_mem_erase, hGnodup.erase k⟩ have hrawLen : raw.length = m := by rw [hraw, List.length_take] apply Nat.min_eq_left by_cases hkG : k ∈ G · rw [List.length_cons, List.length_erase_of_mem hkG]; omega · rw [List.length_cons, List.erase_of_not_mem hkG]; omega have hrawSub : ∀ x ∈ raw, x = k ∨ x ∈ G := by intro x hx rw [hraw] at hx rcases List.mem_cons.mp (List.mem_of_mem_take hx) with rfl | hx' · exact Or.inl rfl · exact Or.inr (List.mem_of_mem_erase hx') have hrawk : k ∈ raw := by rw [hraw, List.mem_take_iff_getElem] refine ⟨0, ?_, rfl⟩ rw [List.length_cons] omega have hrawGt : ∀ x ∈ raw, last < x := by intro x hx rcases hrawSub x hx with rfl | hx' · exact hkgt · exact (hGmem x hx').1 have hrawLt : ∀ x ∈ raw, (x : WithTop Key) < r.end_.key := by intro x hx rcases hrawSub x hx with rfl | hx' · exact hklt · exact (hGmem x hx').2 -- sort the filler set F : List Key := raw.insertionSort (· ≤ ·) with hF have hFperm : raw.Perm F := (List.perm_insertionSort (· ≤ ·) raw).symm have hFsorted : F.SortedLT := by rw [hF, List.sortedLT_iff_pairwise] exact DB.pairwise_lt_of_le_of_nodup (List.pairwise_insertionSort (r := (· ≤ ·)) raw) (hFperm.nodup_iff.mp hrawNodup) have hFlen : F.length = m := by rw [hF, List.length_insertionSort, hrawLen] have hFk : k ∈ F := hFperm.mem_iff.mp hrawk have hFmem : ∀ x ∈ F, last < x ∧ (x : WithTop Key) < r.end_.key := by intro x hx exact ⟨hrawGt x (hFperm.mem_iff.mpr hx), hrawLt x (hFperm.mem_iff.mpr hx)⟩ have hFne : F ≠ [] := by intro h; rw [h] at hFlen; simp at hFlen; omega set D : List Key := res.keys ++ F with hD have hDsort : D.SortedLT := by rw [hD] refine List.sortedLT_append.mpr ⟨hsort, hFsorted, ?_⟩ intro a ha b hb exact lt_of_le_of_lt (hle_last a ha) (hFmem b hb).1 let dbw : DB := ⟨D, hDsort⟩ have hdbw_keys : dbw.keys = D := rfl have hlastFhead : last < F.head hFne := (hFmem (F.head hFne) (List.head_mem hFne)).1 -- the begin selector resolves to `⊥` have hbegin_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by intro htop rw [htop] at hlo exact WithTop.not_top_le_coe (res.keys.head hne) hlo obtain ⟨bk, hbk⟩ := WithTop.ne_top_iff_exists.mp hbegin_ne_top have hbk_le_head : bk ≤ res.keys.head hne := by have h := hlo rw [← hbk] at h exact WithTop.coe_le_coe.mp h have hDmem : ∀ x ∈ D, bk ≤ x := by intro x hx rw [hD] at hx rcases List.mem_append.mp hx with hx | hx · exact le_trans hbk_le_head ((hsort.pairwise.imp le_of_lt).rel_head hx) · exact le_trans (le_trans hbk_le_head ((hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne))) (le_of_lt (hFmem x hx).1) have hcount_begin : D.countP (fun x : Key => decide (x < bk)) = 0 := countP_lt_eq_zero_of_forall_ge hDmem have hrb : resolve dbw r.begin = ((↑([] : Key) : WithTop Key)) := by refine resolve_eq_nil ?_ rw [anchor_of_coe (s := r.begin) (v := bk) hbk.symm, hcount_begin] omega -- every stored key is below `end_.key` have hDlt : ∀ x ∈ D, (x : WithTop Key) < r.end_.key := by intro x hx rw [hD] at hx rcases List.mem_append.mp hx with hx | hx · exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hle_last x hx)) hlastE · exact (hFmem x hx).2 have hlenD : D.length = res.keys.length + m := by rw [hD, List.length_append, hFlen] have hm_int : (m : Int) = 1 - r.end_.offset := by rw [hm]; exact Int.toNat_of_nonneg (by omega) have hcount_end : D.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = D.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] exact hDlt x hx have hanchor_end : r.end_.anchor dbw = (res.keys.length : Int) := by cases hE : r.end_.key with | top => rw [anchor_of_top (s := r.end_) hE, hlenD] push_cast rw [hm_int] ring | coe e => have hce : D.countP (fun x : Key => decide (x < e)) = D.length := by rw [← countP_lt_coe (l := D) e, ← hE] exact hcount_end rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlenD] push_cast rw [hm_int] ring have ht_lt : res.keys.length < D.length := by rw [hlenD]; omega have hDget? : dbw.keys[res.keys.length]? = some (F.head hFne) := by change D[res.keys.length]? = some (F.head hFne) rw [hD, List.getElem?_append] rw [ite_eq_right (not_lt.mpr (le_refl _)), Nat.sub_self] rw [List.getElem?_eq_getElem (by rw [hFlen]; omega), List.head_eq_getElem hFne] have hre : resolve dbw r.end_ = ((F.head hFne : Key) : WithTop Key) := by rw [resolve, ite_eq_right (by rw [hanchor_end]; omega)] rw [hanchor_end, Int.toNat_natCast, hDget?] -- complete keys of the witness are the reported keys have hckw : RangeRead.completeKeys dbw r = res.keys := by rw [completeKeys_eq_of_resolve_nil_coe (db := dbw) hrev hend hrb hre] have hpred : ∀ x ∈ dbw.keys, decide ((↑x : WithTop Key) < ((↑(F.head hFne) : Key) : WithTop Key)) = decide (x < F.head hFne) := by intro x _; rw [decide_eq_decide, WithTop.coe_lt_coe] rw [List.filter_congr hpred, hdbw_keys, hD, List.filter_append] have hres_self : res.keys.filter (fun x : Key => decide (x < F.head hFne)) = res.keys := by rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact lt_of_le_of_lt (hle_last x hx) hlastFhead have hF_nil : F.filter (fun x : Key => decide (x < F.head hFne)) = [] := by rw [List.filter_eq_nil_iff] intro x hx rw [decide_eq_true_eq] exact not_lt.mpr ((hFsorted.pairwise.imp le_of_lt).rel_head hx) rw [hres_self, hF_nil, List.append_nil] have hcompw : RangeRead.Compatible dbw r res := by rw [compatible_iff_truncated_keys hrev hmore hne] refine ⟨hcomp.1, ?_⟩ rw [hckw] rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] rw [← hlast] exact hle_last x hx have hkdbw : k ∈ dbw.keys := by rw [hdbw_keys, hD] exact List.mem_append.mpr (Or.inr hFk) -- now the erased database have hk_not_mem_res : k ∉ res.keys := by intro hk exact absurd (hle_last k hk) (not_le.mpr hkgt) have hD' : (dbw.erase k).keys = res.keys ++ F.erase k := by rw [DB.erase_keys, hdbw_keys, hD] exact List.erase_append_right F hk_not_mem_res have hD'mem : ∀ x ∈ (dbw.erase k).keys, bk ≤ x := by intro x hx exact hDmem x (by rw [DB.erase_keys, hdbw_keys] at hx exact List.mem_of_mem_erase hx) have hrb' : resolve (dbw.erase k) r.begin = ((↑([] : Key) : WithTop Key)) := by refine resolve_eq_nil ?_ rw [anchor_of_coe (s := r.begin) (v := bk) hbk.symm, countP_lt_eq_zero_of_forall_ge hD'mem] omega have hD'lt : ∀ x ∈ (dbw.erase k).keys, (x : WithTop Key) < r.end_.key := by intro x hx exact hDlt x (by rw [DB.erase_keys, hdbw_keys] at hx exact List.mem_of_mem_erase hx) have hlenD' : (dbw.erase k).keys.length = res.keys.length + m - 1 := by rw [hD', List.length_append, List.length_erase_of_mem hFk, hFlen] omega have hcount_end' : (dbw.erase k).keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = (dbw.erase k).keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] exact hD'lt x hx have hanchor_end' : r.end_.anchor (dbw.erase k) = (res.keys.length : Int) - 1 := by cases hE : r.end_.key with | top => rw [anchor_of_top (s := r.end_) hE, hlenD'] rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)] push_cast rw [hm_int] ring | coe e => have hce : (dbw.erase k).keys.countP (fun x : Key => decide (x < e)) = (dbw.erase k).keys.length := by rw [← countP_lt_coe (l := (dbw.erase k).keys) e, ← hE] exact hcount_end' rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlenD'] rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)] push_cast rw [hm_int] ring have ht1 : 1 ≤ res.keys.length := List.length_pos_of_ne_nil hne have hEqInt : (res.keys.length : Int) - 1 = ((res.keys.length - 1 : ℕ) : Int) := by rw [Nat.cast_sub ht1]; norm_num have htoNat' : (r.end_.anchor (dbw.erase k)).toNat = res.keys.length - 1 := by rw [hanchor_end', hEqInt, Int.toNat_natCast] have hD'get? : (dbw.erase k).keys[res.keys.length - 1]? = some last := by rw [hD', List.getElem?_append] rw [ite_eq_left (by omega : res.keys.length - 1 < res.keys.length)] rw [List.getElem?_eq_getElem (by omega : res.keys.length - 1 < res.keys.length)] congr 1 rw [hlast, List.getLast_eq_getElem hne] have hre' : resolve (dbw.erase k) r.end_ = ((last : Key) : WithTop Key) := by rw [resolve, ite_eq_right (by rw [hanchor_end']; omega)] rw [hanchor_end', hEqInt, Int.toNat_natCast, hD'get?] have hckE : RangeRead.completeKeys (dbw.erase k) r = res.keys.dropLast := by rw [completeKeys_eq_of_resolve_nil_coe (db := dbw.erase k) hrev hend hrb' hre'] have hpred : ∀ x ∈ (dbw.erase k).keys, decide ((↑x : WithTop Key) < ((↑last : Key) : WithTop Key)) = decide (x < last) := by intro x _; rw [decide_eq_decide, WithTop.coe_lt_coe] rw [List.filter_congr hpred, hD', List.filter_append] have hres_fil : res.keys.filter (fun x : Key => decide (x < last)) = res.keys.dropLast := by have hcnt : res.keys.countP (fun x : Key => decide ((↑x : WithTop Key) < ((↑last : Key) : WithTop Key))) = res.keys.length - 1 := by rw [countP_lt_coe (l := res.keys) last] refine countP_lt_eq_of_getElem hsort (by omega) ?_ simp only [hlast, List.getLast_eq_getElem hne] have hf : res.keys.filter (fun x : Key => decide (x < last)) = res.keys.filter (fun x : Key => decide ((↑x : WithTop Key) < ((↑last : Key) : WithTop Key))) := by apply List.filter_congr intro x _ rw [decide_eq_decide, WithTop.coe_lt_coe] rw [hf, filter_lt_eq_take_countP hsort ((↑last : Key) : WithTop Key), hcnt, ← List.dropLast_eq_take] have hF_fil : (F.erase k).filter (fun x : Key => decide (x < last)) = [] := by rw [List.filter_eq_nil_iff] intro x hx rw [decide_eq_true_eq] exact not_lt.mpr (le_of_lt (hFmem x (List.mem_of_mem_erase hx)).1) rw [hres_fil, hF_fil, List.append_nil] have hnot : ¬ RangeRead.Compatible (dbw.erase k) r res := by rw [compatible_iff_truncated_keys hrev hmore hne] intro h have heq := h.2 rw [hckE] at heq have hfil : res.keys.dropLast.filter (fun x : Key => decide (x ≤ res.keys.getLast hne)) = res.keys.dropLast := by rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] rw [← hlast] exact hle_last x (List.mem_of_mem_dropLast hx) rw [hfil] at heq have hlen := congrArg List.length heq rw [List.length_dropLast] at hlen omega exact ⟨dbw, hcompw, hkdbw, hnot⟩ /-- Every key strictly above the reported last (and below `end_.key`) is necessary in the nonpositive forward-truncated nonpositive-end case. -/ theorem necessary_above_last_of_nonpos_more_nonpos_end {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) {x : Key} (hxgt : res.keys.getLast hne < x) (hxlt : (x : WithTop Key) < r.end_.key) : Necessary r res x := by obtain ⟨db₀, hcomp⟩ := hread intro cr hs by_contra hxcr obtain ⟨dbw, hcompw, -, hnot⟩ := exists_witness_nonpos_more_nonpos_end hcomp hrev hmore hne hbegin hend hlo hxgt hxlt exact hnot ((hs dbw (dbw.erase x) (ConflictRange.keys_erase_of_not_mem cr dbw hxcr).symm).mp hcompw) /-- **The nonpositive forward-truncated nonpositive-end cell is `[⊥, end_.key)`.** Soundness is `sound_bottomRange_of_nonpos_underEnd_nonempty`; keys at or below the reported last are convex between the (necessary) empty key and the reported keys, and keys above the reported last are `necessary_above_last_of_nonpos_more_nonpos_end`. -/ theorem minimal_bottomRange_of_nonpos_more_nonpos_end {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : Minimal r res ⟨((↑([] : Key) : WithTop Key)), r.end_.key⟩ := by obtain ⟨db₀, hcomp⟩ := hread have hread' : Readable r res := ⟨db₀, hcomp⟩ have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp).subset (List.head_mem hne) obtain ⟨hhead_mem, -, hhead_res⟩ := RangeRead.mem_completeKeys.mp hhead_ck have hheadE : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key := lt_end_key_of_lt_resolve_end_nonpos hend hhead_mem hhead_res have hle : r.begin.key ≤ r.end_.key := le_trans hlo (le_of_lt hheadE) refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_bottomRange_of_nonpos_underEnd_nonempty hrev hbegin (by omega) hle, ?_⟩ intro k _ hk by_cases hk_last : k ≤ res.keys.getLast hne · by_cases hk_head : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key) · exact (necessary_nil_of_begin_offset_nonpos hread' hrev hne hbegin hlo).of_between (necessary_of_mem_result hread' (List.head_mem hne)) (nil_le_key k) (le_of_lt (WithTop.coe_lt_coe.mp hk_head)) · exact necessary_of_between_result hread' (List.head_mem hne) (List.getLast_mem hne) (WithTop.coe_le_coe.mp (not_lt.mp hk_head)) hk_last · exact necessary_above_last_of_nonpos_more_nonpos_end hread' hmore hrev hne hbegin hend hlo (not_le.mp hk_last) hk /-- A nonempty *truncated forward* result at a nonpositive begin offset, cross-free, with `end_.offset ≤ 0`. In this cell the minimal range is `[⊥, end_.key)`. -/ abbrev nonposFwdTruncNonpos (r : RangeRead) (res : Result) : Prop := res.more = true ∧ r.reverse = false ∧ r.begin.offset ≤ 0 ∧ r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) ∧ r.end_.offset ≤ 0 /-- The cross-free nonpositive-begin forward truncated nonpositive-end closed form. -/ noncomputable def closedFormNonposFwdTruncNonpos (r : RangeRead) (_res : Result) : ConflictRange := ⟨((↑([] : Key) : WithTop Key)), r.end_.key⟩ /-- **The cross-free nonpositive-begin forward truncated nonpositive-end closed form is minimal.** -/ theorem minimal_closedForm_of_nonpos_fwdTruncNonpos {r : RangeRead} {res : Result} (hread : Readable r res) (h : nonposFwdTruncNonpos r res) : Minimal r res (closedFormNonposFwdTruncNonpos r res) := by obtain ⟨hmore, hrev, hbegin, hloD, hend⟩ := h obtain ⟨db₀, hcomp₀⟩ := hread have hread' : Readable r res := ⟨db₀, hcomp₀⟩ have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore have hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by have hloD' : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by simpa [leastReported, hrev] using hloD have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl rwa [← hhead] exact minimal_bottomRange_of_nonpos_more_nonpos_end hread' hmore hrev hne hbegin hend hlo end FormalConflictRange