- 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
430 lines
19 KiB
Lean4
430 lines
19 KiB
Lean4
/-
|
||
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
|