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
This commit is contained in:
andrew committed 2026-11-16 21:53:59 -05:00
1 parent 7a0826e873
commit a54a5f82f8
78 files changed
+91636 -2

No files matched your search

@@ -0,0 +1,475 @@
/-
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