Files
conflict-range/FormalConflictRange/NegCrossCompleteResidual.lean
T
andrew a54a5f82f8 Prove conflict-range closed-form minimality
- Vendor the FormalConflictRange reference library needed by the proof
- Add Bridge.lean with simp lemmas connecting the Statement definitions
  to the reference library
- Prove Statement.closedFormMinimal in Proof.lean
- Register the new libraries in the Lake config
2026-11-16 21:53:59 -05:00

476 lines
26 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
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