/- Released under Apache 2.0 license as described in the file LICENSE. -/ 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