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,153 @@
|
||||
import FormalConflictRange.NegCrossComplete
|
||||
|
||||
open FormalConflictRange
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
/-- The negative-begin complete bottom cell: forward, complete, nonempty, nonpositive
|
||||
end, `begin.key ≤ end.key`, and reported head the empty key. -/
|
||||
abbrev negCrossHeadBottom (r : RangeRead) (res : Result) : Prop :=
|
||||
r.reverse = false ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
|
||||
r.end_.offset ≤ 0 ∧ r.begin.key ≤ r.end_.key ∧
|
||||
res.keys.headD ([] : Key) = ([] : Key)
|
||||
|
||||
/-- The closed form for the negative-begin complete bottom cell: `[⊥, end_.key)`. -/
|
||||
noncomputable def closedFormNegCrossHeadBottom (r : RangeRead) (res : Result) :
|
||||
ConflictRange :=
|
||||
⟨(([] : Key) : WithTop Key), r.end_.key⟩
|
||||
|
||||
/-- Filtering keys below `E` is the same as filtering the half-open interval
|
||||
`[⊥, E)`. -/
|
||||
theorem filter_between_bot_eq {l : List Key} {E : WithTop Key} :
|
||||
l.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
|
||||
((k : Key) : WithTop Key) < E)) =
|
||||
l.filter (fun k : Key => decide (((k : Key) : WithTop Key) < E)) := by
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
rw [decide_eq_decide]
|
||||
exact ⟨fun h => h.2, fun h => ⟨coe_nil_le_key_withTop _, h⟩⟩
|
||||
|
||||
/-- **The negative-begin complete bottom cell is minimal.** The reported head is the
|
||||
empty key, so the begin selector resolves to `⊥` in every compatible database; the
|
||||
complete window is a prefix of the keys below `end_.key`, hence agreement on
|
||||
`[⊥, end_.key)` determines compatibility. Every key in `[⊥, end_.key)` is necessary:
|
||||
the reported keys and the gaps between them by convexity, and the keys above the
|
||||
reported last by `necessary_last_to_end_key`. -/
|
||||
theorem minimal_closedForm_of_negCross_headBottom {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hcell : negCrossHeadBottom r res) :
|
||||
Minimal r res (closedFormNegCrossHeadBottom r res) := by
|
||||
obtain ⟨hrev, hbegin, hmore, hne, hend, hB_le_E, hheadD⟩ := hcell
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne
|
||||
have hhead_empty : (res.keys.head hne : Key) = ([] : Key) := by
|
||||
rw [List.headD_eq_head?, List.head?_eq_some_head hne] at hheadD
|
||||
simpa using hheadD
|
||||
rw [show closedFormNegCrossHeadBottom r res =
|
||||
⟨(([] : Key) : WithTop Key), r.end_.key⟩ by rfl]
|
||||
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
|
||||
· have step : ∀ db₁ db₂, AgreeOn ⟨(([] : Key) : WithTop Key), r.end_.key⟩ db₁ db₂ →
|
||||
RangeRead.Compatible db₁ r res → RangeRead.Compatible db₂ r res := by
|
||||
intro db₁ db₂ hagree hcomp₁
|
||||
have hlim : RangeRead.withinLimit r res.keys := hcomp₁.1
|
||||
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 : res.keys.head hne ∈ RangeRead.completeKeys db₁ r := by
|
||||
rw [← hres_eq]; exact hhead_mem
|
||||
have hL₁ : resolve db₁ r.begin = (([] : Key) : WithTop Key) := by
|
||||
have hle : resolve db₁ r.begin ≤ (([] : Key) : WithTop Key) := by
|
||||
have h := (RangeRead.mem_completeKeys.mp hhead_ck).2.1
|
||||
rwa [hhead_empty] at h
|
||||
exact le_antisymm hle (coe_nil_le_key_withTop _)
|
||||
have hfilt : db₁.keys.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤
|
||||
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.end_.key)) =
|
||||
db₂.keys.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤
|
||||
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.end_.key)) := by
|
||||
simpa [AgreeOn, ConflictRange.keys] using hagree
|
||||
have hfiltE : db₁.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) <
|
||||
r.end_.key)) =
|
||||
db₂.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) < r.end_.key)) := by
|
||||
rw [← filter_between_bot_eq, ← filter_between_bot_eq]
|
||||
exact hfilt
|
||||
have hR : resolve db₂ r.end_ = resolve db₁ r.end_ := by
|
||||
rw [resolve_eq_filter_lt_reverse (db := db₁) hend,
|
||||
resolve_eq_filter_lt_reverse (db := db₂) hend, hfiltE]
|
||||
have hfiltB : db₁.keys.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤
|
||||
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) =
|
||||
db₂.keys.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤
|
||||
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < r.begin.key)) :=
|
||||
filter_between_eq_of_filter_end_eq (db₁ := db₁) (db₂ := db₂)
|
||||
(a := ([] : Key)) (B := r.begin.key) (E := r.end_.key) hB_le_E hfilt
|
||||
have hfiltB0 : db₁.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) <
|
||||
r.begin.key)) =
|
||||
db₂.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) <
|
||||
r.begin.key)) := by
|
||||
rw [← filter_between_bot_eq (E := r.begin.key),
|
||||
← filter_between_bot_eq (E := r.begin.key)]
|
||||
exact hfiltB
|
||||
have hL₂ : resolve db₂ r.begin = resolve db₁ r.begin := by
|
||||
rw [resolve_eq_filter_lt_reverse (db := db₁) (s := r.begin) (le_of_lt hbegin),
|
||||
resolve_eq_filter_lt_reverse (db := db₂) (s := r.begin) (le_of_lt hbegin),
|
||||
hfiltB0]
|
||||
have hL₂' : resolve db₂ r.begin = (([] : Key) : WithTop Key) := by rw [hL₂, hL₁]
|
||||
have hres_le : resolve db₁ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
|
||||
have hP : db₁.keys.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤
|
||||
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < resolve db₁ r.end_)) =
|
||||
db₂.keys.filter (fun k : Key => decide ((([] : Key) : WithTop Key) ≤
|
||||
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < resolve db₁ r.end_)) :=
|
||||
filter_between_eq_of_filter_end_eq (db₁ := db₁) (db₂ := db₂)
|
||||
(a := ([] : Key)) (B := resolve db₁ r.end_) (E := r.end_.key) hres_le hfilt
|
||||
have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
|
||||
unfold RangeRead.completeKeys RangeRead.inRange
|
||||
rw [ite_eq_right (by simp [hrev]), ite_eq_right (by simp [hrev]), hL₁, hL₂', hR]
|
||||
exact hP
|
||||
exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩
|
||||
intro db₁ db₂ hagree
|
||||
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
|
||||
· intro k hlo hhi
|
||||
have hk_bot : ([] : Key) ≤ k := WithTop.coe_le_coe.mp hlo
|
||||
by_cases hklast : k ≤ res.keys.getLast hne
|
||||
· exact necessary_of_between_result ⟨db₀, hcomp₀⟩ hhead_mem (List.getLast_mem hne)
|
||||
(by rw [hhead_empty]; exact hk_bot) hklast
|
||||
· exact fun cr hs => necessary_last_to_end_key ⟨db₀, hcomp₀⟩ hrev hmore hne (by omega)
|
||||
cr hs (le_of_lt (lt_of_not_ge hklast)) hhi
|
||||
|
||||
/-- The reversed negative-begin complete bottom cell: the reported last is the empty
|
||||
key. -/
|
||||
abbrev negCrossHeadBottomRev (r : RangeRead) (res : Result) : Prop :=
|
||||
r.reverse = true ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
|
||||
r.end_.offset ≤ 0 ∧ r.begin.key ≤ r.end_.key ∧
|
||||
res.keys.getLastD ([] : Key) = ([] : Key)
|
||||
|
||||
/-- The closed form for the reversed negative-begin complete bottom cell. -/
|
||||
noncomputable def closedFormNegCrossHeadBottomRev (r : RangeRead) (res : Result) :
|
||||
ConflictRange :=
|
||||
⟨(([] : Key) : WithTop Key), r.end_.key⟩
|
||||
|
||||
/-- **The reversed negative-begin complete bottom cell is minimal**, by flipping the
|
||||
traversal. -/
|
||||
theorem minimal_closedForm_of_negCross_headBottom_rev {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hcell : negCrossHeadBottomRev r res) :
|
||||
Minimal r res (closedFormNegCrossHeadBottomRev r res) := by
|
||||
obtain ⟨hrev, hbegin, hmore, hne, hend, hB_le_E, hlastD⟩ := hcell
|
||||
have hne' : res.keys.reverse ≠ [] := by simpa using hne
|
||||
have hheadD : res.keys.reverse.headD ([] : Key) = res.keys.getLastD ([] : Key) := by
|
||||
rw [List.headD_eq_head?, List.getLastD_eq_getLast?, List.head?_reverse]
|
||||
have hcell' : negCrossHeadBottom {r with reverse := false}
|
||||
{ keys := res.keys.reverse, more := false } := by
|
||||
refine ⟨rfl, hbegin, rfl, hne', hend, hB_le_E, ?_⟩
|
||||
rw [hheadD]; exact hlastD
|
||||
have hread' : Readable {r with reverse := false}
|
||||
{ keys := res.keys.reverse, more := false } := by
|
||||
obtain ⟨db, hcomp⟩ := hread
|
||||
exact ⟨db, (compatible_flip (db := db) (r := r) (res := res) (b := true) hrev hmore).mpr hcomp⟩
|
||||
have hmin' : Minimal {r with reverse := false}
|
||||
{ keys := res.keys.reverse, more := false }
|
||||
(closedFormNegCrossHeadBottomRev r res) := by
|
||||
simpa [closedFormNegCrossHeadBottomRev, closedFormNegCrossHeadBottom] using
|
||||
minimal_closedForm_of_negCross_headBottom hread' hcell'
|
||||
exact (minimal_flip (r := r) (res := res) (cr := closedFormNegCrossHeadBottomRev r res)
|
||||
(b := true) hrev hmore).mp hmin'
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user