/- Released under Apache 2.0 license as described in the file LICENSE. -/ import FormalConflictRange.NegCrossTruncNonposGap /-! # The crossed truncated nonpositive-end gap cell at `end_.key < begin.key` This module closes the non-clamping (`¬ clampNonposBottom`) half of the crossed negative-begin truncated nonpositive-end gap cell in the sub-region where the end key lies strictly below the begin key. The minimal sound range is `[head, begin.key)`. The key structural fact is that readability plus `¬ clampNonposBottom` forces the begin slack to equal the reported count plus the end overshoot, `beginSlack r = res.keys.length + clampNonposD r`. Consequently every compatible database supplies exactly `clampNonposD r + 1` filler keys in `(last, end_.key)`, and the closed form is proved by the usual erase (for keys below `end_.key`) and insert (for keys between `end_.key` and `begin.key`) witnesses. -/ namespace FormalConflictRange /-- The crossed negative-begin truncated nonpositive-end gap cell in the sub-region `end_.key < begin.key` with a non-clamping begin selector. -/ def negCrossTruncNonposGapA2aNonbottom (r : RangeRead) (res : Result) : Prop := negCrossTruncNonposGap r res ∧ r.end_.key < r.begin.key ∧ ¬ clampNonposBottom r res /-- The closed form of the crossed nonpositive-end gap cell in the non-clamping `end_.key < begin.key` sub-region: `[head, begin.key)`. -/ noncomputable def closedFormNegCrossTruncNonposGapA2aNonbottom (r : RangeRead) (res : Result) : ConflictRange := ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩ /-- All reported keys lie strictly below the begin key once the reported last does. -/ theorem reportedBelowBegin_eq_length_of_last_lt {r : RangeRead} {res : Result} (hne : res.keys ≠ []) (hsort : res.keys.SortedLT) (hlastB : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key) : reportedBelowBegin r res = res.keys.length := by have hlastD : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl unfold reportedBelowBegin rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] have hxle : x ≤ res.keys.getLast hne := (hsort.pairwise.imp le_of_lt).rel_getLast hx exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hxle) (by rwa [hlastD] at hlastB) /-- In the non-clamping gap cell every compatible database resolves its begin selector onto the reported head. -/ theorem resolve_begin_eq_head_of_nonbottom {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) (hclamp : reportedBelowBegin r res ≤ beginSlack r) (hnbot : ¬ clampNonposBottom r res) : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by have hanc : 0 ≤ r.begin.anchor db := by by_contra h exact hnbot (clampNonposBottom_of_anchor_neg_trunc hcomp hrev hmore hne hbegin hend hclamp (by omega)) have hpre := RangeRead.compatible_keys_prefix hcomp have hckne : RangeRead.completeKeys db r ≠ [] := hpre.ne_nil hne obtain ⟨a, _ha_mem, ha_res, ha_head⟩ := RangeRead.completeKeys_head_resolve hrev hckne hanc have hhead_eq_a : res.keys.head hne = a := by rw [← ha_head] exact hpre.head hne rw [hhead_eq_a] exact ha_res /-- In the `end_.key < begin.key` non-clamping sub-region, readability forces the begin slack to equal the reported count plus the end overshoot. -/ theorem beginSlack_eq_of_A2a_nonbottom {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) (hclamp : reportedBelowBegin r res ≤ beginSlack r) (hnbot : ¬ clampNonposBottom r res) (hEB : r.end_.key < r.begin.key) (hlastB : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key) (hlastE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key) : beginSlack r = res.keys.length + clampNonposD r := by classical set head : Key := res.keys.head hne with hhead set last : Key := res.keys.getLast hne with hlast have hlastD : res.keys.getLastD ([] : Key) = last := by rw [hlast, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne have hlast_mem : last ∈ res.keys := by rw [hlast]; exact List.getLast_mem hne have hhead_le_last : head ≤ last := hle_last head hhead_mem have hlastB' : ((last : Key) : WithTop Key) < r.begin.key := by rwa [hlastD] at hlastB have hlastE' : ((last : Key) : WithTop Key) < r.end_.key := by rwa [hlastD] at hlastE have hheadB : ((head : Key) : WithTop Key) < r.begin.key := lt_of_le_of_lt (WithTop.coe_le_coe.mpr hhead_le_last) hlastB' have hres : resolve db r.begin = ((head : Key) : WithTop Key) := by have := resolve_begin_eq_head_of_nonbottom hcomp hrev hmore hne hbegin hend hclamp hnbot simpa [hhead] using this have hanc : 0 ≤ r.begin.anchor db := by by_contra h exact hnbot (clampNonposBottom_of_anchor_neg_trunc hcomp hrev hmore hne hbegin hend hclamp (by omega)) have hgap : db.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := gap_count_eq_beginSlack_of_resolve_head hbegin hheadB hanc hres -- stored keys in `[head, last]` are exactly the reported keys have hresEnd_gt : ((last : Key) : WithTop Key) < resolve db r.end_ := by have hlast_ck : last ∈ RangeRead.completeKeys db r := (RangeRead.compatible_keys_prefix hcomp).subset hlast_mem exact (RangeRead.mem_completeKeys.mp hlast_ck).2.2 have hfilterComp : (RangeRead.completeKeys db r).filter (fun k => decide (k ≤ last)) = res.keys := ((compatible_iff_truncated_keys hrev hmore hne).mp hcomp).2 have hfilterBegin : (RangeRead.completeKeys db r).filter (fun k => decide (k ≤ last)) = db.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ (k : Key) ≤ last)) := completeKeys_filter_le_of_resolve_begin hrev hres hresEnd_gt have hlen_head_last : (db.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ (k : Key) ≤ last))).length = res.keys.length := by rw [← hfilterBegin, hfilterComp] have hfilter_ka : db.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) = db.keys.filter (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ (k : Key) ≤ last)) := by apply List.filter_congr intro k _ rw [decide_eq_decide] by_cases hk : ((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) · simp only [hk, true_and] exact WithTop.coe_lt_coe.trans (lt_keyAfter_iff k last) · simp only [hk, false_and] have hlen_ka : (between db ((head : Key) : WithTop Key) (((keyAfter last : Key) : WithTop Key))).length = res.keys.length := by unfold between rw [hfilter_ka, hlen_head_last] have hcntB : cnt db r.begin.key = cnt db ((head : Key) : WithTop Key) + db.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) := by rw [cnt_eq_add_between db (le_of_lt hheadB), between, List.countP_eq_length_filter] have hcntKa : cnt db (((keyAfter last : Key) : WithTop Key)) = cnt db ((head : Key) : WithTop Key) + (between db ((head : Key) : WithTop Key) (((keyAfter last : Key) : WithTop Key))).length := cnt_eq_add_between db (WithTop.coe_le_coe.mpr (le_trans hhead_le_last (le_of_lt (keyAfter_self_lt last)))) have hcntKB : cnt db r.begin.key = cnt db (((keyAfter last : Key) : WithTop Key)) + (between db (((keyAfter last : Key) : WithTop Key)) r.begin.key).length := cnt_eq_add_between db (keyAfter_le_of_lt hlastB') have hresEnd_ne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by intro h rw [h] at hresEnd_gt exact absurd hresEnd_gt (not_lt.mpr (coe_nil_le_key_withTop ((last : Key) : WithTop Key))) have hbetween_len : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 := between_resolve_end_length hend hresEnd_ne have hka_le_resEnd : ((keyAfter last : Key) : WithTop Key) ≤ resolve db r.end_ := keyAfter_le_of_lt hresEnd_gt have hG : clampNonposD r + 1 ≤ (between db (((keyAfter last : Key) : WithTop Key)) r.begin.key).length := by rw [← hbetween_len] apply List.Sublist.length_le change List.Sublist (db.keys.filter (fun k : Key => decide (resolve db r.end_ ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.end_.key))) (db.keys.filter (fun k : Key => decide (((keyAfter last : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key))) apply filter_sublist_filter_of_imp intro k hk rw [decide_eq_true_eq] at hk ⊢ exact ⟨le_trans hka_le_resEnd hk.1, lt_trans hk.2 hEB⟩ have hkey : db.keys.countP (fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) = res.keys.length + (between db (((keyAfter last : Key) : WithTop Key)) r.begin.key).length := by rw [hcntKa, hlen_ka] at hcntKB omega have hlow : res.keys.length + clampNonposD r ≤ beginSlack r := by omega have hc0 : intervalCard r.begin.key r.end_.key = 0 := intervalCard_eq_zero_of_le (le_of_lt hEB) have hrep : reportedBelowBegin r res = res.keys.length := reportedBelowBegin_eq_length_of_last_lt hne hsort hlastB have hnot : ¬ (res.keys.length + (clampNonposD r + 1) ≤ beginSlack r) := by intro h apply hnbot unfold clampNonposBottom rw [hc0, hrep, tsub_zero] exact_mod_cast h have hup : beginSlack r ≤ res.keys.length + clampNonposD r := by omega omega /-- Readability supplies enough room in `(last, end_.key)` for the erase and insert witnesses: the end-resolution identity puts `clampNonposD + 1` stored keys there. -/ theorem intervalCard_keyAfter_getLast_ge {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hne : res.keys ≠ []) (hend : r.end_.offset ≤ 0) : (((clampNonposD r + 1 : ℕ)) : ℕ∞) ≤ intervalCard (((keyAfter (res.keys.getLast hne) : Key)) : WithTop Key) r.end_.key := by classical set last : Key := res.keys.getLast hne with hlast have hlast_mem : last ∈ res.keys := by rw [hlast]; exact List.getLast_mem hne have hresEnd_gt : ((last : Key) : WithTop Key) < resolve db r.end_ := by have hlast_ck : last ∈ RangeRead.completeKeys db r := (RangeRead.compatible_keys_prefix hcomp).subset hlast_mem exact (RangeRead.mem_completeKeys.mp hlast_ck).2.2 have hresEnd_ne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by intro h rw [h] at hresEnd_gt exact absurd hresEnd_gt (not_lt.mpr (coe_nil_le_key_withTop ((last : Key) : WithTop Key))) have hbetween_len : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 := between_resolve_end_length hend hresEnd_ne have hka_le_resEnd : ((keyAfter last : Key) : WithTop Key) ≤ resolve db r.end_ := keyAfter_le_of_lt hresEnd_gt have hresEnd_le_E : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos (db := db) (s := r.end_) hend have hkaE : ((keyAfter last : Key) : WithTop Key) ≤ r.end_.key := le_trans hka_le_resEnd hresEnd_le_E have hcard := between_length_le_intervalCard (db := db) (E := ((keyAfter last : Key) : WithTop Key)) (B := r.end_.key) hkaE have hlen_le : (between db (resolve db r.end_) r.end_.key).length ≤ (between db (((keyAfter last : Key) : WithTop Key)) r.end_.key).length := by apply List.Sublist.length_le change List.Sublist (db.keys.filter (fun k : Key => decide (resolve db r.end_ ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.end_.key))) (db.keys.filter (fun k : Key => decide (((keyAfter last : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.end_.key))) apply filter_sublist_filter_of_imp intro k hk rw [decide_eq_true_eq] at hk ⊢ exact ⟨le_trans hka_le_resEnd hk.1, hk.2⟩ calc (((clampNonposD r + 1 : ℕ)) : ℕ∞) = ((between db (resolve db r.end_) r.end_.key).length : ℕ∞) := by rw [hbetween_len] _ ≤ ((between db (((keyAfter last : Key) : WithTop Key)) r.end_.key).length : ℕ∞) := Nat.cast_le.mpr hlen_le _ ≤ intervalCard (((keyAfter last : Key)) : WithTop Key) r.end_.key := hcard /-- The element at the seam of a split list is the head of the right part. -/ theorem getElem_append_length {as bs : List Key} (hbs : bs ≠ []) : (as ++ bs)[as.length]'(by rw [List.length_append]; have := List.length_pos_iff.mpr hbs; omega) = bs.head hbs := by rw [List.getElem_append_right (as := as) (bs := bs) (i := as.length) (by omega) (h₂ := by rw [List.length_append]; have := List.length_pos_iff.mpr hbs; omega)] simp only [Nat.sub_self] exact (List.head_eq_getElem_zero hbs).symm /-- Padding the reported keys with filler keys in `(last, end_.key)` (all of them below `end_.key` and hence below `begin.key`) gives a compatible database whose begin selector resolves to the reported head and whose end selector resolves to the first filler. -/ theorem compatible_fillers_A2a {r : RangeRead} {res : Result} {dbF : DB} (hsort : res.keys.SortedLT) (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hlim : RangeRead.withinLimit r res.keys) (hbegin : r.begin.offset < 0) (hend : r.end_.offset ≤ 0) (hslack : beginSlack r = res.keys.length + clampNonposD r) (hEB : r.end_.key < r.begin.key) (hlastB : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key) (hFlast : ∀ x ∈ dbF.keys, res.keys.getLast hne < x) (hFend : ∀ x ∈ dbF.keys, (x : WithTop Key) < r.end_.key) (hFlen : dbF.keys.length = clampNonposD r + 1) : ∃ dbw : DB, dbw.keys = res.keys ++ dbF.keys ∧ RangeRead.Compatible dbw r res ∧ r.begin.anchor dbw = 0 ∧ r.end_.anchor dbw = (res.keys.length : ℤ) := by classical set last : Key := res.keys.getLast hne with hlast have hlastD : res.keys.getLastD ([] : Key) = last := by rw [hlast, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hlastB' : ((last : Key) : WithTop Key) < r.begin.key := by rw [← hlastD]; exact hlastB have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx have hEne : r.end_.key ≠ (⊤ : WithTop Key) := by intro h rw [h] at hEB exact absurd hEB (not_lt.mpr le_top) obtain ⟨e, he⟩ : ∃ e : Key, r.end_.key = ((e : Key) : WithTop Key) := by cases h : r.end_.key with | top => exact absurd h hEne | coe e => exact ⟨e, rfl⟩ have hDlen : dbF.keys.length = clampNonposD r + 1 := hFlen have hFne : dbF.keys ≠ [] := by intro h; rw [h] at hDlen; simp at hDlen -- sorted concatenation set D : List Key := res.keys ++ dbF.keys with hD have hDsort : D.SortedLT := by rw [hD] exact List.sortedLT_append.mpr ⟨hsort, dbF.sorted, fun a ha b hb => lt_of_le_of_lt (hle_last a ha) (hFlast b hb)⟩ let dbw : DB := ⟨D, hDsort⟩ have hkeyw : dbw.keys = res.keys ++ dbF.keys := rfl have hnodup : dbw.keys.Nodup := dbw.nodup -- every filler lies below `begin.key` have hFltB : ∀ x ∈ dbF.keys, (x : WithTop Key) < r.begin.key := fun x hx => lt_of_lt_of_le (hFend x hx) (le_of_lt hEB) -- begin anchor is zero have hanchorB : r.begin.anchor dbw = 0 := by have hc : dbw.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = dbw.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] rw [hkeyw] 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)) hlastB' · exact hFltB x hx have hc' : ((dbw.keys.length : ℕ) : ℤ) = res.keys.length + clampNonposD r + 1 := by rw [hkeyw, List.length_append, hDlen]; push_cast; ring rw [anchor_eq_count_sub_slack dbw r (le_of_lt hbegin), hc] have hlen : (dbw.keys.length : ℤ) = res.keys.length + clampNonposD r + 1 := by exact_mod_cast hc' have hslack' : (beginSlack r : ℤ) = (res.keys.length : ℤ) + clampNonposD r := by rw [hslack]; push_cast; ring rw [hlen, hslack']; ring have hlast_lt_E : ((last : Key) : WithTop Key) < r.end_.key := by have hhead_mem : dbF.keys.head hFne ∈ dbF.keys := List.head_mem hFne exact lt_trans (WithTop.coe_lt_coe.mpr (hFlast _ hhead_mem)) (hFend _ hhead_mem) -- end anchor is the reported count have hcountE : dbw.keys.countP (fun k : Key => decide (k < e)) = res.keys.length + clampNonposD r + 1 := by have hcl : dbw.keys.countP (fun k : Key => decide (k < e)) = dbw.keys.length := by rw [List.countP_eq_length] intro x hx rw [hkeyw] at hx rw [decide_eq_true_eq] rcases List.mem_append.mp hx with hx | hx · apply WithTop.coe_lt_coe.mp rw [← he] exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hle_last x hx)) hlast_lt_E · apply WithTop.coe_lt_coe.mp simpa [he] using hFend x hx rw [hcl, hkeyw, List.length_append, hDlen] omega have hanchorE : r.end_.anchor dbw = (res.keys.length : ℤ) := by rw [anchor_of_coe (s := r.end_) (v := e) he, hcountE] have hoff : r.end_.offset = -(clampNonposD r : ℤ) := by rw [clampNonposD_eq] have hnonneg : 0 ≤ -r.end_.offset := by omega rw [Int.toNat_of_nonneg hnonneg]; ring rw [hoff]; push_cast; ring refine ⟨dbw, hkeyw, ?_, hanchorB, hanchorE⟩ -- compatibility: the complete keys are exactly the reported keys have hhead_eq : dbw.keys[0]'(by rw [hkeyw, List.length_append]; omega) = res.keys.head hne := by have hleft := List.getElem_append_left (as := res.keys) (bs := dbF.keys) (i := 0) (h := by simp [List.length_pos_iff.mpr hne]) (h' := by simp [List.length_pos_iff.mpr hne]) exact hleft.trans (List.head_eq_getElem_zero hne).symm have hfill_head_gt : ∀ x ∈ dbF.keys, x ≥ dbF.keys.head hFne := fun x hx => (dbF.sorted.pairwise.imp le_of_lt).rel_head hx have hresolve_end : resolve dbw r.end_ = ((dbF.keys.head hFne : Key) : WithTop Key) := by have h0 : 0 ≤ r.end_.anchor dbw := by rw [hanchorE]; exact_mod_cast Nat.zero_le _ have hlt : (r.end_.anchor dbw).toNat < dbw.keys.length := by rw [hanchorE, hkeyw, List.length_append, hDlen] omega rw [resolve_eq_getElem h0 hlt] have hidx : (r.end_.anchor dbw).toNat = res.keys.length := by rw [hanchorE]; simp simp only [hidx] have hget : dbw.keys[res.keys.length]'(by rw [hkeyw, List.length_append, hDlen]; omega) = dbF.keys.head hFne := by have h1 : dbw.keys = res.keys ++ dbF.keys := hkeyw rw [List.getElem_of_eq h1] exact getElem_append_length hFne exact congrArg (fun x : Key => (x : WithTop Key)) hget have hresolve_begin : resolve dbw r.begin = ((res.keys.head hne : Key) : WithTop Key) := by have h0 : 0 ≤ r.begin.anchor dbw := by rw [hanchorB] have hlt : (r.begin.anchor dbw).toNat < dbw.keys.length := by rw [hanchorB, hkeyw, List.length_append, hDlen] simp only [Int.toNat_zero] omega rw [resolve_eq_getElem h0 hlt] have hidx : (r.begin.anchor dbw).toNat = 0 := by rw [hanchorB]; rfl simp only [hidx] exact congrArg (fun x : Key => (x : WithTop Key)) hhead_eq have hckmem : ∀ k : Key, k ∈ RangeRead.completeKeys dbw r ↔ k ∈ res.keys := by intro k rw [RangeRead.mem_completeKeys, hresolve_begin, hresolve_end] constructor · rintro ⟨hk, -, hlt⟩ rw [hkeyw] at hk rcases List.mem_append.mp hk with hk | hk · exact hk · exact absurd hlt (not_lt.mpr (WithTop.coe_le_coe.mpr (hfill_head_gt k hk))) · intro hk refine ⟨?_, ?_, ?_⟩ · rw [hkeyw]; exact List.mem_append_left _ hk · exact WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hk) · exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hle_last k hk)) (WithTop.coe_lt_coe.mpr (hFlast _ (List.head_mem hFne))) have hck : RangeRead.completeKeys dbw r = res.keys := by apply List.SortedLT.eq_of_mem_iff · rw [RangeRead.completeKeys, ite_eq_right (by simp [show r.reverse = false from hrev])] exact List.sortedLT_iff_pairwise.mpr (RangeRead.inRange_pairwise dbw _ _) · exact hsort · exact hckmem refine ⟨hlim, ?_⟩ left refine ⟨hmore, ?_, hne⟩ rw [hck] /-- Inserting a key above every element of a list appends it at the end. -/ theorem orderedInsert_of_forall_lt {l : List Key} {k : Key} (h : ∀ x ∈ l, x < k) : l.orderedInsert (· ≤ ·) k = l ++ [k] := by induction l with | nil => simp | cons a t ih => rw [List.orderedInsert_of_not_le t (r := (· ≤ ·)) (not_le.mpr (h a (List.mem_cons_self ..)))] have := ih (fun x hx => h x (List.mem_cons_of_mem _ hx)) simp only [this, List.cons_append] /-- A key strictly between the reported last and `end_.key` has an erase witness in the A2a non-clamping subcell: the target sits among `clampNonposD + 1` padding keys in `(last, end_.key)`, so the end selector resolves into the padding; erasing the target lowers the end resolution to the reported last, which drops the last reported key from the truncated window. -/ theorem exists_witness_erase_A2a {r : RangeRead} {res : Result} {k : Key} (hread : Readable r res) (hcell : negCrossTruncNonposGapA2aNonbottom r res) (hne : res.keys ≠ []) (hkgt : ((res.keys.getLast hne : Key) : WithTop Key) < (k : WithTop Key)) (hkE : (k : WithTop Key) < r.end_.key) : ∃ dbw : DB, RangeRead.Compatible dbw r res ∧ k ∈ dbw.keys ∧ ¬ RangeRead.Compatible (dbw.erase k) r res := by obtain ⟨hcell0, hEB, hnbot⟩ := hcell obtain ⟨hmore, hrev, hbegin, -, hcross, hend, hclamp, hlastB, hlastE, hEne, hcap⟩ := hcell0 obtain ⟨db₀, hcomp₀⟩ := hread have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev have hlim : RangeRead.withinLimit r res.keys := hcomp₀.1 have hlastD : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hlast_lt_k : res.keys.getLast hne < k := WithTop.coe_lt_coe.mp hkgt have hlast_lt_B : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key := by rw [← hlastD]; exact hlastB have hlast_lt_E : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key := by rw [← hlastD]; exact hlastE have hslack : beginSlack r = res.keys.length + clampNonposD r := beginSlack_eq_of_A2a_nonbottom hcomp₀ hrev hmore hne hbegin hend hclamp hnbot hEB hlastB hlastE have hk_not_res : k ∉ res.keys := by intro hx exact absurd hlast_lt_k (not_lt.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hx)) -- pad keys in `(last, end_.key)` avoiding `k` have hcard : ((clampNonposD r + 1 : ℕ) : ℕ∞) ≤ intervalCard (((keyAfter (res.keys.getLast hne) : Key)) : WithTop Key) r.end_.key := intervalCard_keyAfter_getLast_ge hcomp₀ hne hend obtain ⟨dbB, hBmem, hBk, hBlen⟩ := exists_db_keysIn_avoid (B := (((keyAfter (res.keys.getLast hne) : Key)) : WithTop Key)) (E := r.end_.key) (k := k) (m := clampNonposD r) hcard have hBgt : ∀ x ∈ dbB.keys, res.keys.getLast hne < x := by intro x hx exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt (res.keys.getLast hne))) (hBmem x hx).1) have hBElt : ∀ x ∈ dbB.keys, (x : WithTop Key) < r.end_.key := fun x hx => (hBmem x hx).2 -- assemble `k` with the padding and sort set raw : List Key := k :: dbB.keys with hraw have hrawNodup : raw.Nodup := by rw [hraw] exact List.nodup_cons.mpr ⟨hBk, dbB.sorted.pairwise.nodup⟩ 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) let dbF : DB := ⟨F, hFsorted⟩ have hFlen : dbF.keys.length = clampNonposD r + 1 := by change F.length = clampNonposD r + 1 rw [hF, List.length_insertionSort, hraw, List.length_cons, hBlen] have hFlt : ∀ x ∈ dbF.keys, res.keys.getLast hne < x := by intro x hx have hx' := hFperm.mem_iff.mpr hx rw [hraw] at hx' rcases List.mem_cons.mp hx' with rfl | hxB · exact hlast_lt_k · exact hBgt x hxB have hFend : ∀ x ∈ dbF.keys, (x : WithTop Key) < r.end_.key := by intro x hx have hx' := hFperm.mem_iff.mpr hx rw [hraw] at hx' rcases List.mem_cons.mp hx' with rfl | hxB · exact hkE · exact hBElt x hxB obtain ⟨dbw, hkeyw, hcompw, hanchB, hanchE⟩ := compatible_fillers_A2a hsort hrev hmore hne hlim hbegin hend hslack hEB hlastB hFlt hFend hFlen have hk_in_F : k ∈ dbF.keys := hFperm.mem_iff.mp (by rw [hraw]; exact List.mem_cons_self ..) have hk_in_dbw : k ∈ dbw.keys := by rw [hkeyw]; exact List.mem_append.mpr (Or.inr hk_in_F) refine ⟨dbw, hcompw, hk_in_dbw, ?_⟩ intro hcomp' have herase_keys : (dbw.erase k).keys = res.keys ++ dbF.keys.erase k := by rw [DB.erase_keys, hkeyw, List.erase_append_right _ hk_not_res] obtain ⟨-, hfilt'⟩ := (compatible_iff_truncated_keys hrev hmore hne).mp hcomp' have hcount_erase : (dbw.erase k).keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = res.keys.length + clampNonposD r := by rw [herase_keys, List.countP_append] have h1 : res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = res.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hx)) hlast_lt_E have hFall : dbF.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = dbF.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] exact hFend x hx have hktrue : (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) k = true := by rw [decide_eq_true_eq]; exact hkE have h2 : (dbF.keys.erase k).countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = clampNonposD r := by rw [List.countP_erase, ite_eq_left ⟨hk_in_F, hktrue⟩, hFall, hFlen] omega rw [h1, h2] have hoff : r.end_.offset = -(clampNonposD r : ℤ) := by rw [clampNonposD_eq] have hnonneg : 0 ≤ -r.end_.offset := by omega rw [Int.toNat_of_nonneg hnonneg]; ring have hanchor_erase : r.end_.anchor (dbw.erase k) = (res.keys.length : ℤ) - 1 := by cases hE : r.end_.key with | top => exact absurd hE (ne_of_lt hEne) | coe e => rw [anchor_of_coe (s := r.end_) (v := e) hE] have hce : (dbw.erase k).keys.countP (fun x => decide (x < e)) = res.keys.length + clampNonposD r := by rw [← countP_lt_coe (l := (dbw.erase k).keys) e, ← hE] exact hcount_erase rw [hce, hoff] push_cast ring have ht_pos : 0 < res.keys.length := List.length_pos_iff.mpr hne have hresolve_end : resolve (dbw.erase k) r.end_ = ((res.keys.getLast hne : Key) : WithTop Key) := by have h0 : 0 ≤ r.end_.anchor (dbw.erase k) := by rw [hanchor_erase]; omega have hlenErase : (dbw.erase k).keys.length = res.keys.length + clampNonposD r := by rw [herase_keys, List.length_append, List.length_erase, ite_eq_left hk_in_F, hFlen] omega have hlt : (r.end_.anchor (dbw.erase k)).toNat < (dbw.erase k).keys.length := by rw [hanchor_erase, hlenErase] omega rw [resolve_eq_getElem h0 hlt] have hidx : (r.end_.anchor (dbw.erase k)).toNat = res.keys.length - 1 := by rw [hanchor_erase] have : ((res.keys.length : ℤ) - 1).toNat = res.keys.length - 1 := by omega exact this have hget : (dbw.erase k).keys[(r.end_.anchor (dbw.erase k)).toNat] = res.keys.getLast hne := by simp only [hidx, herase_keys] have hlen : res.keys.length - 1 < res.keys.length := by omega rw [List.getElem_append_left (i := res.keys.length - 1) (h := hlen)] exact (List.getLast_eq_getElem hne).symm rw [hget] have hlast_not_ck : res.keys.getLast hne ∉ RangeRead.completeKeys (dbw.erase k) r := by intro hmem have hlt := (RangeRead.mem_completeKeys.mp hmem).2.2 rw [hresolve_end] at hlt exact lt_irrefl _ hlt have hlast_in_filt : res.keys.getLast hne ∈ (RangeRead.completeKeys (dbw.erase k) r).filter (fun x : Key => decide (x ≤ res.keys.getLast hne)) := by rw [hfilt'] exact List.getLast_mem hne rw [List.mem_filter] at hlast_in_filt exact hlast_not_ck hlast_in_filt.1 /-- A key in `[end_.key, begin.key)` has an insert witness in the A2a non-clamping subcell: padding with `clampNonposD + 1` keys in `(last, end_.key)` makes the begin selector resolve to the reported head with anchor zero; inserting the target raises the begin anchor to one, so the head drops out of the complete window. -/ theorem exists_witness_insert_A2a {r : RangeRead} {res : Result} {k : Key} (hread : Readable r res) (hcell : negCrossTruncNonposGapA2aNonbottom r res) (hne : res.keys ≠ []) (hkE : r.end_.key ≤ (k : WithTop Key)) (hkB : (k : WithTop Key) < r.begin.key) : ∃ dbw : DB, RangeRead.Compatible dbw r res ∧ ¬ RangeRead.Compatible (toggle dbw k) r res := by obtain ⟨hcell0, hEB, hnbot⟩ := hcell obtain ⟨hmore, hrev, hbegin, -, hcross, hend, hclamp, hlastB, hlastE, hEne, hcap⟩ := hcell0 obtain ⟨db₀, hcomp₀⟩ := hread have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev have hlim : RangeRead.withinLimit r res.keys := hcomp₀.1 have hlastD : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hlast_lt_B : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key := by rw [← hlastD]; exact hlastB have hlast_lt_E : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key := by rw [← hlastD]; exact hlastE have hslack : beginSlack r = res.keys.length + clampNonposD r := beginSlack_eq_of_A2a_nonbottom hcomp₀ hrev hmore hne hbegin hend hclamp hnbot hEB hlastB hlastE have hcard : ((clampNonposD r + 1 : ℕ) : ℕ∞) ≤ intervalCard (((keyAfter (res.keys.getLast hne) : Key)) : WithTop Key) r.end_.key := intervalCard_keyAfter_getLast_ge hcomp₀ hne hend obtain ⟨dbF, hFmem, hFlen⟩ := exists_db_keysIn (B := (((keyAfter (res.keys.getLast hne) : Key)) : WithTop Key)) (E := r.end_.key) (m := clampNonposD r + 1) hcard have hFlt : ∀ x ∈ dbF.keys, res.keys.getLast hne < x := by intro x hx exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt (res.keys.getLast hne))) (hFmem x hx).1) have hFend : ∀ x ∈ dbF.keys, (x : WithTop Key) < r.end_.key := fun x hx => (hFmem x hx).2 obtain ⟨dbw, hkeyw, hcompw, hanchB, hanchE⟩ := compatible_fillers_A2a hsort hrev hmore hne hlim hbegin hend hslack hEB hlastB hFlt hFend hFlen have hdbw_lt_k : ∀ x ∈ dbw.keys, x < k := by intro x hx rw [hkeyw] at hx rcases List.mem_append.mp hx with hx | hx · exact WithTop.coe_lt_coe.mp (lt_of_le_of_lt (WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hx)) (WithTop.coe_lt_coe.mpr (WithTop.coe_lt_coe.mp (lt_of_lt_of_le hlast_lt_E hkE)))) · exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hFend x hx) hkE) have hk_not_dbw : k ∉ dbw.keys := fun hx => absurd (hdbw_lt_k k hx) (lt_irrefl k) refine ⟨dbw, hcompw, ?_⟩ rw [toggle_eq_insert_of_not_mem hk_not_dbw] have hins_keys : (dbw.insert k hk_not_dbw).keys = dbw.keys ++ [k] := by rw [DB.insert_keys] exact orderedInsert_of_forall_lt hdbw_lt_k intro hcomp' obtain ⟨-, hfilt'⟩ := (compatible_iff_truncated_keys hrev hmore hne).mp hcomp' have hlen_dbw : 2 ≤ dbw.keys.length := by rw [hkeyw, List.length_append, hFlen] have : 1 ≤ res.keys.length := List.length_pos_iff.mpr hne omega have hhead0 : dbw.keys[0]'(by omega) = res.keys.head hne := by have h1 : dbw.keys = res.keys ++ dbF.keys := hkeyw rw [List.getElem_of_eq h1] have hpos : 0 < res.keys.length := List.length_pos_iff.mpr hne rw [List.getElem_append_left (i := 0) (h := hpos) (h' := by rw [List.length_append]; omega)] exact (List.head_eq_getElem_zero hne).symm have hhead_lt : ((res.keys.head hne : Key) : WithTop Key) < ((dbw.keys[1] : Key) : WithTop Key) := by rw [← hhead0] have hlt := dbw.sorted.getElem_lt_getElem_of_lt (i := 0) (j := 1) (hi := by omega) (hj := by omega) (by omega) exact WithTop.coe_lt_coe.mpr hlt have hcount_before : dbw.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = res.keys.length + clampNonposD r + 1 := by rw [hkeyw, List.countP_append] have h1 : res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = res.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hx)) hlast_lt_B have h2 : dbF.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = dbF.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] exact lt_of_lt_of_le (hFend x hx) (le_of_lt hEB) rw [h1, h2, hFlen] omega have hcount_ins : (dbw.insert k hk_not_dbw).keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = res.keys.length + clampNonposD r + 2 := by rw [hins_keys, List.countP_append, hcount_before, List.countP_singleton, decide_eq_true_eq.mpr hkB] norm_num have hanchor_ins : r.begin.anchor (dbw.insert k hk_not_dbw) = 1 := by rw [anchor_eq_count_sub_slack _ r (le_of_lt hbegin), hcount_ins] have hslack' : (beginSlack r : ℤ) = (res.keys.length : ℤ) + clampNonposD r := by rw [hslack]; push_cast; ring rw [hslack']; push_cast; ring have hresolve_ins : resolve (dbw.insert k hk_not_dbw) r.begin = ((dbw.keys[1] : Key) : WithTop Key) := by have h0 : 0 ≤ r.begin.anchor (dbw.insert k hk_not_dbw) := by rw [hanchor_ins]; norm_num have hlt : (r.begin.anchor (dbw.insert k hk_not_dbw)).toNat < (dbw.insert k hk_not_dbw).keys.length := by rw [hanchor_ins, hins_keys, List.length_append, List.length_singleton] exact Nat.lt_succ_of_lt (by omega) rw [resolve_eq_getElem h0 hlt] have hidx : (r.begin.anchor (dbw.insert k hk_not_dbw)).toNat = 1 := by rw [hanchor_ins]; rfl simp only [hidx, hins_keys] rw [List.getElem_append_left (i := 1) (h := by omega)] have hhead_in : res.keys.head hne ∈ (RangeRead.completeKeys (dbw.insert k hk_not_dbw) r).filter (fun x : Key => decide (x ≤ res.keys.getLast hne)) := by rw [hfilt'] exact List.head_mem hne rw [List.mem_filter] at hhead_in have hge := (RangeRead.mem_completeKeys.mp hhead_in.1).2.1 rw [hresolve_ins] at hge exact absurd hhead_lt (not_lt.mpr hge) /-- **The `end_.key < begin.key` non-clamping subcell of the crossed truncated nonpositive-end gap cell is minimal**, with closed form `[head, begin.key)`. -/ theorem minimal_closedForm_of_negCross_trunc_nonposGap_A2a_nonbottom {r : RangeRead} {res : Result} (hread : Readable r res) (hcell : negCrossTruncNonposGapA2aNonbottom r res) : Minimal r res (closedFormNegCrossTruncNonposGapA2aNonbottom r res) := by have hcellKeep : negCrossTruncNonposGapA2aNonbottom r res := hcell obtain ⟨hcell0, hEB, hnbot⟩ := hcell obtain ⟨hmore, hrev, hbegin, hne, hcross, hend, hclamp, hlastB, hlastE, hEne, hcap⟩ := hcell0 have hmax : max r.begin.key r.end_.key = r.begin.key := max_eq_left (le_of_lt hEB) have hcross' : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by have hle : leastReported r res = res.keys.head hne := by simp [leastReported, hrev, List.head?_eq_some_head hne] rwa [hle] at hcross have hclosed : closedFormNegCrossTruncNonposGapA2aNonbottom r res = ⟨((res.keys.head hne : Key) : WithTop Key), r.begin.key⟩ := by unfold closedFormNegCrossTruncNonposGapA2aNonbottom rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl rw [hclosed] refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩ · have hs := sound_headLong_of_nonbottom hrev hmore hne hbegin hcross' hclamp hnbot hend rwa [hmax] at hs · intro k hkhead hkB have hkhead' : ((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) := hkhead by_cases hkres : k ∈ res.keys · exact necessary_of_mem_result hread hkres · by_cases hklast : (k : WithTop Key) ≤ ((res.keys.getLast hne : Key) : WithTop Key) · exact necessary_of_between_result hread (List.head_mem hne) (List.getLast_mem hne) (WithTop.coe_le_coe.mp hkhead') (WithTop.coe_le_coe.mp hklast) · have hlastk : ((res.keys.getLast hne : Key) : WithTop Key) < (k : WithTop Key) := not_le.mp hklast by_cases hkE : (k : WithTop Key) < r.end_.key · obtain ⟨dbw, hcompw, hkdbw, hnot⟩ := exists_witness_erase_A2a hread hcellKeep hne hlastk hkE exact necessary_of_toggle ⟨dbw, hcompw, by rw [toggle_eq_erase_of_mem hkdbw]; exact hnot⟩ · have hEk : r.end_.key ≤ (k : WithTop Key) := not_lt.mp hkE obtain ⟨dbw, hcompw, hnot⟩ := exists_witness_insert_A2a hread hcellKeep hne hEk hkB exact necessary_of_toggle ⟨dbw, hcompw, hnot⟩ end FormalConflictRange