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,524 @@
|
||||
/-
|
||||
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.NegCrossTruncClampLastGe
|
||||
import FormalConflictRange.Empty
|
||||
|
||||
/-!
|
||||
# The crossed negative-begin truncated cell with the end sentinel
|
||||
|
||||
This module closes a cell left open by the compact residual: a forward, crossed,
|
||||
truncated read with a negative begin offset, a nonpositive end offset, the reported
|
||||
keys below `begin.key`, and the end key at the sentinel `⊤`. The end key being the
|
||||
sentinel means the end selector resolves to an ordinary stored key (since its offset is
|
||||
nonpositive) and the whole key space above `begin.key` is available for padding.
|
||||
|
||||
The minimal sound range is `[⊥, ⊤)`: every genuine key is necessary. Below the reported
|
||||
head, inserting the key prepends it to the complete window; at or above `begin.key`, a
|
||||
witness database stores the reported keys together with `1 - end.offset` pad keys above
|
||||
`begin.key`, so erasing the target shortens the complete window and breaks the reported
|
||||
prefix. Convexity between the reported last and `begin.key` fills the gap.
|
||||
-/
|
||||
|
||||
open FormalConflictRange
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
/-- A forward truncated, crossed, negative-begin read with a nonpositive end offset, a
|
||||
clamped begin selector, the reported keys below `begin.key`, and the end key at the
|
||||
sentinel. -/
|
||||
def negCrossTruncStrictTop (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 = (⊤ : WithTop Key) ∧
|
||||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
||||
r.begin.key < r.end_.key
|
||||
|
||||
/-- Storing the reported keys followed by pad keys at or above `begin.key` gives a
|
||||
compatible database whose begin selector clamps and whose end selector lands on the
|
||||
first pad key. -/
|
||||
theorem compat_of_pad_top {r : RangeRead} {res : Result} {F : List Key} {m : ℕ}
|
||||
(hread : Readable r res) (hne : res.keys ≠ []) (hrev : r.reverse = false)
|
||||
(hmore : res.more = true) (hbegin : r.begin.offset < 0)
|
||||
(hend : r.end_.offset ≤ 0)
|
||||
(htop : r.end_.key = (⊤ : WithTop Key))
|
||||
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
|
||||
(hallB : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.begin.key)
|
||||
(hFsorted : F.SortedLT) (hFlen : F.length = m)
|
||||
(hm : m = (1 - r.end_.offset).toNat)
|
||||
(hFne : F ≠ []) (hFge : ∀ x ∈ F, r.begin.key ≤ ((x : Key) : WithTop Key))
|
||||
(hFlast : ∀ x ∈ F, res.keys.getLast hne < x) :
|
||||
∃ dbw : DB, dbw.keys = res.keys ++ F ∧ RangeRead.Compatible dbw r res ∧
|
||||
resolve dbw r.begin = (([] : Key) : WithTop Key) ∧
|
||||
resolve dbw r.end_ = ((F.head hFne : Key) : WithTop Key) := by
|
||||
classical
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
||||
have hle_last : ∀ x ∈ res.keys, x ≤ res.keys.getLast hne :=
|
||||
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
||||
have hDsort : (res.keys ++ F).SortedLT := by
|
||||
refine List.sortedLT_append.mpr ⟨hsort, hFsorted, ?_⟩
|
||||
intro a ha b hb
|
||||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hallB a ha) (hFge b hb))
|
||||
let dbw : DB := ⟨res.keys ++ F, hDsort⟩
|
||||
have hdbw_keys : dbw.keys = res.keys ++ F := rfl
|
||||
have hcountB : dbw.keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res := by
|
||||
rw [hdbw_keys, List.countP_append]
|
||||
have h1 : res.keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res := rfl
|
||||
have h2 : F.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) = 0 := by
|
||||
rw [List.countP_eq_zero]
|
||||
intro x hx
|
||||
simp only [decide_eq_true_eq]
|
||||
exact not_lt.mpr (hFge x hx)
|
||||
rw [h1, h2, Nat.add_zero]
|
||||
have hanchorB : r.begin.anchor dbw < 0 := by
|
||||
rw [anchor_eq_count_sub_slack dbw r (le_of_lt hbegin), hcountB]
|
||||
have hle : (reportedBelowBegin r res : ℤ) ≤ (beginSlack r : ℤ) := by exact_mod_cast hclamp
|
||||
omega
|
||||
have hrb : resolve dbw r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hanchorB
|
||||
have hlenD : (res.keys ++ F).length = res.keys.length + m := by
|
||||
rw [List.length_append, hFlen]
|
||||
have hm_int : (m : Int) = 1 - r.end_.offset := by
|
||||
rw [hm]; exact Int.toNat_of_nonneg (by omega)
|
||||
have hanchorE : r.end_.anchor dbw = (res.keys.length : Int) := by
|
||||
rw [anchor_of_top (s := r.end_) htop, hdbw_keys, hlenD]
|
||||
push_cast
|
||||
rw [hm_int]; ring
|
||||
have hDget? : dbw.keys[res.keys.length]? = some (F.head hFne) := by
|
||||
change (res.keys ++ F)[res.keys.length]? = some (F.head hFne)
|
||||
rw [List.getElem?_append]
|
||||
rw [if_neg (not_lt.mpr (le_refl _)), Nat.sub_self]
|
||||
rw [List.getElem?_eq_getElem (by rw [hFlen]; omega), List.head_eq_getElem hFne]
|
||||
have hre : resolve dbw r.end_ = ((F.head hFne : Key) : WithTop Key) := by
|
||||
rw [resolve, ite_eq_right (by rw [hanchorE]; omega)]
|
||||
rw [hanchorE, Int.toNat_natCast, hDget?]
|
||||
have hltF : ((res.keys.getLast hne : Key) : WithTop Key) < resolve dbw r.end_ := by
|
||||
rw [hre]
|
||||
exact WithTop.coe_lt_coe.mpr (hFlast (F.head hFne) (List.head_mem hFne))
|
||||
have hckw : (RangeRead.completeKeys dbw r).filter
|
||||
(fun x : Key => decide (x ≤ res.keys.getLast hne)) = res.keys := by
|
||||
rw [completeKeys_filter_le_of_resolve_begin (db := dbw) hrev (H := ([] : Key)) hrb hltF]
|
||||
rw [hdbw_keys, List.filter_append]
|
||||
have hres_fil : res.keys.filter (fun x : Key => decide
|
||||
(((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x ≤ res.keys.getLast hne)) = res.keys := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
exact ⟨coe_nil_le_key_withTop _, hle_last x hx⟩
|
||||
have hF_fil : F.filter (fun x : Key => decide
|
||||
(((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x ≤ res.keys.getLast hne)) = [] := by
|
||||
rw [List.filter_eq_nil_iff]
|
||||
intro x hx
|
||||
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
|
||||
exact fun _ => not_le.mpr (hFlast x hx)
|
||||
rw [hres_fil, hF_fil, List.append_nil]
|
||||
have hcompw : RangeRead.Compatible dbw r res := by
|
||||
rw [compatible_iff_truncated_keys hrev hmore hne]
|
||||
exact ⟨hcomp₀.1, hckw⟩
|
||||
exact ⟨dbw, hdbw_keys, hcompw, hrb, hre⟩
|
||||
|
||||
/-- Below the reported head, inserting the key into the padded witness prepends it to
|
||||
the complete window, breaking the truncated prefix. -/
|
||||
theorem exists_witness_below_head_of_negCross_trunc_strict_top {r : RangeRead} {res : Result}
|
||||
{k : Key}
|
||||
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
|
||||
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
|
||||
(hend : r.end_.offset ≤ 0)
|
||||
(htop : r.end_.key = (⊤ : WithTop Key))
|
||||
(hBltTop : r.begin.key < (⊤ : WithTop Key))
|
||||
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
|
||||
(hallB : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.begin.key)
|
||||
(hk : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)) :
|
||||
∃ dbw : DB, ∃ hkdb : k ∉ dbw.keys, RangeRead.Compatible dbw r res ∧
|
||||
¬ RangeRead.Compatible (dbw.insert k hkdb) r res := by
|
||||
classical
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
||||
have hhead_le_last : res.keys.head hne ≤ res.keys.getLast hne :=
|
||||
(hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)
|
||||
have hhead_le : ∀ x ∈ res.keys, res.keys.head hne ≤ x :=
|
||||
fun x hx => (hsort.pairwise.imp le_of_lt).rel_head hx
|
||||
have hk_head : k < res.keys.head hne := WithTop.coe_lt_coe.mp hk
|
||||
set m : ℕ := (1 - r.end_.offset).toNat with hm
|
||||
have hm1 : 1 ≤ m := by rw [hm]; omega
|
||||
have hcard : (m : ℕ∞) ≤ intervalCard r.begin.key (⊤ : WithTop Key) := by
|
||||
rw [intervalCard_top_right (ne_of_lt hBltTop)]
|
||||
exact le_top
|
||||
obtain ⟨dbf, hdbfIn, hdbfLen⟩ :=
|
||||
exists_db_keysIn (B := r.begin.key) (E := (⊤ : WithTop Key)) (m := m) hcard
|
||||
set F : List Key := dbf.keys with hF
|
||||
have hFsorted : F.SortedLT := dbf.sorted
|
||||
have hFlen : F.length = m := hdbfLen
|
||||
have hFne : F ≠ [] := by
|
||||
intro h; rw [h] at hFlen; simp at hFlen; omega
|
||||
have hFge : ∀ x ∈ F, r.begin.key ≤ ((x : Key) : WithTop Key) :=
|
||||
fun x hx => (hdbfIn x hx).1
|
||||
have hlast_lt_B : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key :=
|
||||
hallB _ (List.getLast_mem hne)
|
||||
have hFlast : ∀ x ∈ F, res.keys.getLast hne < x := by
|
||||
intro x hx
|
||||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le hlast_lt_B (hFge x hx))
|
||||
obtain ⟨dbw, hdbw_keys, hcompw, _hrb, _hre⟩ :=
|
||||
compat_of_pad_top ⟨db₀, hcomp₀⟩ hne hrev hmore hbegin hend htop hclamp hallB hFsorted hFlen
|
||||
hm hFne hFge hFlast
|
||||
have hk_not_res : k ∉ res.keys := fun hx => absurd (hhead_le k hx) (not_le.mpr hk_head)
|
||||
have hhead_lt_B : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key :=
|
||||
hallB _ (List.head_mem hne)
|
||||
have hk_lt_B : ((k : Key) : WithTop Key) < r.begin.key := lt_trans hk hhead_lt_B
|
||||
have hk_not_F : k ∉ F := fun hx => absurd (hFge k hx) (not_le.mpr hk_lt_B)
|
||||
have hkdb : k ∉ dbw.keys := by
|
||||
rw [hdbw_keys]
|
||||
simp [hk_not_res, hk_not_F]
|
||||
have hins_keys : (dbw.insert k hkdb).keys = k :: (res.keys ++ F) := by
|
||||
rw [DB.insert_keys, hdbw_keys]
|
||||
cases hres : res.keys with
|
||||
| nil => exact absurd hres hne
|
||||
| cons a t =>
|
||||
have hka : k ≤ a := le_of_lt (WithTop.coe_lt_coe.mp (by simpa [hres] using hk))
|
||||
rw [List.cons_append]
|
||||
rw [List.orderedInsert_cons_of_le (r := (· ≤ ·)) (a := k) (b := a) (l := t ++ F) hka]
|
||||
have hcountB' : (dbw.insert k hkdb).keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res + 1 := by
|
||||
rw [hins_keys, List.countP_cons, List.countP_append]
|
||||
have h1 : res.keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res := rfl
|
||||
have h2 : F.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) = 0 := by
|
||||
rw [List.countP_eq_zero]
|
||||
intro x hx
|
||||
simp only [decide_eq_true_eq]
|
||||
exact not_lt.mpr (hFge x hx)
|
||||
simp [h1, h2, hk_lt_B]
|
||||
have hanchorB' : r.begin.anchor (dbw.insert k hkdb) ≤ 0 := by
|
||||
rw [anchor_eq_count_sub_slack (dbw.insert k hkdb) r (le_of_lt hbegin), hcountB']
|
||||
have hle : (reportedBelowBegin r res : ℤ) ≤ (beginSlack r : ℤ) := by exact_mod_cast hclamp
|
||||
omega
|
||||
have hlen' : (dbw.insert k hkdb).keys.length = res.keys.length + m + 1 := by
|
||||
rw [hins_keys, List.length_cons, List.length_append, hFlen]
|
||||
have hm_int : (m : Int) = 1 - r.end_.offset := by
|
||||
rw [hm]; exact Int.toNat_of_nonneg (by omega)
|
||||
have hanchorE' : r.end_.anchor (dbw.insert k hkdb) = (res.keys.length : Int) + 1 := by
|
||||
rw [anchor_of_top (s := r.end_) htop, hlen']
|
||||
push_cast
|
||||
rw [hm_int]; ring
|
||||
have hD'get? : (dbw.insert k hkdb).keys[res.keys.length + 1]? = some (F.head hFne) := by
|
||||
rw [hins_keys, List.getElem?_cons_succ]
|
||||
rw [List.getElem?_append]
|
||||
rw [if_neg (not_lt.mpr (le_refl _)), Nat.sub_self]
|
||||
rw [List.getElem?_eq_getElem (by rw [hFlen]; omega), List.head_eq_getElem hFne]
|
||||
have hre' : resolve (dbw.insert k hkdb) r.end_ =
|
||||
((F.head hFne : Key) : WithTop Key) := by
|
||||
rw [resolve, ite_eq_right (by rw [hanchorE']; omega)]
|
||||
have hnat : ((res.keys.length : Int) + 1).toNat = res.keys.length + 1 := by
|
||||
rw [← Nat.cast_one, ← Nat.cast_add, Int.toNat_natCast]
|
||||
rw [hanchorE', hnat, hD'get?]
|
||||
have hltF' : ((res.keys.getLast hne : Key) : WithTop Key) <
|
||||
resolve (dbw.insert k hkdb) r.end_ := by
|
||||
rw [hre']
|
||||
exact WithTop.coe_lt_coe.mpr (hFlast (F.head hFne) (List.head_mem hFne))
|
||||
have hck' : (RangeRead.completeKeys (dbw.insert k hkdb) r).filter
|
||||
(fun x : Key => decide (x ≤ res.keys.getLast hne)) = k :: res.keys := by
|
||||
by_cases hneg : r.begin.anchor (dbw.insert k hkdb) < 0
|
||||
· have hrb' : resolve (dbw.insert k hkdb) r.begin = (([] : Key) : WithTop Key) :=
|
||||
resolve_eq_nil hneg
|
||||
rw [completeKeys_filter_le_of_resolve_begin (db := dbw.insert k hkdb) hrev
|
||||
(H := ([] : Key)) hrb' hltF']
|
||||
rw [hins_keys, List.filter_cons_of_pos]
|
||||
· rw [List.filter_append]
|
||||
have hres_fil : res.keys.filter (fun x : Key => decide
|
||||
(((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x ≤ res.keys.getLast hne)) = res.keys := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
exact ⟨coe_nil_le_key_withTop _, (hsort.pairwise.imp le_of_lt).rel_getLast hx⟩
|
||||
have hF_fil : F.filter (fun x : Key => decide
|
||||
(((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x ≤ res.keys.getLast hne)) = [] := by
|
||||
rw [List.filter_eq_nil_iff]
|
||||
intro x hx
|
||||
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
|
||||
exact fun _ => not_le.mpr (hFlast x hx)
|
||||
rw [hres_fil, hF_fil, List.append_nil]
|
||||
· rw [decide_eq_true_eq]
|
||||
exact ⟨coe_nil_le_key_withTop _, le_of_lt (lt_of_lt_of_le hk_head hhead_le_last)⟩
|
||||
· have hzero : r.begin.anchor (dbw.insert k hkdb) = 0 := by omega
|
||||
have hltlen : (r.begin.anchor (dbw.insert k hkdb)).toNat <
|
||||
(dbw.insert k hkdb).keys.length := by
|
||||
rw [hzero, hins_keys]; simp
|
||||
have hins_ord : dbw.keys.orderedInsert (fun x1 x2 : Key => x1 ≤ x2) k =
|
||||
k :: dbw.keys := by
|
||||
rw [← DB.insert_keys (hk := hkdb)]
|
||||
rw [hins_keys, hdbw_keys]
|
||||
have hrb' : resolve (dbw.insert k hkdb) r.begin = ((k : Key) : WithTop Key) := by
|
||||
rw [resolve_eq_ite, hzero]
|
||||
simp [hins_ord]
|
||||
rw [completeKeys_filter_le_of_resolve_begin (db := dbw.insert k hkdb) hrev
|
||||
(H := k) hrb' hltF']
|
||||
rw [hins_keys, List.filter_cons_of_pos]
|
||||
· rw [List.filter_append]
|
||||
have hres_fil : res.keys.filter (fun x : Key => decide
|
||||
(((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x ≤ res.keys.getLast hne)) = res.keys := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
exact ⟨WithTop.coe_le_coe.mpr (le_trans (le_of_lt hk_head) (hhead_le x hx)),
|
||||
(hsort.pairwise.imp le_of_lt).rel_getLast hx⟩
|
||||
have hF_fil : F.filter (fun x : Key => decide
|
||||
(((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x ≤ res.keys.getLast hne)) = [] := by
|
||||
rw [List.filter_eq_nil_iff]
|
||||
intro x hx
|
||||
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
|
||||
exact fun _ => not_le.mpr (hFlast x hx)
|
||||
rw [hres_fil, hF_fil, List.append_nil]
|
||||
· rw [decide_eq_true_eq]
|
||||
exact ⟨le_rfl, le_of_lt (lt_of_lt_of_le hk_head hhead_le_last)⟩
|
||||
have hnot : ¬ RangeRead.Compatible (dbw.insert k hkdb) r res := by
|
||||
intro hc
|
||||
have heq := ((compatible_iff_truncated_keys hrev hmore hne).mp hc).2
|
||||
rw [hck'] at heq
|
||||
have hlen := congrArg List.length heq
|
||||
rw [List.length_cons] at hlen
|
||||
omega
|
||||
exact ⟨dbw, hkdb, hcompw, hnot⟩
|
||||
|
||||
/-- At or above `begin.key`, erasing the target from the padded witness drops the end
|
||||
resolution onto the reported last, so the complete window loses its last key. -/
|
||||
theorem exists_witness_above_begin_of_negCross_trunc_strict_top {r : RangeRead} {res : Result}
|
||||
{k : Key}
|
||||
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
|
||||
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
|
||||
(hend : r.end_.offset ≤ 0)
|
||||
(htop : r.end_.key = (⊤ : WithTop Key))
|
||||
(hBltTop : r.begin.key < (⊤ : WithTop Key))
|
||||
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
|
||||
(hallB : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.begin.key)
|
||||
(hkB : r.begin.key ≤ ((k : Key) : WithTop Key)) :
|
||||
∃ dbw : DB, k ∈ dbw.keys ∧ RangeRead.Compatible dbw r res ∧
|
||||
¬ RangeRead.Compatible (dbw.erase k) r res := by
|
||||
classical
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
||||
have hle_last : ∀ x ∈ res.keys, x ≤ res.keys.getLast hne :=
|
||||
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
||||
set m : ℕ := (1 - r.end_.offset).toNat with hm
|
||||
have hm1 : 1 ≤ m := by rw [hm]; omega
|
||||
have hcard : ((m - 1 + 1 : ℕ) : ℕ∞) ≤ intervalCard r.begin.key (⊤ : WithTop Key) := by
|
||||
rw [Nat.sub_add_cancel hm1, intervalCard_top_right (ne_of_lt hBltTop)]
|
||||
exact le_top
|
||||
obtain ⟨dba, hdbaIn, hknot, hdbaLen⟩ :=
|
||||
exists_db_keysIn_avoid (B := r.begin.key) (E := (⊤ : WithTop Key)) (k := k) (m := m - 1)
|
||||
hcard
|
||||
have hrawNodup : (k :: dba.keys).Nodup := List.nodup_cons.mpr ⟨hknot, dba.nodup⟩
|
||||
set F : List Key := (k :: dba.keys).insertionSort (· ≤ ·) with hF
|
||||
have hFperm : (k :: dba.keys).Perm F := (List.perm_insertionSort (· ≤ ·) _).symm
|
||||
have hFsorted : F.SortedLT := by
|
||||
rw [hF, List.sortedLT_iff_pairwise]
|
||||
exact DB.pairwise_lt_of_le_of_nodup
|
||||
(List.pairwise_insertionSort (r := (· ≤ ·)) (k :: dba.keys))
|
||||
(hFperm.nodup_iff.mp hrawNodup)
|
||||
have hFlen : F.length = m := by
|
||||
rw [hF, List.length_insertionSort, List.length_cons, hdbaLen]; omega
|
||||
have hFk : k ∈ F := hFperm.mem_iff.mp (List.mem_cons_self ..)
|
||||
have hFge : ∀ x ∈ F, r.begin.key ≤ ((x : Key) : WithTop Key) := by
|
||||
intro x hx
|
||||
have hx' := hFperm.mem_iff.mpr hx
|
||||
rcases List.mem_cons.mp hx' with rfl | hx''
|
||||
· exact hkB
|
||||
· exact (hdbaIn x hx'').1
|
||||
have hlast_lt_B : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key :=
|
||||
hallB _ (List.getLast_mem hne)
|
||||
have hFlast : ∀ x ∈ F, res.keys.getLast hne < x := by
|
||||
intro x hx
|
||||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le hlast_lt_B (hFge x hx))
|
||||
have hFne : F ≠ [] := by
|
||||
intro h; rw [h] at hFlen; simp at hFlen; omega
|
||||
obtain ⟨dbw, hdbw_keys, hcompw, _hrb, _hre⟩ :=
|
||||
compat_of_pad_top ⟨db₀, hcomp₀⟩ hne hrev hmore hbegin hend htop hclamp hallB hFsorted hFlen
|
||||
hm hFne hFge hFlast
|
||||
have hlast_lt_k : res.keys.getLast hne < k := by
|
||||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le hlast_lt_B hkB)
|
||||
have hk_not_res : k ∉ res.keys := fun hx => absurd (hle_last k hx) (not_le.mpr hlast_lt_k)
|
||||
have hD' : (dbw.erase k).keys = res.keys ++ F.erase k := by
|
||||
rw [DB.erase_keys, hdbw_keys]
|
||||
exact List.erase_append_right F hk_not_res
|
||||
have hF'ge : ∀ x ∈ F.erase k, r.begin.key ≤ ((x : Key) : WithTop Key) :=
|
||||
fun x hx => hFge x (List.mem_of_mem_erase hx)
|
||||
have hF'zero : (F.erase k).countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) = 0 := by
|
||||
rw [List.countP_eq_zero]
|
||||
intro x hx
|
||||
simp only [decide_eq_true_eq]
|
||||
exact not_lt.mpr (hF'ge x hx)
|
||||
have hcnt' : (dbw.erase k).keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res := by
|
||||
rw [hD', List.countP_append]
|
||||
have h1 : res.keys.countP
|
||||
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
reportedBelowBegin r res := rfl
|
||||
rw [h1, hF'zero, Nat.add_zero]
|
||||
have hanchor' : r.begin.anchor (dbw.erase k) < 0 := by
|
||||
rw [anchor_eq_count_sub_slack (dbw.erase k) r (le_of_lt hbegin), hcnt']
|
||||
have hle : (reportedBelowBegin r res : ℤ) ≤ (beginSlack r : ℤ) := by exact_mod_cast hclamp
|
||||
omega
|
||||
have hrb' : resolve (dbw.erase k) r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hanchor'
|
||||
have hlenD' : (dbw.erase k).keys.length = res.keys.length + m - 1 := by
|
||||
rw [hD', List.length_append, List.length_erase_of_mem hFk, hFlen]
|
||||
omega
|
||||
have hm_int : (m : Int) = 1 - r.end_.offset := by
|
||||
rw [hm]; exact Int.toNat_of_nonneg (by omega)
|
||||
have hanchor_end' : r.end_.anchor (dbw.erase k) = (res.keys.length : Int) - 1 := by
|
||||
rw [anchor_of_top (s := r.end_) htop, hlenD']
|
||||
rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)]
|
||||
push_cast
|
||||
rw [hm_int]; ring
|
||||
have ht1 : 1 ≤ res.keys.length := List.length_pos_of_ne_nil hne
|
||||
have hEqInt : (res.keys.length : Int) - 1 = ((res.keys.length - 1 : ℕ) : Int) := by
|
||||
rw [Nat.cast_sub ht1]; norm_num
|
||||
have htoNat' : (r.end_.anchor (dbw.erase k)).toNat = res.keys.length - 1 := by
|
||||
rw [hanchor_end', hEqInt, Int.toNat_natCast]
|
||||
have hD'get? : (dbw.erase k).keys[res.keys.length - 1]? =
|
||||
some (res.keys.getLast hne) := by
|
||||
rw [hD', List.getElem?_append]
|
||||
rw [if_pos (by omega : res.keys.length - 1 < res.keys.length)]
|
||||
rw [List.getElem?_eq_getElem (by omega : res.keys.length - 1 < res.keys.length)]
|
||||
congr 1
|
||||
rw [List.getLast_eq_getElem hne]
|
||||
have hre' : resolve (dbw.erase k) r.end_ = ((res.keys.getLast hne : Key) : WithTop Key) := by
|
||||
rw [resolve, ite_eq_right (by rw [hanchor_end']; omega)]
|
||||
rw [hanchor_end', hEqInt, Int.toNat_natCast, hD'get?]
|
||||
have hckE : RangeRead.completeKeys (dbw.erase k) r = res.keys.dropLast := by
|
||||
unfold RangeRead.completeKeys RangeRead.inRange
|
||||
rw [ite_eq_right (by simp [hrev]), hrb', hre']
|
||||
have hpred : ∀ x ∈ (dbw.erase k).keys,
|
||||
decide (((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
((x : Key) : WithTop Key) < (((res.keys.getLast hne) : Key) : WithTop Key)) =
|
||||
decide (((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x < res.keys.getLast hne) := by
|
||||
intro x _
|
||||
rw [decide_eq_decide]
|
||||
exact and_congr_right fun _ => WithTop.coe_lt_coe
|
||||
rw [List.filter_congr hpred, hD', List.filter_append]
|
||||
conv_lhs => arg 1; arg 2; rw [← List.dropLast_append_getLast hne]
|
||||
rw [List.filter_append]
|
||||
have hfil : res.keys.dropLast.filter (fun x : Key => decide
|
||||
(((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x < res.keys.getLast hne)) = res.keys.dropLast := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
exact ⟨coe_nil_le_key_withTop _, by
|
||||
have h := hsort.pairwise.rel_dropLast_getLast hx
|
||||
simpa using h⟩
|
||||
rw [hfil]
|
||||
have hFnil : (F.erase k).filter (fun x : Key => decide
|
||||
(((([] : Key)) : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧
|
||||
x < res.keys.getLast hne)) = [] := by
|
||||
rw [List.filter_eq_nil_iff]
|
||||
intro x hx
|
||||
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
|
||||
exact fun _ => not_lt.mpr (le_of_lt (hFlast x (List.mem_of_mem_erase hx)))
|
||||
rw [hFnil, List.append_nil]
|
||||
simp
|
||||
have hnot : ¬ RangeRead.Compatible (dbw.erase k) r res := by
|
||||
rw [compatible_iff_truncated_keys hrev hmore hne]
|
||||
intro h
|
||||
have heq := h.2
|
||||
rw [hckE] at heq
|
||||
have hfil : res.keys.dropLast.filter
|
||||
(fun x : Key => decide (x ≤ res.keys.getLast hne)) = res.keys.dropLast := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
exact le_of_lt (hsort.pairwise.rel_dropLast_getLast hx)
|
||||
rw [hfil] at heq
|
||||
have hlen := congrArg List.length heq
|
||||
rw [List.length_dropLast] at hlen
|
||||
omega
|
||||
exact ⟨dbw, by rw [hdbw_keys]; exact List.mem_append.mpr (Or.inr hFk), hcompw, hnot⟩
|
||||
|
||||
/-- The sentinel-end strict cell is minimal with the full range `[⊥, ⊤)`. -/
|
||||
theorem minimal_fullRange_of_negCross_trunc_strict_top {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (h : negCrossTruncStrictTop r res) :
|
||||
Minimal r res ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by
|
||||
obtain ⟨hmore, hrev, hbegin, hne, _hcrossD, hend, hclamp, htop, hlastD, hBltE⟩ := h
|
||||
have hreadP : Readable r res := hread
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
||||
have hlastD' : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
|
||||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||||
have hlastB : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key := by
|
||||
rw [← hlastD']; exact hlastD
|
||||
have hBltTop : r.begin.key < (⊤ : WithTop Key) := by
|
||||
rw [← htop]; exact hBltE
|
||||
have hallB : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.begin.key := by
|
||||
intro x hx
|
||||
exact lt_of_le_of_lt
|
||||
(WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hx)) hlastB
|
||||
have hbExists : ∃ b : Key, r.begin.key = ((b : Key) : WithTop Key) := by
|
||||
obtain ⟨b, hb⟩ := WithTop.ne_top_iff_exists.mp (ne_of_lt hBltTop)
|
||||
exact ⟨b, hb.symm⟩
|
||||
obtain ⟨b, hb⟩ := hbExists
|
||||
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)
|
||||
· obtain ⟨dbw, hkdb, hcomp, hnot⟩ :=
|
||||
exists_witness_below_head_of_negCross_trunc_strict_top hreadP hrev hmore hne hbegin hend
|
||||
htop hBltTop hclamp hallB hkhead
|
||||
exact necessary_of_toggle ⟨dbw, hcomp, by
|
||||
rw [toggle_eq_insert_of_not_mem hkdb]; exact hnot⟩
|
||||
· 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 hreadP (List.head_mem hne) (List.getLast_mem hne)
|
||||
hhead_le hklast
|
||||
· have hlast_lt_k : res.keys.getLast hne < k := lt_of_not_ge hklast
|
||||
by_cases hkB : ((k : Key) : WithTop Key) < r.begin.key
|
||||
· have hlast_nec : Necessary r res (res.keys.getLast hne) :=
|
||||
necessary_of_mem_result hreadP (List.getLast_mem hne)
|
||||
have hB_nec : Necessary r res b := by
|
||||
obtain ⟨dbw, hkdb, hcomp, hnot⟩ :=
|
||||
exists_witness_above_begin_of_negCross_trunc_strict_top hreadP hrev hmore hne hbegin
|
||||
hend htop hBltTop hclamp hallB (by rw [hb])
|
||||
exact necessary_of_toggle ⟨dbw, hcomp, by
|
||||
rw [toggle_eq_erase_of_mem hkdb]; exact hnot⟩
|
||||
have hk_le_b : k ≤ b := by
|
||||
rw [hb] at hkB
|
||||
exact le_of_lt (WithTop.coe_lt_coe.mp hkB)
|
||||
exact Necessary.of_between hlast_nec hB_nec (le_of_lt hlast_lt_k) hk_le_b
|
||||
· have hkge : r.begin.key ≤ ((k : Key) : WithTop Key) := le_of_not_gt hkB
|
||||
obtain ⟨dbw, hkdb, hcomp, hnot⟩ :=
|
||||
exists_witness_above_begin_of_negCross_trunc_strict_top hreadP hrev hmore hne hbegin
|
||||
hend htop hBltTop hclamp hallB hkge
|
||||
exact necessary_of_toggle ⟨dbw, hcomp, by
|
||||
rw [toggle_eq_erase_of_mem hkdb]; exact hnot⟩
|
||||
|
||||
/-- The compact closed form for the sentinel-end strict cell. -/
|
||||
noncomputable def closedFormNegCrossTruncStrictTop (r : RangeRead) (_res : Result) :
|
||||
ConflictRange :=
|
||||
⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩
|
||||
|
||||
/-- The compact sentinel-end strict closed form is minimal. -/
|
||||
theorem minimal_closedForm_of_negCross_trunc_strict_top {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (h : negCrossTruncStrictTop r res) :
|
||||
Minimal r res (closedFormNegCrossTruncStrictTop r res) :=
|
||||
minimal_fullRange_of_negCross_trunc_strict_top hread h
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user