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,647 @@
|
||||
/-
|
||||
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.CrossedGeneral
|
||||
|
||||
/-!
|
||||
# The crossed nonpositive-begin complete overshoot closed form
|
||||
|
||||
A forward complete result at a negative begin offset whose `begin.key` lies strictly
|
||||
above the reported head and whose end overshoots has a two-branch minimal sound
|
||||
conflict range. Let `q = -begin.offset` be the begin slack and let `hmin` be the
|
||||
number of reported keys strictly below `begin.key`. If `hmin ≤ q` the begin selector
|
||||
clamps to the empty key, every key is forced, and the minimal range is `[⊥, ⊤)`.
|
||||
Otherwise a compatible database resolves the begin selector exactly onto the reported
|
||||
head (`hmin = q + 1`), the complete keys are the stored keys at or above the head, and
|
||||
the minimal range is `[head, ⊤)`.
|
||||
|
||||
The clamp branch is minimal because inserting any key below the head forces a new
|
||||
complete key; the nonclamp branch is sound because agreement on `[head, ⊤)` fixes the
|
||||
begin resolution and the end sentinel.
|
||||
-/
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
/-- The nonpositive begin slack, `-begin.offset` as a natural. -/
|
||||
def beginSlack (r : RangeRead) : ℕ := (0 - r.begin.offset).toNat
|
||||
|
||||
/-- Reported keys strictly below `begin.key`. -/
|
||||
def reportedBelowBegin (r : RangeRead) (res : Result) : ℕ :=
|
||||
res.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))
|
||||
|
||||
/-- The crossed nonpositive-begin complete overshoot region (forward traversal). -/
|
||||
abbrev negCrossOvershoot (r : RangeRead) (res : Result) : Prop :=
|
||||
r.reverse = false ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
|
||||
2 ≤ r.end_.offset ∧
|
||||
(∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) ∧
|
||||
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key
|
||||
|
||||
/-- The closed form for the crossed complete overshoot at a negative begin offset. -/
|
||||
noncomputable def closedFormNegCrossOvershoot (r : RangeRead) (res : Result) : ConflictRange :=
|
||||
if reportedBelowBegin r res ≤ beginSlack r then
|
||||
⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩
|
||||
else topOfLast (res.keys.headD ([] : Key))
|
||||
|
||||
theorem beginSlack_cast (r : RangeRead) (h : r.begin.offset ≤ 0) :
|
||||
(beginSlack r : ℤ) = -r.begin.offset := by
|
||||
unfold beginSlack
|
||||
rw [Int.toNat_of_nonneg (by omega)]
|
||||
ring
|
||||
|
||||
theorem anchor_eq_count_sub_slack (db : DB) (r : RangeRead) (h : r.begin.offset ≤ 0) :
|
||||
r.begin.anchor db =
|
||||
(db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℤ) -
|
||||
(beginSlack r : ℤ) - 1 := by
|
||||
unfold Selector.anchor
|
||||
rw [beginSlack_cast r h]
|
||||
ring
|
||||
|
||||
theorem result_sublist_db_of_compatible {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) :
|
||||
List.Sublist res.keys db.keys := by
|
||||
have hpre := RangeRead.compatible_keys_prefix hcomp
|
||||
have hck : RangeRead.completeKeys db r =
|
||||
db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧
|
||||
(k : WithTop Key) < resolve db r.end_)) := by
|
||||
rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])]
|
||||
rfl
|
||||
rw [hck] at hpre
|
||||
exact hpre.sublist.trans List.filter_sublist
|
||||
|
||||
theorem resolve_end_top_of_negCross_compat {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
|
||||
(hmore : res.more = false) (hne : res.keys ≠ [])
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) :
|
||||
resolve db r.end_ = (⊤ : WithTop Key) := by
|
||||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
|
||||
have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne :=
|
||||
fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk
|
||||
have hres_eq : res.keys = RangeRead.completeKeys db r := by
|
||||
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
|
||||
· simp [hmore] at hm
|
||||
· exact heq
|
||||
exact resolve_end_eq_top_of_hhi hcomp hend hhi (res.keys.getLast hne)
|
||||
(List.getLast_mem hne) (fun k hk => hmaxres k (by rw [hres_eq]; exact hk))
|
||||
|
||||
/-- The compatibility data used by both branches: when `hmin > q`, a compatible
|
||||
database resolves its begin selector exactly onto the reported head. -/
|
||||
theorem resolve_begin_eq_head_of_negCross_compat {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
|
||||
(hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
|
||||
resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
|
||||
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
|
||||
have hsub : List.Sublist res.keys db.keys := result_sublist_db_of_compatible hcomp hrev
|
||||
have hmin_le : reportedBelowBegin r res ≤ cB := List.Sublist.countP_le hsub
|
||||
have hcB_ge : beginSlack r + 1 ≤ cB :=
|
||||
Nat.succ_le_of_lt (lt_of_lt_of_le hnonclamp hmin_le)
|
||||
have hanchor_ge : 0 ≤ r.begin.anchor db := by
|
||||
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin)]
|
||||
have : (beginSlack r : ℤ) + 1 ≤ (cB : ℤ) := by exact_mod_cast hcB_ge
|
||||
omega
|
||||
have hres_eq : res.keys = RangeRead.completeKeys db r := by
|
||||
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
|
||||
· simp [hmore] at hm
|
||||
· exact heq
|
||||
have hhead_mem : head ∈ res.keys := List.head_mem hne
|
||||
have hhead_ck : head ∈ RangeRead.completeKeys db r := by
|
||||
rw [← hres_eq]; exact 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_ge (le_of_not_gt h))
|
||||
have hresolve_get : resolve db r.begin =
|
||||
((db.keys[(r.begin.anchor db).toNat] : Key) : WithTop Key) :=
|
||||
resolve_eq_getElem hanchor_ge hltlen
|
||||
set k : Key := db.keys[(r.begin.anchor db).toNat] with hk
|
||||
have hk_le_head : k ≤ head := WithTop.coe_le_coe.mp (by rw [← hresolve_get]; exact hle_head)
|
||||
have hk_stored : k ∈ db.keys := List.getElem_mem hltlen
|
||||
have hE := resolve_end_top_of_negCross_compat hcomp hrev hmore hne hend hhi
|
||||
have hk_ck : k ∈ RangeRead.completeKeys db r :=
|
||||
RangeRead.mem_completeKeys.mpr ⟨hk_stored, by rw [hresolve_get],
|
||||
by rw [hE]; exact WithTop.coe_lt_top k⟩
|
||||
have hk_ge_head : head ≤ k := by
|
||||
have hmem : k ∈ res.keys := by rw [hres_eq]; exact hk_ck
|
||||
exact (RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hmem
|
||||
have hk_eq : k = head := le_antisymm hk_le_head hk_ge_head
|
||||
rw [← hk_eq]
|
||||
exact hresolve_get
|
||||
|
||||
|
||||
theorem negCross_compat_filter {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
|
||||
(hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
|
||||
db.keys.filter (fun k : Key => decide (res.keys.head hne ≤ k)) = res.keys := by
|
||||
set head : Key := res.keys.head hne with hhead
|
||||
have hE := resolve_end_top_of_negCross_compat hcomp hrev hmore hne hend hhi
|
||||
have hL := resolve_begin_eq_head_of_negCross_compat hcomp hrev hmore hne hbegin hend hhi
|
||||
hcross hnonclamp
|
||||
have hck := completeKeys_eq_topOfLast_keys (db := db) (r := r) (last := head) hrev hE hL
|
||||
have hres_eq : res.keys = RangeRead.completeKeys db r := by
|
||||
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
|
||||
· simp [hmore] at hm
|
||||
· exact heq
|
||||
rw [hres_eq, hck]
|
||||
|
||||
theorem negCross_count_eq {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
|
||||
(hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
|
||||
db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
|
||||
db.keys.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key))) +
|
||||
reportedBelowBegin r res := by
|
||||
set head : Key := res.keys.head hne with hhead
|
||||
have hfil : db.keys.filter (fun k : Key => decide (head ≤ k)) = res.keys :=
|
||||
negCross_compat_filter hcomp hrev hmore hne hbegin hend hhi hcross hnonclamp
|
||||
cases hB : r.begin.key with
|
||||
| top =>
|
||||
have hcB : db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
|
||||
db.keys.length := by rw [hB]; exact countP_lt_top
|
||||
have hhmin : reportedBelowBegin r res = res.keys.length := by
|
||||
unfold reportedBelowBegin; rw [hB]; exact countP_lt_top
|
||||
have he : db.keys.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) =
|
||||
db.keys.countP (fun k : Key => decide (k < head)) := countP_lt_coe head
|
||||
have hlen := List.length_eq_length_filter_add (l := db.keys)
|
||||
(f := fun k : Key => decide (head ≤ k))
|
||||
have hf1 : (db.keys.filter (fun k : Key => decide (head ≤ k))).length = res.keys.length := by
|
||||
rw [hfil]
|
||||
have hf2 : (db.keys.filter (fun k : Key => !decide (head ≤ k))).length =
|
||||
db.keys.countP (fun k : Key => decide (k < head)) := by
|
||||
rw [List.countP_eq_length_filter]
|
||||
congr 1
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
by_cases h : head ≤ k
|
||||
· simp [h, not_lt.mpr h]
|
||||
· simp [h, lt_of_not_ge h]
|
||||
rw [hB] at hcB
|
||||
rw [hcB, he, hhmin]
|
||||
omega
|
||||
| coe b =>
|
||||
have hcross_key : head < b := by
|
||||
rw [hB] at hcross
|
||||
exact WithTop.coe_lt_coe.mp hcross
|
||||
have hcB : db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
|
||||
db.keys.countP (fun k : Key => decide (k < b)) := by rw [hB]; exact countP_lt_coe b
|
||||
have he : db.keys.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) =
|
||||
db.keys.countP (fun k : Key => decide (k < head)) := countP_lt_coe head
|
||||
have hhmin : reportedBelowBegin r res = res.keys.countP (fun k : Key => decide (k < b)) := by
|
||||
unfold reportedBelowBegin; rw [hB]; exact countP_lt_coe b
|
||||
have hsplit := countP_lt_eq_add_filter db.keys db.nodup (le_of_lt hcross_key)
|
||||
have hfil2 : db.keys.filter (fun k : Key => decide (head ≤ k ∧ k < b)) =
|
||||
res.keys.filter (fun k : Key => decide (k < b)) := by
|
||||
rw [filter_and_eq_filter_filter (fun k : Key => head ≤ k) (fun k : Key => k < b), hfil]
|
||||
have hlen : (db.keys.filter (fun k : Key => decide (head ≤ k ∧ k < b))).length =
|
||||
res.keys.countP (fun k : Key => decide (k < b)) := by
|
||||
rw [hfil2, List.countP_eq_length_filter]
|
||||
rw [hB] at hcB
|
||||
rw [hcB, he, hhmin]
|
||||
omega
|
||||
|
||||
/-- A general count identity: if the stored keys at or above `head` are exactly `R`, then
|
||||
the number of stored keys below `B` splits as those below `head` plus those of `R`
|
||||
below `B`. -/
|
||||
theorem count_eq_of_filter {l : List Key} {R : List Key} {head : Key} {B : WithTop Key}
|
||||
(hnd : l.Nodup) (hheadB : ((head : Key) : WithTop Key) < B)
|
||||
(hfil : l.filter (fun k : Key => decide (head ≤ k)) = R) :
|
||||
l.countP (fun k : Key => decide (((k : Key) : WithTop Key) < B)) =
|
||||
l.countP (fun k : Key => decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) +
|
||||
R.countP (fun k : Key => decide (((k : Key) : WithTop Key) < B)) := by
|
||||
cases B with
|
||||
| top =>
|
||||
have hcB : l.countP (fun k : Key => decide (((k : Key) : WithTop Key) < (⊤ : WithTop Key))) =
|
||||
l.length := countP_lt_top
|
||||
have hhmin : R.countP (fun k : Key => decide (((k : Key) : WithTop Key) < (⊤ : WithTop Key))) =
|
||||
R.length := countP_lt_top
|
||||
have he : l.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) =
|
||||
l.countP (fun k : Key => decide (k < head)) := countP_lt_coe head
|
||||
have hlen := List.length_eq_length_filter_add (l := l)
|
||||
(f := fun k : Key => decide (head ≤ k))
|
||||
have hf1 : (l.filter (fun k : Key => decide (head ≤ k))).length = R.length := by
|
||||
rw [hfil]
|
||||
have hf2 : (l.filter (fun k : Key => !decide (head ≤ k))).length =
|
||||
l.countP (fun k : Key => decide (k < head)) := by
|
||||
rw [List.countP_eq_length_filter]
|
||||
congr 1
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
by_cases h : head ≤ k
|
||||
· simp [h, not_lt.mpr h]
|
||||
· simp [h, lt_of_not_ge h]
|
||||
rw [hcB, he, hhmin]
|
||||
omega
|
||||
| coe b =>
|
||||
have hcross_key : head < b := WithTop.coe_lt_coe.mp hheadB
|
||||
have hcB : l.countP (fun k : Key => decide (((k : Key) : WithTop Key) < (↑b : WithTop Key))) =
|
||||
l.countP (fun k : Key => decide (k < b)) := countP_lt_coe b
|
||||
have he : l.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) =
|
||||
l.countP (fun k : Key => decide (k < head)) := countP_lt_coe head
|
||||
have hhmin : R.countP (fun k : Key => decide (((k : Key) : WithTop Key) < (↑b : WithTop Key))) =
|
||||
R.countP (fun k : Key => decide (k < b)) := countP_lt_coe b
|
||||
have hsplit := countP_lt_eq_add_filter l hnd (le_of_lt hcross_key)
|
||||
have hfil2 : l.filter (fun k : Key => decide (head ≤ k ∧ k < b)) =
|
||||
R.filter (fun k : Key => decide (k < b)) := by
|
||||
rw [filter_and_eq_filter_filter (fun k : Key => head ≤ k) (fun k : Key => k < b), hfil]
|
||||
have hlen : (l.filter (fun k : Key => decide (head ≤ k ∧ k < b))).length =
|
||||
R.countP (fun k : Key => decide (k < b)) := by
|
||||
rw [hfil2, List.countP_eq_length_filter]
|
||||
rw [hcB, he, hhmin]
|
||||
omega
|
||||
|
||||
|
||||
theorem negCross_hmin_eq {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
|
||||
(hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
|
||||
reportedBelowBegin r res = beginSlack r + 1 := by
|
||||
set head : Key := res.keys.head hne with hhead
|
||||
have hcount := negCross_count_eq hcomp hrev hmore hne hbegin hend hhi hcross hnonclamp
|
||||
set cH : ℕ := db.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) with hcH
|
||||
set cB : ℕ := db.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) with hcB
|
||||
have hsub : List.Sublist res.keys db.keys := result_sublist_db_of_compatible hcomp hrev
|
||||
have hmin_le : reportedBelowBegin r res ≤ cB := List.Sublist.countP_le hsub
|
||||
have hcB_ge : beginSlack r + 1 ≤ cB :=
|
||||
Nat.succ_le_of_lt (lt_of_lt_of_le hnonclamp hmin_le)
|
||||
have hanchor_ge : 0 ≤ r.begin.anchor db := by
|
||||
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin)]
|
||||
have : (beginSlack r : ℤ) + 1 ≤ (cB : ℤ) := by exact_mod_cast hcB_ge
|
||||
omega
|
||||
have hL := resolve_begin_eq_head_of_negCross_compat hcomp hrev hmore hne hbegin hend hhi
|
||||
hcross hnonclamp
|
||||
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
|
||||
have hhead_db : head ∈ db.keys := RangeRead.compatible_keys_subset hcomp hhead_mem
|
||||
have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
|
||||
intro htop
|
||||
rw [hL] at htop
|
||||
exact absurd htop (WithTop.coe_ne_top (a := head))
|
||||
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
|
||||
by_contra h
|
||||
exact hnot_top (resolve_eq_top (db := db) hanchor_ge (le_of_not_gt h))
|
||||
have hget := resolve_eq_getElem (db := db) (s := r.begin) hanchor_ge hltlen
|
||||
have hidx : db.keys[(r.begin.anchor db).toNat] = head := by
|
||||
have hcoe : ((db.keys[(r.begin.anchor db).toNat] : Key) : WithTop Key) =
|
||||
((head : Key) : WithTop Key) := by rw [← hget, hL]
|
||||
exact WithTop.coe_injective hcoe
|
||||
have hrank : db.keys.countP (fun k => decide (k < head)) = (r.begin.anchor db).toNat :=
|
||||
countP_lt_eq_of_getElem db.sorted hltlen hidx
|
||||
have hcH_eq : cH = (r.begin.anchor db).toNat := by
|
||||
rw [hcH, countP_lt_coe head]
|
||||
exact hrank
|
||||
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 htoNat : (r.begin.anchor db).toNat = cB - (beginSlack r + 1) := by
|
||||
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 hcH_add : cH + (beginSlack r + 1) = cB := by
|
||||
rw [hcH_eq, htoNat]
|
||||
exact Nat.sub_add_cancel hcB_ge
|
||||
omega
|
||||
|
||||
|
||||
/-- In the clamp region every key below the reported head is necessary: inserting it
|
||||
into the database made of the reported keys either clamps the begin selector to the
|
||||
empty key or lands it on the inserted key, and either way the complete keys gain a
|
||||
key, so the result is no longer compatible. -/
|
||||
theorem necessary_below_head_of_negCross_clamp {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
|
||||
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
|
||||
{k : Key} (hk : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)) :
|
||||
Necessary r res k := by
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
intro cr hs
|
||||
by_contra hkcr
|
||||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
||||
have hk_not : k ∉ res.keys := by
|
||||
intro hkmem
|
||||
exact hkcr (necessary_of_mem_result ⟨db₀, hcomp₀⟩ hkmem cr hs)
|
||||
let db₁ : DB := ⟨res.keys, hsort⟩
|
||||
have hcB₁ : db₁.keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res := rfl
|
||||
have hanchor₁ : r.begin.anchor db₁ < 0 := by
|
||||
rw [anchor_eq_count_sub_slack db₁ r (le_of_lt hbegin), hcB₁]
|
||||
have : (reportedBelowBegin r res : ℤ) ≤ (beginSlack r : ℤ) := by exact_mod_cast hclamp
|
||||
omega
|
||||
have hL₁ : resolve db₁ r.begin = (([] : Key) : WithTop Key) :=
|
||||
resolve_eq_nil (db := db₁) (s := r.begin) hanchor₁
|
||||
have hE₁ : resolve db₁ r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_eq_top_of_all_lt (db := db₁) (fun x hx => hhi x hx) hend
|
||||
have hfil₁ : db₁.keys.filter (fun x : Key => decide (([] : Key) ≤ x)) = res.keys := by
|
||||
have hself : db₁.keys.filter (fun x : Key => decide (([] : Key) ≤ x)) = db₁.keys := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x _; rw [decide_eq_true_eq]; exact nil_le_key x
|
||||
rw [hself]
|
||||
have hcomp₁ : RangeRead.Compatible db₁ r res := by
|
||||
refine ⟨hcomp₀.1, Or.inr ⟨hmore, ?_⟩⟩
|
||||
rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev]), hL₁, hE₁]
|
||||
simpa [RangeRead.inRange] using hfil₁.symm
|
||||
let db₂ : DB := db₁.insert k hk_not
|
||||
have hagree : AgreeOn cr db₁ db₂ :=
|
||||
(ConflictRange.keys_insert_of_not_mem cr db₁ hk_not hkcr).symm
|
||||
have hcomp₂ : RangeRead.Compatible db₂ r res := (hs db₁ db₂ hagree).mp hcomp₁
|
||||
have hck₂ : RangeRead.completeKeys db₂ r = res.keys := by
|
||||
rcases hcomp₂.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
|
||||
· simp [hmore] at hm
|
||||
· exact heq.symm
|
||||
have hdb₂_keys : db₂.keys = k :: res.keys := by
|
||||
unfold db₂
|
||||
rw [DB.insert_keys, show db₁.keys = res.keys from rfl]
|
||||
cases hres : res.keys with
|
||||
| nil => exact absurd hres hne
|
||||
| cons a t =>
|
||||
have hhead_a : res.keys.head hne = a := by simp [hres]
|
||||
have hka : k ≤ a := by
|
||||
rw [hhead_a] at hk
|
||||
exact le_of_lt (WithTop.coe_lt_coe.mp hk)
|
||||
rw [List.orderedInsert_cons_of_le (r := (· ≤ ·)) (a := k) (b := a) t hka]
|
||||
have hkltB : ((k : Key) : WithTop Key) < r.begin.key := lt_trans hk hcross
|
||||
have hcB₂ : db₂.keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res + 1 := by
|
||||
rw [hdb₂_keys, List.countP_cons]
|
||||
rw [decide_eq_true_eq.mpr hkltB]
|
||||
simp [reportedBelowBegin]
|
||||
have hanchor₂ : r.begin.anchor db₂ ≤ 0 := by
|
||||
rw [anchor_eq_count_sub_slack db₂ r (le_of_lt hbegin), hcB₂]
|
||||
have : (reportedBelowBegin r res : ℤ) ≤ (beginSlack r : ℤ) := by exact_mod_cast hclamp
|
||||
omega
|
||||
have hL₂_le : resolve db₂ r.begin ≤ ((k : Key) : WithTop Key) := by
|
||||
by_cases hneg : r.begin.anchor db₂ < 0
|
||||
· rw [resolve_eq_nil (db := db₂) (s := r.begin) hneg]
|
||||
exact WithTop.coe_le_coe.mpr (nil_le_key k)
|
||||
· have hzero : r.begin.anchor db₂ = 0 := by omega
|
||||
have hltlen₂ : (r.begin.anchor db₂).toNat < db₂.keys.length := by
|
||||
rw [hzero, hdb₂_keys]
|
||||
simp
|
||||
rw [resolve_eq_getElem (db := db₂) (s := r.begin) (by omega) hltlen₂]
|
||||
have hval₂ : db₂.keys[(r.begin.anchor db₂).toNat]'hltlen₂ = k := by
|
||||
simp [hzero, hdb₂_keys]
|
||||
exact WithTop.coe_le_coe.mpr (le_of_eq hval₂)
|
||||
have hall₂ : ∀ x ∈ db₂.keys, ((x : Key) : WithTop Key) < r.end_.key := by
|
||||
intro x hx
|
||||
rw [hdb₂_keys] at hx
|
||||
rcases List.mem_cons.mp hx with rfl | hx
|
||||
· exact lt_of_lt_of_le hk (le_of_lt (hhi _ (List.head_mem hne)))
|
||||
· exact hhi x hx
|
||||
have hE₂ : resolve db₂ r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_eq_top_of_all_lt hall₂ hend
|
||||
have hk_ck₂ : k ∈ RangeRead.completeKeys db₂ r := by
|
||||
rw [RangeRead.mem_completeKeys]
|
||||
refine ⟨by rw [hdb₂_keys]; exact List.mem_cons_self .., hL₂_le, ?_⟩
|
||||
rw [hE₂]; exact WithTop.coe_lt_top k
|
||||
rw [hck₂] at hk_ck₂
|
||||
exact hk_not hk_ck₂
|
||||
|
||||
/-- **The clamp branch of the negative-offset crossed complete overshoot.** When the
|
||||
reported keys below `begin.key` fit in the begin slack, every key is necessary, so the
|
||||
full range is minimal. -/
|
||||
theorem minimal_fullRange_of_negCross_clamp {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
|
||||
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hclamp : reportedBelowBegin r res ≤ beginSlack r) :
|
||||
Minimal r res ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by
|
||||
refine (minimal_iff_sound_and_necessary).mpr ⟨sound_fullRange r res, ?_⟩
|
||||
intro k _
|
||||
by_cases hkhead : ((k : Key) : WithTop Key) <
|
||||
((res.keys.head hne : Key) : WithTop Key)
|
||||
· exact necessary_below_head_of_negCross_clamp hread hrev hmore hne hbegin hend hhi
|
||||
hcross hclamp hkhead
|
||||
· have hhead_le : res.keys.head hne ≤ k := WithTop.coe_le_coe.mp (le_of_not_gt hkhead)
|
||||
by_cases hklast : k ≤ res.keys.getLast hne
|
||||
· exact necessary_of_between_result hread (List.head_mem hne) (List.getLast_mem hne)
|
||||
hhead_le hklast
|
||||
· exact necessary_of_end_offset_ge_two hread hrev hmore hne hend hhi
|
||||
(le_of_lt (lt_of_not_ge hklast))
|
||||
|
||||
/-- **Soundness of the top range from the reported head in the nonclamp branch.**
|
||||
Agreement on `[head, ⊤)` fixes the stored keys at or above the head, hence the begin
|
||||
resolution (`hmin = q + 1` forces the selector onto the head) and the end sentinel, so
|
||||
the complete keys are unchanged. -/
|
||||
theorem sound_topOfLast_of_negCross_nonclamp {r : RangeRead} {res : Result}
|
||||
(hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ [])
|
||||
(hbegin : r.begin.offset < 0) (hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
|
||||
Sound r res (topOfLast (res.keys.head hne)) := by
|
||||
intro db₁ db₂ hagree
|
||||
have step : ∀ db db', AgreeOn (topOfLast (res.keys.head hne)) db db' →
|
||||
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
|
||||
intro db db' hag' hcomp_db
|
||||
set head : Key := res.keys.head hne with hhead
|
||||
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
|
||||
have hhmin : reportedBelowBegin r res = beginSlack r + 1 :=
|
||||
negCross_hmin_eq hcomp_db hrev hmore hne hbegin hend hhi hcross hnonclamp
|
||||
have hE := resolve_end_top_of_negCross_compat hcomp_db hrev hmore hne hend hhi
|
||||
have hL := resolve_begin_eq_head_of_negCross_compat hcomp_db hrev hmore hne hbegin
|
||||
hend hhi hcross hnonclamp
|
||||
have hres_eq : res.keys = RangeRead.completeKeys db r := by
|
||||
rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
|
||||
· simp [hmore] at hm
|
||||
· exact heq
|
||||
have hck : RangeRead.completeKeys db r =
|
||||
db.keys.filter (fun k => decide (head ≤ k)) :=
|
||||
completeKeys_eq_topOfLast_keys hrev hE hL
|
||||
have hagree_keys : db.keys.filter (fun k => decide (head ≤ k)) =
|
||||
db'.keys.filter (fun k => decide (head ≤ k)) := by
|
||||
have h := hag'
|
||||
rw [AgreeOn, topOfLast_keys, topOfLast_keys] at h
|
||||
exact h
|
||||
have hfil' : db'.keys.filter (fun k => decide (head ≤ k)) = res.keys := by
|
||||
rw [← hagree_keys, ← hck, hres_eq]
|
||||
have hall' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by
|
||||
intro k hk
|
||||
by_cases hkh : head ≤ k
|
||||
· have : k ∈ db'.keys.filter (fun k => decide (head ≤ k)) :=
|
||||
List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq]; exact hkh⟩
|
||||
rw [hfil'] at this
|
||||
exact hhi k this
|
||||
· exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (lt_of_not_ge hkh))
|
||||
(le_of_lt (hhi head hhead_mem))
|
||||
have hE' : resolve db' r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_eq_top_of_all_lt hall' hend
|
||||
have hhead_db' : head ∈ db'.keys := by
|
||||
have : head ∈ db'.keys.filter (fun k => decide (head ≤ k)) := by
|
||||
rw [hfil']; exact hhead_mem
|
||||
exact List.mem_of_mem_filter this
|
||||
have hcount' : db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
|
||||
db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) +
|
||||
reportedBelowBegin r res :=
|
||||
count_eq_of_filter db'.nodup hcross hfil'
|
||||
have hcB'_ge : beginSlack r + 1 ≤ db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
|
||||
rw [hcount', hhmin]; omega
|
||||
have hanchor'_ge : 0 ≤ r.begin.anchor db' := by
|
||||
rw [anchor_eq_count_sub_slack db' r (le_of_lt hbegin)]
|
||||
have : (beginSlack r : ℤ) + 1 ≤ ((db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))) : ℤ) := by
|
||||
exact_mod_cast hcB'_ge
|
||||
omega
|
||||
have htoNat' : (r.begin.anchor db').toNat =
|
||||
db'.keys.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < r.begin.key)) - (beginSlack r + 1) := by
|
||||
have hz : r.begin.anchor db' = ((db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℤ) -
|
||||
((beginSlack r + 1 : ℕ) : ℤ)) := by
|
||||
rw [anchor_eq_count_sub_slack db' r (le_of_lt hbegin)]; push_cast; ring
|
||||
have hz2 : ((db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) -
|
||||
((beginSlack r + 1 : ℕ) : ℤ) =
|
||||
((db'.keys.countP (fun k : Key =>
|
||||
decide (((k : Key) : WithTop Key) < r.begin.key)) -
|
||||
(beginSlack r + 1) : ℕ) : ℤ) := by
|
||||
rw [← Nat.cast_sub hcB'_ge]
|
||||
rw [hz, hz2, Int.toNat_natCast]
|
||||
have hidx_eq : (r.begin.anchor db').toNat =
|
||||
db'.keys.countP (fun k => decide (k < head)) := by
|
||||
have hcH'_eq : db'.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < ((head : Key) : WithTop Key))) =
|
||||
db'.keys.countP (fun k => decide (k < head)) := countP_lt_coe head
|
||||
rw [htoNat', hcount', hhmin, hcH'_eq]
|
||||
omega
|
||||
have hltlen' : (r.begin.anchor db').toNat < db'.keys.length := by
|
||||
rw [hidx_eq]
|
||||
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_db'
|
||||
rw [countP_lt_eq_of_getElem db'.sorted hi hix]
|
||||
exact hi
|
||||
have hval : db'.keys[(r.begin.anchor db').toNat]'hltlen' = head := by
|
||||
simpa [hidx_eq] using getElem_countP_lt db'.sorted hhead_db'
|
||||
have hL' : resolve db' r.begin = ((head : Key) : WithTop Key) := by
|
||||
rw [resolve_eq_getElem (db := db') (s := r.begin) hanchor'_ge hltlen']
|
||||
exact congrArg (fun x => ((x : Key) : WithTop Key)) hval
|
||||
have hck' : RangeRead.completeKeys db' r =
|
||||
db'.keys.filter (fun k => decide (head ≤ k)) :=
|
||||
completeKeys_eq_topOfLast_keys hrev hE' hL'
|
||||
exact ⟨hcomp_db.1, Or.inr ⟨hmore, by rw [hck', hfil']⟩⟩
|
||||
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
|
||||
|
||||
/-- **The nonclamp branch of the negative-offset crossed complete overshoot.** The top
|
||||
range from the reported head is minimal: soundness is above, and every key at or above
|
||||
the head is necessary by convexity or by the overshoot necessity. -/
|
||||
theorem minimal_topOfLast_of_negCross_nonclamp {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
|
||||
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
|
||||
Minimal r res (topOfLast (res.keys.head hne)) := by
|
||||
refine (minimal_iff_sound_and_necessary).mpr
|
||||
⟨sound_topOfLast_of_negCross_nonclamp hrev hmore hne hbegin hend hhi hcross hnonclamp, ?_⟩
|
||||
intro k hk
|
||||
have hhead_le : res.keys.head hne ≤ k := WithTop.coe_le_coe.mp hk.1
|
||||
by_cases hklast : k ≤ res.keys.getLast hne
|
||||
· exact necessary_of_between_result hread (List.head_mem hne) (List.getLast_mem hne)
|
||||
hhead_le hklast
|
||||
· exact necessary_of_end_offset_ge_two hread hrev hmore hne hend hhi
|
||||
(le_of_lt (lt_of_not_ge hklast))
|
||||
|
||||
theorem headD_eq_head_of_ne {l : List Key} (h : l ≠ []) :
|
||||
l.headD ([] : Key) = l.head h := by
|
||||
cases l with
|
||||
| nil => exact absurd rfl h
|
||||
| cons a t => rfl
|
||||
|
||||
/-- **Closed form for the negative-offset crossed complete overshoot (forward).** -/
|
||||
theorem minimal_closedForm_of_negCross_overshoot {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hrev : r.reverse = false) (hbegin : r.begin.offset < 0)
|
||||
(hmore : res.more = false) (hne : res.keys ≠ []) (hend : 2 ≤ r.end_.offset)
|
||||
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
|
||||
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) :
|
||||
Minimal r res (closedFormNegCrossOvershoot r res) := by
|
||||
unfold closedFormNegCrossOvershoot
|
||||
by_cases hclamp : reportedBelowBegin r res ≤ beginSlack r
|
||||
· rw [ite_eq_left hclamp]
|
||||
exact minimal_fullRange_of_negCross_clamp hread hrev hmore hne hbegin hend hhi hcross hclamp
|
||||
· rw [ite_eq_right hclamp]
|
||||
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne :=
|
||||
headD_eq_head_of_ne hne
|
||||
rw [hheadD]
|
||||
exact minimal_topOfLast_of_negCross_nonclamp hread hrev hmore hne hbegin hend hhi hcross
|
||||
(lt_of_not_ge hclamp)
|
||||
|
||||
|
||||
theorem getLastD_eq_getLast_of_ne {l : List Key} (h : l ≠ []) :
|
||||
l.getLastD ([] : Key) = l.getLast h := by
|
||||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast h]; rfl
|
||||
|
||||
/-- The crossed nonpositive-begin complete overshoot region (reversed traversal). -/
|
||||
abbrev negCrossOvershootRev (r : RangeRead) (res : Result) : Prop :=
|
||||
r.reverse = true ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
|
||||
2 ≤ r.end_.offset ∧
|
||||
(∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) ∧
|
||||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key
|
||||
|
||||
/-- The reversed closed form, expressed through the forward rule on the flipped read. -/
|
||||
noncomputable def closedFormNegCrossOvershootRev (r : RangeRead) (res : Result) :
|
||||
ConflictRange :=
|
||||
closedFormNegCrossOvershoot { r with reverse := false }
|
||||
{ keys := res.keys.reverse, more := false }
|
||||
|
||||
/-- **Closed form for the negative-offset crossed complete overshoot (reversed).** -/
|
||||
theorem minimal_closedForm_of_negCross_overshoot_rev {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (h : negCrossOvershootRev r res) :
|
||||
Minimal r res (closedFormNegCrossOvershootRev r res) := by
|
||||
obtain ⟨hrev, hbegin, hmore, hne, hend, hhi, hcross⟩ := h
|
||||
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 hhi' : ∀ k ∈ res'.keys, ((k : Key) : WithTop Key) < r'.end_.key := by
|
||||
intro k hk
|
||||
exact hhi k (by simpa [res'] using hk)
|
||||
have hhead' : res'.keys.head hne' = res.keys.getLast hne := by
|
||||
simpa [res'] using List.head_reverse (l := res.keys) (by simpa [res'] using hne')
|
||||
have hcross' : ((res'.keys.head hne' : Key) : WithTop Key) < r'.begin.key := by
|
||||
rw [hhead']
|
||||
rw [show res.keys.getLastD ([] : Key) = res.keys.getLast hne from
|
||||
getLastD_eq_getLast_of_ne hne] at hcross
|
||||
simpa [r'] using hcross
|
||||
have hmin' : Minimal r' res' (closedFormNegCrossOvershoot r' res') :=
|
||||
minimal_closedForm_of_negCross_overshoot hread' rfl hbegin rfl hne' hend hhi' hcross'
|
||||
exact (minimal_flip (r := r) (res := res) (cr := closedFormNegCrossOvershoot r' res')
|
||||
(b := true) hrev hmore).mp hmin'
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user