- Vendor the FormalConflictRange reference library needed by the proof - Add Bridge.lean with simp lemmas connecting the Statement definitions to the reference library - Prove Statement.closedFormMinimal in Proof.lean - Register the new libraries in the Lake config
188 lines
9.7 KiB
Lean4
188 lines
9.7 KiB
Lean4
/-
|
|
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
Authors: FormalConflictRange contributors
|
|
-/
|
|
import FormalConflictRange.NegCrossClampLongNonpos
|
|
import FormalConflictRange.NonposRevClosedForm
|
|
|
|
/-!
|
|
# The crossed negative-begin truncated long clamp cell at a nonpositive end offset
|
|
|
|
A forward truncated result with `end_.key < begin.key`, a negative begin offset,
|
|
`end.offset ≤ 0`, a clamping begin selector, and at least one reported key at or above
|
|
`end_.key`. In that situation every stored key in the complete window lies below
|
|
`resolve end ≤ end_.key ≤ last`, so the truncated result is compatible exactly when the
|
|
corresponding complete result is. The minimal sound range is therefore the same as in
|
|
the complete long clamp cell: `[⊥, clampLongUpper r res]`.
|
|
|
|
The two ingredient lemmas are generic. The first says that when the end selector cuts at
|
|
or below the reported last, truncation is invisible: compatibility of the truncated
|
|
result is compatibility of the complete result. The second transfers minimality across a
|
|
change of the result when the compatible databases are the same.
|
|
-/
|
|
|
|
namespace FormalConflictRange
|
|
|
|
/-- Minimality is invariant under a change of the result that preserves compatibility. -/
|
|
theorem minimal_congr_of_compatible_iff_result {r : RangeRead} {res res' : Result}
|
|
{cr : ConflictRange}
|
|
(h : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r res') :
|
|
Minimal r res cr ↔ Minimal r res' cr := by
|
|
have hS : ∀ cr, Sound r res cr ↔ Sound r res' cr := by
|
|
intro cr
|
|
unfold Sound
|
|
constructor
|
|
· intro hs db₁ db₂ hagree
|
|
exact (h db₁).symm.trans ((hs db₁ db₂ hagree).trans (h db₂))
|
|
· intro hs db₁ db₂ hagree
|
|
exact (h db₁).trans ((hs db₁ db₂ hagree).trans (h db₂).symm)
|
|
unfold Minimal
|
|
refine ⟨fun ⟨hs, hn⟩ => ⟨(hS cr).mp hs, ?_⟩, fun ⟨hs, hn⟩ => ⟨(hS cr).mpr hs, ?_⟩⟩
|
|
· intro cr' hsub hs'
|
|
exact hn cr' hsub ((hS cr').mpr hs')
|
|
· intro cr' hsub hs'
|
|
exact hn cr' hsub ((hS cr').mp hs')
|
|
|
|
/-- When the end selector has a nonpositive offset and its key is at or below the
|
|
reported last, the truncated result is compatible exactly when the complete result is:
|
|
every stored key of the complete window lies below `resolve end ≤ end_.key ≤ last`. -/
|
|
theorem compatible_truncated_iff_complete_of_end_le_last {db : DB} {r : RangeRead}
|
|
{res : Result}
|
|
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
|
|
(hne : res.keys ≠ []) (hend : r.end_.offset ≤ 0)
|
|
(hlast : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) :
|
|
RangeRead.Compatible db r res ↔
|
|
RangeRead.Compatible db r { res with more := false } := by
|
|
have hlast' : r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by
|
|
rwa [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne] at hlast
|
|
constructor
|
|
· intro hc
|
|
obtain ⟨hlim, hfil⟩ := (compatible_iff_truncated_keys hrev hmore hne).mp hc
|
|
have hck : RangeRead.completeKeys db r = res.keys := by
|
|
have hself : (RangeRead.completeKeys db r).filter
|
|
(fun (k : Key) => decide (k ≤ res.keys.getLast hne)) =
|
|
RangeRead.completeKeys db r := by
|
|
rw [List.filter_eq_self]
|
|
intro x hx
|
|
rw [decide_eq_true_eq]
|
|
have hxlt : ((x : Key) : WithTop Key) < resolve db r.end_ :=
|
|
(RangeRead.mem_completeKeys.mp hx).2.2
|
|
have h1 : ((x : Key) : WithTop Key) < r.end_.key :=
|
|
lt_of_lt_of_le hxlt (resolve_le_key_of_offset_nonpos hend)
|
|
have h2 : ((x : Key) : WithTop Key) ≤
|
|
((res.keys.getLast hne : Key) : WithTop Key) :=
|
|
le_of_lt (lt_of_lt_of_le h1 hlast')
|
|
exact WithTop.coe_le_coe.mp h2
|
|
rw [hself] at hfil
|
|
exact hfil
|
|
exact ⟨hlim, Or.inr ⟨rfl, hck.symm⟩⟩
|
|
· intro hc
|
|
have hlim : RangeRead.withinLimit r res.keys := hc.1
|
|
have heq : res.keys = RangeRead.completeKeys db r := by
|
|
rcases hc.2 with ⟨hm, _⟩ | ⟨-, heq⟩
|
|
· exact absurd hm (by simp)
|
|
· exact heq
|
|
have hfil : (RangeRead.completeKeys db r).filter
|
|
(fun (k : Key) => decide (k ≤ res.keys.getLast hne)) = res.keys := by
|
|
rw [← heq]
|
|
rw [List.filter_eq_self]
|
|
intro x hx
|
|
rw [decide_eq_true_eq]
|
|
obtain ⟨db₀, hcomp₀⟩ := hread
|
|
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
|
exact (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
|
exact (compatible_iff_truncated_keys hrev hmore hne).mpr ⟨hlim, hfil⟩
|
|
|
|
/-- The crossed negative-begin truncated long clamp cell at `end.offset ≤ 0`: a
|
|
clamping begin selector, `end_.key < begin.key`, and at least one reported key at or above
|
|
`end_.key`. -/
|
|
def negCrossTruncClampLongNonpos (r : RangeRead) (res : Result) : Prop :=
|
|
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
|
|
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
|
r.end_.offset ≤ 0 ∧ reportedBelowBegin r res ≤ beginSlack r ∧
|
|
clampNonposBottom r res ∧ r.end_.key < r.begin.key ∧
|
|
r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
|
|
|
|
/-- **The crossed negative-begin truncated long clamp cell is minimal with the complete
|
|
long clamp closed form `[⊥, clampLongUpper]`.** -/
|
|
theorem minimal_closedForm_of_negCross_trunc_clamp_long_nonpos {r : RangeRead}
|
|
{res : Result} (hread : Readable r res) (hcell : negCrossTruncClampLongNonpos r res) :
|
|
Minimal r res (closedFormNegCrossClampLongNonpos r res) := by
|
|
obtain ⟨hmore, hrev, hbegin, hne, hcrossD, hend, hmq, hbottom, hlong, hlastE⟩ := hcell
|
|
let res' : Result := { res with more := false }
|
|
have hcompat : ∀ db, RangeRead.Compatible db r res ↔
|
|
RangeRead.Compatible db r res' :=
|
|
fun db => compatible_truncated_iff_complete_of_end_le_last hread hrev hmore hne hend hlastE
|
|
have hread' : Readable r res' := by
|
|
obtain ⟨db, hcomp⟩ := hread
|
|
exact ⟨db, (hcompat db).mp hcomp⟩
|
|
have hcell' : negCrossClampLongNonpos r res' := by
|
|
refine ⟨hrev, hbegin, rfl, hne, hend, ?_, hmq, hbottom, hlong⟩
|
|
simpa [res'] using hcrossD
|
|
have hmin := minimal_closedForm_of_negCross_clamp_long_nonpos hread' hcell'
|
|
have hcf : closedFormNegCrossClampLongNonpos r res' =
|
|
closedFormNegCrossClampLongNonpos r res := by
|
|
unfold closedFormNegCrossClampLongNonpos clampLongUpper clampLongCap clampLongC
|
|
simp only [res']
|
|
rfl
|
|
refine (minimal_congr_of_compatible_iff_result (r := r) (res := res) (res' := res')
|
|
(cr := closedFormNegCrossClampLongNonpos r res) hcompat).mpr ?_
|
|
rwa [← hcf]
|
|
|
|
/-- The crossed negative-begin truncated short cell at `end.offset ≤ 0`: `end_.key <
|
|
begin.key` and at least one reported key at or above `end_.key`. Truncation is invisible
|
|
here, because `resolve end ≤ end_.key ≤ last`. Both capacity regimes are included. -/
|
|
def negCrossTruncShortNonpos (r : RangeRead) (res : Result) : Prop :=
|
|
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
|
|
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
|
r.end_.offset ≤ 0 ∧ reportedBelowBegin r res ≤ beginSlack r ∧
|
|
r.end_.key < r.begin.key ∧
|
|
r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
|
|
|
|
/-- The closed form of the crossed negative-begin truncated short cell: the complete long
|
|
clamp rule when the begin selector clamps, and the nonclamping full-window rule
|
|
`[head, begin.key)` otherwise. -/
|
|
noncomputable def closedFormNegCrossTruncShortNonpos (r : RangeRead) (res : Result) :
|
|
ConflictRange :=
|
|
if clampNonposBottom r res then
|
|
⟨(([] : Key) : WithTop Key), clampLongUpper r res⟩
|
|
else ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩
|
|
|
|
/-- **The crossed negative-begin truncated short cell is minimal.** Truncation is
|
|
invisible (`compatible_truncated_iff_complete_of_end_le_last`), so both capacity regimes
|
|
transfer from the complete crossed nonpositive-end theorems. -/
|
|
theorem minimal_closedForm_of_negCross_trunc_short_nonpos {r : RangeRead} {res : Result}
|
|
(hread : Readable r res) (hcell : negCrossTruncShortNonpos r res) :
|
|
Minimal r res (closedFormNegCrossTruncShortNonpos r res) := by
|
|
obtain ⟨hmore, hrev, hbegin, hne, hcrossD, hend, hmq, hlong, hlastE⟩ := hcell
|
|
by_cases hbottom : clampNonposBottom r res
|
|
· rw [closedFormNegCrossTruncShortNonpos, ite_eq_left hbottom]
|
|
exact minimal_closedForm_of_negCross_trunc_clamp_long_nonpos hread
|
|
⟨hmore, hrev, hbegin, hne, hcrossD, hend, hmq, hbottom, hlong, hlastE⟩
|
|
· rw [closedFormNegCrossTruncShortNonpos, ite_eq_right hbottom]
|
|
let res' : Result := { res with more := false }
|
|
have hcompat : ∀ db, RangeRead.Compatible db r res ↔
|
|
RangeRead.Compatible db r res' :=
|
|
fun db => compatible_truncated_iff_complete_of_end_le_last hread hrev hmore hne hend hlastE
|
|
have hread' : Readable r res' := by
|
|
obtain ⟨db, hcomp⟩ := hread
|
|
exact ⟨db, (hcompat db).mp hcomp⟩
|
|
have hcell' : negCrossNonclampLongNonpos r res' := by
|
|
refine ⟨hrev, hbegin, rfl, hne, hend, ?_, ?_, ?_, hlong⟩
|
|
· exact hcrossD
|
|
· exact hmq
|
|
· exact hbottom
|
|
have hmin := minimal_closedForm_of_negCross_nonclamp_long_nonpos hread' hcell'
|
|
have hcf : closedFormNegCrossNonclampLongNonpos r res' =
|
|
(⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩ :
|
|
ConflictRange) := by
|
|
unfold closedFormNegCrossNonclampLongNonpos
|
|
rfl
|
|
rw [hcf] at hmin
|
|
exact (minimal_congr_of_compatible_iff_result (r := r) (res := res) (res' := res')
|
|
(cr := ⟨((res.keys.headD ([] : Key) : Key) : WithTop Key), r.begin.key⟩)
|
|
hcompat).mpr hmin
|
|
|
|
end FormalConflictRange
|