/- 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.NegCrossComplete import FormalConflictRange.NegCrossClosedForm import FormalConflictRange.NonposRevClosedForm /-! # The crossed negative-begin complete non-overshoot residual This module closes the remaining crossed negative-begin complete cells: those with `2 ≤ end.offset`, `begin.key` strictly above the reported head, and at least one reported key at or above `end.key`. The key observation is that the end selector can be shifted to the immediate successor of the last reported key without changing any compatible database. If `L` is the last reported key and `t` is the number of reported keys at or above `end.key`, then the original end anchor is `cnt end.key + end.offset - 1`, while the anchor of `⟨keyAfter L, end.offset - t⟩` is `cnt (keyAfter L) + end.offset - t - 1`. Because the half-open gap `[end.key, keyAfter L)` contains only reported keys in every compatible database, `cnt (keyAfter L) = cnt end.key + t`, so the two anchors agree. The reduced read has all reported keys strictly below its end key; it is therefore a complete overshoot (`2 ≤ end.offset - t`) or an offset-one cell. Minimality transfers between the two reads directly, since their compatible database sets coincide. -/ namespace FormalConflictRange /-- The number of reported keys at or above the end selector key. -/ def reportedAtOrAboveEnd (r : RangeRead) (res : Result) : ℕ := res.keys.countP (fun k : Key => decide (r.end_.key ≤ ((k : Key) : WithTop Key))) /-- The read whose end selector is shifted to the successor of the last reported key. The offset is reduced by the number of reported keys at or above `end.key`, so the end anchor (and hence every resolution) is unchanged on compatible databases. -/ noncomputable def completeResidualReduced (r : RangeRead) (res : Result) : RangeRead := { r with end_ := { key := ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) offset := r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) } } /-- **The gap `[end.key, keyAfter L)` contains exactly the reported keys at or above `end.key`.** The result keys are the stored keys of the half-open window, `L` is the last reported key, and `end.key` lies between the window's lower bound and `L`. Any stored key strictly above `L` but below the window's upper bound would be reported and contradict `L` being last. -/ theorem between_end_keyAfter_length_eq_reportedAtOrAboveEnd {db : DB} {res : Result} {lo hi : WithTop Key} {E : WithTop Key} (hne : res.keys ≠ []) (hkeys : res.keys = RangeRead.inRange db.keys lo hi) (hloE : lo ≤ E) (_hEL : E ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) (_hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) : (between db E ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)).length = res.keys.countP (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key))) := by set L : Key := res.keys.getLastD ([] : Key) with hL have hLget : L = res.keys.getLast hne := by rw [hL] exact getLastD_eq_getLast_of_ne hne have hLmem : L ∈ res.keys := by rw [hLget]; exact List.getLast_mem hne have hpair : res.keys.Pairwise (· < ·) := hkeys.symm ▸ RangeRead.inRange_pairwise db lo hi have hmax : ∀ x ∈ res.keys, x ≤ L := fun x hx => le_getLastD_of_pairwise hpair hx have hLin : L ∈ RangeRead.inRange db.keys lo hi := hkeys.symm ▸ hLmem have hLin' : L ∈ db.keys ∧ lo ≤ (L : WithTop Key) ∧ (L : WithTop Key) < hi := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin have hLstored : L ∈ db.keys := hLin'.1 -- No stored key lies strictly between `L` and the window's upper bound. have hno_above : ∀ x ∈ db.keys, L < x → hi ≤ (x : WithTop Key) := by intro x hxdb hxL by_contra hxhi have hxhi' : (x : WithTop Key) < hi := lt_of_not_ge hxhi have hxin : x ∈ RangeRead.inRange db.keys lo hi := by simp only [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] exact ⟨hxdb, le_trans hLin'.2.1 (WithTop.coe_le_coe.mpr (le_of_lt hxL)), hxhi'⟩ have hxmem : x ∈ res.keys := hkeys.symm ▸ hxin exact absurd (hmax x hxmem) (not_le.mpr hxL) -- The two filters agree: both select the stored keys in `[E, L]`. have hflt : (db.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < ((keyAfter L : Key) : WithTop Key)))) = (db.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < hi))) := by apply List.filter_congr intro x hxdb rw [decide_eq_decide] constructor · rintro ⟨hEx, hxka⟩ refine ⟨hEx, lt_of_le_of_lt ?_ hLin'.2.2⟩ exact WithTop.coe_le_coe.mpr ((lt_keyAfter_iff x L).mp (WithTop.coe_lt_coe.mp hxka)) · rintro ⟨hEx, hxhi⟩ refine ⟨hEx, ?_⟩ by_contra hcon have hxge : ((keyAfter L : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := le_of_not_gt hcon have hxL : L < x := lt_of_lt_of_le (keyAfter_self_lt L) (WithTop.coe_le_coe.mp hxge) exact absurd hxhi (not_lt.mpr (hno_above x hxdb hxL)) -- Convert to the reported-key count. rw [show (between db E ((keyAfter L : Key) : WithTop Key)) = db.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < ((keyAfter L : Key) : WithTop Key))) by rfl] rw [hflt] -- The reported keys at or above `E` are exactly the stored keys in `[E, hi)`. have hreported : res.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key))) = RangeRead.inRange db.keys E hi := by rw [hkeys] unfold RangeRead.inRange rw [List.filter_filter] apply List.filter_congr intro x _ by_cases hE : E ≤ ((x : Key) : WithTop Key) · by_cases hhi : ((x : Key) : WithTop Key) < hi · have hlo : lo ≤ ((x : Key) : WithTop Key) := le_trans hloE hE simp [hE, hhi, hlo] · simp [hE, hhi] · simp [hE] have hlen : (db.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < hi))) = RangeRead.inRange db.keys E hi := rfl rw [hlen, ← hreported, List.countP_eq_length_filter] /-- The count identity behind the reduction: the number of stored keys below the successor of the last reported key is the count below `end.key` plus the number of reported keys at or above `end.key`. -/ theorem cnt_keyAfter_eq_cnt_end_add {db : DB} {r : RangeRead} {res : Result} {lo hi : WithTop Key} (hne : res.keys ≠ []) (hkeys : res.keys = RangeRead.inRange db.keys lo hi) (hloE : lo ≤ r.end_.key) (hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) (hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) : cnt db ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) = cnt db r.end_.key + reportedAtOrAboveEnd r res := by have hEL' : r.end_.key ≤ ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) := le_trans hEL (WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt _))) rw [cnt_eq_add_between db hEL', between_end_keyAfter_length_eq_reportedAtOrAboveEnd hne hkeys hloE hEL hLhi] rfl /-- The shifted end selector has the same anchor as the original on any compatible complete result. -/ theorem reduced_end_anchor_eq {db : DB} {r : RangeRead} {res : Result} {lo hi : WithTop Key} (hne : res.keys ≠ []) (hkeys : res.keys = RangeRead.inRange db.keys lo hi) (hloE : lo ≤ r.end_.key) (hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) (hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) : (completeResidualReduced r res).end_.anchor db = r.end_.anchor db := by have hcnt := cnt_keyAfter_eq_cnt_end_add hne hkeys hloE hEL hLhi change (cnt db ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) : ℤ) + (r.end_.offset - (reportedAtOrAboveEnd r res : ℤ)) - 1 = (cnt db r.end_.key : ℤ) + r.end_.offset - 1 rw [hcnt] push_cast ring /-- The complete keys of a forward read are the stored keys in the resolved window. -/ theorem completeKeys_eq_inRange_of_not_rev {db : DB} {r : RangeRead} (hrev : r.reverse = false) : RangeRead.completeKeys db r = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by unfold RangeRead.completeKeys rw [ite_eq_right (by simp [hrev])] /-- **The reduction preserves compatible databases.** Under the complete-result hypotheses and the cell condition that the resolved begin is at or below `end.key` (which follows from `head ≤ end.key`), shifting the end selector to `⟨keyAfter (last reported), end.offset - t⟩` leaves the set of compatible databases unchanged. -/ theorem compatible_reduced_iff {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hheadE : ((res.keys.headD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key) (hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) : RangeRead.Compatible db r res ↔ RangeRead.Compatible db (completeResidualReduced r res) res := by have hwithin : RangeRead.withinLimit r res.keys ↔ RangeRead.withinLimit (completeResidualReduced r res) res.keys := by simp [RangeRead.withinLimit, completeResidualReduced] have hrev' : (completeResidualReduced r res).reverse = false := hrev constructor · intro h have heq : res.keys = RangeRead.completeKeys db r := by rcases h.2 with ⟨hm, -, -⟩ | ⟨-, he⟩ · simp [hmore] at hm · exact he have hkeys : res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := heq.trans (completeKeys_eq_inRange_of_not_rev hrev) have hloE : resolve db r.begin ≤ r.end_.key := by have hheadmem : res.keys.headD ([] : Key) ∈ res.keys := headD_mem hne have hheadin : res.keys.headD ([] : Key) ∈ RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by rw [← hkeys]; exact hheadmem have hheadin' : (res.keys.headD ([] : Key)) ∈ db.keys ∧ resolve db r.begin ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧ ((res.keys.headD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hheadin exact le_trans hheadin'.2.1 hheadE have hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by have hLin : (res.keys.getLastD ([] : Key)) ∈ RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by rw [← hkeys]; exact getLastD_mem hne have hLin' : (res.keys.getLastD ([] : Key)) ∈ db.keys ∧ resolve db r.begin ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin exact hLin'.2.2 have hanc := reduced_end_anchor_eq (db := db) (r := r) (res := res) (lo := resolve db r.begin) (hi := resolve db r.end_) hne hkeys hloE hEL hLhi have hres_eq : resolve db (completeResidualReduced r res).end_ = resolve db r.end_ := by unfold resolve rw [hanc] refine ⟨hwithin.mp h.1, Or.inr ⟨hmore, ?_⟩⟩ rw [heq, completeKeys_eq_inRange_of_not_rev hrev, completeKeys_eq_inRange_of_not_rev hrev', hres_eq] simp only [completeResidualReduced] · intro h have heq : res.keys = RangeRead.completeKeys db (completeResidualReduced r res) := by rcases h.2 with ⟨hm, -, -⟩ | ⟨-, he⟩ · simp [hmore] at hm · exact he have hkeys : res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db (completeResidualReduced r res).end_) := heq.trans (completeKeys_eq_inRange_of_not_rev hrev') have hloE : resolve db r.begin ≤ r.end_.key := by have hheadmem : res.keys.headD ([] : Key) ∈ res.keys := headD_mem hne have hheadin : res.keys.headD ([] : Key) ∈ RangeRead.inRange db.keys (resolve db r.begin) (resolve db (completeResidualReduced r res).end_) := by rw [← hkeys]; exact hheadmem have hheadin' : (res.keys.headD ([] : Key)) ∈ db.keys ∧ resolve db r.begin ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧ ((res.keys.headD ([] : Key) : Key) : WithTop Key) < resolve db (completeResidualReduced r res).end_ := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hheadin exact le_trans hheadin'.2.1 hheadE have hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db (completeResidualReduced r res).end_ := by have hLin : (res.keys.getLastD ([] : Key)) ∈ RangeRead.inRange db.keys (resolve db r.begin) (resolve db (completeResidualReduced r res).end_) := by rw [← hkeys]; exact getLastD_mem hne have hLin' : (res.keys.getLastD ([] : Key)) ∈ db.keys ∧ resolve db r.begin ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db (completeResidualReduced r res).end_ := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin exact hLin'.2.2 have hanc := reduced_end_anchor_eq (db := db) (r := r) (res := res) (lo := resolve db r.begin) (hi := resolve db (completeResidualReduced r res).end_) hne hkeys hloE hEL hLhi have hres_eq : resolve db r.end_ = resolve db (completeResidualReduced r res).end_ := by unfold resolve rw [hanc] refine ⟨hwithin.mpr h.1, Or.inr ⟨hmore, ?_⟩⟩ rw [heq, completeKeys_eq_inRange_of_not_rev hrev', completeKeys_eq_inRange_of_not_rev hrev, hres_eq] simp only [completeResidualReduced] /-- The number of stored keys below a resolution is at most its clamped anchor index. -/ theorem cnt_resolve_le_anchor_toNat {db : DB} {s : Selector} (h0 : 0 ≤ s.anchor db) : cnt db (resolve db s) ≤ (s.anchor db).toNat := by rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := s) with hnil | htop | ⟨k, hkdb, hkeq⟩ · rw [hnil, cnt_nil]; omega · rw [htop, cnt_top] have hlen : db.keys.length ≤ (s.anchor db).toNat := by by_contra hcon have hlt : (s.anchor db).toNat < db.keys.length := lt_of_not_ge hcon rw [resolve_eq_getElem h0 hlt] at htop exact absurd htop (by simp) exact hlen · rw [hkeq] have hlt : (s.anchor db).toNat < db.keys.length := by by_contra hcon exact absurd (resolve_eq_top h0 (le_of_not_gt hcon) ▸ hkeq : (⊤ : WithTop Key) = ↑k) (by simp) have hget : db.keys[(s.anchor db).toNat] = k := by have := resolve_eq_getElem (db := db) (s := s) h0 hlt rw [hkeq] at this exact WithTop.coe_inj.mp this.symm rw [cnt_coe, countP_lt_eq_of_getElem db.sorted hlt hget] /-- **The reduced end offset is positive.** The last reported key lies strictly below the resolved end, so the successor of the last reported key is at most the resolved end; hence the number of stored keys below the successor is at most the end anchor, which is `cnt end.key + end.offset - 1`. The count identity then gives `end.offset - t ≥ 1`. -/ theorem endOffset_sub_reportedAtOrAboveEnd_ge_one {db : DB} {r : RangeRead} {res : Result} {lo hi : WithTop Key} (hne : res.keys ≠ []) (hkeys : res.keys = RangeRead.inRange db.keys lo hi) (hloE : lo ≤ r.end_.key) (hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) (hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) (hhi : hi = resolve db r.end_) (heo : 1 ≤ r.end_.offset) : 1 ≤ r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) := by have hcnt := cnt_keyAfter_eq_cnt_end_add hne hkeys hloE hEL hLhi have hkeyle : ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) ≤ resolve db r.end_ := by rw [← hhi] exact keyAfter_le_of_lt hLhi have hle1 : cnt db ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) ≤ cnt db (resolve db r.end_) := cnt_le_cnt_of_le db hkeyle have h0 : 0 ≤ r.end_.anchor db := by unfold Selector.anchor have : (0 : ℤ) ≤ (db.keys.countP (fun k : Key => decide ((↑k : WithTop Key) < r.end_.key)) : ℤ) := Int.natCast_nonneg _ omega have hle2 : cnt db (resolve db r.end_) ≤ (r.end_.anchor db).toNat := cnt_resolve_le_anchor_toNat h0 have hanc : (r.end_.anchor db).toNat = cnt db r.end_.key + (r.end_.offset - 1).toNat := anchor_toNat_eq (s := r.end_) heo have hcntle : reportedAtOrAboveEnd r res ≤ (r.end_.offset - 1).toNat := by rw [hcnt] at hle1 omega have hcast : ((reportedAtOrAboveEnd r res : ℕ) : ℤ) ≤ r.end_.offset - 1 := by have hd0 : 0 ≤ r.end_.offset - 1 := by omega have h2 : ((r.end_.offset - 1).toNat : ℤ) = r.end_.offset - 1 := Int.toNat_of_nonneg hd0 exact le_trans (by exact_mod_cast hcntle) (le_of_eq h2) omega /-- The forward crossed negative-begin complete residual non-overshoot cell: at least one reported key is at or above `end.key`, but the reported head is at or below `end.key` and the reported last is at or above it. -/ abbrev negCrossCompleteResidual (r : RangeRead) (res : Result) : Prop := r.reverse = false ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧ 2 ≤ r.end_.offset ∧ ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key ∧ r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) /-- The closed form for the residual: shift the end selector to the successor of the last reported key, then read off the overshoot or offset-one rule of the shifted read. -/ noncomputable def closedFormNegCrossCompleteResidual (r : RangeRead) (res : Result) : ConflictRange := let r' := completeResidualReduced r res if 2 ≤ r'.end_.offset then closedFormNegCrossOvershoot r' res else if reportedBelowBegin r' res ≤ beginSlack r' then closedFormNegCrossClampEndOne r' res else if r.begin.key ≤ r'.end_.key then closedFormNegCrossEndOne r' res else closedFormNegCrossEndOneLong r' res /-- The last reported key lies strictly below the resolved end of any compatible complete forward database, and every reported key is at or below it. -/ theorem complete_residual_last_facts {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hcomp : RangeRead.Compatible db r res) : res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ ∧ List.Pairwise (· < ·) res.keys := by have heq : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, he⟩ · simp [hmore] at hm · exact he have hkeys : res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := heq.trans (completeKeys_eq_inRange_of_not_rev hrev) refine ⟨hkeys, ?_, ?_⟩ · have hLin : (res.keys.getLastD ([] : Key)) ∈ RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by rw [← hkeys]; exact getLastD_mem hne have hLin' : (res.keys.getLastD ([] : Key)) ∈ db.keys ∧ resolve db r.begin ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin exact hLin'.2.2 · exact hkeys.symm ▸ RangeRead.inRange_pairwise db _ _ /-- **The crossed negative-begin complete residual non-overshoot cell is minimal.** -/ theorem minimal_closedForm_of_negCross_complete_residual {r : RangeRead} {res : Result} (hread : Readable r res) (hcell : negCrossCompleteResidual r res) : Minimal r res (closedFormNegCrossCompleteResidual r res) := by obtain ⟨hrev, hbegin, hmore, hne, hend2, hcrossD, hheadE, hEL⟩ := hcell obtain ⟨db₀, hcomp₀⟩ := hread obtain ⟨hkeys₀, hlast_lt, hpair₀⟩ := complete_residual_last_facts hrev hmore hne hcomp₀ have hheadmem : res.keys.headD ([] : Key) ∈ res.keys := headD_mem hne have hheadin : res.keys.headD ([] : Key) ∈ RangeRead.inRange db₀.keys (resolve db₀ r.begin) (resolve db₀ r.end_) := by rw [← hkeys₀]; exact hheadmem have hheadin' : (res.keys.headD ([] : Key)) ∈ db₀.keys ∧ resolve db₀ r.begin ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧ ((res.keys.headD ([] : Key) : Key) : WithTop Key) < resolve db₀ r.end_ := by simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hheadin have hloE₀ : resolve db₀ r.begin ≤ r.end_.key := le_trans hheadin'.2.1 hheadE have hpos : 1 ≤ r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) := endOffset_sub_reportedAtOrAboveEnd_ge_one hne hkeys₀ hloE₀ hEL hlast_lt rfl (by omega) have hcompat : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db (completeResidualReduced r res) res := fun db => compatible_reduced_iff hrev hmore hne hheadE hEL have hread' : Readable (completeResidualReduced r res) res := ⟨db₀, (hcompat db₀).mp hcomp₀⟩ have hrev' : (completeResidualReduced r res).reverse = false := hrev have hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < (completeResidualReduced r res).end_.key := by intro k hk have hkle : k ≤ res.keys.getLastD ([] : Key) := le_getLastD_of_pairwise hpair₀ hk exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkle) (WithTop.coe_lt_coe.mpr (keyAfter_self_lt _)) have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by rw [← headD_eq_head_of_ne hne]; exact hcrossD rw [minimal_congr_of_compatible_iff hcompat] unfold closedFormNegCrossCompleteResidual have hred : (completeResidualReduced r res).end_.offset = r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) := rfl by_cases hbig : 2 ≤ (completeResidualReduced r res).end_.offset · rw [ite_eq_left hbig] exact minimal_closedForm_of_negCross_overshoot hread' hrev' hbegin hmore hne hbig hhi hcross · rw [ite_eq_right hbig] have hoff1 : (completeResidualReduced r res).end_.offset = 1 := by omega by_cases hclamp : reportedBelowBegin (completeResidualReduced r res) res ≤ beginSlack (completeResidualReduced r res) · rw [ite_eq_left hclamp] exact minimal_closedForm_of_negCross_clampEndOne hread' ⟨hrev', hbegin, hmore, hne, hoff1, hcrossD, hclamp⟩ · rw [ite_eq_right hclamp] have hnc : beginSlack (completeResidualReduced r res) < reportedBelowBegin (completeResidualReduced r res) res := not_le.mp hclamp by_cases hB : r.begin.key ≤ (completeResidualReduced r res).end_.key · rw [ite_eq_left hB] exact minimal_closedForm_of_negCross_endOne hread' ⟨hrev', hbegin, hmore, hne, hoff1, hcrossD, hnc, hB⟩ · rw [ite_eq_right hB] exact minimal_closedForm_of_negCross_endOne_long hread' ⟨hrev', hbegin, hmore, hne, hoff1, hcrossD, hnc, not_le.mp hB⟩ /-- The reversed crossed negative-begin complete residual non-overshoot cell. -/ abbrev negCrossCompleteResidualRev (r : RangeRead) (res : Result) : Prop := r.reverse = true ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧ 2 ≤ r.end_.offset ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key ∧ r.end_.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) /-- The reversed closed form, expressed through the forward rule on the flipped read. -/ noncomputable def closedFormNegCrossCompleteResidualRev (r : RangeRead) (res : Result) : ConflictRange := closedFormNegCrossCompleteResidual { r with reverse := false } { keys := res.keys.reverse, more := false } /-- **The reversed crossed negative-begin complete residual non-overshoot cell is minimal**, by flipping the traversal. -/ theorem minimal_closedForm_of_negCross_complete_residual_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hcell : negCrossCompleteResidualRev r res) : Minimal r res (closedFormNegCrossCompleteResidualRev r res) := by obtain ⟨hrev, hbegin, hmore, hne, hend2, hcrossD, hheadE, hEL⟩ := hcell have hne' : res.keys.reverse ≠ [] := by simpa using hne have hheadD : res.keys.reverse.headD ([] : Key) = res.keys.getLastD ([] : Key) := by rw [List.headD_eq_head?, List.getLastD_eq_getLast?, List.head?_reverse] have hlastD : res.keys.reverse.getLastD ([] : Key) = res.keys.headD ([] : Key) := by rw [List.getLastD_eq_getLast?, List.headD_eq_head?, List.getLast?_reverse] have hpair : List.Pairwise (· < ·) res.keys.reverse := by obtain ⟨db, hcompd⟩ := hread simpa using ((RangeRead.compatible_pairwise hcompd).2 hrev).reverse have hcell' : negCrossCompleteResidual { r with reverse := false } { keys := res.keys.reverse, more := false } := by refine ⟨rfl, hbegin, rfl, hne', hend2, ?_, ?_, ?_⟩ · rw [hheadD]; exact hcrossD · rw [hheadD]; exact hheadE · rw [hlastD]; exact hEL have hread' : Readable { r with reverse := false } { keys := res.keys.reverse, more := false } := by obtain ⟨db, hcomp⟩ := hread exact ⟨db, (compatible_flip (db := db) (b := true) hrev hmore).mpr hcomp⟩ have hmin := minimal_closedForm_of_negCross_complete_residual hread' hcell' exact (minimal_flip (b := true) hrev hmore).mp (by change Minimal { r with reverse := false } { keys := res.keys.reverse, more := false } (closedFormNegCrossCompleteResidual { r with reverse := false } { keys := res.keys.reverse, more := false }) exact hmin) end FormalConflictRange