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

+360
View File
@@ -0,0 +1,360 @@
/-
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.Basic
/-!
# Selectors and resolution
A `Selector` names a key together with a signed offset. Resolving a selector
against a database targets the stored key at index
`countP (· < selector.key) + selector.offset - 1`: the last stored key strictly
below `selector.key` when the offset is zero, advancing one key per unit of
offset, so offset `1` is the first key at or above `selector.key`. Indices below
zero resolve to the empty key and indices past the end to `⊤`.
Resolution returns a `WithTop Key`, where `⊤` is the sentinel "no such key".
This makes the past-the-end case explicit in the type, so no concrete sentinel
key and no well-formedness side condition need to be threaded through the API.
The selector's `key` is a `WithTop Key` rather than a plain `Key`: it anchors
the offset in the key space by counting the stored keys strictly below it. The
bottom of `WithTop Key` is the empty key, which counts no keys, and the top
`⊤` counts every stored key, so a selector keyed at `⊤` anchors past the end
of the database whatever its size. This is what makes a database-independent
"read all keys" expressible: `key := ⊤, offset := 1` resolves to `⊤` for every
database, and `key := ↑[], offset := 0` resolves to the empty key, so the read
with those two selectors and no limit returns every stored key (see
`RangeRead.readAll`). No plain key could anchor past every stored key, since
`Key` has no greatest element, and only the empty key — the least key — anchors
at the very start, which is why the bottom needs no sentinel of its own.
Resolution still clamps negative anchors to the empty key, so a selector never
fails to resolve.
-/
namespace FormalConflictRange
/-- A selector names a key position in `WithTop Key`, with an integer offset.
The empty key anchors at the start of the key space, and `⊤` anchors past every
stored key. -/
structure Selector where
key : WithTop Key
offset : Int
/-- The signed index a selector targets: the number of stored keys strictly
below `selector.key` in `WithTop Key` — none for the empty key, all of them for
`⊤` — less one, shifted by `selector.offset`. Offset zero names the last stored
key strictly below `selector.key`, which is index `-1` when there is none;
offset `1` names the first stored key at or above it; offset `-1` names the key
before that. -/
def Selector.anchor (db : DB) (s : Selector) : Int :=
(db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) : Int) + s.offset - 1
/-- Resolve a selector against `db`: target the anchor key, clamping negative
indices to the empty key and indices past the end to the sentinel `⊤`. -/
def resolve (db : DB) (s : Selector) : WithTop Key :=
if s.anchor db < 0 then ([] : Key)
else match db.keys[(s.anchor db).toNat]? with
| some k => k
| none => ⊤
/-- A selector targeting a negative index resolves to the empty key. -/
theorem resolve_eq_nil {db : DB} {s : Selector} (h : s.anchor db < 0) :
resolve db s = ↑([] : Key) := by
rw [resolve, ite_eq_left h]
/-- A selector targeting an in-range index resolves to the stored key there. -/
theorem resolve_eq_getElem {db : DB} {s : Selector}
(h0 : 0 ≤ s.anchor db) (h : (s.anchor db).toNat < db.keys.length) :
resolve db s = ↑(db.keys[(s.anchor db).toNat]) := by
rw [resolve, ite_eq_right (not_lt.mpr h0), List.getElem?_eq_getElem h]
/-- A selector targeting an index at or past the end resolves to `⊤`. -/
theorem resolve_eq_top {db : DB} {s : Selector}
(h0 : 0 ≤ s.anchor db) (h : db.keys.length ≤ (s.anchor db).toNat) :
resolve db s = (⊤ : WithTop Key) := by
rw [resolve, ite_eq_right (not_lt.mpr h0), List.getElem?_eq_none h]
/-- Every resolution is the empty key, the sentinel `⊤`, or a stored key. -/
theorem resolve_eq_nil_or_eq_top_or_mem {db : DB} {s : Selector} :
resolve db s = ↑([] : Key) ∨ resolve db s = (⊤ : WithTop Key) ∨
∃ k ∈ db.keys, resolve db s = ↑k := by
rw [resolve]
split
· exact Or.inl rfl
· rename_i h
cases hlt : db.keys[(s.anchor db).toNat]? with
| none => exact Or.inr (Or.inl rfl)
| some k => exact Or.inr (Or.inr ⟨k, List.mem_of_getElem? hlt, rfl⟩)
/-- Resolution depends on a database only through its keys. -/
theorem resolve_congr {db₁ db₂ : DB} {s : Selector} (hk : db₁.keys = db₂.keys) :
resolve db₁ s = resolve db₂ s := by
unfold resolve Selector.anchor
rw [hk]
/-- Outside the negative clamp, `resolve` is a `getElem?`. -/
theorem resolve_eq_ite (db : DB) (s : Selector) :
resolve db s = (if s.anchor db < 0 then (↑([] : Key) : WithTop Key)
else match db.keys[(s.anchor db).toNat]? with
| some k => (↑k : WithTop Key)
| none => ⊤) := by
unfold resolve
split <;> rfl
/-- A selector keyed at a coerced key `↑v` anchors at the count of stored keys
strictly below `v`. -/
theorem anchor_of_coe {db : DB} {s : Selector} {v : Key} (h : s.key = (↑v : WithTop Key)) :
s.anchor db = (db.keys.countP (fun k => decide (k < v)) : Int) + s.offset - 1 := by
unfold Selector.anchor
rw [h, countP_lt_coe]
/-- A selector keyed at the empty key anchors at its offset less one: the
empty key counts no stored keys below it. -/
theorem anchor_of_nil {db : DB} {s : Selector} (h : s.key = (([] : Key) : WithTop Key)) :
s.anchor db = s.offset - 1 := by
unfold Selector.anchor
rw [h, countP_lt_nil]
omega
/-- A selector keyed at `⊤` anchors past every stored key: all of them lie
strictly below `⊤`. -/
theorem anchor_of_top {db : DB} {s : Selector} (h : s.key = (⊤ : WithTop Key)) :
s.anchor db = (db.keys.length : Int) + s.offset - 1 := by
unfold Selector.anchor
rw [h, countP_lt_top]
/-- The anchor is nonnegative when the offset is at least one. -/
theorem anchor_nonneg_of_one_le {db : DB} {s : Selector} (h : 1 ≤ s.offset) :
0 ≤ s.anchor db := by
unfold Selector.anchor
have : (0 : Int) ≤
(db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) : Int) :=
Int.natCast_nonneg _
omega
/-- The anchor's natural-number value splits as the count of keys strictly below
the selector key plus the nonnegative offset shift. -/
theorem anchor_toNat_eq {db : DB} {s : Selector} (h : 1 ≤ s.offset) :
(s.anchor db).toNat =
db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) +
(s.offset - 1).toNat := by
unfold Selector.anchor
rw [show ((db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) : Int) +
s.offset - 1) =
((db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) : Int) +
(s.offset - 1)) by ring,
Int.toNat_add (Int.natCast_nonneg _) (by omega), Int.toNat_natCast]
/-- Inserting the successor chain of `[a, b)` when the selector is keyed at `a`
leaves the selector's anchor index unchanged: the chain starts at `a` and so
never lies strictly below the selector key. This is the interval analogue of the
anchor stability under a single-key insertion at the selector key. The resolution
itself may still change, since the chain replaces the erased keys at and above
`a`. -/
theorem anchor_insertInterval_below {db : DB} {s : Selector} {a b : Key}
(hkey : s.key = (↑a : WithTop Key)) (hab : a ≤ b) (n : ℕ)
(hn : ∀ i < n, chain a i < b) :
s.anchor (db.insertInterval a b hab n hn) = s.anchor db := by
unfold Selector.anchor
rw [hkey, countP_lt_coe, countP_lt_coe,
countP_lt_insertInterval_of_lt hab (le_refl a) n hn]
/-- Erasing the interval `[a, b)` when the selector is keyed at `a` leaves the
selector's anchor index unchanged: erased keys all lie at or above `a`. This is
the interval analogue of the anchor stability under a single-key erasure at the
selector key. The resolution itself may still change, since keys at and above `a`
are removed. -/
theorem anchor_eraseInterval_below {db : DB} {s : Selector} {a b : Key}
(hkey : s.key = (↑a : WithTop Key)) :
s.anchor (db.eraseInterval (↑a) (↑b)) = s.anchor db := by
unfold Selector.anchor
rw [hkey, countP_lt_coe, countP_lt_coe,
countP_lt_eraseInterval_of_le (x := a) (le_refl a)]
/-- When the selector is keyed at the upper end `b` of the replaced interval, the
interval insertion shifts its anchor by the chain length `n` less the number of
stored keys erased from `[a, b)`: the chain elements replace exactly the erased
keys below `b`. This is the anchor form of the interval perturbation's count
shift, the multi-key analogue of the single-key insertion's `+1`. -/
theorem anchor_insertInterval_self {db : DB} {s : Selector} {a b : Key}
(hkey : s.key = (↑b : WithTop Key)) (hab : a ≤ b) (n : ℕ)
(hn : ∀ i < n, chain a i < b) :
s.anchor (db.insertInterval a b hab n hn) =
s.anchor db + n - (db.keys.filter (fun k => decide (a ≤ k ∧ k < b))).length := by
have hsplit : db.keys.countP (fun k => decide (k < b)) =
(db.keys.filter (fun k => decide (k < a))).length +
(db.keys.filter (fun k => decide (a ≤ k ∧ k < b))).length := by
rw [countP_lt_eq_add_filter db.keys db.nodup hab, List.countP_eq_length_filter]
unfold Selector.anchor
rw [hkey, countP_lt_coe, countP_lt_coe, countP_lt_insertInterval_self hab hn, hsplit]
push_cast
ring
/-- When the selector is keyed at the upper end `b` of the erased interval, the
interval erasure lowers its anchor by the number of erased keys in `[a, b)`:
that is exactly the multi-key analogue of the single-key erasure's `-1`. -/
theorem anchor_eraseInterval_self {db : DB} {s : Selector} {a b : Key}
(hkey : s.key = (↑b : WithTop Key)) (hab : a ≤ b) :
s.anchor (db.eraseInterval (↑a) (↑b)) =
s.anchor db - (db.keys.filter (fun k => decide (a ≤ k ∧ k < b))).length := by
have hsplit : db.keys.countP (fun k => decide (k < b)) =
(db.keys.filter (fun k => decide (k < a))).length +
(db.keys.filter (fun k => decide (a ≤ k ∧ k < b))).length := by
rw [countP_lt_eq_add_filter db.keys db.nodup hab, List.countP_eq_length_filter]
unfold Selector.anchor
rw [hkey, countP_lt_coe, countP_lt_coe, countP_lt_eraseInterval_self hab, hsplit]
push_cast
ring
/-- For a positive integer, `toNat` commutes with subtracting one. -/
theorem toNat_sub_one {z : ℤ} (h : 1 ≤ z) : (z - 1).toNat = z.toNat - 1 := by
rw [← Int.toNat_of_nonneg (show (0 : ℤ) ≤ z by omega)]
exact Int.toNat_sub z.toNat 1
/-- For an integer at least two, `toNat` commutes with subtracting two. -/
theorem toNat_sub_two {z : ℤ} (h : 2 ≤ z) : (z - 2).toNat = z.toNat - 2 := by
have hz : (↑z.toNat : ℤ) = z := Int.toNat_of_nonneg (by omega)
conv_lhs => rw [← hz]
exact Int.toNat_sub z.toNat 2
/-- When a nonnegative anchor resolves to a stored key, the anchor's index holds
that key. -/
theorem getElem?_anchor_eq_some {db : DB} {s : Selector} {a : Key}
(h0 : 0 ≤ s.anchor db) (h : resolve db s = (↑a : WithTop Key)) :
db.keys[(s.anchor db).toNat]? = some a := by
rw [resolve_eq_ite, ite_eq_right (not_lt.mpr h0)] at h
cases hg : db.keys[(s.anchor db).toNat]? with
| none => rw [hg] at h; exact absurd h (by simp)
| some k => rw [hg] at h; rw [WithTop.coe_inj.mp h]
/-- A selector keyed at `⊤` with a positive offset resolves to `⊤`: it targets
past every stored key, whatever the database. -/
theorem resolve_eq_top_of_key_eq_top {db : DB} {s : Selector}
(h : s.key = (⊤ : WithTop Key)) (hoff : 1 ≤ s.offset) :
resolve db s = (⊤ : WithTop Key) := by
have h0 : 0 ≤ s.anchor db := by rw [anchor_of_top h]; omega
refine resolve_eq_top h0 ?_
rw [anchor_toNat_eq hoff, h, countP_lt_top]
have hpos' : 0 ≤ (s.offset - 1).toNat := Nat.zero_le _
omega
/-- A selector keyed at the empty key with offset zero resolves to the empty
key: it targets the start of the key space. -/
theorem resolve_eq_nil_of_key_eq_nil {db : DB} {s : Selector}
(h : s.key = (([] : Key) : WithTop Key)) (hoff : s.offset = 0) :
resolve db s = (↑([] : Key) : WithTop Key) := by
refine resolve_eq_nil ?_
rw [anchor_of_nil h, hoff]
omega
/-- Inserting the chain of `[a, b)` lets a selector keyed at `a` land on any
chosen chain element: with offset `1 + i` its anchor is the stored-key count
below `a` plus `i`, which the insertion fills with `chain a i`. This is the
resolve-level content of the interval perturbation, the multi-key analogue of a
single-key insertion placing the targeted key. -/
theorem resolve_insertInterval_chain {db : DB} {s : Selector} {a b : Key}
(hkey : s.key = (↑a : WithTop Key)) (hab : a ≤ b) {n i : ℕ}
(hn : ∀ j < n, chain a j < b) (hoff : s.offset = (i : ℤ) + 1) (hi : i < n) :
resolve (db.insertInterval a b hab n hn) s = (↑(chain a i) : WithTop Key) := by
have hanc : s.anchor (db.insertInterval a b hab n hn) =
(((db.keys.filter (fun k => decide (k < a))).length + i : ℕ) : ℤ) := by
unfold Selector.anchor
rw [hkey, countP_lt_coe, countP_lt_insertInterval_of_lt hab (le_refl a) n hn, hoff,
List.countP_eq_length_filter]
push_cast
ring
have htoNat : (s.anchor (db.insertInterval a b hab n hn)).toNat =
(db.keys.filter (fun k => decide (k < a))).length + i := by
rw [hanc]; exact Int.toNat_natCast _
have h0 : 0 ≤ s.anchor (db.insertInterval a b hab n hn) := by rw [hanc]; positivity
have hlt : (s.anchor (db.insertInterval a b hab n hn)).toNat <
(db.insertInterval a b hab n hn).keys.length := by
rw [htoNat, DB.insertInterval_keys, List.length_append, List.length_append, List.length_map,
List.length_range]
have hfb : (db.keys.filter (fun k => decide (k < b))).length ≤ db.keys.length := by
simpa using List.length_filter_le (fun k => decide (k < b)) db.keys
have hfa : (db.keys.filter (fun k => decide (k < a))).length ≤ db.keys.length := by
simpa using List.length_filter_le (fun k => decide (k < a)) db.keys
omega
rw [resolve_eq_getElem h0 hlt]
apply WithTop.coe_inj.mpr
have h2 : (db.insertInterval a b hab n hn).keys[
(s.anchor (db.insertInterval a b hab n hn)).toNat]? = some (chain a i) := by
rw [htoNat]
exact getElem?_insertInterval_chain hab hn hi
rw [List.getElem?_eq_getElem hlt] at h2
exact Option.some.inj h2
/-!
## Bounding a resolution by the selector's key
These bounds pin the value `resolve` can produce between the count of stored keys
below the selector key and the successor chain. They are the database-relative
half of the footprint specification and are stated here beside `resolve`.
-/
/-- A selector keyed at a genuine `k₀` with positive offset can only resolve to
keys at or above `chain k₀ (offset - 1)`: the anchor puts `off - 1` chain steps
between the count of keys below `k₀` and the resolved key. -/
theorem chain_le_of_resolve {s : Selector} {k₀ k : Key}
(hk : s.key = (↑k₀ : WithTop Key)) (hoff : 1 ≤ s.offset) {db : DB}
(h : resolve db s = (↑k : WithTop Key)) :
chain k₀ (s.offset - 1).toNat ≤ k := by
have h0 : 0 ≤ s.anchor db := by
rw [anchor_of_coe hk]
have := Int.natCast_nonneg (db.keys.countP (fun x => decide (x < k₀)))
omega
have hsome : db.keys[(s.anchor db).toNat]? = some k := getElem?_anchor_eq_some h0 h
obtain ⟨hidx, hget⟩ := List.getElem?_eq_some_iff.mp hsome
have ht : (s.anchor db).toNat =
db.keys.countP (fun x => decide (x < k₀)) + (s.offset - 1).toNat := by
rw [anchor_toNat_eq hoff, hk, countP_lt_coe]
have hidx' : db.keys.countP (fun x => decide (x < k₀)) + (s.offset - 1).toNat <
db.keys.length := by omega
have hstep := chain_le_getElem_countP db.sorted hidx'
have hsome' : db.keys[db.keys.countP (fun x => decide (x < k₀)) +
(s.offset - 1).toNat]? = some k := by
rw [← ht]
exact hsome
exact hstep.trans_eq (List.getElem?_eq_some_iff.mp hsome').2
/-- A selector keyed at a genuine `k₀` with a nonpositive offset can only
resolve to the empty key or to a key whose `-offset`-fold successor chain stays
strictly below `k₀`: the resolved key sits `-offset` indices below the count of
keys strictly below `k₀`, and a strictly increasing list has a distinct key
between consecutive chain elements. -/
theorem eq_nil_or_chain_lt_of_resolve {s : Selector} {k₀ k : Key}
(hk : s.key = (↑k₀ : WithTop Key)) (hoff : s.offset ≤ 0) {db : DB}
(h : resolve db s = (↑k : WithTop Key)) :
k = [] ∨ chain k (-s.offset).toNat < k₀ := by
by_cases hneg : s.anchor db < 0
· refine Or.inl ?_
exact WithTop.coe_inj.mp (h.symm.trans (resolve_eq_nil hneg))
· have h0 : 0 ≤ s.anchor db := by omega
have hsome : db.keys[(s.anchor db).toNat]? = some k := getElem?_anchor_eq_some h0 h
obtain ⟨hidx, hget⟩ := List.getElem?_eq_some_iff.mp hsome
have hCint : (db.keys.countP (fun x => decide (x < k₀)) : ℤ) =
((s.anchor db).toNat : ℤ) + ((-s.offset).toNat : ℤ) + 1 := by
have hanc : (s.anchor db : ℤ) =
(db.keys.countP (fun x => decide (x < k₀)) : ℤ) + s.offset - 1 := anchor_of_coe hk
have hnat : ((s.anchor db).toNat : ℤ) = s.anchor db := Int.toNat_of_nonneg h0
have hn : (((-s.offset).toNat : ℤ)) = -s.offset := Int.toNat_of_nonneg (by omega)
omega
have hC : db.keys.countP (fun x => decide (x < k₀)) =
(s.anchor db).toNat + (-s.offset).toNat + 1 := by omega
have hindex : (s.anchor db).toNat + (-s.offset).toNat < db.keys.length := by
have := List.countP_le_length (p := fun x : Key => decide (x < k₀)) (l := db.keys)
omega
have hle := chain_getElem_le db.sorted (i := (s.anchor db).toNat)
(j := (-s.offset).toNat) hidx hindex
have hltC : (s.anchor db).toNat + (-s.offset).toNat <
db.keys.countP (fun x => decide (x < k₀)) := by omega
have hlt : db.keys[(s.anchor db).toNat + (-s.offset).toNat] < k₀ :=
getElem_lt_of_lt_countP db.sorted hindex hltC
rw [hget] at hle
exact Or.inr (lt_of_le_of_lt hle hlt)
end FormalConflictRange