Files
conflict-range/FormalConflictRange/SimpleClosedForm.lean
T

3215 lines
175 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.
/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
import FormalConflictRange.ClosedFormAll
import FormalConflictRange.NegCrossTruncClampAny
import FormalConflictRange.NegCrossTruncClampLastGe
import FormalConflictRange.NegCrossTruncClampLong
import FormalConflictRange.NegCrossTruncAnchor
import FormalConflictRange.NegCrossTruncBottomGap
import FormalConflictRange.NegCrossTruncNonposGapA2a
import FormalConflictRange.NegCrossTruncNonposGapA2aBottom
import FormalConflictRange.NegCrossTruncNonposGapCrossFree
import FormalConflictRange.NegCrossTruncNonclampNonpos
import FormalConflictRange.NegCrossTruncStrictTop
import FormalConflictRange.NegCrossTruncTopTop
/-!
# A compact endpoint-oriented closed form
The regional development proves many small formulas correct. This module turns those
certificates into a smaller algorithm. Its first rule handles every nonempty complete
result at a positive begin offset, in forward traversal, without distinguishing
cross-free, equal-selector, residual, and crossed reads at the top level.
Throughout, `b = begin.offset - 1`, `e = end.offset - 1`, and `t` is the number of
reported keys at or above `end.key`. The finite-boundary test is uniformly
`d + t = e`, where `d = max 0 (b - intervalCard begin.key end.key)`. On crossed reads
the interval cardinality is zero, so this is exactly the old crossed test `t + b = e`.
-/
namespace FormalConflictRange
/-- The finite-boundary deficit shared by all positive-offset complete reads. -/
noncomputable def compactDeficit (r : RangeRead) : ℕ :=
residualD r (intervalCard r.begin.key r.end_.key)
/-- The shared finite-boundary condition `d + t = e`. -/
def compactFinite (r : RangeRead) (res : Result) : Prop :=
compactDeficit r + residualT r res = residualE r
/-- A nonpositive begin selector at or below the first reported key clamps to the empty
key. This is the only lower-endpoint normalization needed by the forward formulas. -/
def clampsToBottom (r : RangeRead) (res : Result) : Prop :=
r.begin.offset ≤ 0 ∧ r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)
/-- The effective lower endpoint after begin clamping. -/
noncomputable def compactBegin (r : RangeRead) (res : Result) : WithTop Key := by
classical
exact if clampsToBottom r res then (([] : Key) : WithTop Key) else r.begin.key
/-- Clamping also makes the crossed-capacity test automatic. -/
noncomputable def compactForwardCapacity (r : RangeRead) (res : Result) : ℕ∞ := by
classical
exact if clampsToBottom r res then 0 else intervalCard r.end_.key r.begin.key
/-- The reported key whose immediate successor bounds a finite complete window. -/
def completeBoundary (r : RangeRead) (res : Result) : Key :=
if r.reverse then res.keys.headD ([] : Key) else res.keys.getLastD ([] : Key)
/-- One compact rule for every forward complete result at a positive begin offset.
Below end offset two the answer is the canonical range. On cross-free selectors the
lower end is always `begin.key`; `t = e`, an overshooting end, and the general deficit
test determine the upper end. On crossed selectors the same deficit test gives the
finite answer, while the unique extra capacity test chooses the lower end of an
unbounded answer. -/
noncomputable def compactCompleteForward (r : RangeRead) (res : Result) : ConflictRange := by
classical
exact
if r.end_.offset ≤ 1 then ⟨compactBegin r res, r.end_.key⟩
else if clampsToBottom r res ∨ r.begin.key ≤ r.end_.key then
if residualT r res = residualE r then
⟨compactBegin r res, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
else if ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key then
⟨compactBegin r res, ⊤⟩
else if compactFinite r res then
⟨compactBegin r res, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
else ⟨compactBegin r res, ⊤⟩
else if compactFinite r res then
⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
else
⟨if (crossedOvershootGeneral r res : ℕ∞) ≤ intervalCard r.end_.key r.begin.key
then r.end_.key else r.begin.key, ⊤⟩
/-- On cross-free selectors the compact rule is literally the previously certified
rule. In particular, the equal-selector branch needs no special case: its gap is zero. -/
theorem compactCompleteForward_eq_crossFree {r : RangeRead} {res : Result}
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) :
compactCompleteForward r res = closedFormCompleteCrossFree r res := by
classical
have hclamp : ¬ clampsToBottom r res := by
simp only [clampsToBottom, not_and]
intro h; omega
have hlower : compactBegin r res = r.begin.key := by simp [compactBegin, hclamp]
unfold compactCompleteForward
rw [hlower]
simp only [hclamp, false_or]
by_cases hend : r.end_.offset ≤ 1
· simp [closedFormCompleteCrossFree, canonicalRange, closedFormOffsetOne, hend]
· have htail :
(if r.begin.key = r.end_.key then closedFormKeyEqComplete r res
else closedFormResidualGeneral r res (intervalCard r.begin.key r.end_.key)) =
if compactFinite r res then truncatedRange r (res.keys.getLastD ([] : Key))
else topRange r := by
by_cases hkey : r.begin.key = r.end_.key
· rw [ite_eq_left hkey]
have hgap : intervalCard r.begin.key r.end_.key = 0 :=
intervalCard_eq_zero_of_le (le_of_eq hkey.symm)
simp [closedFormKeyEqComplete, compactFinite, compactDeficit, hgap,
residualD, residualB, residualT, residualE, Nat.add_comm]
· rw [ite_eq_right hkey]
unfold closedFormResidualGeneral compactFinite compactDeficit
by_cases hfin : residualD r (intervalCard r.begin.key r.end_.key) +
residualT r res = residualE r
· simp [hfin]
· simp [hfin]
by_cases ht : residualT r res = residualE r
· have ht' : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat := by
simpa only [residualT, residualE] using ht
have hoff : closedFormOffsetOne r res =
truncatedRange r (res.keys.getLastD ([] : Key)) := by
unfold closedFormOffsetOne
rw [ite_eq_right hend]
dsimp only
rw [ite_eq_left ht']
simp [closedFormCompleteCrossFree, truncatedRange, hend, hcross, ht, hoff]
· have ht' : ¬ res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat := by
simpa only [residualT, residualE] using ht
have hoff : closedFormOffsetOne r res = topRange r := by
unfold closedFormOffsetOne
rw [ite_eq_right hend]
dsimp only
rw [ite_eq_right ht']
by_cases hbelow : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
· simp only [hend, ↓reduceIte, hcross, ht, List.getLastD_eq_getLast?,
closedFormCompleteCrossFree, false_or, hoff, topRange]
rw [ite_eq_left hbelow, ite_eq_left hbelow]
· simpa [closedFormCompleteCrossFree, truncatedRange, topRange, hend, hcross, ht,
hbelow] using htail.symm
/-- On crossed selectors the same compact rule is the previously certified crossed
rule. Here `intervalCard begin.key end.key = 0`, so `compactFinite` is precisely the
old `t + b = e` branch. -/
theorem compactCompleteForward_eq_crossed {r : RangeRead} {res : Result}
(hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) :
compactCompleteForward r res = completeForwardCrossedGeneral r res := by
classical
have hclamp : ¬ clampsToBottom r res := by
simp only [clampsToBottom, not_and]
intro h; omega
have hlower : compactBegin r res = r.begin.key := by simp [compactBegin, hclamp]
unfold compactCompleteForward
rw [hlower]
simp only [hclamp, false_or]
have hgap : intervalCard r.begin.key r.end_.key = 0 :=
intervalCard_eq_zero_of_le (le_of_lt hcross)
have hfin : compactFinite r res ↔
reportedAtEnd r res + (r.begin.offset - 1).toNat = endOvershoot r := by
simp [compactFinite, compactDeficit, residualD, hgap, residualB, residualT,
residualE, reportedAtEnd, endOvershoot, Nat.add_comm]
by_cases hend : r.end_.offset ≤ 1
· simp [completeForwardCrossedGeneral, canonicalRange, hend]
· by_cases hf : compactFinite r res
· have hf' : reportedAtEnd r res + (r.begin.offset - 1).toNat = endOvershoot r :=
hfin.mp hf
have hf'' : reportedAtEnd r res + (r.begin.offset.toNat - 1) = endOvershoot r := by
simpa using hf'
simp [completeForwardCrossedGeneral, hend, not_le.mpr hcross, hf, hf'']
· have hf' : ¬ reportedAtEnd r res + (r.begin.offset - 1).toNat = endOvershoot r :=
fun h => hf (hfin.mpr h)
have hf'' : ¬ reportedAtEnd r res + (r.begin.offset.toNat - 1) = endOvershoot r := by
simpa using hf'
simp [completeForwardCrossedGeneral, hend, not_le.mpr hcross, hf, hf'']
/-- A nonpositive begin offset has zero residual deficit, regardless of the key gap. -/
theorem compactDeficit_of_nonpos {r : RangeRead} (hbegin : r.begin.offset ≤ 0) :
compactDeficit r = 0 := by
simp [compactDeficit, residualD, residualB]
omega
/-- On a clamped nonpositive read, the compact complete rule is exactly the old
bottom-anchored three-branch formula. -/
theorem compactCompleteForward_eq_nonpos {r : RangeRead} {res : Result}
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)) :
compactCompleteForward r res = completeNonposCrossFree r res := by
classical
have hclamp : clampsToBottom r res := ⟨hbegin, hlo⟩
have hlower : compactBegin r res = (([] : Key) : WithTop Key) := by
simp [compactBegin, hclamp]
have hfin : compactFinite r res ↔ residualT r res = residualE r := by
simp [compactFinite, compactDeficit_of_nonpos hbegin]
unfold compactCompleteForward completeNonposCrossFree
rw [ite_eq_right hne, hlower]
simp only [hclamp, true_or, ite_true]
by_cases hend : r.end_.offset ≤ 1
· rw [ite_eq_left hend, ite_eq_left hend]
· rw [ite_eq_right hend, ite_eq_right hend]
by_cases ht : residualT r res = residualE r
· rw [ite_eq_left ht, ite_eq_left ht]
rfl
· rw [ite_eq_right ht, ite_eq_right ht]
by_cases hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
· rw [ite_eq_left hhi]
· rw [ite_eq_right hhi, ite_eq_right (fun hf => ht (hfin.mp hf))]
/-- The compact forward rule is minimal on every readable nonempty complete result at
a positive begin offset. -/
theorem compactCompleteForward_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
Minimal r res (compactCompleteForward r res) := by
by_cases hcross : r.begin.key ≤ r.end_.key
· rw [compactCompleteForward_eq_crossFree hbegin hcross]
exact minimal_closedForm_of_complete_crossFree hread hmore hrev hne hbegin hcross
· have hcrossed : r.end_.key < r.begin.key := lt_of_not_ge hcross
rw [compactCompleteForward_eq_crossed hbegin hcrossed]
exact minimal_completeForwardCrossedGeneral hread hmore hne hrev hbegin hcrossed
/-- Normalize a complete observation to forward traversal. Compatibility is unchanged
by `compatible_flip`; only the order of the reported keys changes. -/
def normalizeCompleteResult (r : RangeRead) (res : Result) : Result :=
{ keys := if r.reverse then res.keys.reverse else res.keys, more := false }
/-- One complete-result algorithm for both traversals: normalize to forward traversal,
then apply the single forward formula. -/
noncomputable def compactComplete (r : RangeRead) (res : Result) : ConflictRange :=
compactCompleteForward { r with reverse := false } (normalizeCompleteResult r res)
/-- The normalized complete formula is minimal in either traversal order. -/
theorem compactComplete_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) :
Minimal r res (compactComplete r res) := by
by_cases hrev : r.reverse = true
· let r' : RangeRead := { r with reverse := false }
let res' : Result := { keys := res.keys.reverse, more := false }
have hread' : Readable r' res' := by
obtain ⟨db, hcomp⟩ := hread
exact ⟨db, (compatible_flip (b := true) hrev hmore).mpr hcomp⟩
have hne' : res'.keys ≠ [] := by simpa [res'] using hne
have hmin' : Minimal r' res' (compactCompleteForward r' res') :=
compactCompleteForward_minimal hread' rfl rfl hne' hbegin
have hmin := (minimal_flip (r := r) (res := res)
(cr := compactCompleteForward r' res') (b := true) hrev hmore).mp hmin'
simpa [compactComplete, normalizeCompleteResult, hrev, r', res'] using hmin
· have hrevf : r.reverse = false := by
cases hr : r.reverse <;> simp_all
have hr : { r with reverse := false } = r := by
cases r
simp_all
have hres : normalizeCompleteResult r res = res := by
cases res
simp_all [normalizeCompleteResult]
unfold compactComplete
rw [hr, hres]
exact compactCompleteForward_minimal hread hmore hrevf hne hbegin
/-- Complete-result normalization also subsumes the old nonpositive cross-free rule:
after reversing the reported keys when necessary, it is literally the same forward
formula with its lower endpoint clamped to `⊥`. -/
theorem compactComplete_eq_nonpos_crossFree {r : RangeRead} {res : Result}
(h : nonposCompleteCrossFree r res) :
compactComplete r res = closedFormCompleteNonposCrossFree r res := by
obtain ⟨hmore, hne, hbegin, hloD⟩ := h
by_cases hrev : r.reverse = true
· let r' : RangeRead := { r with reverse := false }
let res' : Result := { keys := res.keys.reverse, more := false }
have hloD' : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
have hlo' : r'.begin.key ≤ ((res'.keys.headD ([] : Key) : Key) : WithTop Key) := by
simpa [r', res'] using hloD'
have heq := compactCompleteForward_eq_nonpos (r := r') (res := res')
(by simpa [res'] using hne) (by simpa [r'] using hbegin) hlo'
simpa [compactComplete, normalizeCompleteResult, hrev, r', res',
closedFormCompleteNonposCrossFree, completeNonposCrossFreeRev] using heq
· have hrevf : r.reverse = false := by cases hr : r.reverse <;> simp_all
have hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrevf] using hloD
have hr : { r with reverse := false } = r := by cases r; simp_all
have hres : normalizeCompleteResult r res = res := by
cases res
simp_all [normalizeCompleteResult]
unfold compactComplete
rw [hr, hres]
unfold closedFormCompleteNonposCrossFree
rw [ite_eq_right (by simp [hrevf])]
exact compactCompleteForward_eq_nonpos hne hbegin hlo
/-- The compact complete rule is minimal on the whole nonpositive cross-free cell. -/
theorem compactComplete_minimal_nonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (h : nonposCompleteCrossFree r res) :
Minimal r res (compactComplete r res) := by
rw [compactComplete_eq_nonpos_crossFree h]
exact minimal_closedForm_of_complete_nonpos_crossFree hread h
/-- One forward-truncated rule at every positive begin offset. The same capacity
comparison handles crossed and cross-free selectors: in the latter case the interval
`[end.key, begin.key)` is empty, so the comparison is automatic and the lower endpoint
is `begin.key`. -/
noncomputable def compactForwardTruncated (r : RangeRead) (res : Result) : ConflictRange :=
if r.end_.offset ≤ 0 then ⟨compactBegin r res, r.end_.key⟩
else if compactForwardCapacity r res ≤
(((residualE r - res.keys.length - residualB r : ℕ) : ℕ∞)) then
⟨compactBegin r res, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
else
⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
/-- The unified capacity test reduces to the old cross-free truncated rule. -/
theorem compactForwardTruncated_eq_crossFree {r : RangeRead} {res : Result}
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) :
compactForwardTruncated r res = closedFormTruncatedGeneral r res := by
classical
have hclamp : ¬ clampsToBottom r res := by
simp only [clampsToBottom, not_and]
intro h; omega
have hlower : compactBegin r res = r.begin.key := by simp [compactBegin, hclamp]
have hcap : compactForwardCapacity r res = intervalCard r.end_.key r.begin.key := by
simp [compactForwardCapacity, hclamp]
unfold compactForwardTruncated
rw [hlower, hcap]
have hgap : intervalCard r.end_.key r.begin.key = 0 :=
intervalCard_eq_zero_of_le hcross
by_cases hend : r.end_.offset ≤ 0
· simp [closedFormTruncatedGeneral, canonicalRange, hend]
· simp [closedFormTruncatedGeneral, truncatedRange, hend, hgap, residualE, residualB]
/-- On crossed selectors the unified rule is the certified capacity formula. -/
theorem compactForwardTruncated_eq_crossed {r : RangeRead} {res : Result}
(hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) :
compactForwardTruncated r res = truncatedForwardCrossedGeneral r res := by
classical
have hclamp : ¬ clampsToBottom r res := by
simp only [clampsToBottom, not_and]
intro h; omega
have hlower : compactBegin r res = r.begin.key := by simp [compactBegin, hclamp]
have hcap : compactForwardCapacity r res = intervalCard r.end_.key r.begin.key := by
simp [compactForwardCapacity, hclamp]
unfold compactForwardTruncated
rw [hlower, hcap]
have hend0 : ¬ r.end_.offset ≤ 0 := by omega
simp [truncatedForwardCrossedGeneral, truncatedRange, hend0, residualE, residualB]
/-- The compact forward-truncated rule is minimal at every positive begin offset. -/
theorem compactForwardTruncated_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
Minimal r res (compactForwardTruncated r res) := by
by_cases hcross : r.begin.key ≤ r.end_.key
· rw [compactForwardTruncated_eq_crossFree hbegin hcross]
exact minimal_closedForm_of_truncated_general hread hmore hrev hbegin hcross
· have hcrossed : r.end_.key < r.begin.key := lt_of_not_ge hcross
have hend : 2 ≤ r.end_.offset :=
crossed_end_offset_ge_two_truncated hread hmore hbegin hcrossed
rw [compactForwardTruncated_eq_crossed hbegin (by omega)]
exact minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcrossed hend
/-- The compact forward-truncated rule denotes exactly the general necessary-key hull. -/
theorem compactForwardTruncated_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
(compactForwardTruncated r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactForwardTruncated_minimal hread hmore hrev hne hbegin).toSet_eq
(conflictRangeGeneral_minimal hread)
/-- The compact forward-truncated rule agrees with the executable reference. -/
theorem compactForwardTruncated_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
(compactForwardTruncated r res).toSet = (simpleConflictRange r res).toSet :=
(compactForwardTruncated_minimal hread hmore hrev hne hbegin).toSet_eq
(simpleConflictRange_minimal hread)
/-- On a clamped nonpositive forward read, the unified capacity formula is exactly the
bottom-anchored truncated formula, with no split on the selector keys. -/
theorem compactForwardTruncated_eq_nonpos {r : RangeRead} {res : Result}
(hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)) :
compactForwardTruncated r res =
if r.end_.offset ≤ 0 then ⟨(([] : Key) : WithTop Key), r.end_.key⟩
else truncatedRangeBottom (res.keys.getLastD ([] : Key)) := by
classical
have hclamp : clampsToBottom r res := ⟨hbegin, hlo⟩
have hlower : compactBegin r res = (([] : Key) : WithTop Key) := by
simp [compactBegin, hclamp]
have hcap : compactForwardCapacity r res = 0 := by simp [compactForwardCapacity, hclamp]
unfold compactForwardTruncated
rw [hlower, hcap]
by_cases hend : r.end_.offset ≤ 0
· rw [ite_eq_left hend, ite_eq_left hend]
· rw [ite_eq_right hend, ite_eq_right hend,
ite_eq_left (show (0 : ℕ∞) ≤ _ from by simp)]
rfl
/-- The same forward-truncated formula is minimal on every clamped nonpositive read. -/
theorem compactForwardTruncated_minimal_nonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)) :
Minimal r res (compactForwardTruncated r res) := by
have hloD : r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hlo
rw [compactForwardTruncated_eq_nonpos hbegin hlo]
by_cases hend : r.end_.offset ≤ 0
· rw [ite_eq_left hend]
exact minimal_closedForm_of_nonpos_fwdTruncNonpos hread
⟨hmore, hrev, hbegin, hloD, hend⟩
· have hendpos : 1 ≤ r.end_.offset := by omega
rw [ite_eq_right hend]
exact minimal_closedForm_of_nonpos_fwdTrunc hread
⟨hmore, hrev, hbegin, hloD, hendpos⟩
/-- The extra gap capacity allowed when the reported head is the empty key. The empty
key itself accounts for the one-unit difference between the two clamping thresholds. -/
def compactClampSlack (r : RangeRead) (res : Result) : ℕ :=
beginSlack r + 1 - res.keys.length +
if res.keys.headD ([] : Key) = ([] : Key) then 1 else 0
/-- The original small-capacity test: the clamping gap is small enough to lower the
effective begin key to the successor of the reported last key. -/
noncomputable def compactClampGapSmall (r : RangeRead) (res : Result) : Prop :=
intervalCard ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.begin.key ≤
(compactClampSlack r res : ℕ∞)
/-- A nonempty-head gap at exact capacity whose empty-key end window has exactly one
position per reported key. This boundary case has the same shorter range as a small gap. -/
noncomputable def compactClampGapExactSaturated (r : RangeRead) (res : Result) : Prop :=
res.keys.headD ([] : Key) ≠ ([] : Key) ∧
r.end_.key = (([] : Key) : WithTop Key) ∧
(r.end_.offset - 1).toNat = res.keys.length ∧
intervalCard (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key = ((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞)
/-- The clamping cases whose upper endpoint is the successor of the reported last key. -/
noncomputable def compactClampGapLow (r : RangeRead) (res : Result) : Prop :=
compactClampGapSmall r res ∨ compactClampGapExactSaturated r res
/-- The upper endpoint of a clamped nonpositive forward-truncated result. -/
noncomputable def compactClampUpper (r : RangeRead) (res : Result) : WithTop Key := by
classical
exact if compactClampGapLow r res then
((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)
else r.begin.key
/-- A nonclamping low end is saturated when the gap below the reported head and the
reported keys together need more than the `end.offset - 1` available positions. -/
noncomputable def compactForwardSaturated (r : RangeRead) (res : Result) : Prop :=
0 < residualE r ∧
r.end_.key < ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧
(residualE r : ℕ∞) <
intervalCard r.end_.key ((res.keys.headD ([] : Key) : Key) : WithTop Key) +
(res.keys.length : ℕ∞)
/-- One arithmetic rule for every nonpositive-begin forward-truncated result.
The number of reported keys below `begin.key` decides whether the begin selector clamps.
A clamped result starts at `⊥`; its positive-end upper endpoint is governed by the gap
capacity above the reported last key. Otherwise the upper endpoint is the larger of
`begin.key` and that successor, and only a saturated gap below the reported head moves
the lower endpoint down to `end.key`. -/
noncomputable def compactForwardTruncatedNonpos (r : RangeRead) (res : Result) :
ConflictRange := by
classical
exact
if reportedBelowBegin r res ≤ beginSlack r then
if r.end_.offset ≤ 0 then
if r.end_.key < r.begin.key then
if clampNonposBottom r res then
if ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key then
closedFormNegCrossTruncNonposGapA2aBottom r res
else ⟨(([] : Key) : WithTop Key), clampLongUpper r res⟩
else ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩
else if negCrossTruncTopTopEq r res then closedFormNegCrossTruncTopTopEq r res
else if clampNonposBottom r res then ⟨(([] : Key) : WithTop Key), r.end_.key⟩
else ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.end_.key⟩
else ⟨(([] : Key) : WithTop Key), compactClampUpper r res⟩
else if r.end_.offset ≤ 0 then
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key r.end_.key⟩
else
⟨if compactForwardSaturated r res then r.end_.key
else ((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)⟩
/-- Clamping reduces the nonpositive rule to its bottom-anchored branch, provided the
both-sentinel equality branch is not active. -/
theorem compactForwardTruncatedNonpos_eq_clamped {r : RangeRead} {res : Result}
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hnA : ¬ negCrossTruncTopTopEq r res) :
compactForwardTruncatedNonpos r res =
if r.end_.offset ≤ 0 then
if r.end_.key < r.begin.key then
if clampNonposBottom r res then
if ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key then
closedFormNegCrossTruncNonposGapA2aBottom r res
else ⟨(([] : Key) : WithTop Key), clampLongUpper r res⟩
else ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩
else if clampNonposBottom r res then ⟨(([] : Key) : WithTop Key), r.end_.key⟩
else ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.end_.key⟩
else ⟨(([] : Key) : WithTop Key), compactClampUpper r res⟩ := by
classical
simp [compactForwardTruncatedNonpos, hclamp, hnA]
/-- In the both-sentinel equality branch the clamping rule is the closed form
`[head, ⊤)`. -/
theorem compactForwardTruncatedNonpos_eq_topTopEq {r : RangeRead} {res : Result}
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hA : negCrossTruncTopTopEq r res) :
compactForwardTruncatedNonpos r res = closedFormNegCrossTruncTopTopEq r res := by
classical
have hend : r.end_.offset ≤ 0 := NegCrossTruncTopTop.hend hA.1
have hnotlt : ¬ r.end_.key < r.begin.key := by
rw [NegCrossTruncTopTop.hEtop hA.1, NegCrossTruncTopTop.hBtop hA.1]
exact not_lt.mpr le_rfl
simp [compactForwardTruncatedNonpos, hclamp, hend, hnotlt, hA]
open Classical in
/-- Nonclamping at a positive end offset reduces to the reported-boundary rule, with the
single saturation test on the lower endpoint. -/
theorem compactForwardTruncatedNonpos_eq_nonclamp {r : RangeRead} {res : Result}
(hclamp : ¬ reportedBelowBegin r res ≤ beginSlack r) (hend : 1 ≤ r.end_.offset) :
compactForwardTruncatedNonpos r res =
⟨if compactForwardSaturated r res then r.end_.key
else ((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)⟩ := by
classical
have hend0 : ¬ r.end_.offset ≤ 0 := by omega
simp [compactForwardTruncatedNonpos, hclamp, hend0]
/-- A nonclamping nonpositive end has the reported head and the larger selector key as
its two endpoints. -/
theorem compactForwardTruncatedNonpos_eq_nonclamp_nonpos {r : RangeRead} {res : Result}
(hclamp : ¬ reportedBelowBegin r res ≤ beginSlack r) (hend : r.end_.offset ≤ 0) :
compactForwardTruncatedNonpos r res =
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key r.end_.key⟩ := by
classical
simp [compactForwardTruncatedNonpos, hclamp, hend]
/-- The low-capacity clamping branch ends immediately after the reported last key. -/
theorem compactClampUpper_eq_keyAfter {r : RangeRead} {res : Result}
(hlow : compactClampGapLow r res) :
compactClampUpper r res =
((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) := by
classical
simp [compactClampUpper, hlow]
/-- The high-capacity clamping branch ends at the original begin key. -/
theorem compactClampUpper_eq_begin {r : RangeRead} {res : Result}
(hlow : ¬ compactClampGapLow r res) :
compactClampUpper r res = r.begin.key := by
classical
simp [compactClampUpper, hlow]
/-- When there is no gap, either capacity branch gives the same upper endpoint. -/
theorem compactClampUpper_eq_begin_of_noGap {r : RangeRead} {res : Result}
(hgap : r.begin.key =
((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)) :
compactClampUpper r res = r.begin.key := by
classical
simp [compactClampUpper, compactClampGapLow, hgap]
/-- The ordinary low-capacity inequality implies the unified threshold, independently of
whether the reported head is empty. -/
theorem compactClampGapLow_of_le {r : RangeRead} {res : Result}
(hlow : intervalCard ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.begin.key ≤
((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞)) :
compactClampGapLow r res := by
apply Or.inl
unfold compactClampGapSmall compactClampSlack
apply hlow.trans
exact_mod_cast (show beginSlack r + 1 - res.keys.length ≤
beginSlack r + 1 - res.keys.length +
(if res.keys.headD ([] : Key) = ([] : Key) then 1 else 0) by omega)
/-- Exhausting the begin slack by one reported key is exactly the nonclamping side of the
compact clamp test. -/
theorem not_clamp_of_reportedBelowBegin_eq {r : RangeRead} {res : Result}
(h : reportedBelowBegin r res = beginSlack r + 1) :
¬ reportedBelowBegin r res ≤ beginSlack r := by omega
/-- At begin offset zero, a reported head below `begin.key` already rules out clamping. -/
theorem not_clamp_of_zero_cross {r : RangeRead} {res : Result}
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key) :
¬ reportedBelowBegin r res ≤ beginSlack r := by
have hpos : 0 < reportedBelowBegin r res :=
countP_pos_of_mem (headD_mem hne) (by rw [decide_eq_true_eq]; exact hcross)
have hq : beginSlack r = 0 := by simp [beginSlack, hbegin]
omega
/-- Every reported key of a forward end-offset-one result lies strictly below the end
key, whether or not the result is complete. -/
theorem reported_below_end_of_end_one {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hend : r.end_.offset = 1) :
∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by
intro k hk
have hkck := (RangeRead.compatible_keys_prefix hcomp).subset hk
rw [completeKeys_eq_filter_of_end_one hrev hend] at hkck
exact of_decide_eq_true (List.mem_filter.mp (List.mem_filter.mp hkck).1).2
/-- In a crossed negative-begin truncated read, the number of reported keys below
`begin.key` exceeds the begin slack by at most one. In the nonclamping case the begin
selector resolves onto the reported head; its rank equation then shows that exactly
`beginSlack + 1` stored keys lie in `[head, begin.key)`. -/
theorem truncated_reportedBelowBegin_le_succ {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key) :
reportedBelowBegin r res ≤ beginSlack r + 1 := by
obtain ⟨db, hcomp⟩ := hread
by_cases hclamp : reportedBelowBegin r res ≤ beginSlack r
· omega
· have hnon : beginSlack r < reportedBelowBegin r res := lt_of_not_ge hclamp
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcross' : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
rwa [hheadD] at hcross
set head : Key := res.keys.head hne with hhead
set cB : ℕ := db.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) with hcB
set N : ℕ := (db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length with hN
have hsub : List.Sublist res.keys db.keys := result_sublist_db_of_compatible hcomp hrev
have hres_count : res.keys.countP (fun k : Key =>
decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = reportedBelowBegin r res := by
unfold reportedBelowBegin
rw [List.countP_eq_length_filter, List.countP_eq_length_filter]
congr 1
apply List.filter_congr
intro k hk
have hhead_le : ((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr
((RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hk)
rw [decide_eq_decide]
exact and_iff_right hhead_le
have hmin_le : reportedBelowBegin r res ≤ N := by
have h := List.Sublist.countP_le hsub
(p := fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))
rw [hres_count, List.countP_eq_length_filter, ← hN] at h
exact h
have hm_cB : reportedBelowBegin r res ≤ cB := by
have h := List.Sublist.countP_le hsub
(p := fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))
exact h
have hcB_ge : beginSlack r + 1 ≤ cB := by omega
have hanchor : 0 ≤ r.begin.anchor db := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), ← hcB]
have : (beginSlack r : ℤ) + 1 ≤ (cB : ℤ) := by exact_mod_cast hcB_ge
omega
have hpre : res.keys <+: RangeRead.completeKeys db r :=
RangeRead.compatible_keys_prefix hcomp
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
have hhead_ck : head ∈ RangeRead.completeKeys db r := hpre.subset hhead_mem
have hle_head : resolve db r.begin ≤ ((head : Key) : WithTop Key) :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.1
have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
intro htop
rw [htop] at hle_head
exact absurd hle_head (not_le.mpr (WithTop.coe_lt_top head))
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
by_contra h
exact hnot_top (resolve_eq_top hanchor (le_of_not_gt h))
have hL : resolve db r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_negCross_trunc_nonclamp hcomp hrev hmore hne hbegin hcross' hnon
have hget := resolve_eq_getElem (db := db) (s := r.begin) hanchor hltlen
have hval : db.keys[(r.begin.anchor db).toNat] = head :=
WithTop.coe_inj.mp (hget.symm.trans hL)
have hcH : db.keys.countP (fun k : Key => decide (k < head)) =
(r.begin.anchor db).toNat := countP_lt_eq_of_getElem db.sorted hltlen hval
have htoNat : (r.begin.anchor db).toNat = cB - (beginSlack r + 1) := by
have hanchor_cast : r.begin.anchor db = (cB : ℤ) - (beginSlack r : ℤ) - 1 := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), ← hcB]
have hz : r.begin.anchor db = ((cB : ℤ) - ((beginSlack r + 1 : ℕ) : ℤ)) := by
rw [hanchor_cast]; push_cast; ring
have hz2 : ((cB : ℤ) - ((beginSlack r + 1 : ℕ) : ℤ)) =
((cB - (beginSlack r + 1) : ℕ) : ℤ) := by
rw [← Nat.cast_sub hcB_ge]
rw [hz, hz2, Int.toNat_natCast]
have hsplit : cB = db.keys.countP (fun k : Key => decide (k < head)) + N := by
rw [hcB, hN]
exact countP_lt_eq_add_filter_withTop db.keys db.nodup (le_of_lt hcross')
have hN_eq : N = beginSlack r + 1 := by omega
omega
/-- The compact nonpositive rule is minimal on every crossed begin-zero truncated read. -/
theorem compactForwardTruncatedNonpos_minimal_zero {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
have hcrossD : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcross
have hclamp := not_clamp_of_zero_cross hne hbegin hcrossD
by_cases hend : r.end_.offset ≤ 0
· rw [compactForwardTruncatedNonpos_eq_nonclamp_nonpos hclamp hend]
exact minimal_closedForm_of_zeroCross_trunc_nonposEnd hread
⟨hbegin, hrev, hmore, hcross, hend⟩
· have hendpos : 1 ≤ r.end_.offset := by omega
rw [compactForwardTruncatedNonpos_eq_nonclamp hclamp hendpos]
by_cases hEH : r.end_.key < ((res.keys.headD ([] : Key) : Key) : WithTop Key)
· by_cases hend1 : r.end_.offset = 1
· have hsat : ¬ compactForwardSaturated r res := by
simp [compactForwardSaturated, residualE, hend1]
rw [ite_eq_right hsat]
exact minimal_closedForm_of_zeroCross_trunc_readAllEnd hread
⟨hbegin, hrev, hmore, hcross, Or.inl hend1⟩
· have hend2 : 2 ≤ r.end_.offset := by omega
by_cases hsat : compactForwardSaturated r res
· rw [ite_eq_left hsat]
exact minimal_closedForm_of_zeroCross_trunc_lowEndBig hread
⟨hbegin, hrev, hmore, hcross, hend2,
by simpa [leastReported, hrev] using hEH,
by simpa [leastReported, hrev, residualE] using hsat.2.2⟩
· rw [ite_eq_right hsat]
have hcap : intervalCard r.end_.key
((res.keys.headD ([] : Key) : Key) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (residualE r : ℕ∞) := by
apply le_of_not_gt
intro h
exact hsat ⟨by unfold residualE; omega, hEH, h⟩
exact minimal_closedForm_of_zeroCross_trunc_lowEndSmall hread
⟨hbegin, hrev, hmore, hcross, hend2,
by simpa [leastReported, hrev] using hEH,
by simpa [leastReported, hrev, residualE] using hcap⟩
· have hsat : ¬ compactForwardSaturated r res := fun h => hEH h.2.1
rw [ite_eq_right hsat]
exact minimal_closedForm_of_zeroCross_trunc_endGeHead hread
⟨hbegin, hrev, hmore, hcross, hendpos,
by simpa [leastReported, hrev] using not_lt.mp hEH⟩
/-- On a bottom-clamped read, the unified gap test is automatic and recovers the
cross-free nonpositive formula. -/
theorem compactForwardTruncatedNonpos_minimal_bottom {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
obtain ⟨db, hcomp⟩ := hread
have hread' : Readable r res := ⟨db, hcomp⟩
have hzero : reportedBelowBegin r res = 0 := by
rw [reportedBelowBegin, List.countP_eq_zero]
intro k hk
rw [decide_eq_true_eq]
intro hkB
have hheadk : res.keys.headD ([] : Key) ≤ k :=
headD_le_of_pairwise (RangeRead.compatible_sortedLT hcomp hrev).pairwise hk
exact (not_lt.mpr (le_trans hlo (WithTop.coe_le_coe.mpr hheadk))) hkB
have hclamp : reportedBelowBegin r res ≤ beginSlack r := by omega
rw [compactForwardTruncatedNonpos_eq_clamped hclamp
(not_negCross_trunc_topTop_eq_of_begin_le_coe hlo)]
have hloD : r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hlo
by_cases hend : r.end_.offset ≤ 0
· have hhead_ck : res.keys.headD ([] : Key) ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hcomp).subset (headD_mem hne)
have hheadE : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_nonpos hend
(RangeRead.mem_completeKeys.mp hhead_ck).1
(RangeRead.mem_completeKeys.mp hhead_ck).2.2
have hBE : r.begin.key ≤ r.end_.key := le_trans hlo (le_of_lt hheadE)
have hhead_res : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.2
have hB_le_R : r.begin.key ≤ resolve db r.end_ := le_trans hlo (le_of_lt hhead_res)
have hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
rw [hR] at hhead_res
exact absurd hhead_res (not_lt.mpr (coe_nil_le_key_withTop _))
have hcb : clampNonposBottom r res :=
clampNonposBottom_of_le_resolve_end hend hRne hB_le_R hclamp
rw [ite_eq_left hend, ite_eq_right (not_lt_of_ge hBE), ite_eq_left hcb]
exact minimal_closedForm_of_nonpos_fwdTruncNonpos hread'
⟨hmore, hrev, hbegin, hloD, hend⟩
· have hendpos : 1 ≤ r.end_.offset := by omega
have hheadlast : res.keys.headD ([] : Key) ≤ res.keys.getLastD ([] : Key) :=
headD_le_of_pairwise (RangeRead.compatible_sortedLT hcomp hrev).pairwise
(getLastD_mem hne)
have hgap : intervalCard ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
r.begin.key = 0 :=
intervalCard_eq_zero_of_le (le_trans hlo (WithTop.coe_le_coe.mpr hheadlast))
have hlow : compactClampGapLow r res := by
apply Or.inl
unfold compactClampGapSmall
rw [hgap]
exact zero_le
rw [ite_eq_right hend, compactClampUpper_eq_keyAfter hlow]
exact minimal_closedForm_of_nonpos_fwdTrunc hread'
⟨hmore, hrev, hbegin, hloD, hendpos⟩
/-- The compact nonpositive rule is minimal on every crossed negative-begin truncated
nonclamping read with a positive end offset. -/
theorem compactForwardTruncatedNonpos_minimal_neg_nonclamp {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hbegin : r.begin.offset < 0) (hend : 1 ≤ r.end_.offset)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
have hclamp := not_clamp_of_reportedBelowBegin_eq hnonclamp
rw [compactForwardTruncatedNonpos_eq_nonclamp hclamp hend]
by_cases hend1 : r.end_.offset = 1
· have hbelow : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by
obtain ⟨db, hcomp⟩ := hread
exact reported_below_end_of_end_one hcomp hrev hend1
have hsat : ¬ compactForwardSaturated r res := by
simp [compactForwardSaturated, residualE, hend1]
rw [ite_eq_right hsat]
exact minimal_closedForm_of_negCross_trunc_nonclamp_below hread
⟨hmore, hrev, hbegin, hend, hbelow, hcross, hnonclamp⟩
· have hend2 : 2 ≤ r.end_.offset := by omega
by_cases hEH : r.end_.key < ((res.keys.headD ([] : Key) : Key) : WithTop Key)
· by_cases hsat : compactForwardSaturated r res
· rw [ite_eq_left hsat]
exact minimal_closedForm_of_negCross_trunc_nonclamp_lowEndBig hread
⟨hmore, hrev, hbegin, hend2,
by simpa [leastReported, hrev] using hEH, hcross, hnonclamp,
by simpa [leastReported, hrev, residualE] using hsat.2.2⟩
· rw [ite_eq_right hsat]
have hcap : intervalCard r.end_.key
((res.keys.headD ([] : Key) : Key) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (residualE r : ℕ∞) := by
apply le_of_not_gt
intro h
exact hsat ⟨by unfold residualE; omega, hEH, h⟩
exact minimal_closedForm_of_negCross_trunc_nonclamp_lowEndSmall hread
⟨hmore, hrev, hbegin, hend2,
by simpa [leastReported, hrev] using hEH, hcross, hnonclamp,
by simpa [leastReported, hrev, residualE] using hcap⟩
· have hsat : ¬ compactForwardSaturated r res := fun h => hEH h.2.1
rw [ite_eq_right hsat]
exact minimal_closedForm_of_negCross_trunc_nonclamp_endGeHead hread
⟨hmore, hrev, hbegin, hend,
by simpa [leastReported, hrev] using not_lt.mp hEH, hcross, hnonclamp⟩
/-- The compact nonpositive rule is minimal on every crossed negative-begin truncated
nonclamping read with a nonpositive end offset. -/
theorem compactForwardTruncatedNonpos_minimal_neg_nonclamp_nonpos {r : RangeRead}
{res : Result} (hread : Readable r res) (hmore : res.more = true)
(hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hend : r.end_.offset ≤ 0)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
have hclamp : ¬ reportedBelowBegin r res ≤ beginSlack r := by omega
rw [compactForwardTruncatedNonpos_eq_nonclamp_nonpos hclamp hend]
have hmin := minimal_closedForm_of_negCross_trunc_nonclamp_nonposEnd hread
⟨hmore, hrev, hbegin, hne, hcross, hend, hnonclamp⟩
simpa [closedFormNegCrossTruncNonclampNonpos] using hmin
/-- If the reported last reaches `begin.key`, the clamping gap has zero capacity and the
compact rule is the bottom-anchored reported range. This holds for an arbitrary positive
end key: filtering a compatible database below the reported head supplies the necessity
witness even when the end key lies inside the reported window. -/
theorem compactForwardTruncatedNonpos_minimal_neg_clamp_lastGe {r : RangeRead}
{res : Result} (hread : Readable r res) (hmore : res.more = true)
(hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hend : 1 ≤ r.end_.offset)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hBlast : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
obtain ⟨db, hcomp⟩ := hread
have hread' : Readable r res := ⟨db, hcomp⟩
have hlastD : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcrossD : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa only [leastReported, hrev, Bool.false_eq_true, ite_false] using hcross
rw [hheadD] at hcrossD
have hcard : intervalCard ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
r.begin.key = 0 := intervalCard_eq_zero_of_le hBlast
have hlow : compactClampGapLow r res := by
apply Or.inl
unfold compactClampGapSmall
rw [hcard]
exact zero_le
rw [compactForwardTruncatedNonpos_eq_clamped hclamp
(not_negCross_trunc_topTop_eq_of_begin_le_coe hBlast), ite_eq_right (by omega),
compactClampUpper_eq_keyAfter hlow]
have hcr : (⟨(([] : Key) : WithTop Key),
((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)⟩ : ConflictRange) =
truncatedRangeBottom (res.keys.getLast hne) := by
rw [hlastD]
rfl
rw [hcr]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨
sound_truncatedRangeBottom_of_nonpos_more hrev (by omega) hmore hne
(by rwa [← hlastD]) hend, ?_⟩
intro k _ hkend
have hkle : k ≤ res.keys.getLast hne :=
(lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hkend)
by_cases hkhead : k < res.keys.head hne
· exact necessary_below_head_of_negCross_trunc_clamp_lastGe hread' hrev hmore hne hbegin
hend hcrossD hclamp (by rwa [← hlastD]) (WithTop.coe_lt_coe.mpr hkhead)
· exact necessary_of_between_result hread' (List.head_mem hne) (List.getLast_mem hne)
(le_of_not_gt hkhead) hkle
/-- The compact nonpositive rule is minimal on the crossed negative-begin truncated
clamping cell with a nonpositive end offset when the reported last reaches
`begin.key`. The end key then lies strictly above `begin.key`, so the compact rule
selects its bottom-anchored branch `[⊥, end_.key)`. -/
theorem compactForwardTruncatedNonpos_minimal_neg_clamp_nonpos_lastGe {r : RangeRead}
{res : Result} (hread : Readable r res) (hmore : res.more = true)
(hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hend : r.end_.offset ≤ 0)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hBlast : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
obtain ⟨db, hcomp⟩ := hread
have hlastD : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcrossD : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa only [leastReported, hrev, Bool.false_eq_true, ite_false] using hcross
have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne)
obtain ⟨hlast_mem, -, hlast_res⟩ := RangeRead.mem_completeKeys.mp hlast_ck
have hlastE : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_nonpos hend hlast_mem hlast_res
have hB_le_last : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by
rw [← hlastD]; exact hBlast
have hnotlt : ¬ r.end_.key < r.begin.key := by
intro hlt
exact absurd (lt_of_le_of_lt hB_le_last hlastE) (not_lt.mpr (le_of_lt hlt))
have hB_le_R : r.begin.key ≤ resolve db r.end_ := le_trans hB_le_last (le_of_lt hlast_res)
have hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
rw [hR] at hlast_res
exact absurd hlast_res (not_lt.mpr (coe_nil_le_key_withTop _))
have hcb : clampNonposBottom r res :=
clampNonposBottom_of_le_resolve_end hend hRne hB_le_R hclamp
rw [compactForwardTruncatedNonpos_eq_clamped hclamp
(not_negCross_trunc_topTop_eq_of_begin_le_coe hBlast), ite_eq_left hend,
ite_eq_right hnotlt, ite_eq_left hcb]
simpa only [closedFormNegCrossTruncClampLastGe] using
minimal_closedForm_of_negCross_trunc_clamp_lastGe ⟨db, hcomp⟩
⟨hmore, hrev, hbegin, hne, hcrossD, hend, hclamp, hBlast⟩
/-- The compact nonpositive rule is minimal on every crossed negative-begin truncated
clamping read with positive end offset. Small gaps and saturated exact-capacity gaps end
at `keyAfter last`; insertion-capacity and unsaturated padded gaps end at `begin.key`. -/
theorem compactForwardTruncatedNonpos_minimal_neg_clamp {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : 1 ≤ r.end_.offset)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hlastB : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
obtain ⟨db, hcomp⟩ := hread
have hread' : Readable r res := ⟨db, hcomp⟩
rw [compactForwardTruncatedNonpos_eq_clamped hclamp
(not_negCross_trunc_topTop_eq_of_one_le_end hend), ite_eq_right (by omega)]
by_cases hgap : (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key) <
r.begin.key
· by_cases hlow : compactClampGapLow r res
· rw [compactClampUpper_eq_keyAfter hlow]
by_cases hbase : intervalCard
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.begin.key ≤
((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞)
· exact minimal_closedForm_of_negCross_trunc_clamp_gapLow hread'
⟨hmore, hrev, hbegin, hne, hend, hcross, hgap, hclamp, hbase⟩
· by_cases hheadbot : res.keys.headD ([] : Key) = ([] : Key)
· have hsmall : compactClampGapSmall r res := by
rcases hlow with hsmall | hsat
· exact hsmall
· exact absurd hheadbot hsat.1
have hheadbot' : res.keys.head?.getD ([] : Key) = ([] : Key) := by
simpa only [List.headD_eq_head?] using hheadbot
have hmid : intervalCard
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.begin.key ≤
(((beginSlack r + 1 - res.keys.length) + 1 : ℕ) : ℕ∞) := by
simpa [compactClampGapSmall, compactClampSlack, hheadbot, hheadbot'] using hsmall
exact minimal_closedForm_of_negCross_trunc_clamp_gapBotMid hread'
⟨hmore, hrev, hbegin, hne, hend, hcross, hgap, hclamp, hheadbot, hmid⟩
· have hheadne' : res.keys.head?.getD ([] : Key) ≠ ([] : Key) := by
simpa only [List.headD_eq_head?] using hheadbot
have hsat : compactClampGapExactSaturated r res := by
rcases hlow with hsmall | hsat
· have hbase' : intervalCard
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.begin.key ≤
((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞) := by
simpa [compactClampGapSmall, compactClampSlack, hheadbot, hheadne'] using hsmall
exact absurd hbase' hbase
· exact hsat
exact minimal_closedForm_of_negCross_trunc_clamp_gapExactSaturated hread'
⟨hmore, hrev, hbegin, hne, hend, hcross, hgap, hclamp,
hsat.2.1, hsat.2.2.1, hsat.2.2.2⟩
· rw [compactClampUpper_eq_begin hlow]
have hsmall : ¬ compactClampGapSmall r res := fun h => hlow (Or.inl h)
by_cases hins : (((beginSlack r + 1 - res.keys.length) + 1 : ℕ) : ℕ∞) ≤
intervalCard (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key
· exact minimal_beginRange_of_gap_insert_capacity hread' hmore hrev hne hbegin hend
hcross hgap hclamp hins
· have hAfin : intervalCard
(((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key ≠ ⊤ := by
intro htop
apply hins
rw [htop]
exact le_top
have hAle : intervalCard
(((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key ≤ ((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞) := by
apply (ENat.lt_add_one_iff
(n := ((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞)) (by simp)).mp
simpa only [ENat.natCast_add, ENat.natCast_one] using lt_of_not_ge hins
by_cases hheadbot : res.keys.headD ([] : Key) = ([] : Key)
· apply False.elim
apply hsmall
unfold compactClampGapSmall compactClampSlack
rw [ite_eq_left hheadbot, intervalCard_last_eq_keyAfter_add_one hgap]
simpa only [ENat.natCast_add, ENat.natCast_one] using add_le_add_left hAle 1
· have hT_le_A : ((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞) ≤
intervalCard (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key := by
by_contra hnot
apply hsmall
have hAlt : intervalCard
(((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key < ((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞) :=
lt_of_not_ge hnot
have hcard : intervalCard
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.begin.key ≤
((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞) := by
rw [intervalCard_last_eq_keyAfter_add_one hgap]
exact (ENat.add_one_le_iff hAfin).mpr hAlt
have hheadne' : res.keys.head?.getD ([] : Key) ≠ ([] : Key) := by
simpa only [List.headD_eq_head?] using hheadbot
simpa [compactClampGapSmall, compactClampSlack, hheadbot, hheadne'] using hcard
have hAeq : intervalCard
(((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)
r.begin.key = ((beginSlack r + 1 - res.keys.length : ℕ) : ℕ∞) :=
le_antisymm hAle hT_le_A
by_cases hsat : r.end_.key = (([] : Key) : WithTop Key) ∧
(r.end_.offset - 1).toNat = res.keys.length
· exact absurd (Or.inr ⟨hheadbot, hsat.1, hsat.2, hAeq⟩ :
compactClampGapLow r res) hlow
· apply minimal_beginRange_of_gap_padded hread'
refine ⟨hmore, hrev, hbegin, hne, hend, hcross, hgap, hclamp, hheadbot,
hT_le_A, ?_⟩
by_cases hE : r.end_.key = (([] : Key) : WithTop Key)
· exact Or.inr (fun hcount => hsat ⟨hE, hcount⟩)
· exact Or.inl hE
· have hgapEq : r.begin.key =
(((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key) :=
le_antisymm (not_lt.mp hgap) (keyAfter_le_of_lt hlastB)
rw [compactClampUpper_eq_begin_of_noGap hgapEq]
exact minimal_closedForm_of_negCross_trunc_clamp_noGap hread'
⟨hmore, hrev, hbegin, hne, hend, hcross, hgapEq, hclamp⟩
/-- The low-capacity clamping branch is certified for an arbitrary end key. This regional
wrapper is retained for callers, though the general clamping theorem now subsumes it. -/
theorem compactForwardTruncatedNonpos_minimal_neg_clamp_low {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : 1 ≤ r.end_.offset)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hlastB : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key)
(_hlow : compactClampGapLow r res) :
Minimal r res (compactForwardTruncatedNonpos r res) :=
compactForwardTruncatedNonpos_minimal_neg_clamp hread hmore hrev hne hbegin hend
hcross hclamp hlastB
/-- The no-gap clamping branch is also certified for an arbitrary end key, including the
case where the unified capacity test happens to select the high branch. -/
theorem compactForwardTruncatedNonpos_minimal_neg_clamp_noGap {r : RangeRead}
{res : Result} (hread : Readable r res) (hmore : res.more = true)
(hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hend : 1 ≤ r.end_.offset)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hgap : r.begin.key =
((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
rw [compactForwardTruncatedNonpos_eq_clamped hclamp
(not_negCross_trunc_topTop_eq_of_one_le_end hend), ite_eq_right (by omega),
compactClampUpper_eq_begin_of_noGap hgap]
exact minimal_closedForm_of_negCross_trunc_clamp_noGap hread
⟨hmore, hrev, hbegin, hne, hend, hcross, hgap, hclamp⟩
/-- Convenience wrapper for the below-end clamping region. The boundary hypothesis is
retained in this regional interface, but the general clamping proof no longer needs it. -/
theorem compactForwardTruncatedNonpos_minimal_neg_clamp_below {r : RangeRead}
{res : Result} (hread : Readable r res) (hmore : res.more = true)
(hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hend : 1 ≤ r.end_.offset)
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(_hlastE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
by_cases hlastB : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key
· exact compactForwardTruncatedNonpos_minimal_neg_clamp hread hmore hrev hne hbegin hend
hcross hclamp hlastB
· exact compactForwardTruncatedNonpos_minimal_neg_clamp_lastGe hread hmore hrev hne hbegin
hend hcross hclamp (not_lt.mp hlastB)
/-- The exact residual left by the compact nonpositive forward-truncation certificates:
a crossed negative-begin read with a nonpositive end offset that also clamps, except for
the sentinel-end strict cell, the both-sentinel cell, the crossed short cell where a
reported key lies at or above the end key, the bottom-gap cell where the end key lies
at or above the begin key with enough gap capacity, and the `end_.key < begin.key`
non-clamping gap cell. Every nonclamping nonpositive-end cell, every positive-end cell
(including arbitrary-end clamping gaps at exact capacity), the sentinel-end strict cell
with `begin.key < ⊤`, the whole both-sentinel cell, the whole crossed short cell, the
crossed bottom-gap cell, and the crossed nonpositive-end non-clamping gap cell are
certified. -/
def compactForwardNonposResidual (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
r.end_.offset ≤ 0 ∧ reportedBelowBegin r res ≤ beginSlack r ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
¬ (r.end_.key = (⊤ : WithTop Key) ∧ r.begin.key < r.end_.key) ∧
¬ negCrossTruncTopTop r res ∧
¬ negCrossTruncShortNonpos r res ∧
¬ negCrossTruncBottomGap r res ∧
¬ negCrossTruncNonposGapA2aNonbottom r res ∧
¬ negCrossTruncNonposGapA2aBottom r res ∧
¬ negCrossTruncNonposGapCrossFree r res
/-- The forward-truncated nonpositive residual of the compact formula is empty: every cell
it describes falls under one of the certified certificates. -/
theorem not_compactForwardNonposResidual {r : RangeRead} {res : Result} :
¬ compactForwardNonposResidual r res := by
rintro ⟨hmore, hrev, hneg, hne, hcross, hend, hclamp, hlastB, hS, hT, hshort,
hBG, hA2a, hA2ab, hCF⟩
have hcrossD : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcross
by_cases hBE : r.begin.key ≤ r.end_.key
· by_cases hEne : r.end_.key ≠ (⊤ : WithTop Key)
· have hEne' : r.end_.key < (⊤ : WithTop Key) := lt_of_le_of_ne le_top hEne
have hlastE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key :=
lt_of_lt_of_le hlastB hBE
by_cases hcap : ((clampNonposD r + 1 : ℕ) : ℕ∞) ≤
intervalCard r.begin.key r.end_.key
· exact hBG ⟨hmore, hrev, hneg, hne, hlastB, hend, hclamp, hBE, hEne, hcap⟩
· have hgap : negCrossTruncNonposGap r res :=
⟨hmore, hrev, hneg, hne, hcross, hend, hclamp, hlastB, hlastE, hEne',
Or.inr (not_le.mp hcap)⟩
exact hCF ⟨hgap, hBE⟩
· have hEtop : r.end_.key = (⊤ : WithTop Key) := by
by_contra h
exact hEne h
have hBtop : r.begin.key = (⊤ : WithTop Key) := by
by_contra hb
exact hS ⟨hEtop, by rw [hEtop]; exact lt_of_le_of_ne le_top hb⟩
exact hT ⟨hmore, hrev, hneg, hne, hBtop, hEtop, hend⟩
· have hEB' : r.end_.key < r.begin.key := not_le.mp hBE
have hEne : r.end_.key < (⊤ : WithTop Key) := lt_of_lt_of_le hEB' le_top
have hlastE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key := by
by_contra h
exact hshort ⟨hmore, hrev, hneg, hne, hcrossD, hend, hclamp, hEB', not_lt.mp h⟩
have hgap : negCrossTruncNonposGap r res :=
⟨hmore, hrev, hneg, hne, hcross, hend, hclamp, hlastB, hlastE, hEne, Or.inl hEB'⟩
by_cases hcb : clampNonposBottom r res
· exact hA2ab ⟨hgap, hEB', hcb⟩
· exact hA2a ⟨hgap, hEB', hcb⟩
/-- The compact nonpositive forward-truncated formula is minimal outside the explicitly
specified residual. The proof uses no regional dispatcher: bottom clamping, begin zero,
nonclamping, and clamping below the end key are four arithmetic certificates. -/
theorem compactForwardTruncatedNonpos_minimal_of_not_residual {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hresidual : ¬ compactForwardNonposResidual r res) :
Minimal r res (compactForwardTruncatedNonpos r res) := by
classical
by_cases hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)
· exact compactForwardTruncatedNonpos_minimal_bottom hread hmore hrev hne hbegin hlo
· have hcrossD : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key :=
not_le.mp hlo
have hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcrossD
by_cases hzero : r.begin.offset = 0
· exact compactForwardTruncatedNonpos_minimal_zero hread hmore hrev hne hzero hcross
· have hneg : r.begin.offset < 0 := by omega
by_cases hend : r.end_.offset ≤ 0
· by_cases hclamp : reportedBelowBegin r res ≤ beginSlack r
· by_cases hBlast : r.begin.key ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
· exact compactForwardTruncatedNonpos_minimal_neg_clamp_nonpos_lastGe hread hmore
hrev hne hneg hend hcross hclamp hBlast
· by_cases hT : negCrossTruncTopTop r res
· by_cases hA : negCrossTruncTopTopEq r res
· have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncTopTopEq r res :=
compactForwardTruncatedNonpos_eq_topTopEq hclamp hA
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_topTop_eq hread hA
· have hnotlt : ¬ r.end_.key < r.begin.key := by
rw [NegCrossTruncTopTop.hEtop hT, NegCrossTruncTopTop.hBtop hT]
exact not_lt.mpr le_rfl
have hnotH : ¬ (res.keys.length + (1 - r.end_.offset).toNat =
beginSlack r + 1) := fun hH => hA ⟨hT, hH⟩
have hrepTop : reportedBelowBegin r res = res.keys.length := by
unfold reportedBelowBegin
rw [NegCrossTruncTopTop.hBtop hT, List.countP_eq_length]
intro k _
rw [decide_eq_true_eq]
exact WithTop.coe_lt_top k
have hpEq : (1 - r.end_.offset).toNat = clampNonposD r + 1 := by
have hp_cast : (((1 - r.end_.offset).toNat : ℕ) : ℤ) =
1 - r.end_.offset :=
NegCrossTruncTopTop.endPad_cast_of_nonpos hend
have hd_cast : ((clampNonposD r : ℕ) : ℤ) = 0 - r.end_.offset := by
rw [clampNonposD_eq]
have hnn : 0 ≤ -r.end_.offset := by omega
have h := Int.toNat_of_nonneg hnn
omega
have hz : (((1 - r.end_.offset).toNat : ℕ) : ℤ) =
((clampNonposD r + 1 : ℕ) : ℤ) := by
push_cast
omega
exact_mod_cast hz
have hcap0 : intervalCard r.begin.key r.end_.key = 0 := by
rw [NegCrossTruncTopTop.hBtop hT]
exact intervalCard_top_left r.end_.key
have hle := NegCrossTruncTopTop.readable_counts_topTop hT hread
have hlt : res.keys.length + (1 - r.end_.offset).toNat <
beginSlack r + 1 := lt_of_le_of_ne hle hnotH
have hcb : clampNonposBottom r res := by
unfold clampNonposBottom
rw [hrepTop, hcap0]
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
have hh := hlt
rw [hpEq] at hh
omega
have hcast : ((res.keys.length + (clampNonposD r + 1) : ℕ) : ℕ∞) ≤
(beginSlack r : ℕ∞) := Nat.cast_le.mpr hnat
simpa [ENat.natCast_add, add_comm, add_left_comm, add_assoc] using hcast
have hEq : compactForwardTruncatedNonpos r res =
⟨(([] : Key) : WithTop Key), r.end_.key⟩ := by
rw [compactForwardTruncatedNonpos_eq_clamped hclamp hA,
ite_eq_left hend, ite_eq_right hnotlt, ite_eq_left hcb]
have hcf : closedFormNegCrossTruncTopTop r res =
⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by
rw [closedFormNegCrossTruncTopTop, ite_eq_right hnotH]
rw [hEq, NegCrossTruncTopTop.hEtop hT, ← hcf]
exact minimal_closedForm_of_negCross_trunc_topTop hread hT
· by_cases hS : r.end_.key = (⊤ : WithTop Key) ∧
r.begin.key < r.end_.key
· obtain ⟨htop, hBltE⟩ := hS
have hnA : ¬ negCrossTruncTopTopEq r res := by
rintro ⟨hA', -⟩
have hthis : r.begin.key < r.end_.key := hBltE
rw [NegCrossTruncTopTop.hBtop hA',
NegCrossTruncTopTop.hEtop hA'] at hthis
exact absurd hthis (not_lt.mpr le_top)
have hBne : r.begin.key ≠ (⊤ : WithTop Key) := by
rw [← htop]
exact ne_of_lt hBltE
have hcb : clampNonposBottom r res := by
unfold clampNonposBottom
rw [htop, intervalCard_top_right hBne]
simp only [ENat.sub_top, add_zero]
exact Nat.cast_le.mpr hclamp
have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncStrictTop r res := by
rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend]
rw [ite_eq_right (by rw [htop]; exact not_lt.mpr le_top), ite_eq_left hcb]
rw [htop]
rfl
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_strict_top hread
⟨hmore, hrev, hneg, hne, hcrossD, hend, hclamp, htop,
not_le.mp hBlast, hBltE⟩
· by_cases hcellL : negCrossTruncShortNonpos r res
· have hnA : ¬ negCrossTruncTopTopEq r res := by
rintro ⟨hA', -⟩
obtain ⟨-, -, -, -, -, -, -, hlong, -⟩ := hcellL
rw [NegCrossTruncTopTop.hEtop hA', NegCrossTruncTopTop.hBtop hA']
at hlong
exact (not_lt.mpr le_rfl) hlong
have hkeep : negCrossTruncShortNonpos r res := hcellL
obtain ⟨-, -, -, -, -, -, -, hlong, hlastE⟩ := hcellL
have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncShortNonpos r res := by
unfold closedFormNegCrossTruncShortNonpos
by_cases hcb : clampNonposBottom r res
· rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend, ite_eq_left hlong, ite_eq_left hcb,
ite_eq_right (not_lt.mpr hlastE), ite_eq_left hcb]
· rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend, ite_eq_left hlong, ite_eq_right hcb,
ite_eq_right hcb]
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_short_nonpos hread hkeep
· by_cases hBE : r.begin.key ≤ r.end_.key
· by_cases hEne : r.end_.key ≠ (⊤ : WithTop Key)
· by_cases hcap : ((clampNonposD r + 1 : ℕ) : ℕ∞) ≤
intervalCard r.begin.key r.end_.key
· have hcell : negCrossTruncBottomGap r res :=
⟨hmore, hrev, hneg, hne, not_le.mp hBlast, hend, hclamp,
hBE, hEne, hcap⟩
have hnA : ¬ negCrossTruncTopTopEq r res := fun hA => hT hA.1
have hnotlt : ¬ r.end_.key < r.begin.key := not_lt.mpr hBE
have hcb : clampNonposBottom r res :=
clampNonposBottom_of_negCross_trunc_bottomGap hcell
have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncBottomGap r res := by
rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend, ite_eq_right hnotlt, ite_eq_left hcb]
rfl
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_bottomGap hread hcell
· have hlastE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) <
r.end_.key := lt_of_lt_of_le (not_le.mp hBlast) hBE
have hgap : negCrossTruncNonposGap r res :=
⟨hmore, hrev, hneg, hne, hcross, hend, hclamp,
not_le.mp hBlast, hlastE, lt_of_le_of_ne le_top hEne,
Or.inr (not_le.mp hcap)⟩
have hcellCF : negCrossTruncNonposGapCrossFree r res := ⟨hgap, hBE⟩
have hnA : ¬ negCrossTruncTopTopEq r res := fun hA => hT hA.1
have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncNonposGapCrossFree r res := by
rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend, ite_eq_right (not_lt.mpr hBE)]
unfold closedFormNegCrossTruncNonposGapCrossFree
closedFormNegCrossTruncNonposGap
rw [max_eq_right hBE]
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_nonposGap_crossFree
hread hcellCF
· exact absurd ⟨hmore, hrev, hneg, hne, hcross, hend, hclamp,
not_le.mp hBlast, hS, hT, hcellL, fun hcell => by
obtain ⟨-, -, -, -, -, -, -, -, hEne', -⟩ := hcell
exact hEne hEne', fun hA2a => by
obtain ⟨hA, -, -⟩ := hA2a
obtain ⟨-, -, -, -, -, -, -, -, -, hEne', -⟩ := hA
exact hEne (ne_of_lt hEne'),
fun hBot => by
obtain ⟨hA, -, -⟩ := hBot
obtain ⟨-, -, -, -, -, -, -, -, -, hEne', -⟩ := hA
exact hEne (ne_of_lt hEne'),
fun hcf => by
obtain ⟨hgap, -⟩ := hcf
obtain ⟨-, -, -, -, -, -, -, -, -, hEne', -⟩ := hgap
exact hEne (ne_of_lt hEne')⟩ hresidual
· have hEB' : r.end_.key < r.begin.key := not_le.mp hBE
have hlastE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) <
r.end_.key := by
by_contra h
exact hcellL ⟨hmore, hrev, hneg, hne, hcrossD, hend, hclamp,
hEB', not_lt.mp h⟩
have hEne : r.end_.key < (⊤ : WithTop Key) :=
lt_of_lt_of_le hEB' le_top
by_cases hcb : clampNonposBottom r res
· have hcellBot : negCrossTruncNonposGapA2aBottom r res :=
⟨⟨hmore, hrev, hneg, hne, hcross, hend, hclamp,
not_le.mp hBlast, hlastE, hEne, Or.inl hEB'⟩, hEB', hcb⟩
have hnA : ¬ negCrossTruncTopTopEq r res := fun hA => hT hA.1
have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncNonposGapA2aBottom r res := by
rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend, ite_eq_left hEB', ite_eq_left hcb,
ite_eq_left hlastE]
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_nonposGap_A2aBottom
hread hcellBot
· have hcellA2a : negCrossTruncNonposGapA2aNonbottom r res :=
⟨⟨hmore, hrev, hneg, hne, hcross, hend, hclamp,
not_le.mp hBlast, hlastE, hEne, Or.inl hEB'⟩, hEB', hcb⟩
have hnA : ¬ negCrossTruncTopTopEq r res := fun hA => hT hA.1
have hEq : compactForwardTruncatedNonpos r res =
closedFormNegCrossTruncNonposGapA2aNonbottom r res := by
rw [compactForwardTruncatedNonpos_eq_clamped hclamp hnA,
ite_eq_left hend, ite_eq_left hEB', ite_eq_right hcb]
rfl
rw [hEq]
exact minimal_closedForm_of_negCross_trunc_nonposGap_A2a_nonbottom
hread hcellA2a
· have hm := truncated_reportedBelowBegin_le_succ hread hrev hmore hne hneg hcrossD
have hnonclamp : reportedBelowBegin r res = beginSlack r + 1 := by omega
exact compactForwardTruncatedNonpos_minimal_neg_nonclamp_nonpos hread hmore hrev
hne hneg hend hcross hnonclamp
· have hendpos : 1 ≤ r.end_.offset := by omega
have hm := truncated_reportedBelowBegin_le_succ hread hrev hmore hne hneg hcrossD
by_cases hclamp : reportedBelowBegin r res ≤ beginSlack r
· by_cases hBlast : r.begin.key ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
· exact compactForwardTruncatedNonpos_minimal_neg_clamp_lastGe hread hmore hrev
hne hneg hendpos hcross hclamp hBlast
· exact compactForwardTruncatedNonpos_minimal_neg_clamp hread hmore hrev hne
hneg hendpos hcross hclamp (not_le.mp hBlast)
· have hnonclamp : reportedBelowBegin r res = beginSlack r + 1 := by omega
exact compactForwardTruncatedNonpos_minimal_neg_nonclamp hread hmore hrev hneg
hendpos hcross hnonclamp
/-- Outside the explicit residual, the compact nonpositive forward rule denotes the
general necessary-key hull. -/
theorem compactForwardTruncatedNonpos_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hresidual : ¬ compactForwardNonposResidual r res) :
(compactForwardTruncatedNonpos r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactForwardTruncatedNonpos_minimal_of_not_residual hread hmore hrev hne hbegin
hresidual).toSet_eq (conflictRangeGeneral_minimal hread)
/-- Outside the explicit residual, the compact nonpositive forward rule agrees with the
executable reference. -/
theorem compactForwardTruncatedNonpos_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hresidual : ¬ compactForwardNonposResidual r res) :
(compactForwardTruncatedNonpos r res).toSet = (simpleConflictRange r res).toSet :=
(compactForwardTruncatedNonpos_minimal_of_not_residual hread hmore hrev hne hbegin
hresidual).toSet_eq (simpleConflictRange_minimal hread)
/-- The reported count in a reversed truncated finite window. On cross-free reads only
reported keys at or above `end.key` contribute; on crossed reads every reported key does. -/
def compactReverseCount (r : RangeRead) (res : Result) : ℕ :=
if r.end_.key < r.begin.key then res.keys.length else residualT r res
/-- The finite-boundary condition for reversed truncation, using the same deficit as the
complete rule. -/
def compactReverseFinite (r : RangeRead) (res : Result) : Prop :=
compactDeficit r + compactReverseCount r res = residualE r
/-- The crossed reversed top branch has lower endpoint `end.key` exactly when the gap
`[end.key, last reported)` has room for the end overshoot. -/
noncomputable def compactCrossedRoom (r : RangeRead) (res : Result) : Prop :=
(((residualE r - res.keys.length : ℕ) : ℕ∞) ≤
intervalCard r.end_.key ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
/-- One reversed-truncated rule at `begin.offset ≥ 2`. A nonpositive end cut is
canonical and an overshoot below every reported key is unbounded. Otherwise the shared
deficit test chooses a finite reported-head boundary; in the unbounded crossed case one
capacity comparison chooses between the two selector keys as lower endpoint. -/
noncomputable def compactReverseTruncatedSkip (r : RangeRead) (res : Result) : ConflictRange := by
classical
exact
if r.end_.offset ≤ 1 then canonicalRange r
else if ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key then topRange r
else if compactReverseFinite r res then
⟨if r.end_.key < r.begin.key then r.end_.key else r.begin.key,
(keyAfter (res.keys.headD ([] : Key)) : WithTop Key)⟩
else
⟨if r.end_.key < r.begin.key ∧ compactCrossedRoom r res
then r.end_.key else r.begin.key, ⊤⟩
/-- The compact reversed-truncated rule is minimal whenever `begin.offset ≥ 2`. -/
theorem compactReverseTruncatedSkip_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : 2 ≤ r.begin.offset) :
Minimal r res (compactReverseTruncatedSkip r res) := by
classical
obtain ⟨db, hcomp⟩ := hread
have hread' : Readable r res := ⟨db, hcomp⟩
unfold compactReverseTruncatedSkip
by_cases hend : r.end_.offset ≤ 1
· rw [ite_eq_left hend]
exact minimal_canonicalRange_of_end_offset_le_one_rev_more hread' hmore hrev hne hbegin hend
· rw [ite_eq_right hend]
have hend2 : 2 ≤ r.end_.offset := by omega
by_cases hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
· rw [ite_eq_left hhi]
exact minimal_topRange_of_end_offset_ge_two_rev_more hread' hmore hrev hbegin hend2 hhi
· rw [ite_eq_right hhi]
by_cases hcrossed : r.end_.key < r.begin.key
· have hgap : intervalCard r.begin.key r.end_.key = 0 :=
intervalCard_eq_zero_of_le (le_of_lt hcrossed)
have hfin_iff : compactReverseFinite r res ↔
res.keys.length + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat := by
simp [compactReverseFinite, compactReverseCount, compactDeficit, residualD,
residualB, residualE, hgap, hcrossed, Nat.add_comm]
by_cases hfin : compactReverseFinite r res
· have ht := hfin_iff.mp hfin
rw [ite_eq_left hfin, ite_eq_left hcrossed]
exact minimal_truncatedRevCrossed_finite_general hread' hmore hrev (by omega)
hcrossed (by omega) hne ht
· rw [ite_eq_right hfin]
have hne_eq : res.keys.length + (r.begin.offset - 1).toNat ≠
(r.end_.offset - 1).toNat := fun h => hfin (hfin_iff.mpr h)
have hle := crossed_rev_res_length_add_le_end (db := db) hcomp hrev (by omega)
hcrossed (by omega) hne
have hlt : res.keys.length + (r.begin.offset - 1).toNat <
(r.end_.offset - 1).toNat := by omega
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne :=
getLastD_eq_getLast_of_ne hne
have hroom_iff : compactCrossedRoom r res ↔ crossedResidualCond r res hne := by
unfold compactCrossedRoom crossedResidualCond residualE
rw [hlast]
by_cases hroom : compactCrossedRoom r res
· rw [ite_eq_left ⟨hcrossed, hroom⟩]
exact minimal_crossedResidual_cond hread' hmore hrev hbegin hcrossed (by omega)
hne hlt (hroom_iff.mp hroom)
· have hcond : ¬ (r.end_.key < r.begin.key ∧ compactCrossedRoom r res) :=
fun h => hroom h.2
rw [ite_eq_right hcond]
exact minimal_crossedResidual_not_cond hread' hmore hrev hbegin hcrossed
(by omega) hne hlt (fun h => hroom (hroom_iff.mpr h))
· have hcross : r.begin.key ≤ r.end_.key := not_lt.mp hcrossed
have htpos : 0 < residualT r res := by
simp only [not_forall, not_lt] at hhi
obtain ⟨k, hk, hkge⟩ := hhi
exact countP_pos_of_mem hk (by rw [decide_eq_true_eq]; exact hkge)
have hfin_iff : compactReverseFinite r res ↔
residualD r (intervalCard r.begin.key r.end_.key) + residualT r res =
residualE r := by
simp [compactReverseFinite, compactReverseCount, compactDeficit, hcrossed]
by_cases hfin : compactReverseFinite r res
· have hfin' := hfin_iff.mp hfin
rw [ite_eq_left hfin, ite_eq_right hcrossed]
have hmin := minimal_closedForm_of_crossfree_residual hread' hmore hrev hbegin
hcross hend2 hne htpos
unfold closedFormCrossFreeResidual at hmin
rw [ite_eq_left hfin'] at hmin
exact hmin
· rw [ite_eq_right hfin]
have hcond : ¬ (r.end_.key < r.begin.key ∧ compactCrossedRoom r res) :=
fun h => hcrossed h.1
rw [ite_eq_right hcond]
have hfin' : ¬ residualD r (intervalCard r.begin.key r.end_.key) +
residualT r res = residualE r := fun h => hfin (hfin_iff.mpr h)
have hmin := minimal_closedForm_of_crossfree_residual hread' hmore hrev hbegin
hcross hend2 hne htpos
unfold closedFormCrossFreeResidual at hmin
rw [ite_eq_right hfin'] at hmin
exact hmin
/-- The compact reversed-truncated rule denotes exactly the general necessary-key hull. -/
theorem compactReverseTruncatedSkip_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : 2 ≤ r.begin.offset) :
(compactReverseTruncatedSkip r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactReverseTruncatedSkip_minimal hread hmore hrev hne hbegin).toSet_eq
(conflictRangeGeneral_minimal hread)
/-- The compact reversed-truncated rule agrees with the executable reference. -/
theorem compactReverseTruncatedSkip_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : 2 ≤ r.begin.offset) :
(compactReverseTruncatedSkip r res).toSet = (simpleConflictRange r res).toSet :=
(compactReverseTruncatedSkip_minimal hread hmore hrev hne hbegin).toSet_eq
(simpleConflictRange_minimal hread)
/-- Reversed truncation with no begin skip. The finite branch uses the reported-head
successor. On the unbounded branch, `[end.key, last reported)` must contain the unused
end positions before the lower endpoint can move from the reported last to `end.key`. -/
def compactReverseTruncatedZero (r : RangeRead) (res : Result) : ConflictRange :=
if r.end_.offset ≤ 1 then
truncatedRangeRev r (res.keys.getLastD ([] : Key))
else
let L : WithTop Key := (res.keys.getLastD ([] : Key) : WithTop Key)
let H : Key := res.keys.headD ([] : Key)
if residualT r res = residualE r then
⟨min L r.end_.key, ((keyAfter H : Key) : WithTop Key)⟩
else
match r.end_.key with
| some E =>
if keyAfterN (residualE r - residualT r res - 1) E <
res.keys.getLastD ([] : Key) then
⟨(E : WithTop Key), ⊤⟩
else ⟨L, ⊤⟩
| none => ⟨L, ⊤⟩
/-- The no-skip rule is the direct arithmetic form of the certified offset-one rule. -/
theorem compactReverseTruncatedZero_eq_offsetOne (r : RangeRead) (res : Result) :
compactReverseTruncatedZero r res = closedFormOffsetOneTruncatedRevFullC r res := by
rfl
/-- One reversed-truncated algorithm at every positive begin offset. The only boundary
distinction is whether the begin selector skips a positive number of keys. -/
noncomputable def compactReverseTruncated (r : RangeRead) (res : Result) : ConflictRange :=
if residualB r = 0 then compactReverseTruncatedZero r res
else compactReverseTruncatedSkip r res
/-- At begin offset one the total reversed rule is the no-skip formula. -/
theorem compactReverseTruncated_eq_offsetOne {r : RangeRead} {res : Result}
(hbegin : r.begin.offset = 1) :
compactReverseTruncated r res = closedFormOffsetOneTruncatedRevFullC r res := by
simp [compactReverseTruncated, compactReverseTruncatedZero_eq_offsetOne,
residualB, hbegin]
/-- With a positive begin skip the total reversed rule is the selector-capacity formula. -/
theorem compactReverseTruncated_eq_skip {r : RangeRead} {res : Result}
(hbegin : 2 ≤ r.begin.offset) :
compactReverseTruncated r res = compactReverseTruncatedSkip r res := by
have hb : residualB r ≠ 0 := by
unfold residualB
omega
simp [compactReverseTruncated, hb]
/-- The compact reversed-truncated rule is minimal at every positive begin offset. -/
theorem compactReverseTruncated_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
Minimal r res (compactReverseTruncated r res) := by
by_cases hone : r.begin.offset = 1
· rw [compactReverseTruncated_eq_offsetOne hone]
by_cases hcross : r.begin.key ≤ r.end_.key
· exact minimal_closedForm_of_offset_one_truncated_rev_fullC hread hmore hrev
hone hcross
· have hcrossed : r.end_.key < r.begin.key := lt_of_not_ge hcross
have hend : 2 ≤ r.end_.offset :=
crossed_end_offset_ge_two_truncated hread hmore (by omega) hcrossed
exact minimal_closedForm_of_offset_one_truncated_rev_fullC_crossed hread hmore
hrev hone hcrossed hend
· rw [compactReverseTruncated_eq_skip (by omega)]
exact compactReverseTruncatedSkip_minimal hread hmore hrev hne (by omega)
/-- The total compact reversed rule denotes exactly the general necessary-key hull. -/
theorem compactReverseTruncated_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
(compactReverseTruncated r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactReverseTruncated_minimal hread hmore hrev hne hbegin).toSet_eq
(conflictRangeGeneral_minimal hread)
/-- The total compact reversed rule agrees with the executable reference. -/
theorem compactReverseTruncated_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) :
(compactReverseTruncated r res).toSet = (simpleConflictRange r res).toSet :=
(compactReverseTruncated_minimal hread hmore hrev hne hbegin).toSet_eq
(simpleConflictRange_minimal hread)
/-- The shared result-shape dispatch of the compact algorithm: complete results use the
normalized complete rule, forward truncations the forward rule, and reversed truncations
the supplied traversal-specific rule. This is the common body of `compactPositive` and
`compactClamped`, which differ only in their reversed-truncation rule. -/
noncomputable def compactSplit (revRule : RangeRead → Result → ConflictRange)
(r : RangeRead) (res : Result) : ConflictRange :=
if res.more = false then compactComplete r res
else if r.reverse = false then compactForwardTruncated r res
else revRule r res
/-- The compact algorithm for every readable result at a positive begin offset.
Complete results are normalized to forward traversal. Forward and reversed truncation
each have one total arithmetic rule; neither delegates to the regional dispatcher. -/
noncomputable def compactPositive (r : RangeRead) (res : Result) : ConflictRange :=
if res.keys = [] then emptyValue r
else compactSplit compactReverseTruncated r res
/-- The compact positive-offset algorithm is minimal for every readable result. -/
theorem compactPositive_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hbegin : 1 ≤ r.begin.offset) :
Minimal r res (compactPositive r res) := by
classical
unfold compactPositive
by_cases hne : res.keys = []
· rw [ite_eq_left hne]
exact minimal_emptyValue_of_emptyInference emptyInference hread hne
· rw [ite_eq_right hne]
unfold compactSplit
by_cases hmore : res.more = false
· rw [ite_eq_left hmore]
exact compactComplete_minimal hread hmore hne hbegin
· rw [ite_eq_right hmore]
have hm : res.more = true := by cases h : res.more <;> simp_all
by_cases hrev : r.reverse = false
· rw [ite_eq_left hrev]
exact compactForwardTruncated_minimal hread hm hrev hne hbegin
· rw [ite_eq_right hrev]
have hrevt : r.reverse = true := by cases h : r.reverse <;> simp_all
exact compactReverseTruncated_minimal hread hm hrevt hne hbegin
/-- The compact positive-offset algorithm denotes exactly the general necessary-key
hull. -/
theorem compactPositive_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hbegin : 1 ≤ r.begin.offset) :
(compactPositive r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactPositive_minimal hread hbegin).toSet_eq (conflictRangeGeneral_minimal hread)
/-- The compact positive-offset algorithm agrees with the executable reference. -/
theorem compactPositive_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hbegin : 1 ≤ r.begin.offset) :
(compactPositive r res).toSet = (simpleConflictRange r res).toSet :=
(compactPositive_minimal hread hbegin).toSet_eq (simpleConflictRange_minimal hread)
/-- A nonempty read whose nonpositive begin selector is at or below the least reported
key. These reads clamp to the same bottom-anchored core regardless of selector crossing. -/
abbrev clampedNonpos (r : RangeRead) (res : Result) : Prop :=
res.keys ≠ [] ∧ r.begin.offset ≤ 0 ∧
r.begin.key ≤ ((leastReported r res : Key) : WithTop Key)
/-- One algorithm for all clamped nonpositive reads. This single rule subsumes the old
complete, forward-truncated positive-end, forward-truncated nonpositive-end, and reversed
truncated dispatcher branches. -/
noncomputable def compactClamped (r : RangeRead) (res : Result) : ConflictRange :=
compactSplit closedFormNonposRevTrunc r res
/-- The clamped nonpositive algorithm is minimal in either traversal and for either
result completeness flag. -/
theorem compactClamped_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (h : clampedNonpos r res) :
Minimal r res (compactClamped r res) := by
obtain ⟨hne, hbegin, hloD⟩ := h
unfold compactClamped compactSplit
by_cases hmore : res.more = false
· rw [ite_eq_left hmore]
exact compactComplete_minimal_nonpos hread ⟨hmore, hne, hbegin, hloD⟩
· rw [ite_eq_right hmore]
have hm : res.more = true := by cases h : res.more <;> simp_all
by_cases hrev : r.reverse = false
· rw [ite_eq_left hrev]
have hlo : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
exact compactForwardTruncated_minimal_nonpos hread hm hrev hbegin hlo
· rw [ite_eq_right hrev]
have hrevt : r.reverse = true := by cases h : r.reverse <;> simp_all
exact minimal_closedForm_of_nonpos_revTrunc hread ⟨hm, hrevt, hbegin, hloD⟩
/-- The clamped nonpositive algorithm denotes exactly the general necessary-key hull. -/
theorem compactClamped_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (h : clampedNonpos r res) :
(compactClamped r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactClamped_minimal hread h).toSet_eq (conflictRangeGeneral_minimal hread)
/-- The clamped nonpositive algorithm agrees with the executable reference. -/
theorem compactClamped_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (h : clampedNonpos r res) :
(compactClamped r res).toSet = (simpleConflictRange r res).toSet :=
(compactClamped_minimal hread h).toSet_eq (simpleConflictRange_minimal hread)
/-- The compact complete algorithm denotes exactly the general necessary-key hull. -/
theorem compactComplete_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) :
(compactComplete r res).toSet = (conflictRangeGeneral r res).toSet :=
(compactComplete_minimal hread hmore hne hbegin).toSet_eq
(conflictRangeGeneral_minimal hread)
/-- The compact complete algorithm agrees with the executable reference algorithm. -/
theorem compactComplete_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) :
(compactComplete r res).toSet = (simpleConflictRange r res).toSet :=
(compactComplete_minimal hread hmore hne hbegin).toSet_eq
(simpleConflictRange_minimal hread)
/-! ## Totality of the compact algorithm
The rules above certify every nonempty readable result at a positive begin offset, every
clamped nonpositive read, and every nonpositive forward-truncated read outside the
explicit crossed nonpositive-end residual `compactForwardNonposResidual`. The remaining
nonpositive cells — crossed complete results, crossed reversed truncation, and the
forward residual — are exposed as `compactResidual`; they are answered by the certified
total closed-form dispatcher `conflictRangeClosedForm`, so the compact body itself never
mentions the executable reference. The dispatcher's own innermost fallback is the only
remaining executable call, and it is confined to a handful of crossed cells. -/
/-! ## A genuinely closed total dispatcher
The certified dispatcher `conflictRangeClosedForm` has one remaining fallback to the
general algorithm on the crossed nonpositive truncated cells. On the compact residual
those cells are unreachable, and on the remaining fallback cells the read is a forward
truncation, whose compact rule `compactForwardTruncatedNonpos` is already certified.
The dispatcher below replaces that fallback by the compact forward rule, so it contains
no reference to the general or executable algorithm, and it is proved minimal on every
readable pair. -/
/-- The shared unbounded-upper closed form of the crossed nonpositive complete overshoot
cells. The lower end is `⊥` exactly in the clamping regime and the reported least key
otherwise; both the crossed begin-zero overshoot and the crossed negative-begin overshoot
have this endpoint pair, so one definition serves both. -/
noncomputable def closedFormNegCrossTopUnified (r : RangeRead) (res : Result) :
ConflictRange :=
⟨if reportedBelowBegin r res ≤ beginSlack r then (([] : Key) : WithTop Key)
else ((leastReported r res : Key) : WithTop Key), ⊤⟩
/-- In the crossed begin-zero overshoot cell the clamping test is vacuous, so the shared
top closed form is the certified begin-zero rule. -/
theorem closedFormNegCrossTopUnified_eq_zeroCross {r : RangeRead} {res : Result}
(h : zeroCrossOvershootComplete r res) :
closedFormNegCrossTopUnified r res = closedFormZeroCrossOvershoot r res := by
obtain ⟨hb, _hmore, hrev, hov, hcross⟩ := h
obtain ⟨_hend, hne, _hbelow⟩ := hov
have hslack : beginSlack r = 0 := by simp [beginSlack, hb]
have hmem : leastReported r res ∈ res.keys := by
have hL : leastReported r res = res.keys.head hne := by
simp only [leastReported, hrev]
exact headD_eq_head_of_ne hne
rw [hL]
exact List.head_mem hne
have hpos : 0 < reportedBelowBegin r res := by
unfold reportedBelowBegin
refine countP_pos_of_mem hmem ?_
rw [decide_eq_true_eq]
exact hcross
have hcond : ¬ reportedBelowBegin r res ≤ beginSlack r := by omega
simp [closedFormNegCrossTopUnified, closedFormZeroCrossOvershoot, topOfLast, hcond]
/-- In the crossed negative-begin overshoot cell the shared top closed form is the
certified negative-begin rule. -/
theorem closedFormNegCrossTopUnified_eq_negCross {r : RangeRead} {res : Result}
(h : negCrossOvershoot r res) :
closedFormNegCrossTopUnified r res = closedFormNegCrossOvershoot r res := by
obtain ⟨hrev, _hbeg, _hmore, _hne, _hend, _hbelow, _hcross⟩ := h
unfold closedFormNegCrossTopUnified closedFormNegCrossOvershoot
by_cases hcond : reportedBelowBegin r res ≤ beginSlack r
· simp [hcond]
· simp [hcond, topOfLast, leastReported, hrev]
/-- The shared closed form of the crossed nonpositive complete nonclamping cells: the
reported head up to the larger selector key. The low and offset-one `end` cells both end
at `end_.key`, and the long `end` cells end at `begin_.key`, so one endpoint pair serves
all five. -/
noncomputable def closedFormNegCrossNonclampUnified (r : RangeRead) (res : Result) :
ConflictRange :=
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), max r.end_.key r.begin.key⟩
/-- On the non-long cells the shared form is the certified `[head, end_.key)` rule. -/
theorem closedFormNegCrossNonclampUnified_eq_of_le {r : RangeRead} {res : Result}
(h : r.begin.key ≤ r.end_.key) :
closedFormNegCrossNonclampUnified r res =
(⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.end_.key⟩ : ConflictRange) := by
unfold closedFormNegCrossNonclampUnified
rw [max_eq_left h]
/-- On the long cells the shared form is the certified `[head, begin_.key)` rule. -/
theorem closedFormNegCrossNonclampUnified_eq_of_lt {r : RangeRead} {res : Result}
(h : r.end_.key < r.begin.key) :
closedFormNegCrossNonclampUnified r res =
(⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩ : ConflictRange) := by
unfold closedFormNegCrossNonclampUnified
rw [max_eq_right (le_of_lt h)]
/-- On a readable nonempty complete forward crossed read at begin offset zero with a
nonpositive end offset, the begin selector key lies at or below the end selector key.
Otherwise the end resolution, a stored key below `end_.key`, would lie below `begin.key`
and hence at or below the begin resolution, contradicting the nonempty complete window. -/
theorem zeroCrossEndNonpos_begin_le_end {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossEndNonpos r res) :
r.begin.key ≤ r.end_.key := by
obtain ⟨hbegin, hmore, hrev, hend, hne, hcrossD⟩ := h
obtain ⟨db, hcomp⟩ := hread
have hleast : leastReported r res = res.keys.head hne := by
simp only [leastReported, hrev]
exact headD_eq_head_of_ne hne
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
rw [← hleast]; exact hcrossD
have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne
have hhead_stored : res.keys.head hne ∈ db.keys :=
RangeRead.compatible_keys_subset hcomp hhead_mem
have hres_eq : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hhead_ck := RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem)
have hhead_lt_res : ((res.keys.head hne : Key) : WithTop Key) < resolve db r.end_ :=
hhead_ck.2.2
have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
apply le_antisymm
· exact hhead_ck.2.1
· exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross
(res.keys.head hne) hhead_stored hcross
have hres_le_E : resolve db r.end_ ≤ r.end_.key :=
resolve_le_key_of_offset_nonpos hend
by_contra hcon
have hEB : r.end_.key < r.begin.key := lt_of_not_ge hcon
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hn | ht | ⟨k, hkdb, hkres⟩
· rw [hn] at hhead_lt_res
exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le_key_withTop _))
· exact absurd ht (resolve_ne_top_of_offset_nonpos hend)
· have hk_lt_B : (k : WithTop Key) < r.begin.key :=
lt_of_le_of_lt (by rw [← hkres]; exact hres_le_E) hEB
have hk_le_head : (k : WithTop Key) ≤ ((res.keys.head hne : Key) : WithTop Key) := by
have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross
k hkdb hk_lt_B
rwa [hL] at hb
have hhead_lt_k : ((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) := by
rw [← hkres]; exact hhead_lt_res
exact absurd hk_le_head (not_le.mpr hhead_lt_k)
/-- The crossed begin-zero complete under-end cells with `begin.key ≤ end_.key` share
the certified `[head, end_.key)` nonclamping form. -/
theorem closedFormNegCrossNonclampUnified_eq_zeroCrossEndOne {r : RangeRead} {res : Result}
(h : zeroCrossEndOne r res) :
closedFormNegCrossNonclampUnified r res = closedFormZeroCrossEndOne r res := by
obtain ⟨-, -, hrev, -, -, -, hle⟩ := h
rw [closedFormNegCrossNonclampUnified_eq_of_le hle]
simp [closedFormZeroCrossEndOne, leastReported, hrev]
/-- The crossed begin-zero complete nonpositive-end cell also has `begin.key ≤
end_.key`, so it shares the same `[head, end_.key)` form. -/
theorem closedFormNegCrossNonclampUnified_eq_zeroCrossEndNonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossEndNonpos r res) :
closedFormNegCrossNonclampUnified r res = closedFormZeroCrossEndNonpos r res := by
have hrev : r.reverse = false := h.2.2.1
rw [closedFormNegCrossNonclampUnified_eq_of_le (zeroCrossEndNonpos_begin_le_end hread h)]
simp [closedFormZeroCrossEndNonpos, leastReported, hrev]
/-- The crossed begin-zero complete long under-end cell has `end_.key < begin.key`, so
it shares the `[head, begin_.key)` form. -/
theorem closedFormNegCrossNonclampUnified_eq_zeroCrossEndOneLong {r : RangeRead} {res : Result}
(h : zeroCrossEndOneLong r res) :
closedFormNegCrossNonclampUnified r res = closedFormZeroCrossEndOneLong r res := by
obtain ⟨-, -, hrev, -, -, -, hlt⟩ := h
rw [closedFormNegCrossNonclampUnified_eq_of_lt hlt]
simp [closedFormZeroCrossEndOneLong, leastReported, hrev]
/-- The crossed nonpositive complete clamping cells all have lower endpoint `⊥`. The
offset-one cell can raise the upper endpoint to `begin.key`; the nonpositive-end bottom
group ends at `end_.key`; and the long nonpositive cell can raise it to `begin.key`.
The checks are ordered as in the dispatcher. -/
noncomputable def closedFormNegCrossClampUnified (r : RangeRead) (res : Result) :
ConflictRange :=
⟨(([] : Key) : WithTop Key),
if negCrossClampEndOne r res then clampEndOneUpper r res
else if (negCrossHeadBottom r res ∨ negCrossClampNonposInfinite r res ∨
negCrossClampNonposLastGe r res ∨ negCrossClampNonposBottom r res) then r.end_.key
else if negCrossClampLongNonpos r res then clampLongUpper r res
else r.end_.key⟩
/-- In the clamp end-one cell the shared form is the certified rule. -/
theorem closedFormNegCrossClampUnified_eq_endOne {r : RangeRead} {res : Result}
(h : negCrossClampEndOne r res) :
closedFormNegCrossClampUnified r res = closedFormNegCrossClampEndOne r res := by
unfold closedFormNegCrossClampUnified closedFormNegCrossClampEndOne
rw [ite_eq_left h]
/-- In the bottom group the shared form is the certified `[⊥, end_.key)` rule. -/
theorem closedFormNegCrossClampUnified_eq_bottom {r : RangeRead} {res : Result}
(h : negCrossHeadBottom r res ∨ negCrossClampNonposInfinite r res ∨
negCrossClampNonposLastGe r res ∨ negCrossClampNonposBottom r res) :
closedFormNegCrossClampUnified r res = closedFormNegCrossHeadBottom r res := by
have hend : r.end_.offset ≤ 0 := by
rcases h with h | h | h | h
· exact h.2.2.2.2.1
· exact h.2.2.2.2.1
· exact h.2.2.2.2.1
· exact h.2.2.2.2.1
have hnot : ¬ negCrossClampEndOne r res := by
rintro he
unfold negCrossClampEndOne at he
omega
unfold closedFormNegCrossClampUnified closedFormNegCrossHeadBottom
rw [ite_eq_right hnot, ite_eq_left h]
/-- In the long nonpositive cell the shared form is the certified rule. -/
theorem closedFormNegCrossClampUnified_eq_long {r : RangeRead} {res : Result}
(hbot : ¬ (negCrossHeadBottom r res ∨ negCrossClampNonposInfinite r res ∨
negCrossClampNonposLastGe r res ∨ negCrossClampNonposBottom r res))
(h : negCrossClampLongNonpos r res) :
closedFormNegCrossClampUnified r res = closedFormNegCrossClampLongNonpos r res := by
have hnot : ¬ negCrossClampEndOne r res := by
rintro he
unfold negCrossClampEndOne at he
have hend : r.end_.offset ≤ 0 := h.2.2.2.2.1
omega
unfold closedFormNegCrossClampUnified closedFormNegCrossClampLongNonpos
rw [ite_eq_right hnot, ite_eq_right hbot, ite_eq_left h]
/-- The crossed complete begin-zero residual cells (`end_.offset ≥ 2`). The under-end
and long cells are the two sides of `begin.key ≤ end_.key` versus `end_.key <
begin.key`; the under-end check comes first, matching the dispatcher. -/
noncomputable def closedFormZeroCrossResidual (r : RangeRead) (res : Result) : ConflictRange :=
if zeroCrossUnderEnd r res then closedFormZeroCrossUnderEnd r res
else closedFormZeroCrossLong r res
/-- In the under-end cell the shared form is the certified anchor rule. -/
theorem closedFormZeroCrossResidual_eq_under {r : RangeRead} {res : Result}
(h : zeroCrossUnderEnd r res) :
closedFormZeroCrossResidual r res = closedFormZeroCrossUnderEnd r res := by
unfold closedFormZeroCrossResidual
rw [ite_eq_left h]
/-- In the long cells the shared form is the certified long rule. -/
theorem closedFormZeroCrossResidual_eq_long {r : RangeRead} {res : Result}
(hnot : ¬ zeroCrossUnderEnd r res)
(_h : zeroCrossLongTop r res ∨ zeroCrossLongFinite r res) :
closedFormZeroCrossResidual r res = closedFormZeroCrossLong r res := by
unfold closedFormZeroCrossResidual
rw [ite_eq_right hnot]
/-- The crossed negative-begin complete cells with `2 ≤ end_.offset`: the high cell and
the residual. The high check comes first, matching the dispatcher. -/
noncomputable def closedFormNegCrossCompleteHighResidual (r : RangeRead) (res : Result) :
ConflictRange :=
if negCrossCompleteHigh r res then closedFormNegCrossCompleteHigh r res
else closedFormNegCrossCompleteResidual r res
/-- In the high cell the shared form is the certified high rule. -/
theorem closedFormNegCrossCompleteHighResidual_eq_high {r : RangeRead} {res : Result}
(h : negCrossCompleteHigh r res) :
closedFormNegCrossCompleteHighResidual r res = closedFormNegCrossCompleteHigh r res := by
unfold closedFormNegCrossCompleteHighResidual
rw [ite_eq_left h]
/-- In the residual cell the shared form is the certified residual rule. -/
theorem closedFormNegCrossCompleteHighResidual_eq_residual {r : RangeRead} {res : Result}
(h : ¬ negCrossCompleteHigh r res) :
closedFormNegCrossCompleteHighResidual r res = closedFormNegCrossCompleteResidual r res := by
unfold closedFormNegCrossCompleteHighResidual
rw [ite_eq_right h]
/-- The eight low-end crossed complete cells (`end_.offset ≤ 1`) share the closed form
`[head, max end begin)`. Their union has a compact description: at `end_.offset = 1`
the begin selector must be non-clamping, and at `end_.offset ≤ 0` the only excluded
subcase is the clamping bottom cell. -/
abbrev crossedCompleteEndLeOne (r : RangeRead) (res : Result) : Prop :=
r.reverse = false ∧ res.more = false ∧ res.keys ≠ [] ∧ r.begin.offset ≤ 0 ∧
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
((r.end_.offset = 1 ∧ beginSlack r < reportedBelowBegin r res) ∨
(r.end_.offset ≤ 0 ∧
¬ (reportedBelowBegin r res ≤ beginSlack r ∧ clampNonposBottom r res)))
/-- The compact low-end predicate is exactly the union of the eight routed cells. -/
theorem crossedCompleteEndLeOne_iff (r : RangeRead) (res : Result) :
crossedCompleteEndLeOne r res ↔
(zeroCrossEndOne r res ∨ zeroCrossEndNonpos r res ∨ zeroCrossEndOneLong r res ∨
negCrossLowFwd r res ∨ negCrossEndOne r res ∨ negCrossNonclampNonpos r res ∨
negCrossEndOneLong r res ∨ negCrossNonclampLongNonpos r res) := by
classical
constructor
· rintro ⟨hrev, hmore, hne, hbeginle, hcross, h1 | h1⟩
· obtain ⟨hend1, hslack⟩ := h1
by_cases hb0 : r.begin.offset = 0
· by_cases hBE : r.begin.key ≤ r.end_.key
· exact Or.inl ⟨hb0, hmore, hrev, hend1, hne,
by simpa [leastReported, hrev] using hcross, hBE⟩
· exact Or.inr (Or.inr (Or.inl ⟨hb0, hmore, hrev, hend1, hne,
by simpa [leastReported, hrev] using hcross, not_le.mp hBE⟩))
· have hbneg : r.begin.offset < 0 := by omega
by_cases hBE : r.begin.key ≤ r.end_.key
· exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inl
⟨hrev, hbneg, hmore, hne, hend1, hcross, hslack, hBE⟩))))
· exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl
⟨hrev, hbneg, hmore, hne, hend1, hcross, hslack, not_le.mp hBE⟩))))))
· obtain ⟨hend0, hnot⟩ := h1
by_cases hb0 : r.begin.offset = 0
· exact Or.inr (Or.inl ⟨hb0, hmore, hrev, hend0, hne,
by simpa [leastReported, hrev] using hcross⟩)
· have hbneg : r.begin.offset < 0 := by omega
by_cases hslack : beginSlack r < reportedBelowBegin r res
· exact Or.inr (Or.inr (Or.inr (Or.inl
⟨hrev, hbneg, hmore, hne, hend0, hcross, hslack⟩)))
· have hle : reportedBelowBegin r res ≤ beginSlack r := by omega
have hnb : ¬ clampNonposBottom r res := fun hc => hnot ⟨hle, hc⟩
by_cases hBE : r.begin.key ≤ r.end_.key
· exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl
⟨hrev, hbneg, hmore, hne, hend0, hBE, hcross, hle, hnb⟩)))))
· exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr
⟨hrev, hbneg, hmore, hne, hend0, hcross, hle, hnb, not_le.mp hBE⟩))))))
· rintro (h | h | h | h | h | h | h | h)
· obtain ⟨hb0, hmore, hrev, hend1, hne, hcrossL, hBE⟩ := h
have hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcrossL
have hnb : ¬ reportedBelowBegin r res ≤ beginSlack r :=
not_clamp_of_zero_cross hne hb0 hcross
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inl ⟨hend1, by omega⟩⟩
· obtain ⟨hb0, hmore, hrev, hend0, hne, hcrossL⟩ := h
have hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcrossL
have hnb : ¬ reportedBelowBegin r res ≤ beginSlack r :=
not_clamp_of_zero_cross hne hb0 hcross
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inr ⟨hend0, fun hc => hnb hc.1⟩⟩
· obtain ⟨hb0, hmore, hrev, hend1, hne, hcrossL, hlt⟩ := h
have hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcrossL
have hnb : ¬ reportedBelowBegin r res ≤ beginSlack r :=
not_clamp_of_zero_cross hne hb0 hcross
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inl ⟨hend1, by omega⟩⟩
· obtain ⟨hrev, hbneg, hmore, hne, hend0, hcross, hslack⟩ := h
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inr ⟨hend0, fun hc => by omega⟩⟩
· obtain ⟨hrev, hbneg, hmore, hne, hend1, hcross, hslack, hBE⟩ := h
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inl ⟨hend1, hslack⟩⟩
· obtain ⟨hrev, hbneg, hmore, hne, hend0, hBE, hcross, hle, hnb⟩ := h
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inr ⟨hend0, fun hc => hnb hc.2⟩⟩
· obtain ⟨hrev, hbneg, hmore, hne, hend1, hcross, hslack, hlt⟩ := h
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inl ⟨hend1, hslack⟩⟩
· obtain ⟨hrev, hbneg, hmore, hne, hend0, hcross, hle, hnb, hlt⟩ := h
exact ⟨hrev, hmore, hne, by omega, hcross, Or.inr ⟨hend0, fun hc => hnb hc.2⟩⟩
/-- The crossed complete overshoot cells: every reported key lies below the end key at
`end_.offset ≥ 2`. -/
abbrev crossedCompleteOvershoot (r : RangeRead) (res : Result) : Prop :=
zeroCrossOvershootComplete r res ∨ negCrossOvershoot r res
/-- The crossed complete begin-zero non-overshoot cells at `end_.offset ≥ 2`. -/
abbrev crossedCompleteBeginZero (r : RangeRead) (res : Result) : Prop :=
zeroCrossUnderEnd r res ∨ zeroCrossLongTop r res ∨ zeroCrossLongFinite r res
/-- The crossed complete clamping cells at `end_.offset ≤ 1`. -/
abbrev crossedCompleteClamp (r : RangeRead) (res : Result) : Prop :=
negCrossClampEndOne r res ∨ negCrossHeadBottom r res ∨
negCrossClampNonposInfinite r res ∨ negCrossClampNonposLastGe r res ∨
negCrossClampNonposBottom r res ∨ negCrossClampLongNonpos r res
open Classical in
/-- The complete-result part of the crossed closed form, with the read in forward
traversal; the reversed case reuses it on the flipped read. The five rows are the crossed
complete cells: overshoot, the low end (`end_.offset ≤ 1`), the begin-zero non-overshoot,
the clamping cells, and the high / residual fallback. The fallback is unreachable on
readable crossed nonpositive complete forward reads (`nonposCompleteForward_false`). -/
noncomputable def compactCrossedComplete (r : RangeRead) (res : Result) :
ConflictRange :=
if crossedCompleteOvershoot r res then
closedFormNegCrossTopUnified r res
else if crossedCompleteEndLeOne r res then
closedFormNegCrossNonclampUnified r res
else if crossedCompleteBeginZero r res then
closedFormZeroCrossResidual r res
else if crossedCompleteClamp r res then
closedFormNegCrossClampUnified r res
else closedFormNegCrossCompleteHighResidual r res
/-- The legacy name for the complete-result part, kept as the proof-side reference for
the multi-row dispatcher. -/
noncomputable def conflictRangeClosedFormResidualCompleteFwd (r : RangeRead) (res : Result) :
ConflictRange :=
compactCrossedComplete r res
/-- The sentinel-begin cell shares the large-capacity crossed closed form: its begin key
is `⊤`, so `[last, begin.key)` and `[last, ⊤)` coincide. -/
theorem closedFormNegCrossTruncRevCrossedNonposLarge_eq_beginTop {r : RangeRead} {res : Result}
(h : negCrossTruncRevBeginTop r res) :
closedFormNegCrossTruncRevCrossedNonposLarge r res =
closedFormNegCrossTruncRevBeginTop r res := by
obtain ⟨_, _, _, _, _, hBtop, _⟩ := h
unfold closedFormNegCrossTruncRevCrossedNonposLarge closedFormNegCrossTruncRevBeginTop
topOfLast
rw [hBtop]
/-- The finite under and over cells of the reversed residual share their upper endpoint;
only the lower endpoint moves from the reported last to `end_.key`. -/
noncomputable def closedFormNegCrossTruncRevResidualFiniteUnified
(r : RangeRead) (res : Result) : ConflictRange :=
if negCrossTruncRevResidualFiniteOver r res then
⟨r.end_.key, (closedFormNegCrossTruncRevResidualFiniteUnder r res).end_⟩
else closedFormNegCrossTruncRevResidualFiniteUnder r res
/-- In the finite under cell the shared finite closed form is the certified under rule. -/
theorem closedFormNegCrossTruncRevResidualFiniteUnified_eq_under
{r : RangeRead} {res : Result}
(h : negCrossTruncRevResidualFiniteUnder r res) :
closedFormNegCrossTruncRevResidualFiniteUnified r res =
closedFormNegCrossTruncRevResidualFiniteUnder r res := by
have hover : ¬ negCrossTruncRevResidualFiniteOver r res := by
rintro ⟨_, _, _, _, _, hEL, _⟩
exact absurd hEL (not_lt.mpr h.2.2.2.2.2.1)
unfold closedFormNegCrossTruncRevResidualFiniteUnified
rw [ite_eq_right hover]
/-- In the finite over cell the shared finite closed form is the certified over rule. -/
theorem closedFormNegCrossTruncRevResidualFiniteUnified_eq_over
{r : RangeRead} {res : Result}
(h : negCrossTruncRevResidualFiniteOver r res) :
closedFormNegCrossTruncRevResidualFiniteUnified r res =
closedFormNegCrossTruncRevResidualFiniteOver r res := by
unfold closedFormNegCrossTruncRevResidualFiniteUnified
closedFormNegCrossTruncRevResidualFiniteOver closedFormNegCrossTruncRevResidualFiniteUnder
rw [ite_eq_left h]
/-- The two large-gap top subcells share the unbounded upper endpoint; only the
sentinel-begin cell can lower the lower endpoint to the reported last. -/
noncomputable def closedFormNegCrossTruncRevResidualTopLargeUnified
(r : RangeRead) (res : Result) : ConflictRange := by
classical
exact if negCrossTruncRevResidualTopLargeSentinel r res then
closedFormNegCrossTruncRevResidualTopLargeSentinel r res
else ⟨r.end_.key, ⊤⟩
/-- In the crossed large-gap subcell the shared form is the certified `[end_.key, ⊤)`
rule. -/
theorem closedFormNegCrossTruncRevResidualTopLargeUnified_eq_crossed
{r : RangeRead} {res : Result} (h : negCrossTruncRevResidualTopLargeCrossed r res) :
closedFormNegCrossTruncRevResidualTopLargeUnified r res =
closedFormNegCrossTruncRevResidualTopLargeCrossed r res := by
have hnot : ¬ negCrossTruncRevResidualTopLargeSentinel r res := by
rintro ⟨-, htop⟩
exact h.2.2 htop
unfold closedFormNegCrossTruncRevResidualTopLargeUnified
closedFormNegCrossTruncRevResidualTopLargeCrossed
rw [ite_eq_right hnot]
/-- In the sentinel-begin large-gap subcell the shared form is the certified
conditional rule. -/
theorem closedFormNegCrossTruncRevResidualTopLargeUnified_eq_sentinel
{r : RangeRead} {res : Result} (h : negCrossTruncRevResidualTopLargeSentinel r res) :
closedFormNegCrossTruncRevResidualTopLargeUnified r res =
closedFormNegCrossTruncRevResidualTopLargeSentinel r res := by
unfold closedFormNegCrossTruncRevResidualTopLargeUnified
rw [ite_eq_left h]
/-- The low reversed-truncated cells at `end_.offset ≤ 1`: the finite under-end range
`[last, end_.key)` (`Under`, `CrossedNonposSmall` and `CrossedSmall` are the same range
definitionally). -/
abbrev revTruncLeOneLow (r : RangeRead) (res : Result) : Prop :=
negCrossTruncRevUnder r res ∨ negCrossTruncRevCrossedNonposSmall r res ∨
negCrossTruncRevCrossedSmall r res
/-- The high reversed-truncated cells at `end_.offset ≤ 1`: the large-capacity range
`[last, begin.key)` (`CrossedNonposLarge` and `CrossedLarge` are the same range; the
sentinel-begin cell joins because its begin key is `⊤`). -/
abbrev revTruncLeOneHigh (r : RangeRead) (res : Result) : Prop :=
negCrossTruncRevBeginTop r res ∨ negCrossTruncRevCrossedNonposLarge r res ∨
negCrossTruncRevCrossedLarge r res
/-- The reversed-truncated cells with end offset at most one. The nonpositive and
offset-one groups share their closed forms definitionally, so they are merged into one
table. -/
noncomputable def conflictRangeClosedFormResidualRevTruncLeOne (r : RangeRead) (res : Result) :
ConflictRange :=
if revTruncLeOneLow r res then
closedFormNegCrossTruncRevUnder r res
else closedFormNegCrossTruncRevCrossedNonposLarge r res
/-- The top reversed-truncated cells at `end_.offset ≥ 2`: the unbounded range
`[last, ⊤)` (below-end first). -/
abbrev revTruncGeTwoTop (r : RangeRead) (res : Result) : Prop :=
negCrossTruncRevBelowEnd r res ∨ negCrossTruncRevResidualRoom r res ∨
negCrossTruncRevResidualTopCrossedSmallGap r res ∨
negCrossTruncRevResidualTopCrossed r res
/-- The large-gap reversed-truncated cells at `end_.offset ≥ 2`. -/
abbrev revTruncGeTwoLarge (r : RangeRead) (res : Result) : Prop :=
negCrossTruncRevResidualTopLargeCrossed r res ∨
negCrossTruncRevResidualTopLargeSentinel r res
/-- The reversed-truncated cells with end offset at least two. -/
noncomputable def conflictRangeClosedFormResidualRevTruncGeTwo (r : RangeRead) (res : Result) :
ConflictRange :=
if revTruncGeTwoTop r res then
closedFormNegCrossTruncRevBelowEnd r res
else if revTruncGeTwoLarge r res then
closedFormNegCrossTruncRevResidualTopLargeUnified r res
else closedFormNegCrossTruncRevResidualFiniteUnified r res
/-- The reversed-truncated part of the residual dispatcher, factored by the end offset.
The begin-zero crossed cell is checked first because it is offset-agnostic; the remaining
cells are grouped by `end_.offset ≤ 1` and `2 ≤ end_.offset`. The fallback is unreachable
on readable crossed nonpositive reversed-truncated reads (`nonposTruncRev_false`). -/
noncomputable def conflictRangeClosedFormResidualRevTrunc (r : RangeRead) (res : Result) :
ConflictRange :=
if zeroCrossTruncRevCrossed r res then closedFormZeroCrossTruncRevCrossed r res
else if r.end_.offset ≤ 1 then conflictRangeClosedFormResidualRevTruncLeOne r res
else conflictRangeClosedFormResidualRevTruncGeTwo r res
/-- The multi-row residual dispatcher, kept as the proof-side reference for the compact
closed form. The algorithm itself uses `compactCrossed`, whose body is this dispatcher
with the three sub-dispatchers inlined. -/
noncomputable def conflictRangeClosedFormResidualAux (r : RangeRead) (res : Result) :
ConflictRange :=
if res.more = false then
if r.reverse = false then
conflictRangeClosedFormResidualCompleteFwd r res
else
conflictRangeClosedFormResidualCompleteFwd { r with reverse := false }
{ keys := res.keys.reverse, more := false }
else if r.reverse = true then
conflictRangeClosedFormResidualRevTrunc r res
else
compactForwardTruncatedNonpos r res
open Classical in
/-- **The crossed nonpositive closed form, as a single self-contained function.** The
complete cells come from the shared `compactCrossedComplete` rule, used directly on a
forward read and on the flipped read for a reversed complete result. The reversed
truncation is one flat priority chain: the offset-agnostic begin-zero cell first, then the
`end_.offset ≤ 1` cells, then the `2 ≤ end_.offset` cells. The two groups are disjoint
because every `LeOne` cell carries `end_.offset ≤ 1` and every `GeTwo` cell carries
`2 ≤ end_.offset`, so no offset test is needed between them. The forward truncation falls
back to the certified compact rule. No branch calls the general or executable algorithm. -/
noncomputable def compactCrossed (r : RangeRead) (res : Result) : ConflictRange :=
if res.more = false then
if r.reverse = false then compactCrossedComplete r res
else compactCrossedComplete { r with reverse := false }
{ keys := res.keys.reverse, more := false }
else if r.reverse = true then
if zeroCrossTruncRevCrossed r res then closedFormZeroCrossTruncRevCrossed r res
else if revTruncLeOneLow r res then closedFormNegCrossTruncRevUnder r res
else if r.end_.offset ≤ 1 then closedFormNegCrossTruncRevCrossedNonposLarge r res
else if revTruncGeTwoTop r res then closedFormNegCrossTruncRevBelowEnd r res
else if revTruncGeTwoLarge r res then closedFormNegCrossTruncRevResidualTopLargeUnified r res
else closedFormNegCrossTruncRevResidualFiniteUnified r res
else compactForwardTruncatedNonpos r res
/-- The crossed nonpositive closed form is the single entry point: the legacy name
`conflictRangeClosedFormResidual` is now a one-line alias. -/
noncomputable def conflictRangeClosedFormResidual (r : RangeRead) (res : Result) :
ConflictRange :=
compactCrossed r res
/-- The single closed form is definitionally the legacy residual name. -/
theorem compactCrossed_eq_residual (r : RangeRead) (res : Result) :
compactCrossed r res = conflictRangeClosedFormResidual r res :=
rfl
/-- The single closed form agrees with the multi-row proof-side dispatcher. The complete
and forward-truncated branches are definitional; on the reversed-truncated branch the flat
chain agrees with the offset-split tables because every `LeOne` cell carries
`end_.offset ≤ 1` and every `GeTwo` cell carries `2 ≤ end_.offset`. -/
theorem compactCrossed_eq_residualAux (r : RangeRead) (res : Result) :
compactCrossed r res = conflictRangeClosedFormResidualAux r res := by
classical
unfold compactCrossed conflictRangeClosedFormResidualAux
by_cases hmore : res.more = false
· simp only [ite_eq_left hmore]
by_cases hrev : r.reverse = false
· simp only [ite_eq_left hrev]
rfl
· simp only [ite_eq_right hrev]
rfl
· simp only [ite_eq_right hmore]
by_cases hrev : r.reverse = true
· simp only [ite_eq_left hrev]
unfold conflictRangeClosedFormResidualRevTrunc
conflictRangeClosedFormResidualRevTruncLeOne
conflictRangeClosedFormResidualRevTruncGeTwo
by_cases hz : zeroCrossTruncRevCrossed r res
· simp only [ite_eq_left hz]
· simp only [ite_eq_right hz]
by_cases hle : r.end_.offset ≤ 1
· simp only [ite_eq_left hle]
· simp only [ite_eq_right hle]
have hlow : ¬ revTruncLeOneLow r res := by
rintro (h | h | h)
· exact absurd h.2.2.2.2.2.2 hle
· exact absurd h.2.2.2.2.2.2.1 (by omega)
· exact absurd (le_of_eq h.2.2.2.2.2.2.1) hle
simp only [ite_eq_right hlow]
· simp only [ite_eq_right hrev]
/-- The genuinely closed total dispatcher. It factors through the compact top-level
split: the empty result, the positive-offset algorithm, and the clamped nonpositive
algorithm are each certified separately, and the remaining crossed complete,
reversed-truncated, and forward-truncated cells are answered by the single closed form
`compactCrossed` (whose own fallback is the certified compact forward-truncation rule).
No branch calls the general or executable algorithm. -/
noncomputable def conflictRangeClosedFormClosed (r : RangeRead) (res : Result) : ConflictRange :=
if res.keys = [] then emptyValue r
else if 1 ≤ r.begin.offset then compactPositive r res
else if clampedNonpos r res then compactClamped r res
else compactCrossed r res
/-- Coverage of the nonpositive-begin crossed complete forward cell by the closed-form
dispatcher predicates: if all the corresponding predicates fail, there is no readable
forward complete result. -/
theorem nonposCompleteForward_false {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key)
(h_ov : ¬ zeroCrossOvershootComplete r res)
(h_e1 : ¬ zeroCrossEndOne r res)
(h_e1l : ¬ zeroCrossEndOneLong r res)
(h_en : ¬ zeroCrossEndNonpos r res)
(h_ue : ¬ zeroCrossUnderEnd r res)
(h_lt : ¬ zeroCrossLongTop r res)
(h_lf : ¬ zeroCrossLongFinite r res)
(h_low : ¬ negCrossLowFwd r res)
(h_lge : ¬ negCrossClampNonposLastGe r res)
(h_bot : ¬ negCrossClampNonposBottom r res)
(h_nc : ¬ negCrossNonclampNonpos r res)
(h_cl : ¬ negCrossClampLongNonpos r res)
(h_ncl : ¬ negCrossNonclampLongNonpos r res)
(h_eo : ¬ negCrossEndOne r res)
(h_eol : ¬ negCrossEndOneLong r res)
(h_ce : ¬ negCrossClampEndOne r res)
(h_ov2 : ¬ negCrossOvershoot r res)
(h_hs : ¬ negCrossCompleteHighSmall r res)
(h_hf : ¬ negCrossCompleteHighClampFinite r res)
(h_res : ¬ negCrossCompleteResidual r res) : False := by
classical
obtain ⟨db, hcomp⟩ := hread
have hread' : Readable r res := ⟨db, hcomp⟩
have hlastle : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) :=
fun k hk => WithTop.coe_le_coe.mpr
(le_getLastD_of_pairwise (RangeRead.compatible_sortedLT hcomp hrev).pairwise hk)
have hcrossL : ((leastReported r res : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcross
by_cases h0 : r.begin.offset = 0
· -- begin offset zero
by_cases hend0 : r.end_.offset ≤ 0
· exact h_en ⟨h0, hmore, hrev, hend0, hne, hcrossL⟩
· have hend1 : 1 ≤ r.end_.offset := by omega
by_cases hend1eq : r.end_.offset = 1
· by_cases hBE : r.begin.key ≤ r.end_.key
· exact h_e1 ⟨h0, hmore, hrev, hend1eq, hne, hcrossL, hBE⟩
· exact h_e1l ⟨h0, hmore, hrev, hend1eq, hne, hcrossL, not_le.mp hBE⟩
· have hend2 : 2 ≤ r.end_.offset := by omega
by_cases hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
· exact h_ov ⟨h0, hmore, hrev, ⟨hend2, hne, hhi⟩, hcrossL⟩
· have hElast : r.end_.key ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by
push Not at hhi
obtain ⟨k, hk, hkge⟩ := hhi
exact le_trans hkge (hlastle k hk)
by_cases hBE : r.begin.key ≤ r.end_.key
· exact h_ue ⟨h0, hmore, hrev, hend2, hne, hcrossL, hBE⟩
· have hEB : r.end_.key < r.begin.key := not_le.mp hBE
by_cases hBtop : r.begin.key = (⊤ : WithTop Key)
· exact h_lt ⟨h0, hmore, hrev, hend2, hne, hBtop⟩
· exact h_lf ⟨h0, hmore, hrev, hend2, hne, hBtop, hEB, hcrossL⟩
· have hneg : r.begin.offset < 0 := by omega
by_cases hend0 : r.end_.offset ≤ 0
· -- end offset nonpositive
by_cases hnonclamp : beginSlack r < reportedBelowBegin r res
· exact h_low ⟨hrev, hneg, hmore, hne, hend0, hcross, hnonclamp⟩
· have hclamp : reportedBelowBegin r res ≤ beginSlack r := not_lt.mp hnonclamp
by_cases hlastB : r.begin.key ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
· exact h_lge ⟨hrev, hneg, hmore, hne, hend0, hcross, hlastB, hclamp⟩
· have hlastlt : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) <
r.begin.key := not_le.mp hlastB
by_cases hBE : r.begin.key ≤ r.end_.key
· by_cases hbot : clampNonposBottom r res
· exact h_bot ⟨hrev, hneg, hmore, hne, hend0, hBE, hcross, hbot⟩
· exact h_nc ⟨hrev, hneg, hmore, hne, hend0, hBE, hcross, hclamp, hbot⟩
· have hEB : r.end_.key < r.begin.key := not_le.mp hBE
by_cases hbot : clampNonposBottom r res
· exact h_cl ⟨hrev, hneg, hmore, hne, hend0, hcross, hclamp, hbot, hEB⟩
· exact h_ncl ⟨hrev, hneg, hmore, hne, hend0, hcross, hclamp, hbot, hEB⟩
· have hendpos : 1 ≤ r.end_.offset := by omega
by_cases hend1eq : r.end_.offset = 1
· by_cases hnonclamp : beginSlack r < reportedBelowBegin r res
· by_cases hBE : r.begin.key ≤ r.end_.key
· exact h_eo ⟨hrev, hneg, hmore, hne, hend1eq, hcross, hnonclamp, hBE⟩
· exact h_eol ⟨hrev, hneg, hmore, hne, hend1eq, hcross, hnonclamp,
not_le.mp hBE⟩
· have hclamp : reportedBelowBegin r res ≤ beginSlack r := not_lt.mp hnonclamp
exact h_ce ⟨hrev, hneg, hmore, hne, hend1eq, hcross, hclamp⟩
· have hend2 : 2 ≤ r.end_.offset := by omega
by_cases hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
· exact h_ov2 ⟨hrev, hneg, hmore, hne, hend2, hhi, hcross⟩
· have hElast : r.end_.key ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by
push Not at hhi
obtain ⟨k, hk, hkge⟩ := hhi
exact le_trans hkge (hlastle k hk)
by_cases hEH : r.end_.key < ((res.keys.headD ([] : Key) : Key) : WithTop Key)
· have hhigh : negCrossCompleteHigh r res :=
⟨hrev, hneg, hmore, hne, hend2, hcross, hEH⟩
have htle := high_length_le_end hread' hrev hmore hne hend2 hEH
by_cases hte : res.keys.length = (r.end_.offset - 1).toNat
· by_cases hclamp : reportedBelowBegin r res ≤ beginSlack r
· exact h_hf ⟨hhigh, hclamp, hte⟩
· exact h_hs (Or.inr (Or.inl ⟨hhigh, not_le.mp hclamp, hte⟩))
· have htlt : res.keys.length < (r.end_.offset - 1).toNat :=
lt_of_le_of_ne htle hte
by_cases hclamp : reportedBelowBegin r res ≤ beginSlack r
· exact h_hs (Or.inl ⟨hhigh, hclamp, htlt⟩)
· exact h_hs (Or.inr (Or.inr ⟨hhigh, not_le.mp hclamp, htlt⟩))
· have hEHle : ((res.keys.headD ([] : Key) : Key) : WithTop Key) ≤
r.end_.key := not_lt.mp hEH
exact h_res ⟨hrev, hneg, hmore, hne, hend2, hcross, hEHle, hElast⟩
/-- Coverage of the nonpositive-begin crossed complete reversed cell by the closed-form
dispatcher predicates. -/
theorem nonposCompleteReverse_false {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key)
(h_zcr : ¬ zeroCrossCompleteRev r res)
(h_ovr : ¬ negCrossOvershootRev r res)
(h_lowr : ¬ negCrossLowFwdRev r res)
(h_lger : ¬ negCrossClampNonposLastGeRev r res)
(h_botr : ¬ negCrossClampNonposBottomRev r res)
(h_ncr : ¬ negCrossNonclampNonposRev r res)
(h_clr : ¬ negCrossClampLongNonposRev r res)
(h_nclr : ¬ negCrossNonclampLongNonposRev r res)
(h_eor : ¬ negCrossEndOneRev r res)
(h_eolr : ¬ negCrossEndOneLongRev r res)
(h_cer : ¬ negCrossClampEndOneRev r res)
(h_hr : ¬ negCrossCompleteHighRev r res)
(h_resr : ¬ negCrossCompleteResidualRev r res) : False := by
classical
obtain ⟨db, hcomp⟩ := hread
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 hcountP : (res.keys.reverse).countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
res.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) :=
List.Perm.countP_eq _ (List.reverse_perm res.keys)
have hcrossL : ((leastReported r res : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcross
by_cases h0 : r.begin.offset = 0
· exact h_zcr ⟨h0, hmore, hrev, hne, hcrossL⟩
· have hneg : r.begin.offset < 0 := by omega
apply nonposCompleteForward_false
(r := { r with reverse := false })
(res := { keys := res.keys.reverse, more := false })
· exact ⟨db, (compatible_flip (db := db) (b := true) hrev hmore).mpr hcomp⟩
· rfl
· rfl
· exact hne'
· simpa using hbegin
· simpa [hheadD] using hcross
· intro h; exact h0 (by simpa using h.1)
· intro h; exact h0 (by simpa using h.1)
· intro h; exact h0 (by simpa using h.1)
· intro h; exact h0 (by simpa using h.1)
· intro h; exact h0 (by simpa using h.1)
· intro h; exact h0 (by simpa using h.1)
· intro h; exact h0 (by simpa using h.1)
· intro h
obtain ⟨-, -, -, -, hend, hcross', hnonclamp⟩ := h
refine h_lowr ⟨hrev, hneg, hmore, hne, hend, ?_, ?_⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hnonclamp
· intro h
obtain ⟨-, -, -, -, hend, hcross', hlastB, hclamp⟩ := h
refine h_lger ⟨hrev, hneg, hmore, hne, hend, ?_, ?_, ?_⟩
· simpa [hheadD] using hcross'
· simpa [hlastD] using hlastB
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hclamp
· intro h
obtain ⟨-, -, -, -, hend, hBE, hcross', hbottom⟩ := h
refine h_botr ⟨hrev, hneg, hmore, hne, hend, hBE, ?_, ?_⟩
· simpa [hheadD] using hcross'
· simpa only [clampNonposBottom, clampNonposD, beginSlack, reportedBelowBegin, hcountP]
using hbottom
· intro h
obtain ⟨-, -, -, -, hend, hBE, hcross', hclamp, hnotbottom⟩ := h
refine h_ncr ⟨hrev, hneg, hmore, hne, hend, hBE, ?_, ?_, ?_⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hclamp
· simpa only [clampNonposBottom, clampNonposD, beginSlack, reportedBelowBegin, hcountP]
using hnotbottom
· intro h
obtain ⟨-, -, -, -, hend, hcross', hclamp, hbottom, hlong⟩ := h
refine h_clr ⟨hrev, hneg, hmore, hne, hend, ?_, ?_, ?_, hlong⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hclamp
· simpa only [clampNonposBottom, clampNonposD, beginSlack, reportedBelowBegin, hcountP]
using hbottom
· intro h
obtain ⟨-, -, -, -, hend, hcross', hclamp, hnotbottom, hlong⟩ := h
refine h_nclr ⟨hrev, hneg, hmore, hne, hend, ?_, ?_, ?_, hlong⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hclamp
· simpa only [clampNonposBottom, clampNonposD, beginSlack, reportedBelowBegin, hcountP]
using hnotbottom
· intro h
obtain ⟨-, -, -, -, hend, hcross', hnonclamp, hBE⟩ := h
refine h_eor ⟨hrev, hneg, hmore, hne, hend, ?_, ?_, hBE⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hnonclamp
· intro h
obtain ⟨-, -, -, -, hend, hcross', hnonclamp, hlong⟩ := h
refine h_eolr ⟨hrev, hneg, hmore, hne, hend, ?_, ?_, hlong⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hnonclamp
· intro h
obtain ⟨-, -, -, -, hend, hcross', hclamp⟩ := h
refine h_cer ⟨hrev, hneg, hmore, hne, hend, ?_, ?_⟩
· simpa [hheadD] using hcross'
· simpa only [beginSlack, reportedBelowBegin, hcountP] using hclamp
· intro h
obtain ⟨-, -, -, -, hend, hhi, hcross'⟩ := h
exact h_ovr ⟨hrev, hneg, hmore, hne, hend,
(fun k hk => hhi k (by simpa using hk)), by simpa [hheadD] using hcross'⟩
· intro h
rcases h with hc | hc | hc
· exact h_hr ⟨hrev, hmore, hne, hc.1⟩
· exact h_hr ⟨hrev, hmore, hne, hc.1⟩
· exact h_hr ⟨hrev, hmore, hne, hc.1⟩
· intro h
exact h_hr ⟨hrev, hmore, hne, h.1⟩
· intro h
obtain ⟨-, -, -, -, hend, hcross', hheadE, hEL⟩ := h
exact h_resr ⟨hrev, hneg, hmore, hne, hend, by simpa [hheadD] using hcross',
by simpa [hheadD] using hheadE, by simpa [hlastD] using hEL⟩
/-- Reported-key count bound: at a positive end offset, a compatible result reports at
most `end.offset - 1` keys at or above `end.key`. -/
theorem reportedCount_le_endOffset {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hend : 1 ≤ r.end_.offset) :
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤
(r.end_.offset - 1).toNat := by
have hpre := (RangeRead.compatible_keys_prefix hcomp).sublist
exact le_trans (List.Sublist.countP_le hpre)
(completeKeys_count_ge_le_end_offset (db := db) (r := r) hend)
/-- In a strictly descending list, the last entry is at most the head. -/
theorem getLastD_le_headD_of_sortedGT {res : Result} (hne : res.keys ≠ [])
(hsort : res.keys.SortedGT) :
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤
((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
rw [getLastD_eq_getLast_of_ne hne, headD_eq_head_of_ne hne]
exact WithTop.coe_le_coe.mpr
((hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne))
/-- In a strictly descending list, every entry is at most the head. -/
theorem le_headD_of_sortedGT {res : Result} (hne : res.keys ≠ [])
(hsort : res.keys.SortedGT) :
∀ k ∈ res.keys, ((k : Key) : WithTop Key) ≤
((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
intro k hk
rw [headD_eq_head_of_ne hne]
exact WithTop.coe_le_coe.mpr
((hsort.pairwise.imp le_of_lt).rel_head hk)
/-- In a strictly descending list, the last entry is at most every entry. -/
theorem getLastD_le_of_sortedGT {res : Result} (hne : res.keys ≠ [])
(hsort : res.keys.SortedGT) :
∀ k ∈ res.keys, ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤
((k : Key) : WithTop Key) := by
intro k hk
rw [getLastD_eq_getLast_of_ne hne]
exact WithTop.coe_le_coe.mpr
((hsort.pairwise.imp le_of_lt).rel_getLast hk)
/-- Complement of a capacity bound in `ℕ∞`. -/
theorem capacity_complement {a b : ℕ∞} (h : ¬ a ≤ b + 1) : b + 2 ≤ a := by
have h1 : b + 1 < a := not_le.mp h
have hne : b + 1 ≠ ⊤ := by
intro hb
rw [hb] at h1
exact (not_lt_of_ge le_top) h1
have h2 : (b + 1) + 1 ≤ a := (ENat.add_one_le_iff hne).mpr h1
calc b + 2 = b + (1 + 1) := by rw [one_add_one_eq_two]
_ = (b + 1) + 1 := by rw [add_assoc]
_ ≤ a := h2
/-- Coverage of the nonpositive-begin crossed reversed truncated cell by the closed-form
dispatcher predicates. -/
theorem nonposTruncRev_false {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key)
(h_zc : ¬ zeroCrossTruncRevCrossed r res)
(h_be : ¬ negCrossTruncRevBelowEnd r res)
(h_cs : ¬ negCrossTruncRevCrossedSmall r res)
(h_cl : ¬ negCrossTruncRevCrossedLarge r res)
(h_un : ¬ negCrossTruncRevUnder r res)
(h_cns : ¬ negCrossTruncRevCrossedNonposSmall r res)
(h_cnl : ¬ negCrossTruncRevCrossedNonposLarge r res)
(h_tcs : ¬ negCrossTruncRevResidualTopCrossedSmallGap r res)
(h_tc : ¬ negCrossTruncRevResidualTopCrossed r res)
(h_tlc : ¬ negCrossTruncRevResidualTopLargeCrossed r res)
(h_tls : ¬ negCrossTruncRevResidualTopLargeSentinel r res)
(h_fuc : ¬ negCrossTruncRevResidualFiniteUnderCrossed r res)
(h_func : ¬ negCrossTruncRevResidualFiniteUnderNotCrossed r res)
(h_fo : ¬ negCrossTruncRevResidualFiniteOver r res) : False := by
classical
obtain ⟨db, hcomp⟩ := hread
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
set L : Key := res.keys.getLastD ([] : Key) with hLdef
set H : Key := res.keys.headD ([] : Key) with hHdef
set cnt : ℕ := res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hcntdef
set e : ℕ := (r.end_.offset - 1).toNat with hedef
have hcrossL : ((L : Key) : WithTop Key) < r.begin.key := by
rw [hLdef]; exact hcross
by_cases h0 : r.begin.offset = 0
· exact h_zc ⟨h0, hrev, hmore, hne,
by simpa [leastReported, hrev, hLdef] using hcrossL⟩
· have hneg : r.begin.offset < 0 := by omega
by_cases hend0 : r.end_.offset ≤ 0
· by_cases hEB : r.end_.key < r.begin.key
· by_cases hsmall : intervalCard r.end_.key r.begin.key +
(res.keys.length : ℕ∞) + ((1 - r.end_.offset).toNat : ℕ∞) ≤
(beginSlack r : ℕ∞) + 1
· exact h_cns ⟨hmore, hrev, hneg, hne, hcrossL, hEB, hend0, hsmall⟩
· exact h_cnl ⟨hmore, hrev, hneg, hne, hcrossL, hEB, hend0,
capacity_complement hsmall⟩
· exact h_un ⟨hmore, hrev, hneg, hne, hcrossL, not_lt.mp hEB, by omega⟩
· by_cases hend1eq : r.end_.offset = 1
· by_cases hEB : r.end_.key < r.begin.key
· by_cases hsmall : intervalCard r.end_.key r.begin.key +
(res.keys.length : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1
· exact h_cs ⟨hmore, hrev, hneg, hne, hcrossL, hEB, hend1eq, hsmall⟩
· exact h_cl ⟨hmore, hrev, hneg, hne, hcrossL, hEB, hend1eq,
capacity_complement hsmall⟩
· exact h_un ⟨hmore, hrev, hneg, hne, hcrossL, not_lt.mp hEB, by omega⟩
· have hend2 : 2 ≤ r.end_.offset := by omega
have hcnt_le : cnt ≤ e := by
rw [hcntdef, hedef]
exact reportedCount_le_endOffset hcomp (by omega)
by_cases hEtop : r.end_.key = (⊤ : WithTop Key)
· -- the sentinel end is subsumed by the under / below-end cells
by_cases hoff : r.end_.offset ≤ 1
· exact h_un ⟨hmore, hrev, hneg, hne, hcrossL, by rw [hEtop]; exact le_top, hoff⟩
· exact h_be ⟨hmore, hrev, hneg, hne, hcrossL, by omega, by
intro k hk; rw [hEtop]; exact WithTop.coe_lt_top _⟩
· by_cases hLE : ((L : Key) : WithTop Key) ≤ r.end_.key
· by_cases hcntlt : cnt < e
· exact h_tc ⟨hmore, hrev, hneg, hne, hend2, hLE,
by simpa [hcntdef, hedef] using hcntlt⟩
· have hcnte : cnt = e := le_antisymm hcnt_le (not_lt.mp hcntlt)
have hbase : negCrossTruncRevResidualFiniteUnder r res :=
⟨hmore, hrev, hneg, hne, hend2, hLE, hcrossL,
by simpa [hcntdef, hedef] using hcnte⟩
by_cases hka : (((keyAfter H : Key)) : WithTop Key) < r.begin.key
· exact h_fuc ⟨hbase, by simpa [hHdef] using hka⟩
· exact h_func ⟨hbase, by simpa [hHdef] using hka⟩
· have hEL : r.end_.key < ((L : Key) : WithTop Key) := not_le.mp hLE
by_cases hcnte : cnt = e
· exact h_fo ⟨hmore, hrev, hneg, hne, hend2, hEL, hcrossL,
by simpa [hcntdef, hedef] using hcnte⟩
· have hcntlt : cnt < e := lt_of_le_of_ne hcnt_le hcnte
by_cases hcap : ((e : ℕ) : ℕ∞) ≤
intervalCard r.end_.key ((L : Key) : WithTop Key) +
(res.keys.length : ℕ∞)
· have hlarge : negCrossTruncRevResidualTopLarge r res :=
⟨hmore, hrev, hneg, hne, hend2, hEL,
by simpa [hcntdef, hedef] using hcntlt,
by simpa [hedef, hLdef] using hcap⟩
by_cases hBtop : r.begin.key = (⊤ : WithTop Key)
· exact h_tls ⟨hlarge, hBtop⟩
· exact h_tlc ⟨hlarge, hcrossL, hBtop⟩
· have hsmallgap : negCrossTruncRevResidualTopCrossedSmallGap r res :=
⟨hmore, hrev, hneg, hne, hend2, hEL, by
have hh : intervalCard r.end_.key ((L : Key) : WithTop Key) +
(res.keys.length : ℕ∞) < ((e : ℕ) : ℕ∞) := not_le.mp hcap
simpa [hedef, hLdef] using hh⟩
exact h_tcs hsmallgap
/-- The cross-free nonpositive complete predicate is false on a crossed read. -/
theorem not_nonposCompleteCrossFree_of_crossed {r : RangeRead} {res : Result}
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
¬ nonposCompleteCrossFree r res := by
rintro ⟨-, -, -, hle⟩
exact absurd hle (not_le.mpr hcross)
/-- The cross-free nonpositive reversed-truncated predicate is false on a crossed
read. -/
theorem not_nonposRevTrunc_of_crossed {r : RangeRead} {res : Result}
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
¬ nonposRevTrunc r res := by
rintro ⟨-, -, -, hle⟩
exact absurd hle (not_le.mpr hcross)
/-- `negCrossTruncRevBeginTopGeTwo` is subsumed by `negCrossTruncRevBelowEnd`. -/
theorem negCrossTruncRevBelowEnd_of_beginTopGeTwo {r : RangeRead} {res : Result}
(h : negCrossTruncRevBeginTopGeTwo r res) : negCrossTruncRevBelowEnd r res := by
obtain ⟨hm, hrev, hneg, hne, hBtop, hend2, hendlt, hbelow⟩ := h
refine ⟨hm, hrev, hneg, hne, ?_, hend2, hbelow⟩
rw [hBtop]
exact WithTop.coe_lt_top _
/-- `negCrossTruncRevTop` is subsumed by `negCrossTruncRevUnder` or
`negCrossTruncRevBelowEnd`. -/
theorem negCrossTruncRevUnder_or_belowEnd_of_top {r : RangeRead} {res : Result}
(h : negCrossTruncRevTop r res) :
negCrossTruncRevUnder r res ∨ negCrossTruncRevBelowEnd r res := by
obtain ⟨hm, hrev, hneg, hne, hcross, hEtop⟩ := h
by_cases hoff : r.end_.offset ≤ 1
· left
exact ⟨hm, hrev, hneg, hne, hcross, by rw [hEtop]; exact le_top, hoff⟩
· right
have hend2 : 2 ≤ r.end_.offset := by omega
refine ⟨hm, hrev, hneg, hne, hcross, hend2, ?_⟩
intro k hk
rw [hEtop]
exact WithTop.coe_lt_top _
set_option maxHeartbeats 0 in
-- This declaration performs an expensive finite case analysis.
/-- **The residual dispatcher is minimal on the residual region.** The residual is
crossed and either complete or reversed truncated, so all forward-truncated, clamped and
cross-free branches have already been discharged by the compact certificates. -/
theorem minimal_conflictRangeClosedFormResidualCompleteFwd {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false)
(hempty : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key) :
Minimal r res (conflictRangeClosedFormResidualCompleteFwd r res) := by
classical
unfold conflictRangeClosedFormResidualCompleteFwd compactCrossedComplete
by_cases h1 : crossedCompleteOvershoot r res
· rw [ite_eq_left h1]
rcases h1 with h1 | h1
· rw [closedFormNegCrossTopUnified_eq_zeroCross h1]
exact minimal_closedForm_of_zeroCross_overshoot hread h1
· rw [closedFormNegCrossTopUnified_eq_negCross h1]
have hcross' : ((res.keys.head h1.2.2.2.1 : Key) : WithTop Key) < r.begin.key := by
have h := h1.2.2.2.2.2.2
rwa [headD_eq_head_of_ne h1.2.2.2.1] at h
exact minimal_closedForm_of_negCross_overshoot hread h1.1 h1.2.1
h1.2.2.1 h1.2.2.2.1 h1.2.2.2.2.1 h1.2.2.2.2.2.1 hcross'
· rw [ite_eq_right h1]
by_cases h2 : crossedCompleteEndLeOne r res
· rw [ite_eq_left h2]
have h2' := (crossedCompleteEndLeOne_iff r res).mp h2
rcases h2' with h2 | h2 | h2 | h2 | h2 | h2 | h2 | h2
· rw [closedFormNegCrossNonclampUnified_eq_zeroCrossEndOne h2]
exact minimal_closedForm_of_zeroCross_endOne hread h2
· rw [closedFormNegCrossNonclampUnified_eq_zeroCrossEndNonpos hread h2]
exact minimal_closedForm_of_zeroCross_endNonpos hread h2
· rw [closedFormNegCrossNonclampUnified_eq_zeroCrossEndOneLong h2]
exact minimal_closedForm_of_zeroCross_endOne_long hread h2
· have hcell := h2
obtain ⟨hrev7, hbeg7, hmore7, hne7, hend7, hcrossD7, hnonclamp7⟩ := h2
obtain ⟨db₀, hcomp₀⟩ := hread
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne7 :=
headD_eq_head_of_ne hne7
have hcross7 : ((res.keys.head hne7 : Key) : WithTop Key) < r.begin.key := by
rw [← hheadD]; exact hcrossD7
have hBleE : r.begin.key ≤ r.end_.key :=
negCross_begin_le_end hcomp₀ hrev7 hmore7 hne7 hbeg7 hcross7 hnonclamp7 hend7
rw [closedFormNegCrossNonclampUnified_eq_of_le hBleE]
exact minimal_closedForm_of_negCross_lowFwd ⟨db₀, hcomp₀⟩ hcell
· rw [closedFormNegCrossNonclampUnified_eq_of_le h2.2.2.2.2.2.2.2]
exact minimal_closedForm_of_negCross_endOne hread h2
· rw [closedFormNegCrossNonclampUnified_eq_of_le h2.2.2.2.2.2.1]
exact minimal_closedForm_of_negCross_nonclamp_nonpos hread h2
· rw [closedFormNegCrossNonclampUnified_eq_of_lt h2.2.2.2.2.2.2.2]
exact minimal_closedForm_of_negCross_endOne_long hread h2
· rw [closedFormNegCrossNonclampUnified_eq_of_lt h2.2.2.2.2.2.2.2.2]
exact minimal_closedForm_of_negCross_nonclamp_long_nonpos hread h2
· rw [ite_eq_right h2]
by_cases h4 : crossedCompleteBeginZero r res
· rw [ite_eq_left h4]
by_cases h5 : zeroCrossUnderEnd r res
· rw [closedFormZeroCrossResidual_eq_under h5]
exact minimal_closedForm_of_zeroCross_underEnd hread h5
· have h5' : zeroCrossLongTop r res ∨ zeroCrossLongFinite r res := by
rcases h4 with h | h | h
· exact absurd h h5
· exact Or.inl h
· exact Or.inr h
rw [closedFormZeroCrossResidual_eq_long h5 h5']
rcases h5' with h5' | h5'
· exact minimal_closedForm_of_zeroCross_longTop hread h5'
· exact minimal_closedForm_of_zeroCross_longFinite hread h5'
· rw [ite_eq_right h4]
by_cases h9 : crossedCompleteClamp r res
· rw [ite_eq_left h9]
by_cases he : negCrossClampEndOne r res
· rw [closedFormNegCrossClampUnified_eq_endOne he]
exact minimal_closedForm_of_negCross_clampEndOne hread he
· by_cases hb : negCrossHeadBottom r res ∨ negCrossClampNonposInfinite r res ∨
negCrossClampNonposLastGe r res ∨ negCrossClampNonposBottom r res
· rw [closedFormNegCrossClampUnified_eq_bottom hb]
rcases hb with hb | hb | hb | hb
· exact minimal_closedForm_of_negCross_headBottom hread hb
· exact minimal_closedForm_of_negCross_clampNonpos_infinite hread hb
· exact minimal_closedForm_of_negCross_clampNonpos_lastGe hread hb
· exact minimal_closedForm_of_negCross_clampNonpos_bottom hread hb
· have hl : negCrossClampLongNonpos r res := by
rcases h9 with h | h | h | h | h | h
· exact absurd h he
· exact absurd (Or.inl h) hb
· exact absurd (Or.inr (Or.inl h)) hb
· exact absurd (Or.inr (Or.inr (Or.inl h))) hb
· exact absurd (Or.inr (Or.inr (Or.inr h))) hb
· exact h
rw [closedFormNegCrossClampUnified_eq_long hb hl]
exact minimal_closedForm_of_negCross_clamp_long_nonpos hread hl
· rw [ite_eq_right h9]
by_cases h12 : negCrossCompleteHigh r res
· rw [closedFormNegCrossCompleteHighResidual_eq_high h12]
exact minimal_closedForm_of_negCrossCompleteHigh hread h12
· rw [closedFormNegCrossCompleteHighResidual_eq_residual h12]
by_cases h13 : negCrossCompleteResidual r res
· exact minimal_closedForm_of_negCross_complete_residual hread h13
· exfalso
exact nonposCompleteForward_false hread hmore hrev hempty hbegin hcross
(fun h => h1 (Or.inl h))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inl h)))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inr (Or.inl h)))))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inl h))))
(fun h => h4 (Or.inl h))
(fun h => h4 (Or.inr (Or.inl h)))
(fun h => h4 (Or.inr (Or.inr h)))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inr (Or.inr
(Or.inl h))))))
(fun h => h9 (Or.inr (Or.inr (Or.inr (Or.inl h)))))
(fun h => h9 (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl h))))))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inr (Or.inr
(Or.inr (Or.inr (Or.inl h))))))))
(fun h => h9 (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr h))))))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inr (Or.inr
(Or.inr (Or.inr (Or.inr (Or.inr h)))))))))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inr (Or.inr
(Or.inr (Or.inl h)))))))
(fun h => h2 ((crossedCompleteEndLeOne_iff r res).mpr (Or.inr (Or.inr (Or.inr
(Or.inr (Or.inr (Or.inr (Or.inl h)))))))))
(fun h => h9 (Or.inl h))
(fun h => h1 (Or.inr h))
(fun h => by
rcases h with h | h | h
· exact h12 h.1
· exact h12 h.1
· exact h12 h.1)
(fun h => h12 h.1) h13
theorem minimal_conflictRangeClosedFormResidualRevTruncLeOne {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hempty : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key)
(h_zc : ¬ zeroCrossTruncRevCrossed r res) (hend : r.end_.offset ≤ 1) :
Minimal r res (conflictRangeClosedFormResidualRevTruncLeOne r res) := by
classical
unfold conflictRangeClosedFormResidualRevTruncLeOne
by_cases h1 : revTruncLeOneLow r res
· rw [ite_eq_left h1]
rcases h1 with h1 | h1 | h1
· exact minimal_closedForm_of_negCross_trunc_rev_under hread h1
· exact minimal_closedForm_of_negCross_trunc_rev_crossedNonpos_small hread h1
· exact minimal_closedForm_of_negCross_trunc_rev_crossedSmall hread h1
· rw [ite_eq_right h1]
by_cases h4 : revTruncLeOneHigh r res
· rcases h4 with h4 | h4 | h4
· rw [closedFormNegCrossTruncRevCrossedNonposLarge_eq_beginTop h4]
exact minimal_closedForm_of_negCross_trunc_rev_beginTop hread h4
· exact minimal_closedForm_of_negCross_trunc_rev_crossedNonpos_large hread h4
· exact minimal_closedForm_of_negCross_trunc_rev_crossedLarge hread h4
· exfalso
have hbe : ¬ negCrossTruncRevBelowEnd r res := fun h => by
unfold negCrossTruncRevBelowEnd at h
omega
have htcs : ¬ negCrossTruncRevResidualTopCrossedSmallGap r res := fun h => by
unfold negCrossTruncRevResidualTopCrossedSmallGap at h
omega
have htc : ¬ negCrossTruncRevResidualTopCrossed r res := fun h => by
unfold negCrossTruncRevResidualTopCrossed at h
omega
have htlc : ¬ negCrossTruncRevResidualTopLargeCrossed r res := fun h => by
unfold negCrossTruncRevResidualTopLargeCrossed negCrossTruncRevResidualTopLarge at h
omega
have htls : ¬ negCrossTruncRevResidualTopLargeSentinel r res := fun h => by
unfold negCrossTruncRevResidualTopLargeSentinel negCrossTruncRevResidualTopLarge at h
omega
have hfuc : ¬ negCrossTruncRevResidualFiniteUnderCrossed r res := fun h => by
unfold negCrossTruncRevResidualFiniteUnderCrossed negCrossTruncRevResidualFiniteUnder at h
omega
have hfunc : ¬ negCrossTruncRevResidualFiniteUnderNotCrossed r res := fun h => by
unfold negCrossTruncRevResidualFiniteUnderNotCrossed negCrossTruncRevResidualFiniteUnder
at h
omega
have hfo : ¬ negCrossTruncRevResidualFiniteOver r res := fun h => by
unfold negCrossTruncRevResidualFiniteOver at h
omega
exact nonposTruncRev_false hread hmore hrev hempty hbegin hcross h_zc hbe
(fun h => h1 (Or.inr (Or.inr h)))
(fun h => h4 (Or.inr (Or.inr h)))
(fun h => h1 (Or.inl h))
(fun h => h1 (Or.inr (Or.inl h)))
(fun h => h4 (Or.inr (Or.inl h)))
htcs htc htlc htls hfuc hfunc hfo
theorem minimal_conflictRangeClosedFormResidualRevTruncGeTwo {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hempty : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key)
(h_zc : ¬ zeroCrossTruncRevCrossed r res) (hend : 2 ≤ r.end_.offset) :
Minimal r res (conflictRangeClosedFormResidualRevTruncGeTwo r res) := by
classical
unfold conflictRangeClosedFormResidualRevTruncGeTwo
by_cases h1 : revTruncGeTwoTop r res
· rw [ite_eq_left h1]
rcases h1 with h1 | h1 | h1 | h1
· exact minimal_closedForm_of_negCross_trunc_rev_belowEnd hread h1
· exact minimal_closedForm_of_negCross_trunc_rev_residual_room hread h1
· exact minimal_closedForm_of_negCross_trunc_rev_residual_top_crossed_smallGap hread h1
· exact minimal_closedForm_of_negCross_trunc_rev_residual_top_crossed hread h1
· rw [ite_eq_right h1]
by_cases h2 : revTruncGeTwoLarge r res
· rw [ite_eq_left h2]
rcases h2 with h2 | h2
· rw [closedFormNegCrossTruncRevResidualTopLargeUnified_eq_crossed h2]
exact minimal_closedForm_of_negCross_trunc_rev_residual_top_large_crossed hread h2
· rw [closedFormNegCrossTruncRevResidualTopLargeUnified_eq_sentinel h2]
exact minimal_closedForm_of_negCross_trunc_rev_residual_top_large_sentinel hread h2
· rw [ite_eq_right h2]
by_cases h4 : negCrossTruncRevResidualFiniteUnderCrossed r res ∨
negCrossTruncRevResidualFiniteUnderNotCrossed r res ∨
negCrossTruncRevResidualFiniteOver r res
· rcases h4 with h4 | h4 | h4
· rw [closedFormNegCrossTruncRevResidualFiniteUnified_eq_under h4.1]
exact minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_crossed hread h4
· rw [closedFormNegCrossTruncRevResidualFiniteUnified_eq_under h4.1]
exact minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_notCrossed hread h4
· rw [closedFormNegCrossTruncRevResidualFiniteUnified_eq_over h4]
exact minimal_closedForm_of_negCross_trunc_rev_residualFinite_over hread h4
· exfalso
have hcs : ¬ negCrossTruncRevCrossedSmall r res := fun h => by
unfold negCrossTruncRevCrossedSmall at h
omega
have hcl : ¬ negCrossTruncRevCrossedLarge r res := fun h => by
unfold negCrossTruncRevCrossedLarge at h
omega
have hun : ¬ negCrossTruncRevUnder r res := fun h => by
unfold negCrossTruncRevUnder at h
omega
have hcns : ¬ negCrossTruncRevCrossedNonposSmall r res := fun h => by
unfold negCrossTruncRevCrossedNonposSmall at h
omega
have hcnl : ¬ negCrossTruncRevCrossedNonposLarge r res := fun h => by
unfold negCrossTruncRevCrossedNonposLarge at h
omega
exact nonposTruncRev_false hread hmore hrev hempty hbegin hcross h_zc
(fun h => h1 (Or.inl h)) hcs hcl hun hcns hcnl
(fun h => h1 (Or.inr (Or.inr (Or.inl h))))
(fun h => h1 (Or.inr (Or.inr (Or.inr h))))
(fun h => h2 (Or.inl h)) (fun h => h2 (Or.inr h))
(fun h => h4 (Or.inl h)) (fun h => h4 (Or.inr (Or.inl h)))
(fun h => h4 (Or.inr (Or.inr h)))
theorem minimal_conflictRangeClosedFormResidualRevTrunc {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hempty : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hcross : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key) :
Minimal r res (conflictRangeClosedFormResidualRevTrunc r res) := by
classical
unfold conflictRangeClosedFormResidualRevTrunc
by_cases hzc : zeroCrossTruncRevCrossed r res
· rw [ite_eq_left hzc]
exact minimal_closedForm_of_zeroCross_trunc_revCrossed hread hzc
· rw [ite_eq_right hzc]
by_cases hn : r.end_.offset ≤ 1
· rw [ite_eq_left hn]
exact minimal_conflictRangeClosedFormResidualRevTruncLeOne hread hmore hrev hempty
hbegin hcross hzc hn
· rw [ite_eq_right hn]
have hg : 2 ≤ r.end_.offset := by omega
exact minimal_conflictRangeClosedFormResidualRevTruncGeTwo hread hmore hrev hempty
hbegin hcross hzc hg
theorem minimal_conflictRangeClosedFormResidualAux {r : RangeRead} {res : Result}
(hread : Readable r res) (hbegin : r.begin.offset ≤ 0) (hempty : res.keys ≠ [])
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
Minimal r res (conflictRangeClosedFormResidualAux r res) := by
classical
unfold conflictRangeClosedFormResidualAux
by_cases hmore : res.more = false
· rw [ite_eq_left hmore]
by_cases hrev : r.reverse = false
· rw [ite_eq_left hrev]
have hcrossH : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcross
exact minimal_conflictRangeClosedFormResidualCompleteFwd hread hmore hrev hempty
hbegin hcrossH
· rw [ite_eq_right hrev]
have hrvt : r.reverse = true := by
cases h : r.reverse with
| false => exact absurd h hrev
| true => rfl
have hcrossL : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrvt] using hcross
have hread' : Readable { r with reverse := false }
{ keys := res.keys.reverse, more := false } := by
obtain ⟨db, hcomp⟩ := hread
exact ⟨db, (compatible_flip (b := true) hrvt hmore).mpr hcomp⟩
have hne' : ({ keys := res.keys.reverse, more := false } : Result).keys ≠ [] := by
rwa [List.reverse_ne_nil_iff]
have hcross' : ((res.keys.reverse.headD ([] : Key) : Key) : WithTop Key) <
r.begin.key := by
have hr : res.keys.reverse.headD ([] : Key) = res.keys.getLastD ([] : Key) := by
rw [List.headD_eq_head?, List.getLastD_eq_getLast?, List.head?_reverse]
rw [hr]; exact hcrossL
have hmin' := minimal_conflictRangeClosedFormResidualCompleteFwd hread' rfl rfl hne'
hbegin hcross'
exact (minimal_flip (b := true) hrvt hmore).mp hmin'
· rw [ite_eq_right hmore]
have hm : res.more = true := by
cases h : res.more with
| false => exact absurd h hmore
| true => rfl
by_cases hrev : r.reverse = true
· rw [ite_eq_left hrev]
have hcrossL : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcross
exact minimal_conflictRangeClosedFormResidualRevTrunc hread hm hrev hempty hbegin hcrossL
· rw [ite_eq_right hrev]
have hrvf : r.reverse = false := by
cases h : r.reverse with
| false => rfl
| true => exact absurd h hrev
exact compactForwardTruncatedNonpos_minimal_of_not_residual hread hm hrvf hempty hbegin
not_compactForwardNonposResidual
/-- **The single crossed nonpositive closed form is minimal.** Transported across the
definitional equality with the residual dispatcher. -/
theorem compactCrossed_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) (hbegin : r.begin.offset ≤ 0) (hempty : res.keys ≠ [])
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
Minimal r res (compactCrossed r res) := by
rw [compactCrossed_eq_residualAux r res]
exact minimal_conflictRangeClosedFormResidualAux hread hbegin hempty hcross
/-- The single closed form denotes the same key set as the residual dispatcher. -/
theorem compactCrossed_toSet_eq_residual {r : RangeRead} {res : Result}
(_hread : Readable r res) (_hbegin : r.begin.offset ≤ 0) (_hempty : res.keys ≠ [])
(_hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
(compactCrossed r res).toSet = (conflictRangeClosedFormResidual r res).toSet := by
rw [compactCrossed_eq_residual r res]
/-- Minimality under the legacy residual name (a one-line alias of `compactCrossed`). -/
theorem minimal_conflictRangeClosedFormResidual {r : RangeRead} {res : Result}
(hread : Readable r res) (hbegin : r.begin.offset ≤ 0) (hempty : res.keys ≠ [])
(hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key) :
Minimal r res (conflictRangeClosedFormResidual r res) :=
compactCrossed_minimal hread hbegin hempty hcross
/-- **The closed dispatcher is minimal for every readable result.** It factors through
the four compact certificates, and the residual branch is the single closed form
`compactCrossed`. -/
theorem minimal_conflictRangeClosedFormClosed {r : RangeRead} {res : Result}
(hread : Readable r res) :
Minimal r res (conflictRangeClosedFormClosed r res) := by
classical
unfold conflictRangeClosedFormClosed
by_cases hempty : res.keys = []
· rw [ite_eq_left hempty]
exact minimal_emptyValue_of_emptyInference emptyInference hread hempty
· rw [ite_eq_right hempty]
by_cases hpos : 1 ≤ r.begin.offset
· rw [ite_eq_left hpos]
exact compactPositive_minimal hread hpos
· rw [ite_eq_right hpos]
by_cases hclamp : clampedNonpos r res
· rw [ite_eq_left hclamp]
exact compactClamped_minimal hread hclamp
· rw [ite_eq_right hclamp]
have hcross : ((leastReported r res : Key) : WithTop Key) < r.begin.key := by
by_contra h
exact hclamp ⟨hempty, by omega, not_lt.mp h⟩
exact compactCrossed_minimal hread (by omega) hempty hcross
/-- The explicit residual of the compact dispatcher: nonempty nonpositive-begin cells
outside the clamped certificate. These are exactly the crossed cells, where the compact
certificates do not apply and `compactCrossed` takes over. -/
def compactResidual (r : RangeRead) (res : Result) : Prop :=
res.keys ≠ [] ∧ r.begin.offset ≤ 0 ∧ ¬ clampedNonpos r res
/-- The total compact closed form. It is the certified dispatcher
`conflictRangeClosedFormClosed`: three certificate branches (empty, positive offset,
clamped nonpositive) plus the crossed nonpositive residual, whose own fallback is the
certified compact forward rule. Thus the body contains no reference to the general or
executable algorithm. -/
noncomputable def compact (r : RangeRead) (res : Result) : ConflictRange :=
conflictRangeClosedFormClosed r res
/-- The residual branch is literally the residual-only dispatcher. -/
theorem compact_eq_closedFormClosed_of_residual {r : RangeRead} {res : Result}
(_h : compactResidual r res) :
compact r res = conflictRangeClosedFormClosed r res :=
rfl
/-- The residual branch agrees with the certified total dispatcher in key-set terms. -/
theorem compact_eq_closedForm_of_residual {r : RangeRead} {res : Result}
(hread : Readable r res) (h : compactResidual r res) :
(compact r res).toSet = (conflictRangeClosedForm r res).toSet := by
rw [compact_eq_closedFormClosed_of_residual h]
exact (minimal_conflictRangeClosedFormClosed hread).toSet_eq
(minimal_conflictRangeClosedForm_total hread)
/-- The residual is exactly the crossed nonpositive region: a nonempty result at a
nonpositive begin offset whose least reported key lies strictly below `begin.key`. -/
theorem compactResidual_iff_crossed {r : RangeRead} {res : Result} :
compactResidual r res ↔
res.keys ≠ [] ∧ r.begin.offset ≤ 0 ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key := by
unfold compactResidual clampedNonpos
constructor
· rintro ⟨hne, hnonpos, hclamp⟩
exact ⟨hne, hnonpos, not_le.mp (fun hle => hclamp ⟨hne, hnonpos, hle⟩)⟩
· rintro ⟨hne, hnonpos, hcross⟩
exact ⟨hne, hnonpos, fun h => absurd h.2.2 (not_le.mpr hcross)⟩
/-- The total compact algorithm is minimal on every readable pair. -/
theorem compact_minimal {r : RangeRead} {res : Result} (hread : Readable r res) :
Minimal r res (compact r res) :=
minimal_conflictRangeClosedFormClosed hread
/-- The total compact algorithm denotes exactly the general necessary-key hull. -/
theorem compact_toSet_eq_general {r : RangeRead} {res : Result} (hread : Readable r res) :
(compact r res).toSet = (conflictRangeGeneral r res).toSet :=
(compact_minimal hread).toSet_eq (conflictRangeGeneral_minimal hread)
/-- The total compact algorithm agrees with the executable reference. -/
theorem compact_toSet_eq_simple {r : RangeRead} {res : Result} (hread : Readable r res) :
(compact r res).toSet = (simpleConflictRange r res).toSet :=
(compact_minimal hread).toSet_eq (simpleConflictRange_minimal hread)
/-- The compact algorithm and the exhaustive closed-form dispatcher denote the same range:
the residual branch of `compact` is answered by `conflictRangeClosedForm`. -/
theorem compact_toSet_eq_closedForm {r : RangeRead} {res : Result} (hread : Readable r res) :
(compact r res).toSet = (conflictRangeClosedForm r res).toSet :=
(compact_minimal hread).toSet_eq (minimal_conflictRangeClosedForm_total hread)
/-- The simplified compact closed form is not merely equal in key set but is the same
`ConflictRange` as the exhaustive closed-form dispatcher. On an empty result both are
`emptyValue`; on a nonempty result both are sound minimal ranges, so both contain the
reported keys and are nonempty, and `ConflictRange.eq_of_toSet_eq_of_nonempty` upgrades
the key-set equality to a structure equality. This lets the simplification be certified
by extensional equality rather than by re-deriving minimality of every merged branch. -/
theorem compact_eq_closedForm {r : RangeRead} {res : Result} (hread : Readable r res) :
compact r res = conflictRangeClosedForm r res := by
classical
by_cases hne : res.keys = []
· simp [compact, conflictRangeClosedFormClosed, conflictRangeClosedForm, hne]
· have hmem : res.keys.head hne ∈ compact r res :=
mem_of_sound_of_mem_result hread (compact_minimal hread).sound
(res.keys.head hne) (List.head_mem hne)
exact ConflictRange.eq_of_toSet_eq_of_nonempty (compact_toSet_eq_closedForm hread)
⟨res.keys.head hne, hmem⟩
end FormalConflictRange