Files
conflict-range/FormalConflictRange/RangeRead.lean
T
andrew a54a5f82f8 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
2026-11-16 21:53:59 -05:00

430 lines
19 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
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