Prove conflict-range closed-form minimality
- Vendor the FormalConflictRange reference library needed by the proof - Add Bridge.lean with simp lemmas connecting the Statement definitions to the reference library - Prove Statement.closedFormMinimal in Proof.lean - Register the new libraries in the Lake config
This commit is contained in:
1 parent
7a0826e873
commit
a54a5f82f8
78 files changed
+91636
-2
No files matched your search
@@ -0,0 +1,187 @@
|
||||
/-
|
||||
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
|
||||
Reference in new issue
Block a user