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:
andrew committed 2026-11-16 21:53:59 -05:00
1 parent 7a0826e873
commit a54a5f82f8
78 files changed
+91636 -2

No files matched your search

+429
View File
@@ -0,0 +1,429 @@
/-
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.Selector
/-!
# Range reads and results
A `RangeRead` requests the keys between a `begin` and `end` selector (ordered
lexicographically), optionally capped by a positive `limit` and optionally
reversed. A `Result` reports the keys produced along with a `more` flag
indicating whether the range was truncated.
Resolved endpoints live in `WithTop Key`, where `⊤` is past-the-end. Because a
selector's key is itself a `WithTop Key`, the unbounded ends of the key space
are reachable by fixed selectors: `readAll` below is the read whose complete
result is every stored key, in either traversal order.
-/
namespace FormalConflictRange
/-- A range read names `begin` and `end` selectors, an optional positive
`limit`, and whether to traverse in `reverse`. -/
structure RangeRead where
begin : Selector
end_ : Selector
limit : Option ℕ+
reverse : Bool
/-- The outcome of a range read: the `keys` produced and whether `more` remain
beyond what was returned. -/
structure Result where
keys : List Key
more : Bool
namespace RangeRead
/-- The keys of `ks` lying in the half-open interval `[lo, hi)`, ascending.
The bounds are `WithTop Key`, so `⊤` naturally means "past the end". -/
def inRange (ks : List Key) (lo hi : WithTop Key) : List Key :=
ks.filter (fun k => decide (lo ≤ (k : WithTop Key) ∧ (k : WithTop Key) < hi))
/-- The complete keys of a range read: every stored key in the half-open
interval `[resolve begin, resolve end_)`, reversed when `reverse` is set. The
`limit` is ignored, as the complete result is untruncated. -/
def completeKeys (db : DB) (r : RangeRead) : List Key :=
let ks := inRange db.keys (resolve db r.begin) (resolve db r.end_)
if r.reverse then ks.reverse else ks
/-- The complete result of a range read: the untruncated keys, with `more` set
to `false`. -/
def complete (db : DB) (r : RangeRead) : Result :=
{ keys := completeKeys db r, more := false }
/-- The complete keys depend on a database only through its keys. -/
theorem completeKeys_congr {db₁ db₂ : DB} (hk : db₁.keys = db₂.keys) (r : RangeRead) :
completeKeys db₁ r = completeKeys db₂ r := by
unfold completeKeys inRange
rw [resolve_congr hk, resolve_congr hk, hk]
/-- The keys of a complete result are exactly the stored keys in the resolved
half-open interval. -/
theorem mem_completeKeys {db : DB} {r : RangeRead} {k : Key} :
k ∈ completeKeys db r ↔
k ∈ db.keys ∧ resolve db r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db r.end_ := by
unfold completeKeys inRange
by_cases h : r.reverse <;> simp [h, List.mem_filter]
/-- The complete keys are a permutation of the ascending in-range keys. -/
theorem completeKeys_perm_inRange (db : DB) (r : RangeRead) :
(completeKeys db r).Perm
(inRange db.keys (resolve db r.begin) (resolve db r.end_)) := by
unfold completeKeys
split
· exact List.reverse_perm _
· exact List.Perm.refl _
/-- The complete keys are duplicate-free. -/
theorem completeKeys_nodup (db : DB) (r : RangeRead) : (completeKeys db r).Nodup := by
unfold completeKeys
split
· rw [List.nodup_reverse]
exact List.Nodup.filter _ db.sorted.pairwise.nodup
· exact List.Nodup.filter _ db.sorted.pairwise.nodup
/-- The ascending in-range keys are strictly increasing. -/
theorem inRange_pairwise (db : DB) (lo hi : WithTop Key) :
List.Pairwise (· < ·) (inRange db.keys lo hi) := by
unfold inRange
exact db.sorted.pairwise.sublist
(List.filter_sublist
(p := fun (k : Key) => decide (lo ≤ (k : WithTop Key) ∧ (k : WithTop Key) < hi)))
/-- The complete keys are strictly increasing when not reversed and strictly
decreasing when reversed. -/
theorem completeKeys_pairwise {db : DB} {r : RangeRead} :
if r.reverse then List.Pairwise (· > ·) (completeKeys db r)
else List.Pairwise (· < ·) (completeKeys db r) := by
unfold completeKeys
split
· exact List.Pairwise.reverse (inRange_pairwise db _ _)
· exact inRange_pairwise db _ _
/-- The length bound imposed by an optional positive limit. -/
def withinLimit (r : RangeRead) (ks : List Key) : Prop :=
match r.limit with
| none => True
| some n => ks.length ≤ (n : ℕ)
/-- A result is compatible with a range read when it respects the limit and is a
valid (possibly truncated) response: a nonempty prefix of the complete keys
reporting `more`, or exactly the complete result reporting no more. -/
def Compatible (db : DB) (r : RangeRead) (res : Result) : Prop :=
withinLimit r res.keys ∧
((res.more = true ∧ res.keys <+: completeKeys db r ∧ res.keys ≠ [])
∨ (res.more = false ∧ res.keys = completeKeys db r))
/-- A compatible result respects the limit. -/
theorem compatible_withinLimit {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) : withinLimit r res.keys := h.1
/-- A compatible result reporting `more` is nonempty: a truncated response must
report at least one key. -/
theorem compatible_ne_nil_of_more {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) (hmore : res.more = true) : res.keys ≠ [] := by
rcases h.2 with ⟨_, _, hne⟩ | ⟨hm, _⟩
· exact hne
· simp [hmore] at hm
/-- The keys of a compatible result are a prefix of the complete keys. -/
theorem compatible_keys_prefix {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) : res.keys <+: completeKeys db r := by
rcases h.2 with ⟨_, hpre, _⟩ | ⟨_, heq⟩
· exact hpre
· exact heq ▸ List.prefix_refl _
/-- The keys of a compatible result are stored in the database. -/
theorem compatible_keys_subset {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) : res.keys ⊆ db.keys :=
fun _ hk => (mem_completeKeys.mp ((compatible_keys_prefix h).subset hk)).1
/-- If a predicate picks out the first element that is at least `a` in a strictly
increasing list containing `a`, it finds `a`. -/
theorem find?_eq_some_of_pairwise {l : List Key} (hs : l.Pairwise (· < ·)) {a : Key}
(ha : a ∈ l) {p : Key → Bool} (hpa : p a)
(hpbefore : ∀ k ∈ l, k < a → p k = false) : l.find? p = some a := by
induction l with
| nil => exact absurd ha (by simp)
| cons k t ih =>
rw [List.mem_cons] at ha
rcases ha with rfl | ha
· simp [hpa]
· have hkt : k < a := (List.pairwise_cons.mp hs).1 a ha
have hpk : p k = false := hpbefore k (by simp) hkt
rw [List.find?_cons_of_neg (by simp [hpk])]
exact ih (List.pairwise_cons.mp hs).2 ha fun x hx hxa => hpbefore x (by simp [hx]) hxa
/-- In a non-reversed read, if `resolve begin` is the stored key `a` and `a` is in
the complete result, then `a` is the head of the complete keys. -/
theorem completeKeys_head_eq {db : DB} {r : RangeRead} (hrev : r.reverse = false)
(hne : completeKeys db r ≠ []) {a : Key}
(ha : resolve db r.begin = (↑a : WithTop Key)) (hain : a ∈ completeKeys db r) :
(completeKeys db r).head hne = a := by
have hain' : a ∈ inRange db.keys (resolve db r.begin) (resolve db r.end_) := by
rw [completeKeys] at hain
simpa only [hrev, Bool.false_eq_true, ite_false] using hain
have hhead? : (completeKeys db r).head? = some a := by
rw [completeKeys, ite_eq_right (by simp [hrev])]
unfold inRange
rw [List.head?_filter]
refine find?_eq_some_of_pairwise db.sorted.pairwise ?_ ?_ ?_
· exact (List.mem_filter.mp hain').1
· rw [decide_eq_true_eq]
exact ⟨by rw [ha], (decide_eq_true_eq.mp (List.mem_filter.mp hain').2).2⟩
· intro k _ hka
rw [decide_eq_false_iff_not]
intro h
rw [ha] at h
exact absurd h.1 (not_le.mpr (by exact_mod_cast hka))
exact (List.head_eq_iff_head?_eq_some hne).mpr hhead?
/-- In a non-reversed read with nonnegative begin anchor and nonempty complete
result, the head of the complete keys is a stored key that `resolve begin` equals. -/
theorem completeKeys_head_resolve {db : DB} {r : RangeRead} (hrev : r.reverse = false)
(hne : completeKeys db r ≠ []) (hpos : 0 ≤ r.begin.anchor db) :
∃ a, a ∈ db.keys ∧ resolve db r.begin = (↑a : WithTop Key) ∧
(completeKeys db r).head hne = a := by
obtain ⟨k, hk⟩ : ∃ k, k ∈ completeKeys db r := by
cases h : completeKeys db r with
| nil => exact absurd h hne
| cons k t => exact ⟨k, by simp⟩
have hk' := mem_completeKeys.mp hk
have hlt : r.begin.anchor db < (db.keys.length : Int) := by
by_contra h
have htop : resolve db r.begin = (⊤ : WithTop Key) := resolve_eq_top hpos (by omega)
have hle : (⊤ : WithTop Key) ≤ (↑k : WithTop Key) := by rw [← htop]; exact hk'.2.1
exact absurd hle (not_le.mpr (WithTop.coe_lt_top k))
refine ⟨db.keys[(r.begin.anchor db).toNat], List.getElem_mem _, ?_, ?_⟩
· exact resolve_eq_getElem hpos (by omega)
· have hlt2 : (↑db.keys[(r.begin.anchor db).toNat] : WithTop Key) < resolve db r.end_ := by
rw [resolve_eq_getElem hpos (by omega)] at hk'
exact lt_of_le_of_lt hk'.2.1 hk'.2.2
have hain : db.keys[(r.begin.anchor db).toNat] ∈ completeKeys db r :=
mem_completeKeys.mpr
⟨List.getElem_mem _, by rw [resolve_eq_getElem hpos (by omega)], hlt2⟩
exact completeKeys_head_eq hrev hne (resolve_eq_getElem hpos (by omega)) hain
/-- If a predicate picks out the first element below `a` in a strictly
decreasing list containing `a`, it finds `a`. -/
theorem find?_eq_some_of_pairwise_gt {l : List Key} (hs : l.Pairwise (· > ·)) {a : Key}
(ha : a ∈ l) {p : Key → Bool} (hpa : p a)
(hpabove : ∀ k ∈ l, a < k → p k = false) : l.find? p = some a := by
induction l with
| nil => exact absurd ha (by simp)
| cons k t ih =>
rw [List.mem_cons] at ha
rcases ha with rfl | ha
· simp [hpa]
· have hkt : a < k := (List.pairwise_cons.mp hs).1 a ha
have hpk : p k = false := hpabove k (by simp) hkt
rw [List.find?_cons_of_neg (by simp [hpk])]
exact ih (List.pairwise_cons.mp hs).2 ha fun x hx hxa => hpabove x (by simp [hx]) hxa
/-- With nonempty complete keys the end anchor is at least one. -/
theorem one_le_anchor_of_completeKeys_ne_nil {db : DB} {r : RangeRead}
(hne : completeKeys db r ≠ []) : 1 ≤ r.end_.anchor db := by
obtain ⟨k, hk⟩ := List.exists_mem_of_ne_nil _ hne
obtain ⟨hkm, hkB, hklt⟩ := mem_completeKeys.mp hk
have h0 : 0 ≤ r.end_.anchor db := by
by_contra h
rw [resolve_eq_nil (db := db) (s := r.end_) (by omega)] at hklt
exact absurd (WithTop.coe_lt_coe.mp hklt) (List.not_lt_nil k)
by_contra h1
have hz : r.end_.anchor db = 0 := by omega
have hlt : (r.end_.anchor db).toNat < db.keys.length := by
rw [hz, Int.toNat_zero]
exact List.length_pos_of_mem hkm
rw [resolve_eq_getElem h0 hlt] at hklt
rw [WithTop.coe_lt_coe] at hklt
obtain ⟨i, hi, hik⟩ := List.mem_iff_getElem.mp hkm
subst hik
have hle : db.keys[(r.end_.anchor db).toNat]'hlt ≤ db.keys[i]'hi :=
(db.sorted.getElem_le_getElem_iff).mpr (by rw [hz, Int.toNat_zero]; omega)
exact absurd hklt (not_lt.mpr hle)
/-- With `end_.offset ≤ 1` the end anchor never exceeds the database length. -/
theorem end_anchor_toNat_le {db : DB} {r : RangeRead} (hoff : r.end_.offset ≤ 1) :
(r.end_.anchor db).toNat ≤ db.keys.length := by
rw [Int.toNat_le]
have h3 := List.countP_le_length
(p := fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) (l := db.keys)
unfold Selector.anchor
omega
/-- In a reversed read with `end_.offset ≤ 1`, the head of the complete keys is
the stored key just below the end anchor. -/
theorem completeKeys_head?_rev {db : DB} {r : RangeRead} (hrev : r.reverse = true)
(hoff : r.end_.offset ≤ 1) (hne : completeKeys db r ≠ []) :
(completeKeys db r).head? = db.keys[(r.end_.anchor db - 1).toNat]? := by
have hA : 1 ≤ r.end_.anchor db := one_le_anchor_of_completeKeys_ne_nil hne
set m := (r.end_.anchor db).toNat with hm_def
have hmlt : m - 1 < db.keys.length := by
have h := end_anchor_toNat_le (db := db) (r := r) hoff
omega
have hkey_lt : ∀ (i : Nat) (hi : i < db.keys.length),
((↑(db.keys[i]'hi) : WithTop Key) < resolve db r.end_) ↔ i < m := by
intro i hi
rcases lt_or_ge m db.keys.length with hlt | hge
· have hlt' : (r.end_.anchor db).toNat < db.keys.length := by rw [← hm_def]; exact hlt
rw [resolve_eq_getElem (db := db) (s := r.end_) (by omega) hlt', WithTop.coe_lt_coe]
rw [hm_def]
exact db.sorted.getElem_lt_getElem_iff
· have hm : m = db.keys.length := by omega
rw [resolve_eq_top (db := db) (s := r.end_) (by omega) (by omega)]
exact ⟨fun _ => by omega, fun _ => WithTop.coe_lt_top _⟩
have hB : resolve db r.begin ≤ (↑(db.keys[m-1]'hmlt) : WithTop Key) := by
obtain ⟨k, hk⟩ := List.exists_mem_of_ne_nil _ hne
obtain ⟨hkm, hkB, hklt⟩ := mem_completeKeys.mp hk
obtain ⟨i, hi, hik⟩ := List.mem_iff_getElem.mp hkm
have hkB' : resolve db r.begin ≤ (↑(db.keys[i]'hi) : WithTop Key) := hik.symm ▸ hkB
have hklt' : (↑(db.keys[i]'hi) : WithTop Key) < resolve db r.end_ := hik.symm ▸ hklt
have him : i < m := (hkey_lt i hi).mp hklt'
have hile : i ≤ m - 1 := by omega
calc resolve db r.begin ≤ (↑(db.keys[i]'hi) : WithTop Key) := hkB'
_ ≤ (↑(db.keys[m-1]'hmlt) : WithTop Key) := by
rw [WithTop.coe_le_coe]
exact (db.sorted.getElem_le_getElem_iff).mpr hile
have hE : (↑(db.keys[m-1]'hmlt) : WithTop Key) < resolve db r.end_ :=
(hkey_lt (m - 1) hmlt).mpr (by omega)
rw [completeKeys, ite_eq_left (by simp [hrev])]
unfold inRange
rw [← List.filter_reverse, List.head?_filter, toNat_sub_one hA, ← hm_def,
List.getElem?_eq_getElem hmlt]
refine find?_eq_some_of_pairwise_gt (List.Pairwise.reverse (R := (· > ·)) db.sorted.pairwise)
(List.mem_reverse.mpr (List.getElem_mem hmlt)) ?_ ?_
· rw [decide_eq_true_eq]
exact ⟨hB, hE⟩
· intro k hk hklt
rw [decide_eq_false_iff_not]
intro hcon
rw [List.mem_reverse] at hk
obtain ⟨i, hi, hik⟩ := List.mem_iff_getElem.mp hk
subst hik
have hgt : m - 1 < i := db.sorted.getElem_lt_getElem_iff.mp hklt
have hnlt : ¬ i < m := by omega
exact hnlt ((hkey_lt i hi).mp hcon.2)
/-- A compatible result is ordered: ascending when not reversed, descending when
reversed. -/
theorem compatible_pairwise {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) :
(r.reverse = false → List.Pairwise (· < ·) res.keys) ∧
(r.reverse = true → List.Pairwise (· > ·) res.keys) := by
have hpre := (compatible_keys_prefix h).sublist
constructor
· intro hf
have hp : List.Pairwise (· < ·) (completeKeys db r) := by
simpa [hf] using completeKeys_pairwise (db := db) (r := r)
exact hp.sublist hpre
· intro ht
have hp : List.Pairwise (· > ·) (completeKeys db r) := by
simpa [ht] using completeKeys_pairwise (db := db) (r := r)
exact hp.sublist hpre
/-- A compatible result is strictly ascending when not reversed. -/
theorem compatible_sortedLT {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) (hf : r.reverse = false) : res.keys.SortedLT :=
List.sortedLT_iff_pairwise.mpr ((compatible_pairwise h).1 hf)
/-- A compatible result is strictly descending when reversed. -/
theorem compatible_sortedGT {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) (ht : r.reverse = true) : res.keys.SortedGT :=
List.sortedGT_iff_pairwise.mpr ((compatible_pairwise h).2 ht)
/-- The keys of a compatible result are the complete keys or a proper prefix. -/
theorem compatible_keys_eq_or_prefix {db : DB} {r : RangeRead} {res : Result}
(h : Compatible db r res) :
res.keys = completeKeys db r ∨ res.keys <+: completeKeys db r := by
rcases h.2 with ⟨_, hpre, _⟩ | ⟨_, heq⟩
· exact Or.inr hpre
· exact Or.inl heq
/-- The complete result is compatible exactly when it fits within the limit. -/
theorem complete_compatible_iff {db : DB} {r : RangeRead} :
Compatible db r (complete db r) ↔ withinLimit r (completeKeys db r) := by
unfold Compatible complete
simp
/-- A result longer than the limit is never compatible. -/
theorem not_compatible_of_limit_lt {db : DB} {r : RangeRead} {res : Result}
{n : ℕ+} (h : r.limit = some n) (hlen : (n : ℕ) < res.keys.length) :
¬ Compatible db r res := by
rintro ⟨hlim, _⟩
simp [withinLimit, h] at hlim
omega
/-- Compatibility depends on the database only through its complete keys. -/
theorem compatible_congr {db₁ db₂ : DB} {r : RangeRead} {res : Result}
(h : completeKeys db₁ r = completeKeys db₂ r) :
(Compatible db₁ r res ↔ Compatible db₂ r res) := by
unfold Compatible
rw [h]
/-- The read of every stored key: it begins at the empty key with offset zero,
so `resolve` yields the start of the key space, and ends at `⊤` with offset
one, so `resolve` yields `⊤` past every stored key. Neither endpoint could be
named by a fixed plain key — the empty key is the least key, and no key lies
above all stored keys of an arbitrary database — so this "read all keys" read
is expressible precisely because selector keys are `WithTop Key`. -/
def readAll : RangeRead where
begin := { key := (([] : Key) : WithTop Key), offset := 0 }
end_ := { key := (⊤ : WithTop Key), offset := 1 }
limit := none
reverse := false
/-- The begin selector of `readAll` anchors at its offset less one: the empty
key counts no stored keys below it, and the offset is zero. -/
theorem anchor_readAll_begin (db : DB) :
readAll.begin.anchor db = readAll.begin.offset - 1 :=
anchor_of_nil rfl
/-- The begin selector of `readAll` resolves to the empty key. -/
theorem resolve_readAll_begin (db : DB) :
resolve db readAll.begin = (↑([] : Key) : WithTop Key) := by
have ho : readAll.begin.offset = 0 := rfl
refine resolve_eq_nil ?_
rw [anchor_readAll_begin, ho]
omega
/-- The end selector of `readAll` anchors at the database's key count: `⊤`
counts every stored key below it, and the offset is one. -/
theorem anchor_readAll_end (db : DB) :
readAll.end_.anchor db = (db.keys.length : Int) := by
rw [anchor_of_top (show readAll.end_.key = (⊤ : WithTop Key) from rfl),
show readAll.end_.offset = 1 from rfl]
omega
/-- The end selector of `readAll` resolves to `⊤`, past every stored key. -/
theorem resolve_readAll_end (db : DB) : resolve db readAll.end_ = (⊤ : WithTop Key) := by
refine resolve_eq_top ?_ ?_
· rw [anchor_readAll_end]; omega
· rw [anchor_readAll_end, Int.toNat_natCast]
/-- Every key lies in the half-open interval from the empty key to `⊤`. -/
theorem inRange_unbounded (ks : List Key) :
inRange ks ((↑([] : Key) : Key) : WithTop Key) (⊤ : WithTop Key) = ks := by
unfold inRange
rw [List.filter_eq_self]
intro k _
rw [decide_eq_true_eq]
exact ⟨WithTop.coe_le_coe.mpr (nil_le_key k), WithTop.coe_lt_top k⟩
/-- The complete keys of `readAll` are all of the database's keys, ascending. -/
theorem completeKeys_readAll (db : DB) : completeKeys db readAll = db.keys := by
simp [completeKeys, resolve_readAll_begin, resolve_readAll_end, inRange_unbounded,
show readAll.reverse = false from rfl]
/-- The complete keys of the reversed `readAll` are all of the database's keys,
descending. -/
theorem completeKeys_readAll_reverse (db : DB) :
completeKeys db {readAll with reverse := true} = db.keys.reverse := by
simp [completeKeys, resolve_readAll_begin, resolve_readAll_end, inRange_unbounded]
end RangeRead
end FormalConflictRange