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,163 @@
|
||||
/-
|
||||
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.NegCrossTruncRevBeginTop
|
||||
|
||||
/-!
|
||||
# Sentinel-begin reversed truncated cells at end offset at least two
|
||||
|
||||
This module extends the sentinel-begin reversed truncated cell
|
||||
(`r.begin.key = ⊤`) from end offsets at most one to every end offset at least two,
|
||||
under the extra hypothesis that every reported key lies strictly below `r.end_.key`.
|
||||
|
||||
* `reverse = true`, `more = true`, `res.keys ≠ []`, `begin.offset < 0`;
|
||||
* `begin.key = ⊤`;
|
||||
* `2 ≤ end_.offset`, with every reported key strictly below `end_.key`.
|
||||
|
||||
The minimal range is again `[last reported, ⊤)`, the top range at the reported last key.
|
||||
|
||||
Soundness is the sentinel-begin argument with the overshoot: the reported keys are a
|
||||
prefix of an unbounded window, so agreement on `[last, ⊤)` fixes the stored keys at or
|
||||
above `last` and keeps the begin resolution at or below it. Necessity is the
|
||||
offset-agnostic `necessary_of_ge_last_of_negCross_trunc_rev_beginTop`: every key at or
|
||||
above the reported last is necessary.
|
||||
-/
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
/-- **Soundness of the top range at the reported last for a sentinel begin and an
|
||||
end offset of at least two.** The overshoot hypothesis makes the reduced read's
|
||||
window unbounded, and the sentinel begin keeps the resolved begin at or below the
|
||||
reported last under agreement on `[last, ⊤)`. -/
|
||||
theorem sound_topOfLast_of_negCross_trunc_rev_beginTop_ge_two {r : RangeRead}
|
||||
{res : Result}
|
||||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||||
(hne : res.keys ≠ []) (hend : 2 ≤ r.end_.offset)
|
||||
(hB : r.begin.key = (⊤ : WithTop Key))
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) :
|
||||
Sound r res (topOfLast (res.keys.getLast hne)) := by
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||||
have hcross : ((L : Key) : WithTop Key) < r.begin.key := by
|
||||
rw [hB]; exact WithTop.coe_lt_top L
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
let r' : RangeRead :=
|
||||
{ r with begin := { key := ((L : Key) : WithTop Key), offset := 1 } }
|
||||
have hr'_rev : r'.reverse = true := by simp [r', hrev]
|
||||
have hr'_end : r'.end_ = r.end_ := rfl
|
||||
have hr'_beg : r'.begin = ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) :=
|
||||
rfl
|
||||
have hr'_off : r'.begin.offset = 1 := rfl
|
||||
have hreduce : ∀ (db : DB), RangeRead.Compatible db r res →
|
||||
RangeRead.Compatible db r' res := by
|
||||
intro db hcomp
|
||||
have hfil : (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) =
|
||||
res.keys :=
|
||||
(compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp |>.2
|
||||
have hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfil]; exact hLmem
|
||||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
(RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt).1).2.1
|
||||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||||
have hres' : resolve db r'.begin = ((L : Key) : WithTop Key) := by
|
||||
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb
|
||||
have hLck_filter : (RangeRead.completeKeys db r').filter (fun k => decide (L ≤ k)) =
|
||||
RangeRead.completeKeys db r' := by
|
||||
rw [List.filter_eq_self]
|
||||
intro k hk
|
||||
rw [decide_eq_true_eq]
|
||||
have hk' := (RangeRead.mem_completeKeys.mp hk).2.1
|
||||
exact WithTop.coe_le_coe.mp (by rwa [hres'] at hk')
|
||||
have hck' : RangeRead.completeKeys db r' = res.keys := by
|
||||
rw [← hLck_filter]
|
||||
exact (completeKeys_filter_ge_eq_of_both_le (db := db) (r₁ := r) (r₂ := r')
|
||||
hrev hr'_rev hr'_end hrb (le_of_eq hres')).symm.trans hfil
|
||||
refine ⟨by simpa [r', RangeRead.withinLimit] using hcomp.1, Or.inl ⟨hmore, ?_, hne⟩⟩
|
||||
rw [hck']
|
||||
have hread' : Readable r' res := ⟨db₀, hreduce db₀ hcomp₀⟩
|
||||
have hgetLastD : res.keys.getLastD ([] : Key) = L := by
|
||||
rw [hLdef, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||||
have hmin' : Minimal r' res (topOfLast L) := by
|
||||
have hm := minimal_topOfLast_of_end_offset_ge_two_rev (r := r') hread' hmore
|
||||
hr'_rev hr'_off hend (by simpa [r'] using hhi)
|
||||
rwa [hgetLastD] at hm
|
||||
have hS' : Sound r' res (topOfLast L) := hmin'.sound
|
||||
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
|
||||
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
|
||||
intro db db' hag' hcomp
|
||||
have hcomp' : RangeRead.Compatible db r' res := hreduce db hcomp
|
||||
have hcomp'' : RangeRead.Compatible db' r' res := (hS' db db' hag').mp hcomp'
|
||||
have hbound : ((between db ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 :=
|
||||
between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
|
||||
-- the agreement, restricted to the stored keys at or above `L`
|
||||
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
|
||||
db.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
have h := hag'
|
||||
unfold AgreeOn at h
|
||||
rw [topOfLast_keys, topOfLast_keys] at h
|
||||
exact h.symm
|
||||
have hbetween_eq : between db' ((L : Key) : WithTop Key) r.begin.key =
|
||||
between db ((L : Key) : WithTop Key) r.begin.key := by
|
||||
rw [hB]
|
||||
unfold between
|
||||
simpa [WithTop.coe_le_coe] using hfilEq
|
||||
have hbound' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 := by
|
||||
rw [hbetween_eq]; exact hbound
|
||||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||||
have hLdb' : L ∈ db'.keys := by
|
||||
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfilEq]
|
||||
exact List.mem_filter.mpr ⟨hLdb, by simp⟩
|
||||
exact (List.mem_filter.mp hmem).1
|
||||
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
resolve_begin_le_of_between_bound hLdb' hcross hbound'
|
||||
have hres'_db' : resolve db' r'.begin = ((L : Key) : WithTop Key) := by
|
||||
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb'
|
||||
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
|
||||
refine ⟨by simpa [r', RangeRead.withinLimit] using hcomp''.1, ?_⟩
|
||||
have h1 := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r) hrev hrb'
|
||||
have h2' := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r') hr'_rev
|
||||
(le_of_eq hres'_db')
|
||||
have h2 := (compatible_iff_truncated_keys_rev (db := db') hr'_rev hmore hne).mp
|
||||
hcomp'' |>.2
|
||||
rw [h1, ← h2']
|
||||
exact h2
|
||||
intro db₁ db₂ hagree
|
||||
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
|
||||
|
||||
/-- The sentinel-begin reversed truncated cell with end offset at least two and every
|
||||
reported key below the end key. -/
|
||||
abbrev negCrossTruncRevBeginTopGeTwo (r : RangeRead) (res : Result) : Prop :=
|
||||
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
|
||||
r.begin.key = (⊤ : WithTop Key) ∧ 2 ≤ r.end_.offset ∧
|
||||
r.end_.key < (⊤ : WithTop Key) ∧
|
||||
∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
|
||||
|
||||
/-- The closed form of the sentinel-begin reversed truncated overshoot cell:
|
||||
`[last reported, ⊤)`. -/
|
||||
noncomputable def closedFormNegCrossTruncRevBeginTopGeTwo (_r : RangeRead)
|
||||
(res : Result) : ConflictRange :=
|
||||
topOfLast (res.keys.getLastD ([] : Key))
|
||||
|
||||
/-- **The sentinel-begin reversed truncated overshoot closed form is minimal.** -/
|
||||
theorem minimal_closedForm_of_negCross_trunc_rev_beginTop_ge_two {r : RangeRead}
|
||||
{res : Result} (hread : Readable r res) (h : negCrossTruncRevBeginTopGeTwo r res) :
|
||||
Minimal r res (closedFormNegCrossTruncRevBeginTopGeTwo r res) := by
|
||||
obtain ⟨hmore, hrev, hbeg, hne, hB, hend, _hEtop, hhi⟩ := h
|
||||
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
|
||||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||||
unfold closedFormNegCrossTruncRevBeginTopGeTwo
|
||||
rw [hlast]
|
||||
refine (minimal_iff_sound_and_necessary).mpr
|
||||
⟨sound_topOfLast_of_negCross_trunc_rev_beginTop_ge_two hread hmore hrev hne hend hB
|
||||
hhi, ?_⟩
|
||||
intro k hk
|
||||
exact necessary_of_ge_last_of_negCross_trunc_rev_beginTop hread hmore hrev hne hbeg hB
|
||||
(k := k) (ConflictRange.mem_iff.mp hk).1
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user