/- Released under Apache 2.0 license as described in the file LICENSE. -/ import FormalConflictRange.ConflictRange /-! # Sound conflict ranges Reading a range returns a `Result`, which tells us something about the database: in particular, which answer sets are still possible. A conflict range `cr` is *sound* when all of that information is already determined by the keys stored inside `cr`. Equivalently: any two databases that agree on `cr` agree on whether the result is compatible with the read, so no inference drawn from the result can be invalidated by a database matching the range. A conflict-range inference never sees the database contents: it sees only the read `r` and the returned result `res`. The necessity rules therefore take the compatibility hypothesis as `Readable r res` — some database is compatible with the pair — and each proof obtains one witness database to reason with. Soundness is monotone under enlargement: a conflict range that contains (and so agreement on which implies agreement on) a sound range is itself sound. Dually, minimal ranges are the smallest sound ranges. -/ namespace FormalConflictRange /-- Two databases agree on a conflict range when they store the same keys in it. -/ def AgreeOn (cr : ConflictRange) (db₁ db₂ : DB) : Prop := cr.keys db₁ = cr.keys db₂ namespace AgreeOn theorem refl (cr : ConflictRange) (db : DB) : AgreeOn cr db db := rfl theorem symm {cr : ConflictRange} {db₁ db₂ : DB} (h : AgreeOn cr db₁ db₂) : AgreeOn cr db₂ db₁ := Eq.symm h theorem trans {cr : ConflictRange} {db₁ db₂ db₃ : DB} (h₁ : AgreeOn cr db₁ db₂) (h₂ : AgreeOn cr db₂ db₃) : AgreeOn cr db₁ db₃ := Eq.trans h₁ h₂ /-- Databases agree on a range after erasing an interval disjoint from it. This is the interval analogue of `erase_of_not_mem`. -/ theorem eraseInterval_of_disjoint {cr : ConflictRange} (db : DB) {a b : Key} (hdisj : ∀ x, a ≤ x → x < b → x ∉ cr) : AgreeOn cr db (db.eraseInterval (↑a) (↑b)) := (ConflictRange.keys_eraseInterval_of_disjoint cr db hdisj).symm /-- Databases agree on a range after replacing an interval disjoint from it by a successor chain. This is the interval analogue of the insert case of `erase_of_not_mem`/`keys_insert_of_not_mem`. -/ theorem insertInterval_of_disjoint {cr : ConflictRange} (db : DB) {a b : Key} (hab : a ≤ b) (n : ℕ) (hn : ∀ i < n, chain a i < b) (hdisj : ∀ x, a ≤ x → x < b → x ∉ cr) : AgreeOn cr db (db.insertInterval a b hab n hn) := (ConflictRange.keys_insertInterval_of_disjoint cr db hab n hn hdisj).symm /-- Databases agree on a range after erasing a key outside that range. This is the `[k, keyAfter k)` case of `eraseInterval_of_disjoint`. -/ theorem erase_of_not_mem {cr : ConflictRange} (db : DB) {k : Key} (hk : k ∉ cr) : AgreeOn cr db (db.erase k) := (ConflictRange.keys_erase_of_not_mem cr db hk).symm /-- Interval perturbation, packaged for the soundness analysis: a database can be rebuilt to agree with a given one on any range disjoint from `[a, b)` while realizing any gap `d` up to `intervalCard a b` in the count of stored keys below `b`. This is the `AgreeOn` form of `exists_db_perturb_interval`, the batch companion of the single-key `erase`/`insert` perturbations: the new database keeps exactly the stored keys outside `[a, b)`, so it agrees on any range avoiding the interval, while the count below `b` can be shifted by `d`. -/ theorem exists_perturb_interval_of_disjoint {db : DB} {a b : Key} (hab : a ≤ b) (d : ℕ) (hd : (d : ℕ∞) ≤ intervalCard (↑a : WithTop Key) (↑b : WithTop Key)) {cr : ConflictRange} (hdisj : ∀ x, a ≤ x → x < b → x ∉ cr) : ∃ db' : DB, AgreeOn cr db db' ∧ db'.keys.countP (fun x => decide (x < b)) = (db.keys.filter (fun x => decide (x < a))).length + d := by obtain ⟨db', hlo, hhi, hcount⟩ := exists_db_perturb_interval (db := db) hab d hd refine ⟨db', ?_, hcount⟩ refine List.SortedLT.eq_of_mem_iff (List.sortedLT_iff_pairwise.mpr (ConflictRange.keys_pairwise cr db)) (List.sortedLT_iff_pairwise.mpr (ConflictRange.keys_pairwise cr db')) ?_ intro x rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff] have hxab : ∀ {y : Key}, y ∈ cr → y < a ∨ b ≤ y := by intro y hycr rcases lt_or_ge y a with h | h · exact Or.inl h · exact Or.inr (le_of_not_gt fun hyb => hdisj y h hyb hycr) constructor · rintro ⟨hx, hxcr⟩ rcases hxab hxcr with h | h · have : x ∈ db.keys.filter (fun x => decide (x < a)) := List.mem_filter.mpr ⟨hx, by rw [decide_eq_true_eq]; exact h⟩ rw [← hlo] at this exact ⟨(List.mem_filter.mp this).1, hxcr⟩ · have : x ∈ db.keys.filter (fun x => decide (b ≤ x)) := List.mem_filter.mpr ⟨hx, by rw [decide_eq_true_eq]; exact h⟩ rw [← hhi] at this exact ⟨(List.mem_filter.mp this).1, hxcr⟩ · rintro ⟨hx, hxcr⟩ rcases hxab hxcr with h | h · have : x ∈ db'.keys.filter (fun x => decide (x < a)) := List.mem_filter.mpr ⟨hx, by rw [decide_eq_true_eq]; exact h⟩ rw [hlo] at this exact ⟨(List.mem_filter.mp this).1, hxcr⟩ · have : x ∈ db'.keys.filter (fun x => decide (b ≤ x)) := List.mem_filter.mpr ⟨hx, by rw [decide_eq_true_eq]; exact h⟩ rw [hhi] at this exact ⟨(List.mem_filter.mp this).1, hxcr⟩ /-- Selector control by interval perturbation, packaged for the soundness analysis: a database can be rebuilt to agree with a given one on any range disjoint from `[a, b)` while driving a selector keyed at `a` with offset `1 + j` to resolve to the chain element `chain a j`, provided `[a, b)` is long enough. This is the caller-facing form of `resolve_insertInterval_chain`: where the single-key perturbations nudge the resolved key by one stored key, this moves it to any chosen position in `[a, b)`. -/ theorem exists_db_resolve_chain_of_disjoint {db : DB} {a b : Key} (hab : a ≤ b) {s : Selector} (hkey : s.key = (↑a : WithTop Key)) {j : ℕ} (hoff : s.offset = (j : ℤ) + 1) (hj : ((j + 1 : ℕ) : ℕ∞) ≤ intervalCard (↑a : WithTop Key) (↑b : WithTop Key)) {cr : ConflictRange} (hdisj : ∀ x, a ≤ x → x < b → x ∉ cr) : ∃ db' : DB, AgreeOn cr db db' ∧ resolve db' s = (↑(chain a j) : WithTop Key) := by have hn : ∀ i < j + 1, chain a i < b := fun i hi => (chain_lt_iff a b i).mpr (lt_of_lt_of_le (by exact_mod_cast hi) hj) exact ⟨db.insertInterval a b hab (j + 1) hn, AgreeOn.insertInterval_of_disjoint db hab (j + 1) hn hdisj, resolve_insertInterval_chain hkey hab hn hoff (by omega)⟩ end AgreeOn /-- A conflict range is sound for a read and result when every pair of databases that agree on the range also agree on whether the result is compatible with the read. -/ def Sound (r : RangeRead) (res : Result) (cr : ConflictRange) : Prop := ∀ db₁ db₂, AgreeOn cr db₁ db₂ → (RangeRead.Compatible db₁ r res ↔ RangeRead.Compatible db₂ r res) /-- If a result is compatible with one database and the range is sound, then the result is compatible with any database that agrees with it on the range. -/ theorem Compatible.of_agreeOn {db₁ db₂ : DB} {r : RangeRead} {res : Result} {cr : ConflictRange} (hread : RangeRead.Compatible db₁ r res) (hsound : Sound r res cr) (hagree : AgreeOn cr db₁ db₂) : RangeRead.Compatible db₂ r res := (hsound db₁ db₂ hagree).mp hread /-- Agreement on a conflict range is pointwise agreement of membership on its keys. This is the form in which the soundness filter is closed under intersections of key sets, independent of their interval representation. -/ theorem agreeOn_iff (cr : ConflictRange) (db₁ db₂ : DB) : AgreeOn cr db₁ db₂ ↔ ∀ k, k ∈ cr → (k ∈ db₁.keys ↔ k ∈ db₂.keys) := by constructor · intro h k hkcr rw [AgreeOn] at h constructor · intro hk1 have hmem : k ∈ cr.keys db₁ := ConflictRange.mem_keys_iff.mpr ⟨hk1, hkcr⟩ rw [h] at hmem exact (ConflictRange.mem_keys_iff.mp hmem).1 · intro hk2 have hmem : k ∈ cr.keys db₂ := ConflictRange.mem_keys_iff.mpr ⟨hk2, hkcr⟩ rw [← h] at hmem exact (ConflictRange.mem_keys_iff.mp hmem).1 · intro h refine List.SortedLT.eq_of_mem_iff (List.sortedLT_iff_pairwise.mpr (ConflictRange.keys_pairwise cr db₁)) (List.sortedLT_iff_pairwise.mpr (ConflictRange.keys_pairwise cr db₂)) ?_ intro k rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff] exact ⟨fun hk => ⟨(h k hk.2).mp hk.1, hk.2⟩, fun hk => ⟨(h k hk.2).mpr hk.1, hk.2⟩⟩ /-- Soundness stated for an arbitrary set of keys rather than an interval: agreement on `S` fixes compatibility. `sound_iff_soundSet` shows the range predicate is the interval-represented case. This form is what makes the filter closed under set intersections, which is not available for intervals. -/ def SoundSet (r : RangeRead) (res : Result) (S : Set Key) : Prop := ∀ db₁ db₂, (∀ k, k ∈ S → (k ∈ db₁.keys ↔ k ∈ db₂.keys)) → (RangeRead.Compatible db₁ r res ↔ RangeRead.Compatible db₂ r res) /-- Range soundness is set-level soundness of its key set. -/ theorem sound_iff_soundSet {r : RangeRead} {res : Result} {cr : ConflictRange} : Sound r res cr ↔ SoundSet r res cr.toSet := by constructor · intro h db₁ db₂ hagree exact h db₁ db₂ ((agreeOn_iff cr db₁ db₂).mpr hagree) · intro h db₁ db₂ hagree exact h db₁ db₂ ((agreeOn_iff cr db₁ db₂).mp hagree) /-- A key is necessary for a read and result when it lies in every sound conflict range. These are exactly the keys any correct conflict range must track. -/ def Necessary (r : RangeRead) (res : Result) (k : Key) : Prop := ∀ cr, Sound r res cr → k ∈ cr /-- The set of keys necessary for a read and result: the intersection of every sound range. Agreement on exactly this set is what the soundness filter determines, so it is the natural non-interval form of the minimal range. -/ def necessarySet (r : RangeRead) (res : Result) : Set Key := {k | Necessary r res k} /-- A read/result pair is realizable: some database is compatible with it. A conflict-range inference sees only the read and the returned result, never the database contents, so this — rather than a particular database — is the hypothesis the necessity rules are stated with. -/ def Readable (r : RangeRead) (res : Result) : Prop := ∃ db, RangeRead.Compatible db r res /-- Necessity may be established from any one witness database; the conclusion does not mention it, so an existential suffices. -/ theorem Necessary.of_readable {r : RangeRead} {res : Result} {k : Key} (hread : Readable r res) (h : ∀ db, RangeRead.Compatible db r res → Necessary r res k) : Necessary r res k := hread.elim fun db hdb => h db hdb /-- The necessary keys are convex: any key between two necessary keys is itself necessary, since every sound range is an interval. -/ theorem Necessary.of_between {r : RangeRead} {res : Result} {a b k : Key} (ha : Necessary r res a) (hb : Necessary r res b) (hak : a ≤ k) (hkb : k ≤ b) : Necessary r res k := fun _ hs => ConflictRange.mem_of_between (ha _ hs) (hb _ hs) hak hkb /-- **The necessary set is order-convex.** Any key lying between two necessary keys is itself necessary (`Necessary.of_between`), so the set of necessary keys is an interval of genuine keys. This is the structural half of representability: the remaining question is whether that interval's endpoints are attained at genuine keys (rather than at non-key limits such as the cut above the chain `⊥, [0], [0,0], …`). -/ theorem necessarySet_ordConnected (r : RangeRead) (res : Result) : (necessarySet r res).OrdConnected := Set.OrdConnected.mk fun _ ha _ hb _ hk => Necessary.of_between ha hb hk.1 hk.2 /-- Every key of the half-open interval `[a, b)` is necessary. This is the interval form of `Necessary`: instead of one key at a time, it asks that a whole interval be tracked, which is what an interval perturbation establishes at once. For `a = cr.begin` and `b = cr.end_` it says `cr` is contained in every sound range, i.e. every key of `cr` is necessary. -/ def NecessaryRange (r : RangeRead) (res : Result) (a b : WithTop Key) : Prop := ∀ k : Key, a ≤ (k : WithTop Key) → (k : WithTop Key) < b → Necessary r res k /-- A key that a compatible result reports is necessary: erasing it yields a database that still agrees on any range avoiding it, but whose complete keys no longer admit the result. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_mem_result {r : RangeRead} {res : Result} (hread : Readable r res) {k : Key} (hk : k ∈ res.keys) : Necessary r res k := by obtain ⟨db₀, hread⟩ := hread intro cr hs by_contra hkcr have hagree : AgreeOn cr db₀ (db₀.erase k) := AgreeOn.erase_of_not_mem db₀ hkcr have hcomp : RangeRead.Compatible (db₀.erase k) r res := (hs db₀ _ hagree).mp hread exact DB.not_mem_erase_self db₀ k (RangeRead.compatible_keys_subset hcomp hk) /-- Every key a compatible result reports lies in every sound conflict range. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem mem_of_sound_of_mem_result {r : RangeRead} {res : Result} (hread : Readable r res) {cr : ConflictRange} (hs : Sound r res cr) : ∀ k ∈ res.keys, k ∈ cr := fun _ hk => necessary_of_mem_result hread hk cr hs /-- The set of reported keys is contained in every sound conflict range. -/ theorem result_keys_subset_sound {db₀ : DB} {r : RangeRead} {res : Result} (hread : RangeRead.Compatible db₀ r res) {cr : ConflictRange} (hs : Sound r res cr) : res.keys ⊆ cr.keys db₀ := by intro k hk rw [ConflictRange.mem_keys_iff] exact ⟨RangeRead.compatible_keys_subset hread hk, mem_of_sound_of_mem_result ⟨db₀, hread⟩ hs k hk⟩ /-- Any key between two reported keys is necessary: every sound range is an interval, so it contains everything spanning the reported keys. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_between_result {r : RangeRead} {res : Result} (hread : Readable r res) {a b : Key} (ha : a ∈ res.keys) (hb : b ∈ res.keys) {k : Key} (hak : a ≤ k) (hkb : k ≤ b) : Necessary r res k := (necessary_of_mem_result hread ha).of_between (necessary_of_mem_result hread hb) hak hkb /-- In a non-reversed read with `begin.offset ≥ 1` and a nonempty result, the selector's key is necessary: any sound range must contain it. Perturbing the database by toggling that key (without changing anything in a range that omits it) shifts `resolve begin` off the result's head, so the range could not be sound. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_begin_key {r : RangeRead} {res : Result} {v : Key} (hread : Readable r res) (hrev : r.reverse = false) (hlen : 0 < res.keys.length) (hoff : 1 ≤ r.begin.offset) (hkey : r.begin.key = (↑v : WithTop Key)) : Necessary r res v := by obtain ⟨db₀, hread⟩ := hread intro cr hs by_contra hcr have hresne : res.keys ≠ [] := List.ne_nil_of_length_pos hlen have hne : RangeRead.completeKeys db₀ r ≠ [] := (RangeRead.compatible_keys_prefix hread).ne_nil hresne have hpos : 0 ≤ r.begin.anchor db₀ := anchor_nonneg_of_one_le hoff obtain ⟨a, _ha_mem, ha_res, ha_head⟩ := RangeRead.completeKeys_head_resolve hrev hne hpos have hreshead : res.keys.head hresne = a := by rw [← ha_head] exact (RangeRead.compatible_keys_prefix hread).head hresne set c := db₀.keys.countP (fun k => decide (k < v)) with hc_def set t := (r.begin.offset - 1).toNat with ht_def set j := c + t with hj_def have hcount_toNat : (r.begin.anchor db₀).toNat = j := by rw [anchor_toNat_eq hoff, hkey, countP_lt_coe, ← hc_def, ← ht_def, ← hj_def] have hget := getElem?_anchor_eq_some hpos ha_res rw [hcount_toNat, List.getElem?_eq_some_iff] at hget have hjlt : j < db₀.keys.length := hget.1 have ha_eq : a = db₀.keys[j] := hget.2.symm have hcle : c ≤ j := by rw [hj_def]; exact Nat.le_add_right _ _ have hclt : c < db₀.keys.length := lt_of_le_of_lt hcle hjlt have key_neq (db₁ : DB) (hanc : (r.begin.anchor db₁).toNat = j) (hneq : db₁.keys[j]? ≠ some a) : resolve db₁ r.begin ≠ (↑a : WithTop Key) := by intro h rw [resolve_eq_ite, ite_eq_right (not_lt.mpr (anchor_nonneg_of_one_le hoff)), hanc] at h cases hg : db₁.keys[j]? with | none => rw [hg] at h; exact absurd h (by simp) | some k => rw [hg] at h exact hneq (by rw [hg, WithTop.coe_inj.mp h]) have contra (db₁ : DB) (hagree : AgreeOn cr db₀ db₁) (hanc : (r.begin.anchor db₁).toNat = j) (hneq : db₁.keys[j]? ≠ some a) : False := by have compat₁ : RangeRead.Compatible db₁ r res := (hs db₀ db₁ hagree).mp hread have hpre₁ := RangeRead.compatible_keys_prefix compat₁ have hne₁ : RangeRead.completeKeys db₁ r ≠ [] := hpre₁.ne_nil hresne obtain ⟨a', _, ha'_res, ha'_head⟩ := RangeRead.completeKeys_head_resolve hrev hne₁ (anchor_nonneg_of_one_le hoff) have hhead₁ : (RangeRead.completeKeys db₁ r).head hne₁ = a := by rw [← hreshead] exact (hpre₁.head hresne).symm have hresolve : resolve db₁ r.begin = (↑a : WithTop Key) := by rw [ha'_res, ha'_head.symm.trans hhead₁] exact key_neq db₁ hanc hneq hresolve by_cases hvm : v ∈ db₀.keys · have hcv : db₀.keys[c] = v := getElem_countP_lt db₀.sorted hvm let db₁ : DB := db₀.erase v have hkeys₁ : db₁.keys = db₀.keys.eraseIdx c := by change db₀.keys.erase v = db₀.keys.eraseIdx c rw [← hcv] exact List.Nodup.erase_getElem db₀.nodup c hclt have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_erase_of_not_mem cr db₀ hcr).symm have hcount' : db₁.keys.countP (fun k => decide (k < v)) = c := by rw [hkeys₁]; exact eraseIdx_countP db₀.sorted hclt hcv have hanc' : (r.begin.anchor db₁).toNat = j := by rw [anchor_toNat_eq hoff, hkey, countP_lt_coe, hcount', hj_def] refine contra db₁ hagree hanc' ?_ intro hk rw [hkeys₁, List.getElem?_eraseIdx_of_ge hcle] at hk cases hg : db₀.keys[j+1]? with | none => rw [hg] at hk; exact absurd hk (by simp) | some k => rw [hg, Option.some.injEq] at hk have hge := List.getElem?_eq_some_iff.mp hg have heq : db₀.keys[j+1]'(hge.1) = db₀.keys[j] := by rw [hge.2, hk, ha_eq] exact absurd ((db₀.nodup.getElem_inj_iff).mp heq) (by omega) · let db₁ : DB := db₀.insert v hvm have hkeys₁ : db₁.keys = db₀.keys.insertIdx c v := by change db₀.keys.orderedInsert (· ≤ ·) v = _ exact orderedInsert_eq_insertIdx db₀.sorted hvm have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_insert_of_not_mem cr db₀ hvm hcr).symm have hcount' : db₁.keys.countP (fun k => decide (k < v)) = c := by rw [hkeys₁]; exact countP_insertIdx _ c v (by simp) have hanc' : (r.begin.anchor db₁).toNat = j := by rw [anchor_toNat_eq hoff, hkey, countP_lt_coe, hcount', hj_def] refine contra db₁ hagree hanc' ?_ rcases lt_or_eq_of_le hcle with hjc | hjc · intro hk rw [hkeys₁, List.getElem?_insertIdx_of_gt hjc] at hk cases hg : db₀.keys[j-1]? with | none => rw [hg] at hk; exact absurd hk (by simp) | some k => rw [hg, Option.some.injEq] at hk have hge := List.getElem?_eq_some_iff.mp hg have : db₀.keys[j-1] < db₀.keys[j] := db₀.sorted.getElem_lt_getElem_of_lt (by omega) rw [hge.2, hk, ha_eq] at this exact absurd this (lt_irrefl _) · intro hk rw [hkeys₁, hjc, List.getElem?_insertIdx_self] at hk rw [ite_eq_left (le_of_lt hjlt), Option.some.injEq] at hk have ha_ne : a ≠ v := by intro hav exact hvm (hav ▸ (ha_eq ▸ List.getElem_mem hjlt)) exact ha_ne hk.symm /-- In a reversed read with `end_.offset ≤ 1` (so `resolve end_` is the last stored key strictly below `end_.key` at offset zero, or the first key at or above it at offset one) and a nonempty result, the range `[res.keys[0], end_.key)` is necessary: every sound conflict range contains every key of it. Erasing a stored key of the range drops `resolve end_` past the result's head, and inserting an unstored one splits the reversed prefix, so no database agreeing on a sound range that omits it can stay compatible. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_head_to_end_key {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hoff : r.end_.offset ≤ 1) (cr : ConflictRange) (hs : Sound r res cr) {x : Key} (hlo : res.keys.head hne ≤ x) (hhi : (x : WithTop Key) < r.end_.key) : x ∈ cr := by obtain ⟨db₀, hread⟩ := hread rcases eq_or_ne x (res.keys.head hne) with hx | hxa · exact necessary_of_mem_result ⟨db₀, hread⟩ (by rw [hx]; exact List.head_mem hne) cr hs · have hax : res.keys.head hne < x := lt_of_le_of_ne hlo (Ne.symm hxa) have hpre : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hread have hne₀ : RangeRead.completeKeys db₀ r ≠ [] := hpre.ne_nil hne have hA₀ : 1 ≤ r.end_.anchor db₀ := RangeRead.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 := RangeRead.end_anchor_toNat_le (db := db₀) (r := r) hoff omega -- The heads of all compatible complete-key lists agree with the result's head. have head?_prefix : ∀ (db : DB), res.keys <+: RangeRead.completeKeys db r → (RangeRead.completeKeys db r).head? = res.keys.head? := by intro db hpre' obtain ⟨t, ht⟩ := hpre' rw [← ht, List.head?_append, (List.head_eq_iff_head?_eq_some hne).mp rfl, Option.some_or] have hhead?₀ : (RangeRead.completeKeys db₀ r).head? = some (db₀.keys[m-1]'hmlt) := by rw [RangeRead.completeKeys_head?_rev hrev hoff hne₀] rw [show (r.end_.anchor db₀ - 1).toNat = m - 1 by rw [toNat_sub_one hA₀, ← hm_def]] exact List.getElem?_eq_getElem hmlt have hreshead? : res.keys.head? = some (db₀.keys[m-1]'hmlt) := (head?_prefix db₀ hpre).symm.trans hhead?₀ have hhead₀ : res.keys.head hne = db₀.keys[m-1]'hmlt := (List.head_eq_iff_head?_eq_some hne).mpr hreshead? have hlt : db₀.keys[m-1]'hmlt < x := by rw [← hhead₀]; exact hax -- Any database compatible with the same result stores `x`'s predecessor at -- the index `end_.anchor - 1` derived from its own key count. have key?_eq : ∀ (db : DB) (hne' : RangeRead.completeKeys db r ≠ []) {j : Nat}, j = (r.end_.anchor db - 1).toNat → res.keys <+: RangeRead.completeKeys db r → db.keys[j]? = db₀.keys[m-1]? := by intro db hne' j hj hpre' calc db.keys[j]? = (RangeRead.completeKeys db r).head? := by rw [RangeRead.completeKeys_head?_rev hrev hoff hne', hj] _ = res.keys.head? := head?_prefix db hpre' _ = some (db₀.keys[m-1]'hmlt) := hreshead? _ = db₀.keys[m-1]? := (List.getElem?_eq_getElem hmlt).symm by_contra hcr by_cases hxm : x ∈ db₀.keys · -- `x` is stored: erasing it drops the anchor by one, pulling the -- predecessor of `x` into the index that `x` itself used to occupy. set c := db₀.keys.countP (fun k => decide (k < x)) with hc_def have hcval : db₀.keys[c]? = some x := by obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hxm have hce : c = i := by rw [hc_def, countP_lt_eq_of_getElem db₀.sorted hi hix] rw [hce, List.getElem?_eq_getElem hi, hix] obtain ⟨hclt, hc_eq⟩ := List.getElem?_eq_some_iff.mp hcval have hclen : c ≤ db₀.keys.length := by rw [hc_def]; exact List.countP_le_length have hjc : m ≤ c := by have h1 : m - 1 < c := by rw [hc_def] exact lt_countP_of_getElem_lt db₀.sorted hmlt hlt omega let db₁ : DB := db₀.erase x have hkeys₁ : db₁.keys = db₀.keys.eraseIdx c := by change db₀.keys.erase x = db₀.keys.eraseIdx c rw [← hc_eq] exact List.Nodup.erase_getElem db₀.nodup c hclt have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_erase_of_not_mem cr db₀ hcr).symm have compat₁ : RangeRead.Compatible db₁ r res := (hs db₀ db₁ hagree).mp hread have hne₁ : RangeRead.completeKeys db₁ r ≠ [] := (RangeRead.compatible_keys_prefix compat₁).ne_nil hne have hJ1le : 1 ≤ db₀.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) := countP_pos_of_mem hxm (by rw [decide_eq_true_eq]; exact hhi) have hJ₁ : db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = db₀.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) - 1 := by change (db₀.keys.erase x).countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = db₀.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) - 1 rw [List.countP_erase, ite_eq_left ⟨hxm, by rw [decide_eq_true_eq]; exact hhi⟩] have hanc₁ : r.end_.anchor db₁ = r.end_.anchor db₀ - 1 := by unfold Selector.anchor rw [hJ₁, Nat.cast_sub hJ1le] ring have hanc2 : (2 : ℤ) ≤ r.end_.anchor db₀ := by have h1 := RangeRead.one_le_anchor_of_completeKeys_ne_nil (db := db₁) (r := r) hne₁ rw [hanc₁] at h1 omega have hk₁ : (r.end_.anchor db₁ - 1).toNat = m - 2 := by have h2 : r.end_.anchor db₁ - 1 = r.end_.anchor db₀ - 2 := by rw [hanc₁]; ring rw [h2, toNat_sub_two hanc2, hm_def] have hbad : db₁.keys[(r.end_.anchor db₁ - 1).toNat]? = db₀.keys[m-1]? := key?_eq db₁ hne₁ rfl (RangeRead.compatible_keys_prefix compat₁) have hbad' : (db₀.keys.eraseIdx c)[m-2]? = db₀.keys[m-1]? := by rw [hk₁, hkeys₁] at hbad exact hbad have hb2 : db₀.keys[m-2]? = db₀.keys[m-1]? := by rw [List.getElem?_eraseIdx_of_lt (show m - 2 < c by omega)] at hbad' exact hbad' exact absurd ((db₀.nodup.getElem?_inj (show m - 2 < db₀.keys.length by omega)).mp hb2) (by omega) · -- `x` is unstored: inserting it at its rank raises the anchor by one, so -- the index that used to hold `x`'s predecessor now holds a larger key. set c := db₀.keys.countP (fun k => decide (k < x)) with hc_def have hclen : c ≤ db₀.keys.length := by rw [hc_def]; exact List.countP_le_length have hjc : m ≤ c := by have h1 : m - 1 < c := by rw [hc_def] exact lt_countP_of_getElem_lt db₀.sorted hmlt hlt omega let db₁ : DB := db₀.insert x hxm have hkeys₁ : db₁.keys = db₀.keys.insertIdx c x := by change db₀.keys.orderedInsert (· ≤ ·) x = _ exact orderedInsert_eq_insertIdx db₀.sorted hxm have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_insert_of_not_mem cr db₀ hxm hcr).symm have compat₁ : RangeRead.Compatible db₁ r res := (hs db₀ db₁ hagree).mp hread have hne₁ : RangeRead.completeKeys db₁ r ≠ [] := (RangeRead.compatible_keys_prefix compat₁).ne_nil hne have hJ₁ : db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = db₀.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) + 1 := by rw [hkeys₁] exact countP_insertIdx_of_lt db₀.sorted hhi have hanc₁ : r.end_.anchor db₁ = r.end_.anchor db₀ + 1 := by unfold Selector.anchor rw [hJ₁, Nat.cast_add, Nat.cast_one] ring have hk₁ : (r.end_.anchor db₁ - 1).toNat = m := by have h2 : r.end_.anchor db₁ - 1 = r.end_.anchor db₀ := by rw [hanc₁]; ring rw [h2, hm_def] have hbad : db₁.keys[(r.end_.anchor db₁ - 1).toNat]? = db₀.keys[m-1]? := key?_eq db₁ hne₁ rfl (RangeRead.compatible_keys_prefix compat₁) have hbad' : (db₀.keys.insertIdx c x)[m]? = db₀.keys[m-1]? := by rw [hk₁, hkeys₁] at hbad exact hbad rcases lt_or_eq_of_le hjc with hltmc | heq · -- `x` sits strictly after index `m`, so index `m` shifted down onto its -- own predecessor: impossible in a duplicate-free list. have hstep : db₀.keys[m]? = db₀.keys[m-1]? := by rw [List.getElem?_insertIdx_of_lt hltmc] at hbad' exact hbad' exact absurd ((db₀.nodup.getElem?_inj (show m < db₀.keys.length by omega)).mp hstep) (by omega) · -- `x` sits exactly at index `m`, so it would be the result's head, which -- the hypothesis `hxa` excludes. have hsome : (db₀.keys.insertIdx c x)[m]? = some x := by rw [heq, List.getElem?_insertIdx_self, ite_eq_left hclen] have hxval : db₀.keys[m-1]'hmlt = x := by refine Option.some.inj ?_ rw [← List.getElem?_eq_getElem hmlt, ← hbad'] exact hsome exact absurd (hhead₀.trans hxval) (Ne.symm hxa) /-- Reversal is invisible to compatibility once the result is complete: flipping the traversal order and reversing the reported keys gives an equally compatible read, since `more = false` forces the keys to be the complete keys and reversal commutes with `completeKeys`. -/ theorem compatible_flip {db : DB} {r : RangeRead} {res : Result} {b : Bool} (hrev : r.reverse = b) (hmore : res.more = false) : (RangeRead.Compatible db {r with reverse := !b} {keys := res.keys.reverse, more := false} ↔ RangeRead.Compatible db r res) := by have hck : RangeRead.completeKeys db {r with reverse := !b} = (RangeRead.completeKeys db r).reverse := by cases b <;> simp [RangeRead.completeKeys, hrev] rw [RangeRead.Compatible, RangeRead.Compatible, hmore, hck] simp only [RangeRead.withinLimit, List.length_reverse, Bool.false_eq_true, false_and, true_and, false_or, List.reverse_inj] /-- Soundness is invariant under flipping the traversal order and reversing the reported keys: each database's compatibility is preserved by `compatible_flip`. -/ theorem sound_flip {r : RangeRead} {res : Result} {cr : ConflictRange} {b : Bool} (hrev : r.reverse = b) (hmore : res.more = false) : (Sound {r with reverse := !b} {keys := res.keys.reverse, more := false} cr ↔ Sound r res cr) := by constructor · intro h db₁ db₂ hagree rw [← compatible_flip (db := db₁) hrev hmore, ← compatible_flip (db := db₂) hrev hmore] exact h db₁ db₂ hagree · intro h db₁ db₂ hagree rw [compatible_flip (db := db₁) hrev hmore, compatible_flip (db := db₂) hrev hmore] exact h db₁ db₂ hagree /-- **Necessity is invariant under flipping the traversal order of a complete read.** The sound ranges of `r` and of its flip are the same (`sound_flip`), so a key lies in all of them for one exactly when it does for the other. Completeness (`more = false`) is what lets the flip preserve soundness; for a truncated result the flipped result is a suffix rather than a prefix, so this reduction does not apply. -/ theorem necessary_flip {r : RangeRead} {res : Result} {k : Key} {b : Bool} (hrev : r.reverse = b) (hmore : res.more = false) : (Necessary {r with reverse := !b} {keys := res.keys.reverse, more := false} k ↔ Necessary r res k) := ⟨fun h cr hs => h cr ((sound_flip hrev hmore).mpr hs), fun h cr hs => h cr ((sound_flip hrev hmore).mp hs)⟩ /-- In a non-reversed read that is complete (`more = false`), the keys from the result's last key up to `end_.key` are necessary: since the result reports every in-range key, perturbing a key in `[res.keys.getLast, end_.key)` shifts `resolve end_` and changes the complete keys, so no sound range can omit it. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_last_to_end_key {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hoff : r.end_.offset ≤ 1) (cr : ConflictRange) (hs : Sound r res cr) {x : Key} (hlo : res.keys.getLast hne ≤ x) (hhi : (x : WithTop Key) < r.end_.key) : x ∈ cr := by obtain ⟨db₀, hread⟩ := hread exact necessary_head_to_end_key (r := {r with reverse := true}) (res := {keys := res.keys.reverse, more := false}) ⟨db₀, (compatible_flip (db := db₀) (b := false) hrev hmore).mpr hread⟩ (by simp) (by simpa using hne) hoff cr ((sound_flip (b := false) hrev hmore).mpr hs) (by simpa using hlo) (by simpa using hhi) /-- In a reversed read that is complete (`more = false`) and has `begin.offset ≥ 1`, the selector's key is necessary: any sound range must contain it. Completeness ensures the result reaches the begin end of the range, so perturbing `begin.key` shifts `resolve begin` and changes the reported keys. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_begin_key_rev {r : RangeRead} {res : Result} {v : Key} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = false) (hlen : 0 < res.keys.length) (hoff : 1 ≤ r.begin.offset) (hkey : r.begin.key = (↑v : WithTop Key)) : Necessary r res v := by obtain ⟨db₀, hread⟩ := hread have hbase : Necessary {r with reverse := false} {keys := res.keys.reverse, more := false} v := necessary_begin_key (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) ⟨db₀, (compatible_flip (db := db₀) (b := true) hrev hmore).mpr hread⟩ rfl (by simpa using hlen) hoff hkey exact fun cr hs => hbase cr ((sound_flip (b := true) hrev hmore).mpr hs) /-- In a non-reversed read with `begin.offset ≤ 0` and a nonempty result whose head is at or above `begin.key`, the empty key is necessary: every sound conflict range must contain it. A database compatible with the result cannot store the empty key, since being least it would head the window, which begins at or below `begin.key`; inserting it into a database a range omits it from keeps agreement, so that range would have to be unsound. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_nil_of_begin_offset_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hoff : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : Necessary r res ([] : Key) := by obtain ⟨db₀, hread⟩ := hread -- A database compatible with `res` cannot store the empty key: the window starts -- at or below `begin.key`, and the empty key is least, so it would head it. have hkey : ∀ db : DB, RangeRead.Compatible db r res → res.keys.head hne ≠ [] → ([] : Key) ∉ db.keys := by intro db hdb hnea h0 have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hdb have hne_ck : RangeRead.completeKeys db r ≠ [] := hpre.ne_nil hne have hhe : resolve db r.begin ≤ (↑(res.keys.head hne) : WithTop Key) := (RangeRead.mem_completeKeys.mp (hpre.subset (List.head_mem hne))).2.1 have hlt_hi : resolve db r.begin < resolve db r.end_ := by obtain ⟨a, ha⟩ := List.exists_mem_of_ne_nil _ hne_ck exact lt_of_le_of_lt (RangeRead.mem_completeKeys.mp ha).2.1 (RangeRead.mem_completeKeys.mp ha).2.2 -- A stored key `a` that `resolve begin` lands on heads the window: it is -- minimal there, and the window starts at it. have hhead_eq : ∀ a : Key, resolve db r.begin = (↑a : WithTop Key) → a ∈ db.keys → res.keys.head hne = a := by intro a ha hmem have halt : (↑a : WithTop Key) < resolve db r.end_ := by rw [← ha]; exact hlt_hi rw [hpre.head hne] exact RangeRead.completeKeys_head_eq hrev hne_ck ha (RangeRead.mem_completeKeys.mpr ⟨hmem, by rw [ha], halt⟩) rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with hn | ht | ⟨k, hkdb, hkres⟩ · exact hnea (hhead_eq ([] : Key) hn h0) · rw [ht] at hhe exact absurd hhe (not_le.mpr (WithTop.coe_lt_top (res.keys.head hne))) · by_cases hneg : r.begin.anchor db < 0 · have hk_nil : k = ([] : Key) := WithTop.coe_inj.mp (hkres.symm.trans (resolve_eq_nil (db := db) (s := r.begin) hneg)) exact hnea ((hhead_eq k hkres hkdb).trans hk_nil) · -- A nonnegative anchor holds the key below `begin.key`'s count of stored -- keys below it, hence below `begin.key` itself. have hpos : 0 ≤ r.begin.anchor db := not_lt.mp hneg obtain ⟨hnlt, hidx⟩ := List.getElem?_eq_some_iff.mp (getElem?_anchor_eq_some hpos hkres) have hlt2 : (r.begin.anchor db).toNat < db.keys.countP (fun (x : Key) => decide ((↑x : WithTop Key) < r.begin.key)) := by have hcast : ((r.begin.anchor db).toNat : ℤ) = r.begin.anchor db := Int.toNat_of_nonneg hpos have hltI : ((r.begin.anchor db).toNat : ℤ) < ((db.keys.countP (fun (x : Key) => decide ((↑x : WithTop Key) < r.begin.key)) : ℤ)) := by rw [hcast] unfold Selector.anchor omega exact_mod_cast hltI have hlt_k : ((k : WithTop Key) < r.begin.key) := by rw [← hidx] exact getElem_lt_of_lt_countP_top db.sorted hnlt hlt2 have hhead : res.keys.head hne = k := hhead_eq k hkres hkdb rw [hhead] at hlo exact absurd (WithTop.coe_lt_coe.mp (lt_of_lt_of_le hlt_k hlo)) (lt_irrefl k) intro cr hs by_contra hcr rcases eq_or_ne ([] : Key) (res.keys.head hne) with hx | hxa · exact hcr (necessary_of_mem_result ⟨db₀, hread⟩ (by rw [hx]; exact List.head_mem hne) cr hs) · by_cases h0 : ([] : Key) ∈ db₀.keys · exact hkey db₀ hread (Ne.symm hxa) h0 · -- Inserting the omitted empty key preserves agreement on the range while -- making the database incompatible, so the range was not sound. have hagree : AgreeOn cr db₀ (db₀.insert ([] : Key) h0) := (ConflictRange.keys_insert_of_not_mem cr db₀ h0 hcr).symm exact hkey (db₀.insert ([] : Key) h0) ((hs db₀ _ hagree).mp hread) (Ne.symm hxa) (DB.mem_insert_self db₀ ([] : Key) h0) /-- In a reversed complete read (`more = false`) with `begin.offset ≤ 0` and a nonempty result whose last key is at or above `begin.key`, the empty key is necessary: every sound conflict range must contain it. Reversal makes the result's last key its least, so flipping back to a non-reversed read reduces this to `necessary_nil_of_begin_offset_nonpos`. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_nil_of_begin_offset_nonpos_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = false) (hne : res.keys ≠ []) (hoff : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : Necessary r res ([] : Key) := by obtain ⟨db₀, hread⟩ := hread have hbase : Necessary {r with reverse := false} {keys := res.keys.reverse, more := false} ([] : Key) := necessary_nil_of_begin_offset_nonpos (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) ⟨db₀, (compatible_flip (db := db₀) (b := true) hrev hmore).mpr hread⟩ rfl (by simpa using hne) hoff (by simpa [List.head_reverse] using hlo) exact fun cr hs => hbase cr ((sound_flip (b := true) hrev hmore).mpr hs) /-- **The lower endpoint is attained at the empty key once the empty key is necessary.** The empty key is the least key, so if it is necessary it is the least necessary key. This is the trivial half of endpoint attainment for the nonpositive-begin regions, where `necessary_nil_of_begin_offset_nonpos` and its reversed twin supply the hypothesis. -/ theorem exists_least_necessary_of_nil {r : RangeRead} {res : Result} (h : Necessary r res ([] : Key)) : ∃ A : Key, Necessary r res A ∧ ∀ k : Key, Necessary r res k → A ≤ k := ⟨[], h, fun k _ => nil_le_key k⟩ /-- **Lower endpoint attained for the nonpositive-begin cross-free forward region.** With `begin.offset ≤ 0` and `begin.key` at or below the reported head, the empty key is necessary (`necessary_nil_of_begin_offset_nonpos`) and, being least, is the least necessary key. This is the nonpositive-offset analogue of `exists_least_necessary_of_one_le_le`. -/ theorem exists_least_necessary_of_begin_offset_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hoff : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : ∃ A : Key, Necessary r res A ∧ ∀ k : Key, Necessary r res k → A ≤ k := exists_least_necessary_of_nil (necessary_nil_of_begin_offset_nonpos hread hrev hne hoff hlo) /-- **Lower endpoint attained for the nonpositive-begin cross-free reversed region.** The reversal-symmetric twin of `exists_least_necessary_of_begin_offset_nonpos`, with the result's last key in place of its head and `necessary_nil_of_begin_offset_nonpos_rev` supplying the necessary empty key. -/ theorem exists_least_necessary_of_begin_offset_nonpos_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = false) (hne : res.keys ≠ []) (hoff : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : ∃ A : Key, Necessary r res A ∧ ∀ k : Key, Necessary r res k → A ≤ k := exists_least_necessary_of_nil (necessary_nil_of_begin_offset_nonpos_rev hread hrev hmore hne hoff hlo) /-- A key lies in the window `inRange db.keys lo hi` exactly when it is stored and lies in `[lo, hi)`. -/ private theorem mem_inRange {db : DB} {lo hi : WithTop Key} {k : Key} : k ∈ RangeRead.inRange db.keys lo hi ↔ k ∈ db.keys ∧ lo ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < hi := by unfold RangeRead.inRange rw [List.mem_filter, decide_eq_true_eq] /-- Two strictly increasing key lists listing the same keys are equal. -/ theorem eq_of_forall_mem_iff_of_pairwise {l₁ l₂ : List Key} (h₁ : l₁.Pairwise (· < ·)) (h₂ : l₂.Pairwise (· < ·)) (h : ∀ k, k ∈ l₁ ↔ k ∈ l₂) : l₁ = l₂ := List.Perm.eq_of_pairwise (fun _ _ _ _ hab hba => (lt_asymm hab hba).elim) h₁ h₂ ((List.subperm_of_subset h₁.nodup (fun _ ha => (h _).mp ha)).antisymm (List.subperm_of_subset h₂.nodup (fun _ ha => (h _).mpr ha))) /-- Under the library's existing hypotheses for the empty key, every key strictly below the reported head is necessary: `of_between` chains the empty-key theorem with the reported head's own necessity. -/ theorem necessary_below_head_of_begin_offset_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hoff : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) {k : Key} (hk : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)) : Necessary r res k := (necessary_nil_of_begin_offset_nonpos hread hrev hne hoff hlo).of_between (necessary_of_mem_result hread (List.head_mem hne)) (nil_le_key k) (le_of_lt (WithTop.coe_lt_coe.mp hk)) /-- The last element of a strictly increasing list is at or above every element. -/ private theorem pairwise_le_getLast {l : List Key} (h : l.Pairwise (· < ·)) {a : Key} (ha : a ∈ l) {hne : l ≠ []} : a ≤ l.getLast hne := (h.imp le_of_lt).rel_getLast ha /-- For a reversed read, the reported keys head the reversed window, so the reported head question reduces to the window's last element. -/ private theorem head?_eq_getLast?_of_prefix_rev {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = true) (hpre : res.keys <+: RangeRead.completeKeys db r) (hne : res.keys ≠ []) : res.keys.head? = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).getLast? := by have hck : RangeRead.completeKeys db r = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).reverse := by simp [RangeRead.completeKeys, hrev] obtain ⟨t, ht⟩ := hpre rw [← ht] at hck calc res.keys.head? = (res.keys ++ t).head? := (List.head?_append_of_ne_nil _ hne).symm _ = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).reverse.head? := by rw [hck] _ = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).getLast? := List.head?_reverse /-- In a reversed read, every complete key is at or below the reported head. -/ private theorem le_head_of_mem_completeKeys_rev {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = true) (hpre : res.keys <+: RangeRead.completeKeys db r) (hne : res.keys ≠ []) {k : Key} (hk : k ∈ RangeRead.completeKeys db r) : k ≤ res.keys.head hne := by have hck : RangeRead.completeKeys db r = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).reverse := by simp [RangeRead.completeKeys, hrev] have hWne : RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) ≠ [] := fun h => hpre.ne_nil hne (hck.trans (List.reverse_eq_nil_iff.mpr h)) rw [hck, List.mem_reverse] at hk have h1 : k ≤ (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).getLast hWne := pairwise_le_getLast (RangeRead.inRange_pairwise db _ _) hk have h2 : res.keys.head hne = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).getLast hWne := by refine (List.head_eq_iff_head?_eq_some hne).mpr ?_ rw [head?_eq_getLast?_of_prefix_rev hrev hpre hne, List.getLast?_eq_getLast_of_ne_nil hWne] rw [h2] exact h1 /-- If every stored key of `db` is at or below `x` and the read's complete keys are nonempty, then `resolve begin` is at or below `x`. -/ private theorem resolve_begin_le {db : DB} {r : RangeRead} {x : Key} (h : ∀ k ∈ db.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key)) (hne : RangeRead.completeKeys db r ≠ []) : resolve db r.begin ≤ ((x : Key) : WithTop Key) := by rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with hn | ht | ⟨k, hkdb, hkres⟩ · rw [hn] exact WithTop.coe_le_coe.mpr (nil_le_key x) · exfalso refine hne ?_ refine List.eq_nil_iff_forall_not_mem.mpr fun k hk => ?_ obtain ⟨_, h1, _⟩ := RangeRead.mem_completeKeys.mp hk rw [ht] at h1 exact absurd h1 (not_le.mpr (WithTop.coe_lt_top k)) · rw [hkres] exact h k hkdb /-- A nonempty complete-keys list forces the begin selector's key to be genuine, not `⊤`: a `⊤`-keyed begin resolves to the sentinel, which empties the window. -/ private theorem begin_key_ne_top_of_completeKeys_ne_nil {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hne : RangeRead.completeKeys db r ≠ []) (hoff : 1 ≤ r.begin.offset) : r.begin.key ≠ (⊤ : WithTop Key) := by intro htop have hresolve : resolve db r.begin = (⊤ : WithTop Key) := resolve_eq_top_of_key_eq_top htop hoff have hnil : RangeRead.completeKeys db r = [] := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] unfold RangeRead.inRange rw [hresolve, List.filter_eq_nil_iff] intro k _ hk exact absurd (of_decide_eq_true hk).1 (not_le.mpr (WithTop.coe_lt_top k)) exact hne hnil /-- A `WithTop Key` that is not `⊤` is a coerced genuine key. -/ private theorem exists_begin_key_of_ne_top {r : RangeRead} (h : r.begin.key ≠ (⊤ : WithTop Key)) : ∃ v : Key, r.begin.key = (↑v : WithTop Key) := by cases hk : r.begin.key with | top => exact absurd hk h | coe v => exact ⟨v, rfl⟩ /-- A stored key strictly below `w` at index `i` of a strictly increasing list forces more than `i` keys strictly below `w`, where `w` may be the sentinel. -/ private theorem lt_countP_of_getElem_lt_top {l : List Key} (hs : l.SortedLT) {w : WithTop Key} {i : Nat} (hi : i < l.length) (hlt : ((l[i] : Key) : WithTop Key) < w) : i < l.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < w)) := by have h1 : (l.take (i + 1)).countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < w)) = (l.take (i + 1)).length := by rw [List.countP_eq_length] intro k hk rw [List.mem_take_iff_getElem] at hk obtain ⟨j, hj, rfl⟩ := hk rw [decide_eq_true_eq] exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr ((hs.getElem_le_getElem_iff).mpr (by omega))) hlt have h3 : (l.take (i + 1)).countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < w)) ≤ l.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < w)) := List.Sublist.countP_le (List.take_prefix (i + 1) l).sublist rw [h1, List.length_take, Nat.min_eq_left (by omega)] at h3 omega /-- With an end offset of at least two and no reported key reaching `end_.key`, the end selector resolves to the sentinel: the stored key just past the last key below `end_.key` would lie in the window and be reported, unless the window ends at `⊤`. -/ theorem resolve_end_eq_top_of_hhi {db : DB} {r : RangeRead} {res : Result} (hread : RangeRead.Compatible db r res) (hoff : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) (m : Key) (hmm : m ∈ res.keys) (hmaxm : ∀ k ∈ RangeRead.completeKeys db r, k ≤ m) : resolve db r.end_ = (⊤ : WithTop Key) := by have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hread obtain ⟨hlo₀, hlt₀⟩ := (RangeRead.mem_completeKeys.mp (hpre.subset hmm)).2 have hltm : ((m : Key) : WithTop Key) < r.end_.key := hhi m hmm have hlo_lt : resolve db r.begin < r.end_.key := lt_of_le_of_lt hlo₀ hltm rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hn | ht | ⟨k₀, _, hk₀res⟩ · exfalso rw [hn, WithTop.coe_lt_coe] at hlt₀ exact List.not_lt_nil m hlt₀ · exact ht · set j := db.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) with hj have htoNat : (r.end_.anchor db).toNat = j + (r.end_.offset - 1).toNat := by rw [anchor_toNat_eq (by omega : 1 ≤ r.end_.offset), ← hj] have ho1 : 1 ≤ (r.end_.offset - 1).toNat := by omega have hpos : 0 ≤ r.end_.anchor db := by unfold Selector.anchor rw [← hj] omega obtain ⟨hilt, hidx⟩ := List.getElem?_eq_some_iff.mp (getElem?_anchor_eq_some hpos hk₀res) have hjlt : j < (r.end_.anchor db).toNat := by rw [htoNat]; omega have hjlen : j < db.keys.length := lt_trans hjlt hilt have hjge : r.end_.key ≤ ((db.keys[j]'hjlen : Key) : WithTop Key) := by by_contra hlt exact absurd (lt_countP_of_getElem_lt_top db.sorted hjlen (lt_of_not_ge hlt)) (by omega) have hjlt₀ : db.keys[j] < k₀ := by rw [← hidx] exact db.sorted.getElem_lt_getElem_iff.mpr hjlt by_cases hmem : resolve db r.begin ≤ ((db.keys[j] : Key) : WithTop Key) · have hin : db.keys[j] ∈ RangeRead.completeKeys db r := RangeRead.mem_completeKeys.mpr ⟨List.getElem_mem hjlen, hmem, by rw [hk₀res]; exact WithTop.coe_lt_coe.mpr hjlt₀⟩ exact absurd (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hmaxm _ hin)) hltm) (not_lt.mpr hjge) · have hltj : ((db.keys[j] : Key) : WithTop Key) < resolve db r.begin := lt_of_not_ge hmem exact absurd (lt_trans (lt_of_lt_of_le hltj hlo₀) hltm) (not_lt.mpr hjge) /-- Inserting a key at or above every stored key keeps the end overshoot: with `end_.offset ≥ 2` and every stored key strictly below `end_.key`, the end selector still resolves to the sentinel after the insertion. -/ private theorem resolve_end_eq_top_of_insert {db₀ : DB} {r : RangeRead} {x : Key} (hsort : db₀.keys.SortedLT) (hx0 : x ∉ db₀.keys) (hall_lt : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) < r.end_.key) (hoff : 2 ≤ r.end_.offset) : resolve (db₀.insert x hx0) r.end_ = (⊤ : WithTop Key) := by have hcnt₀ : db₀.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) = db₀.keys.length := List.countP_eq_length.mpr fun k hk => by rw [decide_eq_true_eq]; exact hall_lt k hk have hJ₁ : db₀.keys.length ≤ (db₀.insert x hx0).keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) := by rw [DB.insert_keys, orderedInsert_eq_insertIdx hsort hx0] rcases lt_or_ge (((x : Key) : WithTop Key)) r.end_.key with hlt | hge · rw [countP_insertIdx_of_lt hsort hlt, hcnt₀] omega · rw [List.countP_eq_length_filter, filter_insertIdx_of_not _ _ _ (by simp [hge])] rw [← List.countP_eq_length_filter, hcnt₀] refine resolve_eq_top ?_ ?_ · unfold Selector.anchor omega · have htoNat : (r.end_.anchor (db₀.insert x hx0)).toNat = (db₀.insert x hx0).keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := anchor_toNat_eq (by omega : 1 ≤ r.end_.offset) have ho1 : 1 ≤ (r.end_.offset - 1).toNat := by omega have hlen : (db₀.insert x hx0).keys.length = db₀.keys.length + 1 := by rw [DB.insert_keys, orderedInsert_eq_insertIdx hsort hx0] rw [List.length_insertIdx_of_le_length List.countP_le_length] rw [htoNat, hlen] omega /-- Inserting an unstored key `x` at or above every stored key of `db₀`, into a database that a sound range omits `x` from, forces a complete non-reversed result to report `x`: the inserted key joins the complete keys. -/ theorem mem_result_of_insert {db₀ : DB} {r : RangeRead} {res : Result} {cr : ConflictRange} {x : Key} (hread : RangeRead.Compatible db₀ r res) (hs : Sound r res cr) (hcr : x ∉ cr) (hmore : res.more = false) (hne : res.keys ≠ []) (hx0 : x ∉ db₀.keys) (hsub : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key)) (hE : resolve (db₀.insert x hx0) r.end_ = (⊤ : WithTop Key)) : x ∈ res.keys := by have hagree : AgreeOn cr db₀ (db₀.insert x hx0) := (ConflictRange.keys_insert_of_not_mem cr db₀ hx0 hcr).symm have hcompat : RangeRead.Compatible (db₀.insert x hx0) r res := (hs db₀ _ hagree).mp hread have heq₁ : res.keys = RangeRead.completeKeys (db₀.insert x hx0) r := by rcases hcompat.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsub₁ : ∀ k ∈ (db₀.insert x hx0).keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := fun k hk => ((DB.mem_insert_iff hx0).mp hk).elim (fun he => by rw [he]) (fun hk₀ => hsub k hk₀) have hlo₁ : resolve (db₀.insert x hx0) r.begin ≤ ((x : Key) : WithTop Key) := resolve_begin_le hsub₁ (by rw [← heq₁]; exact hne) rw [heq₁] exact RangeRead.mem_completeKeys.mpr ⟨DB.mem_insert_self db₀ x hx0, hlo₁, by rw [hE]; exact WithTop.coe_lt_top x⟩ /-- The reversed twin: inserting an unstored key at or above every stored key makes it head the reversed window, so the reported keys' head is the inserted key. -/ private theorem head_mem_result_of_insert {db₀ : DB} {r : RangeRead} {res : Result} {cr : ConflictRange} {x : Key} (hread : RangeRead.Compatible db₀ r res) (hs : Sound r res cr) (hcr : x ∉ cr) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hx0 : x ∉ db₀.keys) (hsub : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key)) (hE : resolve (db₀.insert x hx0) r.end_ = (⊤ : WithTop Key)) : x ∈ res.keys := by have hagree : AgreeOn cr db₀ (db₀.insert x hx0) := (ConflictRange.keys_insert_of_not_mem cr db₀ hx0 hcr).symm have hcompat : RangeRead.Compatible (db₀.insert x hx0) r res := (hs db₀ _ hagree).mp hread have hpre₁ : res.keys <+: RangeRead.completeKeys (db₀.insert x hx0) r := RangeRead.compatible_keys_prefix hcompat have hne₁ : RangeRead.completeKeys (db₀.insert x hx0) r ≠ [] := hpre₁.ne_nil hne have hsub₁ : ∀ k ∈ (db₀.insert x hx0).keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := fun k hk => ((DB.mem_insert_iff hx0).mp hk).elim (fun he => by rw [he]) (fun hk₀ => hsub k hk₀) have hlo₁ : resolve (db₀.insert x hx0) r.begin ≤ ((x : Key) : WithTop Key) := resolve_begin_le hsub₁ hne₁ have hxwin : x ∈ RangeRead.inRange (db₀.insert x hx0).keys (resolve (db₀.insert x hx0) r.begin) ((⊤ : WithTop Key)) := by rw [mem_inRange] exact ⟨DB.mem_insert_self db₀ x hx0, hlo₁, WithTop.coe_lt_top x⟩ have hWne : RangeRead.inRange (db₀.insert x hx0).keys (resolve (db₀.insert x hx0) r.begin) ((⊤ : WithTop Key)) ≠ [] := List.ne_nil_of_mem hxwin have hmax : ∀ k ∈ RangeRead.inRange (db₀.insert x hx0).keys (resolve (db₀.insert x hx0) r.begin) ((⊤ : WithTop Key)), ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := fun k hk => hsub₁ k (mem_inRange.mp hk).1 have hxlast : (RangeRead.inRange (db₀.insert x hx0).keys (resolve (db₀.insert x hx0) r.begin) ((⊤ : WithTop Key))).getLast hWne = x := le_antisymm (WithTop.coe_le_coe.mp (hmax _ (List.getLast_mem hWne))) (pairwise_le_getLast (RangeRead.inRange_pairwise (db₀.insert x hx0) _ _) hxwin) have hhead : res.keys.head hne = (RangeRead.inRange (db₀.insert x hx0).keys (resolve (db₀.insert x hx0) r.begin) ((⊤ : WithTop Key))).getLast hWne := by refine (List.head_eq_iff_head?_eq_some hne).mpr ?_ have h1 : res.keys.head? = (RangeRead.inRange (db₀.insert x hx0).keys (resolve (db₀.insert x hx0) r.begin) (resolve (db₀.insert x hx0) r.end_)).getLast? := head?_eq_getLast?_of_prefix_rev hrev hpre₁ hne rw [hE] at h1 rw [h1, List.getLast?_eq_getLast_of_ne_nil hWne] rw [← hxlast, ← hhead] exact List.head_mem hne /-- A stored key strictly below `l[i]`, with `1 ≤ i`, is at most `l[i-1]`. -/ private theorem le_pred_of_lt_getElem {l : List Key} (hs : l.SortedLT) {a : Key} {i : Nat} (hi1 : 1 ≤ i) (hilt : i < l.length) (hmem : a ∈ l) (hlt : ((a : Key) : WithTop Key) < ((l[i] : Key) : WithTop Key)) : a ≤ l[i-1] := by obtain ⟨j, hj, hjl⟩ := List.mem_iff_getElem.mp hmem rw [← hjl] have hji : j < i := hs.getElem_lt_getElem_iff.mp (WithTop.coe_lt_coe.mp (by rw [hjl]; exact hlt)) exact (hs.getElem_le_getElem_iff).mpr (by omega) /-- If a read's end selector resolves to the stored key at index `i + 1`, the key at index `i` lies in the complete keys whenever they are nonempty: it is the greatest stored key strictly below the resolved end, and the window's lower end is at most it since the window contains some stored key below the resolved end. -/ private theorem mem_completeKeys_of_end_getElem_succ {db : DB} {r : RangeRead} {i : Nat} (hilt : i + 1 < db.keys.length) (hres : resolve db r.end_ = ((db.keys[i + 1] : Key) : WithTop Key)) (hne : RangeRead.completeKeys db r ≠ []) : db.keys[i] ∈ RangeRead.completeKeys db r := by obtain ⟨k, hk⟩ := List.exists_mem_of_ne_nil _ hne obtain ⟨hkm, hkB, hklt⟩ := RangeRead.mem_completeKeys.mp hk obtain ⟨idx, hidx, hidxk⟩ := List.mem_iff_getElem.mp hkm have hklt' : ((k : Key) : WithTop Key) < ((db.keys[i + 1] : Key) : WithTop Key) := by rw [← hres]; exact hklt have hstep : db.keys[idx] < db.keys[i + 1] := by rw [hidxk]; exact WithTop.coe_lt_coe.mp hklt' have hidx_lt : idx < i + 1 := db.sorted.getElem_lt_getElem_iff.mp hstep refine RangeRead.mem_completeKeys.mpr ⟨List.getElem_mem (by omega), ?_, ?_⟩ · calc resolve db r.begin ≤ ((k : Key) : WithTop Key) := hkB _ = ((db.keys[idx] : Key) : WithTop Key) := by rw [hidxk] _ ≤ ((db.keys[i] : Key) : WithTop Key) := WithTop.coe_le_coe.mpr ((db.sorted.getElem_le_getElem_iff).mpr (by omega)) · rw [hres] exact WithTop.coe_lt_coe.mpr (db.sorted.getElem_lt_getElem_iff.mpr (by omega)) /-- In a non-reversed read whose end selector is keyed at `⊤` with a positive offset, so the read's window ends at `⊤`, past every stored key of *every* database, every key at or above the result's last key is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. -/ private theorem necessary_of_end_key_top_of_one_le {db₀ : DB} {r : RangeRead} {res : Result} {x : Key} (hread : RangeRead.Compatible db₀ r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hoff : 1 ≤ r.end_.offset) (htop : r.end_.key = (⊤ : WithTop Key)) (hlo : res.keys.getLast hne ≤ x) (cr : ConflictRange) (hs : Sound r res cr) (hx : x ∉ res.keys) : x ∈ cr := by by_contra hcr have hcomp : res.keys = RangeRead.completeKeys db₀ r := by rcases hread.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hE : ∀ db : DB, resolve db r.end_ = (⊤ : WithTop Key) := fun db => resolve_eq_top_of_key_eq_top htop hoff have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hread hrev have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hle₀ : resolve db₀ r.begin ≤ ((x : Key) : WithTop Key) := by have h1 : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := by rw [← hcomp]; exact List.getLast_mem hne calc resolve db₀ r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp h1).2.1 _ ≤ ((x : Key) : WithTop Key) := WithTop.coe_le_coe.mpr hlo have hx0 : x ∉ db₀.keys := by intro hxm refine hx ?_ rw [hcomp] refine RangeRead.mem_completeKeys.mpr ⟨hxm, hle₀, ?_⟩ rw [hE db₀] exact WithTop.coe_lt_top x have hall : ∀ k ∈ db₀.keys, k < x := by intro k hk by_contra hge have h2 : x ≤ k := le_of_not_gt hge have h1 : k ∈ RangeRead.completeKeys db₀ r := RangeRead.mem_completeKeys.mpr ⟨hk, hle₀.trans (WithTop.coe_le_coe.mpr h2), by rw [hE db₀]; exact WithTop.coe_lt_top k⟩ have h4 : k = x := le_antisymm (le_trans (hmaxres k (by rw [hcomp]; exact h1)) hlo) h2 rw [h4] at hk exact hx0 hk exact absurd (mem_result_of_insert hread hs hcr hmore hne hx0 (fun k hk => WithTop.coe_le_coe.mpr (le_of_lt (hall k hk))) (hE _)) hx /-- In a non-reversed read whose end selector is keyed at `⊤` with a nonpositive offset, every key at or above the result's last key is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. Here `resolve end_` is the stored key `db.keys[m]` at index `m = |db| + offset - 1` and the result's last key is the stored key `db.keys[m-1]`: inserting an unstored key at or above the result's last key enlarges the perturbed window's top to `db.keys[m+1]`, so the perturbed complete keys are nonempty and end strictly above the reported last key, breaking the equality a complete result demands; erasing an unreported stored key at or above the reported last key (possible only for a nonpositive offset, since a positive offset ends the window at `⊤`) drops `resolve end_` onto the reported last key itself, which then falls out of the window. -/ private theorem necessary_of_end_key_top_of_offset_nonpos {db₀ : DB} {r : RangeRead} {res : Result} {x : Key} (hread : RangeRead.Compatible db₀ r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hoff : r.end_.offset ≤ 0) (htop : r.end_.key = (⊤ : WithTop Key)) (hlo : res.keys.getLast hne ≤ x) (cr : ConflictRange) (hs : Sound r res cr) (hx : x ∉ res.keys) : x ∈ cr := by by_contra hcr have hcomp : res.keys = RangeRead.completeKeys db₀ r := by rcases hread.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hread hrev have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hck₀ne : RangeRead.completeKeys db₀ r ≠ [] := by rw [← hcomp]; exact hne have hAnc : r.end_.anchor db₀ = ((db₀.keys.length : ℤ) + r.end_.offset - 1) := anchor_of_top htop have hA1 : 1 ≤ r.end_.anchor db₀ := RangeRead.one_le_anchor_of_completeKeys_ne_nil hck₀ne have hcast : ((r.end_.anchor db₀).toNat : ℤ) = r.end_.anchor db₀ := Int.toNat_of_nonneg (by omega) set m := (r.end_.anchor db₀).toNat with hm_def have hm1 : 1 ≤ m := by omega have hmlt : m < db₀.keys.length := by omega have hmlt1 : m - 1 < db₀.keys.length := by omega have hres₀ : resolve db₀ r.end_ = ((db₀.keys[m] : Key) : WithTop Key) := by have h := resolve_eq_getElem (db := db₀) (s := r.end_) (h0 := by omega) (h := by rw [← hm_def]; exact hmlt) rw [h] -- The result's last key is the stored key just below the resolved end. have hmem_m1 : db₀.keys[m - 1] ∈ res.keys := by have hck₀ : RangeRead.completeKeys db₀ r = RangeRead.inRange db₀.keys (resolve db₀ r.begin) ((db₀.keys[m] : Key) : WithTop Key) := by simp [RangeRead.completeKeys, hrev, hres₀] rw [hcomp, hck₀, mem_inRange] refine ⟨List.getElem_mem (by omega), ?_, ?_⟩ · obtain ⟨k, hk⟩ := List.exists_mem_of_ne_nil _ hne obtain ⟨hstored, hB, hC⟩ := RangeRead.mem_completeKeys.mp (by rw [← hcomp]; exact hk) have hlt : ((k : Key) : WithTop Key) < ((db₀.keys[m] : Key) : WithTop Key) := by rw [← hres₀]; exact hC obtain ⟨j, hj, hjk⟩ := List.mem_iff_getElem.mp (RangeRead.compatible_keys_subset hread hk) calc resolve db₀ r.begin ≤ ((k : Key) : WithTop Key) := hB _ ≤ ((db₀.keys[m - 1] : Key) : WithTop Key) := WithTop.coe_le_coe.mpr (le_pred_of_lt_getElem (a := k) db₀.sorted hm1 hmlt (hjk ▸ List.getElem_mem hj) hlt) · exact WithTop.coe_lt_coe.mpr (db₀.sorted.getElem_lt_getElem_iff.mpr (by omega)) have hlast : res.keys.getLast hne = db₀.keys[m - 1] := by refine le_antisymm ?_ (pairwise_le_getLast hsort.pairwise hmem_m1) obtain ⟨hstored, _, hC⟩ := RangeRead.mem_completeKeys.mp (by rw [← hcomp]; exact List.getLast_mem hne) refine le_pred_of_lt_getElem db₀.sorted hm1 hmlt hstored ?_ rw [← hres₀] exact hC have hxne : x ≠ db₀.keys[m - 1] := by intro hcon subst hcon exact hx hmem_m1 have hxlt : db₀.keys[m - 1] < x := by refine lt_of_le_of_ne ?_ (Ne.symm hxne) rw [← hlast] exact hlo by_cases hxm : x ∈ db₀.keys · -- `x` is stored: erasing it drops `resolve end_` onto the result's last key itself. obtain ⟨j, hj, hjx⟩ := List.mem_iff_getElem.mp hxm have hjm : m ≤ j := by have h1 : db₀.keys[m - 1] < db₀.keys[j] := by rw [hjx]; exact hxlt have h2 := db₀.sorted.getElem_lt_getElem_iff.mp h1 omega let db₁ : DB := db₀.erase x have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_erase_of_not_mem cr db₀ hcr).symm have hkeys₁ : db₁.keys = db₀.keys.eraseIdx j := by change db₀.keys.erase x = db₀.keys.eraseIdx j rw [← hjx] exact List.Nodup.erase_getElem db₀.nodup j hj have hlen₁ : db₁.keys.length = db₀.keys.length - 1 := by rw [hkeys₁, List.length_eraseIdx, ite_eq_left hj] have hJ₁ : ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) = ((db₀.keys.length : ℤ) - 1) := by rw [htop, countP_lt_top, hlen₁] omega have hanc₁ : r.end_.anchor db₁ = (r.end_.anchor db₀ : ℤ) - 1 := by have e1 : r.end_.anchor db₁ = ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) + r.end_.offset - 1 := rfl rw [e1, hJ₁, hAnc] ring have hidx : (r.end_.anchor db₁).toNat = m - 1 := by rw [hanc₁, toNat_sub_one hA1, ← hm_def] have hmlt1' : m - 1 < db₁.keys.length := by rw [hlen₁]; omega have hget : db₁.keys[m - 1] = db₀.keys[m - 1] := by have h1 : db₁.keys[m - 1]? = db₀.keys[m - 1]? := by rw [hkeys₁, List.getElem?_eraseIdx_of_lt (show m - 1 < j by omega)] rw [List.getElem?_eq_getElem hmlt1', List.getElem?_eq_getElem hmlt1] at h1 exact Option.some.inj h1 have hres₁ : resolve db₁ r.end_ = ((db₀.keys[m - 1] : Key) : WithTop Key) := by have h0 : 0 ≤ r.end_.anchor db₁ := by rw [hanc₁]; omega have hlt : (r.end_.anchor db₁).toNat < db₁.keys.length := by rw [hidx]; omega have h := resolve_eq_getElem (db := db₁) (s := r.end_) h0 hlt refine h.trans ?_ have h1' : db₁.keys[(r.end_.anchor db₁).toNat]? = db₁.keys[m - 1]? := by rw [hidx] rw [List.getElem?_eq_getElem hlt, List.getElem?_eq_getElem hmlt1', hget] at h1' exact congrArg _ (Option.some.inj h1') have hin : ¬ RangeRead.Compatible db₁ r res := by intro hcomp₁ have hsub₁ : res.keys ⊆ RangeRead.completeKeys db₁ r := (RangeRead.compatible_keys_prefix hcomp₁).subset have hmem : res.keys.getLast hne ∈ RangeRead.completeKeys db₁ r := hsub₁ (List.getLast_mem hne) obtain ⟨_, _, hlt⟩ := RangeRead.mem_completeKeys.mp hmem rw [hres₁, hlast] at hlt exact lt_irrefl _ hlt exact hin ((hs db₀ db₁ hagree).mp hread) · -- `x` is unstored: inserting it enlarges the window's top past the result's last key. let db₁ : DB := db₀.insert x hxm have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_insert_of_not_mem cr db₀ hxm hcr).symm have hcomp₁ : RangeRead.Compatible db₁ r res := (hs db₀ db₁ hagree).mp hread have heq₁ : res.keys = RangeRead.completeKeys db₁ r := by rcases hcomp₁.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hne₁ : RangeRead.completeKeys db₁ r ≠ [] := by rw [← heq₁]; exact hne have hlen₁ : db₁.keys.length = db₀.keys.length + 1 := by rw [DB.insert_keys, orderedInsert_eq_insertIdx db₀.sorted hxm] rw [List.length_insertIdx_of_le_length List.countP_le_length] have hmlt' : m < db₁.keys.length := by rw [hlen₁]; omega have hmlt1' : m - 1 < db₁.keys.length := by rw [hlen₁]; omega have hmltp : m + 1 < db₁.keys.length := by rw [hlen₁]; omega have hJ₁ : ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) = ((db₀.keys.length : ℤ) + 1) := by rw [htop, countP_lt_top, hlen₁] omega have hanc₁ : r.end_.anchor db₁ = (r.end_.anchor db₀ : ℤ) + 1 := by have e1 : r.end_.anchor db₁ = ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) + r.end_.offset - 1 := rfl rw [e1, hJ₁, hAnc] ring have hidx : (r.end_.anchor db₁).toNat = m + 1 := by rw [hanc₁] have h2 : (((r.end_.anchor db₀ + 1 : ℤ).toNat : ℤ)) = r.end_.anchor db₀ + 1 := Int.toNat_of_nonneg (by omega) omega have hres₁ : resolve db₁ r.end_ = ((db₁.keys[m + 1] : Key) : WithTop Key) := by have h0 : 0 ≤ r.end_.anchor db₁ := by rw [hanc₁]; omega have hlt : (r.end_.anchor db₁).toNat < db₁.keys.length := by rw [hidx]; omega have h := resolve_eq_getElem (db := db₁) (s := r.end_) h0 hlt refine h.trans ?_ have h1 : db₁.keys[(r.end_.anchor db₁).toNat]? = db₁.keys[m + 1]? := by rw [hidx] rw [List.getElem?_eq_getElem hlt, List.getElem?_eq_getElem hmltp] at h1 exact congrArg _ (Option.some.inj h1) have hmem : db₁.keys[m] ∈ RangeRead.completeKeys db₁ r := mem_completeKeys_of_end_getElem_succ hmltp hres₁ hne₁ have hmem' : db₁.keys[m] ∈ res.keys := by rw [heq₁]; exact hmem have hgt : db₀.keys[m - 1] < db₁.keys[m] := by have hcge : m ≤ db₀.keys.countP (fun k => decide (k < x)) := by have h := lt_countP_of_getElem_lt db₀.sorted hmlt1 hxlt omega have hkeys₁ : db₁.keys = db₀.keys.insertIdx (db₀.keys.countP (fun k => decide (k < x))) x := by rw [DB.insert_keys]; exact orderedInsert_eq_insertIdx db₀.sorted hxm have hget : db₁.keys[m - 1] = db₀.keys[m - 1] := by have h1 : db₁.keys[m - 1]? = db₀.keys[m - 1]? := by rw [hkeys₁, List.getElem?_insertIdx_of_lt (show m - 1 < db₀.keys.countP (fun k => decide (k < x)) by omega)] rw [List.getElem?_eq_getElem hmlt1', List.getElem?_eq_getElem hmlt1] at h1 exact Option.some.inj h1 have h2 : db₁.keys[m - 1] < db₁.keys[m] := db₁.sorted.getElem_lt_getElem_iff.mpr (by omega) rw [hget] at h2 exact h2 have hle : db₁.keys[m] ≤ db₀.keys[m - 1] := by rw [← hlast]; exact hmaxres _ hmem' exact absurd hle (not_le.mpr hgt) /-- In a reversed read whose end selector is keyed at `⊤` with a nonpositive offset, every key at or above the result's head is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. Here `resolve end_` is the stored key `db.keys[m]` at index `m = |db| + offset - 1` and the result's head is the stored key `db.keys[m-1]`: inserting an unstored key at or above the reported head enlarges the perturbed window's top to `db.keys[m+1]`, so the key at index `m` joins the reversed complete keys above the reported head and breaks the required prefix; erasing an unreported stored key at or above the reported head (possible only for a nonpositive offset, since a positive offset ends the window at `⊤`) drops `resolve end_` onto the reported head itself, which then falls out of the window. -/ private theorem necessary_of_end_key_top_rev_of_offset_nonpos {db₀ : DB} {r : RangeRead} {res : Result} {x : Key} (hread : RangeRead.Compatible db₀ r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hoff : r.end_.offset ≤ 0) (htop : r.end_.key = (⊤ : WithTop Key)) (hlo : res.keys.head hne ≤ x) (cr : ConflictRange) (hs : Sound r res cr) (hx : x ∉ res.keys) : x ∈ cr := by by_contra hcr have hpre : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hread have hck₀ne : RangeRead.completeKeys db₀ r ≠ [] := hpre.ne_nil hne have hAnc : r.end_.anchor db₀ = ((db₀.keys.length : ℤ) + r.end_.offset - 1) := anchor_of_top htop have hA1 : 1 ≤ r.end_.anchor db₀ := RangeRead.one_le_anchor_of_completeKeys_ne_nil hck₀ne have hcast : ((r.end_.anchor db₀).toNat : ℤ) = r.end_.anchor db₀ := Int.toNat_of_nonneg (by omega) set m := (r.end_.anchor db₀).toNat with hm_def have hm1 : 1 ≤ m := by omega have hmlt : m < db₀.keys.length := by omega have hmlt1 : m - 1 < db₀.keys.length := by omega have hres₀ : resolve db₀ r.end_ = ((db₀.keys[m] : Key) : WithTop Key) := by have h := resolve_eq_getElem (db := db₀) (s := r.end_) (h0 := by omega) (h := by rw [← hm_def]; exact hmlt) rw [h] have hhead : res.keys.head hne = db₀.keys[m - 1] := by have hpref : (RangeRead.completeKeys db₀ r).head? = res.keys.head? := by obtain ⟨t, ht⟩ := hpre rw [← ht, List.head?_append, (List.head_eq_iff_head?_eq_some hne).mp rfl, Option.some_or] refine (List.head_eq_iff_head?_eq_some hne).mpr ?_ rw [← hpref, RangeRead.completeKeys_head?_rev hrev (by omega : r.end_.offset ≤ 1) hck₀ne, toNat_sub_one hA1, ← hm_def, List.getElem?_eq_getElem hmlt1] have hxne : x ≠ db₀.keys[m - 1] := by intro hcon subst hcon exact hx (hhead ▸ List.head_mem hne) have hxlt : db₀.keys[m - 1] < x := by refine lt_of_le_of_ne ?_ (Ne.symm hxne) rw [← hhead] exact hlo by_cases hxm : x ∈ db₀.keys · -- `x` is stored: erasing it drops `resolve end_` onto the result's head itself. obtain ⟨j, hj, hjx⟩ := List.mem_iff_getElem.mp hxm have hjm : m ≤ j := by have h1 : db₀.keys[m - 1] < db₀.keys[j] := by rw [hjx]; exact hxlt have h2 := db₀.sorted.getElem_lt_getElem_iff.mp h1 omega let db₁ : DB := db₀.erase x have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_erase_of_not_mem cr db₀ hcr).symm have hkeys₁ : db₁.keys = db₀.keys.eraseIdx j := by change db₀.keys.erase x = db₀.keys.eraseIdx j rw [← hjx] exact List.Nodup.erase_getElem db₀.nodup j hj have hlen₁ : db₁.keys.length = db₀.keys.length - 1 := by rw [hkeys₁, List.length_eraseIdx, ite_eq_left hj] have hJ₁ : ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) = ((db₀.keys.length : ℤ) - 1) := by rw [htop, countP_lt_top, hlen₁] omega have hanc₁ : r.end_.anchor db₁ = (r.end_.anchor db₀ : ℤ) - 1 := by have e1 : r.end_.anchor db₁ = ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) + r.end_.offset - 1 := rfl rw [e1, hJ₁, hAnc] ring have hidx : (r.end_.anchor db₁).toNat = m - 1 := by rw [hanc₁, toNat_sub_one hA1, ← hm_def] have hmlt1' : m - 1 < db₁.keys.length := by rw [hlen₁]; omega have hget : db₁.keys[m - 1] = db₀.keys[m - 1] := by have h1 : db₁.keys[m - 1]? = db₀.keys[m - 1]? := by rw [hkeys₁, List.getElem?_eraseIdx_of_lt (show m - 1 < j by omega)] rw [List.getElem?_eq_getElem hmlt1', List.getElem?_eq_getElem hmlt1] at h1 exact Option.some.inj h1 have hres₁ : resolve db₁ r.end_ = ((db₀.keys[m - 1] : Key) : WithTop Key) := by have h0 : 0 ≤ r.end_.anchor db₁ := by rw [hanc₁]; omega have hlt : (r.end_.anchor db₁).toNat < db₁.keys.length := by rw [hidx]; omega have h := resolve_eq_getElem (db := db₁) (s := r.end_) h0 hlt refine h.trans ?_ have h1 : db₁.keys[(r.end_.anchor db₁).toNat]? = db₁.keys[m - 1]? := by rw [hidx] rw [List.getElem?_eq_getElem hlt, List.getElem?_eq_getElem hmlt1', hget] at h1 exact congrArg _ (Option.some.inj h1) have hin : ¬ RangeRead.Compatible db₁ r res := by intro hcomp₁ have hsub₁ : res.keys ⊆ RangeRead.completeKeys db₁ r := (RangeRead.compatible_keys_prefix hcomp₁).subset have hmem : res.keys.head hne ∈ RangeRead.completeKeys db₁ r := hsub₁ (List.head_mem hne) obtain ⟨_, _, hlt⟩ := RangeRead.mem_completeKeys.mp hmem rw [hres₁, hhead] at hlt exact lt_irrefl _ hlt exact hin ((hs db₀ db₁ hagree).mp hread) · -- `x` is unstored: inserting it enlarges the window's top past the result's head. let db₁ : DB := db₀.insert x hxm have hagree : AgreeOn cr db₀ db₁ := (ConflictRange.keys_insert_of_not_mem cr db₀ hxm hcr).symm have hcomp₁ : RangeRead.Compatible db₁ r res := (hs db₀ db₁ hagree).mp hread have hpre₁ : res.keys <+: RangeRead.completeKeys db₁ r := RangeRead.compatible_keys_prefix hcomp₁ have hne₁ : RangeRead.completeKeys db₁ r ≠ [] := hpre₁.ne_nil hne have hlen₁ : db₁.keys.length = db₀.keys.length + 1 := by rw [DB.insert_keys, orderedInsert_eq_insertIdx db₀.sorted hxm] rw [List.length_insertIdx_of_le_length List.countP_le_length] have hmlt' : m < db₁.keys.length := by rw [hlen₁]; omega have hmlt1' : m - 1 < db₁.keys.length := by rw [hlen₁]; omega have hmltp : m + 1 < db₁.keys.length := by rw [hlen₁]; omega have hJ₁ : ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) = ((db₀.keys.length : ℤ) + 1) := by rw [htop, countP_lt_top, hlen₁] omega have hanc₁ : r.end_.anchor db₁ = (r.end_.anchor db₀ : ℤ) + 1 := by have e1 : r.end_.anchor db₁ = ((db₁.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) : ℤ)) + r.end_.offset - 1 := rfl rw [e1, hJ₁, hAnc] ring have hidx : (r.end_.anchor db₁).toNat = m + 1 := by rw [hanc₁] have h2 : (((r.end_.anchor db₀ + 1 : ℤ).toNat : ℤ)) = r.end_.anchor db₀ + 1 := Int.toNat_of_nonneg (by omega) omega have hres₁ : resolve db₁ r.end_ = ((db₁.keys[m + 1] : Key) : WithTop Key) := by have h0 : 0 ≤ r.end_.anchor db₁ := by rw [hanc₁]; omega have hlt : (r.end_.anchor db₁).toNat < db₁.keys.length := by rw [hidx]; omega have h := resolve_eq_getElem (db := db₁) (s := r.end_) h0 hlt refine h.trans ?_ have h1 : db₁.keys[(r.end_.anchor db₁).toNat]? = db₁.keys[m + 1]? := by rw [hidx] rw [List.getElem?_eq_getElem hlt, List.getElem?_eq_getElem hmltp] at h1 exact congrArg _ (Option.some.inj h1) have hmem : db₁.keys[m] ∈ RangeRead.completeKeys db₁ r := mem_completeKeys_of_end_getElem_succ hmltp hres₁ hne₁ have hle := le_head_of_mem_completeKeys_rev hrev hpre₁ hne hmem have hgt : db₀.keys[m - 1] < db₁.keys[m] := by have hcge : m ≤ db₀.keys.countP (fun k => decide (k < x)) := by have h := lt_countP_of_getElem_lt db₀.sorted hmlt1 hxlt omega have hkeys₁ : db₁.keys = db₀.keys.insertIdx (db₀.keys.countP (fun k => decide (k < x))) x := by rw [DB.insert_keys]; exact orderedInsert_eq_insertIdx db₀.sorted hxm have hget : db₁.keys[m - 1] = db₀.keys[m - 1] := by have h1 : db₁.keys[m - 1]? = db₀.keys[m - 1]? := by rw [hkeys₁, List.getElem?_insertIdx_of_lt (show m - 1 < db₀.keys.countP (fun k => decide (k < x)) by omega)] rw [List.getElem?_eq_getElem hmlt1', List.getElem?_eq_getElem hmlt1] at h1 exact Option.some.inj h1 have h2 : db₁.keys[m - 1] < db₁.keys[m] := db₁.sorted.getElem_lt_getElem_iff.mpr (by omega) rw [hget] at h2 exact h2 rw [hhead] at hle exact absurd hle (not_le.mpr hgt) /-- In a reversed read whose end selector is keyed at `⊤` with a positive offset, every key at or above the result's head is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. -/ private theorem necessary_of_end_key_top_rev_of_one_le {db₀ : DB} {r : RangeRead} {res : Result} {x : Key} (hread : RangeRead.Compatible db₀ r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hoff : 1 ≤ r.end_.offset) (htop : r.end_.key = (⊤ : WithTop Key)) (hlo : res.keys.head hne ≤ x) (cr : ConflictRange) (hs : Sound r res cr) (hx : x ∉ res.keys) : x ∈ cr := by by_contra hcr have hpre : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hread have hE : ∀ db : DB, resolve db r.end_ = (⊤ : WithTop Key) := fun db => resolve_eq_top_of_key_eq_top htop hoff have hmax₀ : ∀ k ∈ RangeRead.completeKeys db₀ r, k ≤ res.keys.head hne := fun k hk => le_head_of_mem_completeKeys_rev hrev hpre hne hk have hlo₀ : resolve db₀ r.begin ≤ ((res.keys.head hne : Key) : WithTop Key) := by have h1 : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := hpre.subset (List.head_mem hne) exact (RangeRead.mem_completeKeys.mp h1).2.1 have hle₀ : resolve db₀ r.begin ≤ ((x : Key) : WithTop Key) := hlo₀.trans (WithTop.coe_le_coe.mpr hlo) have hx0 : x ∉ db₀.keys := by intro hxm have hxin : x ∈ RangeRead.completeKeys db₀ r := by refine RangeRead.mem_completeKeys.mpr ⟨hxm, hle₀, ?_⟩ rw [hE db₀] exact WithTop.coe_lt_top x refine hx ?_ rw [le_antisymm (hmax₀ x hxin) hlo] exact List.head_mem hne have hall : ∀ k ∈ db₀.keys, k < x := by intro k hk by_contra hge have h2 : x ≤ k := le_of_not_gt hge have h1 : k ∈ RangeRead.completeKeys db₀ r := RangeRead.mem_completeKeys.mpr ⟨hk, hle₀.trans (WithTop.coe_le_coe.mpr h2), by rw [hE db₀]; exact WithTop.coe_lt_top k⟩ have h4 : k = x := le_antisymm (le_trans (hmax₀ k h1) hlo) h2 rw [h4] at hk exact hx0 hk exact absurd (head_mem_result_of_insert hread hs hcr hrev hne hx0 (fun k hk => WithTop.coe_le_coe.mpr (le_of_lt (hall k hk))) (hE _)) hx /-- In a complete non-reversed read whose end selector is keyed at `⊤`, every key at or above the result's last key is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. This is the analog of `necessary_nil_of_begin_offset_nonpos` for the top of the key space, and it holds for every offset. For a positive offset the window ends at `⊤` past every stored key of *every* database (`resolve_eq_top_of_key_eq_top`), and inserting an unstored key at or above the result's last key into a database a range omits it from joins the complete keys and breaks the equality a complete result demands. For a nonpositive offset the window ends at a stored key, and the same conclusion follows from the count- and endpoint-shift perturbations recorded in `necessary_of_end_key_top_of_offset_nonpos`: inserting an unstored key at or above the result's last key enlarges the perturbed window's top past the reported last key, breaking that equality, and erasing an unreported stored key at or above the reported last key — possible only for a nonpositive offset, since a positive offset ends the window at `⊤` — drops `resolve end_` onto the reported last key itself, which then falls out of the window. The bottom of `WithTop Key` is the empty key, a genuine key, so an unbounded lower end is witnessed by the single necessary empty key, while no key lies above every stored key, so an unbounded upper end is witnessed by the unbounded family of keys beyond the result's last. Completeness is what confines necessity to that family: past a truncated result the complete keys merely extend the reported prefix, so inserting an unstored key into a database a range omits it from only appends it to the complete keys and leaves the reported keys a prefix of them, keeping the truncated result compatible; only a complete result, whose keys are all of the complete keys, is broken by that insertion. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_end_key_top {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (htop : r.end_.key = (⊤ : WithTop Key)) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hread⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hread⟩ hx cr hs · rcases lt_or_ge r.end_.offset 1 with hoff | hoff · exact necessary_of_end_key_top_of_offset_nonpos hread hrev hmore hne (by omega : r.end_.offset ≤ 0) htop hlo cr hs hx · exact necessary_of_end_key_top_of_one_le hread hrev hmore hne (by omega : 1 ≤ r.end_.offset) htop hlo cr hs hx /-- In a reversed read whose end selector is keyed at `⊤`, every key at or above the result's head is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. This is the reversal-symmetric twin of `necessary_of_end_key_top`, with the roles of head and last exchanged as in `necessary_nil_of_begin_offset_nonpos_rev`, and no completeness is needed, matching `necessary_head_to_end_key`. For a positive offset the window ends at `⊤` for every database, and inserting an unstored key above the reported head makes the new key head the reversed complete keys instead, breaking the required prefix whether or not the result is truncated. For a nonpositive offset the window ends at a stored key, and the same conclusion follows from the endpoint-shift perturbations recorded in `necessary_of_end_key_top_rev_of_offset_nonpos`: inserting an unstored key at or above the reported head breaks the prefix, and erasing an unreported stored key at or above the reported head — possible only for a nonpositive offset, since a positive offset ends the window at `⊤` — drops `resolve end_` onto the reported head itself, which then falls out of the window. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_end_key_top_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (htop : r.end_.key = (⊤ : WithTop Key)) {x : Key} (hlo : res.keys.head hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hread⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hread⟩ hx cr hs · rcases lt_or_ge r.end_.offset 1 with hoff | hoff · exact necessary_of_end_key_top_rev_of_offset_nonpos hread hrev hne (by omega : r.end_.offset ≤ 0) htop hlo cr hs hx · exact necessary_of_end_key_top_rev_of_one_le hread hrev hne (by omega : 1 ≤ r.end_.offset) htop hlo cr hs hx /-- In a complete non-reversed read whose end offset is at least two and none of whose reported keys reaches `end_.key`, every key at or above the result's last key is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. This is `necessary_of_end_key_top` without requiring the selector to be keyed at the sentinel: the offset overshoot puts `resolve end_` strictly past the first stored key at or above `end_.key`, and that key would itself be reported since the window begins below `end_.key`, contradicting the hypothesis, so the window must end at `⊤`; completeness then reports every stored key of the window, forcing `end_.key` above every stored key — the property the sentinel `⊤` has by construction. The perturbation is the usual one: a reported key is necessary by `necessary_of_mem_result`, and an unstored key at or above the result's last key, inserted into a database a range omits it from, still resolves the end to `⊤` (the offset overshoot survives the insertion), so it joins the complete keys and breaks the equality a complete result demands. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_end_offset_ge_two {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hoff : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hread⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hread⟩ hx cr hs · by_contra hcr have hcomp : res.keys = RangeRead.completeKeys db₀ r := by rcases hread.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hread hrev have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hlo_lt : resolve db₀ r.begin < r.end_.key := by have h1 : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := by rw [← hcomp]; exact List.getLast_mem hne calc resolve db₀ r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp h1).2.1 _ < r.end_.key := hhi _ (List.getLast_mem hne) have hE₀ : resolve db₀ r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hread hoff hhi (res.keys.getLast hne) (List.getLast_mem hne) (fun k hk => hmaxres k (by rw [hcomp]; exact hk)) have hle₀ : resolve db₀ r.begin ≤ ((x : Key) : WithTop Key) := by have h1 : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := by rw [← hcomp]; exact List.getLast_mem hne calc resolve db₀ r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp h1).2.1 _ ≤ ((x : Key) : WithTop Key) := WithTop.coe_le_coe.mpr hlo have hx0 : x ∉ db₀.keys := by intro hxm refine hx ?_ rw [hcomp] refine RangeRead.mem_completeKeys.mpr ⟨hxm, hle₀, ?_⟩ rw [hE₀] exact WithTop.coe_lt_top x have hall_lt : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_contra hge have h1 : k ∈ RangeRead.completeKeys db₀ r := RangeRead.mem_completeKeys.mpr ⟨hk, le_of_lt (lt_of_lt_of_le hlo_lt (le_of_not_gt hge)), by rw [hE₀]; exact WithTop.coe_lt_top k⟩ exact hge (hhi k (by rw [hcomp]; exact h1)) have hall : ∀ k ∈ db₀.keys, k < x := by intro k hk by_contra hge have h2 : x ≤ k := le_of_not_gt hge have h1 : k ∈ RangeRead.completeKeys db₀ r := RangeRead.mem_completeKeys.mpr ⟨hk, hle₀.trans (WithTop.coe_le_coe.mpr h2), by rw [hE₀]; exact WithTop.coe_lt_top k⟩ have h4 : k = x := le_antisymm (le_trans (hmaxres k (by rw [hcomp]; exact h1)) hlo) h2 rw [h4] at hk exact hx0 hk exact absurd (mem_result_of_insert hread hs hcr hmore hne hx0 (fun k hk => WithTop.coe_le_coe.mpr (le_of_lt (hall k hk))) (resolve_end_eq_top_of_insert db₀.sorted hx0 hall_lt hoff)) hx /-- In a reversed read whose end offset is at least two and none of whose reported keys reaches `end_.key`, every key at or above the result's head is necessary: every sound conflict range contains it, so every sound range extends to `⊤`. This is the reversal-symmetric twin of `necessary_of_end_offset_ge_two` and, as in `necessary_of_end_key_top_rev`, no completeness is needed: the reported keys head the complete keys, whose head is the greatest stored key of the window, so the hypotheses again force `resolve end_` to be `⊤` with `end_.key` above every stored key, and inserting an unstored key at or above the reported head makes the new key head the complete keys instead, breaking the required prefix whether or not the result is truncated. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_end_offset_ge_two_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hoff : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) {x : Key} (hlo : res.keys.head hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hread⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hread⟩ hx cr hs · by_contra hcr have hpre : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hread have hck : RangeRead.completeKeys db₀ r = (RangeRead.inRange db₀.keys (resolve db₀ r.begin) (resolve db₀ r.end_)).reverse := by simp [RangeRead.completeKeys, hrev] have hWne : RangeRead.inRange db₀.keys (resolve db₀ r.begin) (resolve db₀ r.end_) ≠ [] := fun h => hpre.ne_nil hne (hck.trans (List.reverse_eq_nil_iff.mpr h)) have hmaxW : ∀ k ∈ RangeRead.completeKeys db₀ r, k ≤ (RangeRead.inRange db₀.keys (resolve db₀ r.begin) (resolve db₀ r.end_)).getLast hWne := by intro k hk rw [hck, List.mem_reverse] at hk exact pairwise_le_getLast (RangeRead.inRange_pairwise db₀ _ _) hk have hhead : res.keys.head hne = (RangeRead.inRange db₀.keys (resolve db₀ r.begin) (resolve db₀ r.end_)).getLast hWne := by refine (List.head_eq_iff_head?_eq_some hne).mpr ?_ rw [head?_eq_getLast?_of_prefix_rev hrev hpre hne, List.getLast?_eq_getLast_of_ne_nil hWne] have hmax₀ : ∀ k ∈ RangeRead.completeKeys db₀ r, k ≤ res.keys.head hne := by intro k hk rw [hhead] exact hmaxW k hk have hlo₀ : resolve db₀ r.begin ≤ ((res.keys.head hne : Key) : WithTop Key) := by have h1 : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := hpre.subset (List.head_mem hne) exact (RangeRead.mem_completeKeys.mp h1).2.1 have hle₀ : resolve db₀ r.begin ≤ ((x : Key) : WithTop Key) := hlo₀.trans (WithTop.coe_le_coe.mpr hlo) have hlo_lt : resolve db₀ r.begin < r.end_.key := lt_of_le_of_lt hlo₀ (hhi _ (List.head_mem hne)) have hE₀ : resolve db₀ r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hread hoff hhi (res.keys.head hne) (List.head_mem hne) hmax₀ have hx0 : x ∉ db₀.keys := by intro hxm have hxin : x ∈ RangeRead.completeKeys db₀ r := by refine RangeRead.mem_completeKeys.mpr ⟨hxm, hle₀, ?_⟩ rw [hE₀] exact WithTop.coe_lt_top x refine hx ?_ rw [le_antisymm (hmax₀ x hxin) hlo] exact List.head_mem hne have hall_lt : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_contra hge have h1 : k ∈ RangeRead.completeKeys db₀ r := RangeRead.mem_completeKeys.mpr ⟨hk, le_of_lt (lt_of_lt_of_le hlo_lt (le_of_not_gt hge)), by rw [hE₀]; exact WithTop.coe_lt_top k⟩ exact absurd (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hmax₀ k h1)) (hhi _ (List.head_mem hne))) hge have hall : ∀ k ∈ db₀.keys, k < x := by intro k hk by_contra hge have h2 : x ≤ k := le_of_not_gt hge have h1 : k ∈ RangeRead.completeKeys db₀ r := RangeRead.mem_completeKeys.mpr ⟨hk, hle₀.trans (WithTop.coe_le_coe.mpr h2), by rw [hE₀]; exact WithTop.coe_lt_top k⟩ have h4 : k = x := le_antisymm (le_trans (hmax₀ k h1) hlo) h2 rw [h4] at hk exact hx0 hk exact absurd (head_mem_result_of_insert hread hs hcr hrev hne hx0 (fun k hk => WithTop.coe_le_coe.mpr (le_of_lt (hall k hk))) (resolve_end_eq_top_of_insert db₀.sorted hx0 hall_lt hoff)) hx /-- When a conflict range captures the whole database, agreement on the range means agreement on the database, so every read and result is sound. -/ theorem sound_of_keys_eq {r : RangeRead} {res : Result} {cr : ConflictRange} (hcr : ∀ db, cr.keys db = db.keys) : Sound r res cr := by intro db₁ db₂ hagree rw [AgreeOn] at hagree rw [hcr db₁, hcr db₂] at hagree exact RangeRead.compatible_congr (RangeRead.completeKeys_congr hagree r) /-- Soundness is monotone in the conflict range: if agreement on `cr'` implies agreement on the sound range `cr`, then `cr'` is sound too. -/ theorem Sound.mono {r : RangeRead} {res : Result} {cr cr' : ConflictRange} (hfin : ∀ db₁ db₂, AgreeOn cr' db₁ db₂ → AgreeOn cr db₁ db₂) (h : Sound r res cr) : Sound r res cr' := by intro db₁ db₂ hagree exact h db₁ db₂ (hfin db₁ db₂ hagree) /-- A conflict range is minimal for a read and result when it is sound and no proper subrange of it is sound: every key in the range is needed. -/ def Minimal (r : RangeRead) (res : Result) (cr : ConflictRange) : Prop := Sound r res cr ∧ ∀ cr', ProperSubrange cr' cr → ¬ Sound r res cr' /-- A minimal conflict range is sound. -/ theorem Minimal.sound {r : RangeRead} {res : Result} {cr : ConflictRange} (h : Minimal r res cr) : Sound r res cr := h.1 /-- A sound range is minimal when every proper subrange fails to be sound. This is the introduction rule matching the definition. -/ theorem minimal_of_sound_of_no_proper {r : RangeRead} {res : Result} {cr : ConflictRange} (hs : Sound r res cr) (hsub : ∀ cr', ProperSubrange cr' cr → ¬ Sound r res cr') : Minimal r res cr := ⟨hs, hsub⟩ /-- No proper subrange of a minimal range is sound. -/ theorem Minimal.not_sound_of_proper {r : RangeRead} {res : Result} {cr : ConflictRange} (h : Minimal r res cr) {cr' : ConflictRange} (hsub : ProperSubrange cr' cr) : ¬ Sound r res cr' := h.2 cr' hsub /-- No sound range is a proper subrange of a minimal range. -/ theorem Minimal.not_properSubrange_of_sound {r : RangeRead} {res : Result} {cr cr' : ConflictRange} (h : Minimal r res cr) (hs : Sound r res cr') (hsub : ProperSubrange cr' cr) : False := h.not_sound_of_proper hsub hs /-- Minimality is invariant under flipping the traversal order and reversing the reported keys when the result is complete: soundness is `sound_flip`, the conflict range is unchanged, and the proper-subrange condition is its own converse. -/ theorem minimal_flip {r : RangeRead} {res : Result} {cr : ConflictRange} {b : Bool} (hrev : r.reverse = b) (hmore : res.more = false) : (Minimal {r with reverse := !b} {keys := res.keys.reverse, more := false} cr ↔ Minimal r res cr) := by constructor · intro h refine ⟨(sound_flip (b := b) hrev hmore).mp h.sound, fun cr' hsub => ?_⟩ exact fun hs => h.not_sound_of_proper hsub ((sound_flip (b := b) hrev hmore).mpr hs) · intro h refine ⟨(sound_flip (b := b) hrev hmore).mpr h.sound, fun cr' hsub => ?_⟩ exact fun hs => h.not_sound_of_proper hsub ((sound_flip (b := b) hrev hmore).mp hs) /-- Soundness is closed under intersection of conflict ranges. Given agreement on `cr₁ ⊓ cr₂`, agreement on `cr₁` and on `cr₂` transfer along a bridge database holding exactly `(db₁ ∩ cr₁) ∪ (db₂ ∩ cr₂)`: on `cr₁` that database agrees with `db₁`, and on `cr₂` it agrees with `db₂` because the two databases already agree on the intersection. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem Sound.inter {r : RangeRead} {res : Result} {cr₁ cr₂ : ConflictRange} (h₁ : Sound r res cr₁) (h₂ : Sound r res cr₂) : Sound r res (ConflictRange.inter cr₁ cr₂) := by classical intro db₁ db₂ hagree let s : Finset Key := db₁.keys.toFinset.filter (fun k => k ∈ cr₁) ∪ db₂.keys.toFinset.filter (fun k => k ∈ cr₂) let db : DB := ⟨s.sort (· ≤ ·), Finset.sortedLT_sort s⟩ have hmem (k : Key) : k ∈ db.keys ↔ (k ∈ db₁.keys ∧ k ∈ cr₁) ∨ (k ∈ db₂.keys ∧ k ∈ cr₂) := by simp only [db, s, Finset.mem_sort, Finset.mem_union, Finset.mem_filter, List.mem_toFinset] -- On `cr₁` the bridge stores exactly what `db₁` stores; the agreement -- hypothesis is used only for keys lying in both ranges. have hkey₁ : cr₁.keys db₁ = cr₁.keys db := by refine eq_of_forall_mem_iff_of_pairwise (ConflictRange.keys_pairwise _ _) (ConflictRange.keys_pairwise _ _) fun k => ?_ rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff, hmem k] constructor · rintro ⟨hk₁, hk₁'⟩ exact ⟨Or.inl ⟨hk₁, hk₁'⟩, hk₁'⟩ · rintro ⟨hd, hk₁'⟩ rcases hd with ⟨hk₁, _⟩ | ⟨hk₂, hk₂'⟩ · exact ⟨hk₁, hk₁'⟩ · have hinter : k ∈ (ConflictRange.inter cr₁ cr₂).keys db₂ := by rw [ConflictRange.mem_keys_iff] exact ⟨hk₂, ConflictRange.mem_inter_iff.mpr ⟨hk₁', hk₂'⟩⟩ rw [← hagree] at hinter exact ⟨(ConflictRange.mem_keys_iff.mp hinter).1, hk₁'⟩ -- Dually, on `cr₂` the bridge stores exactly what `db₂` stores. have hkey₂ : cr₂.keys db = cr₂.keys db₂ := by refine eq_of_forall_mem_iff_of_pairwise (ConflictRange.keys_pairwise _ _) (ConflictRange.keys_pairwise _ _) fun k => ?_ rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff, hmem k] constructor · rintro ⟨hd, hk₂'⟩ rcases hd with ⟨hk₁, hk₁'⟩ | ⟨hk₂, _⟩ · have hinter : k ∈ (ConflictRange.inter cr₁ cr₂).keys db₁ := by rw [ConflictRange.mem_keys_iff] exact ⟨hk₁, ConflictRange.mem_inter_iff.mpr ⟨hk₁', hk₂'⟩⟩ rw [hagree] at hinter exact ⟨(ConflictRange.mem_keys_iff.mp hinter).1, hk₂'⟩ · exact ⟨hk₂, hk₂'⟩ · rintro ⟨hk₂, hk₂'⟩ exact ⟨Or.inr ⟨hk₂, hk₂'⟩, hk₂'⟩ exact (h₁ db₁ db (show AgreeOn cr₁ db₁ db from hkey₁)).trans (h₂ db db₂ (show AgreeOn cr₂ db db₂ from hkey₂)) /-- A nonincreasing sequence of nonempty subsets of a finite set has nonempty intersection. This is the finiteness fact that makes soundness survive a descending sequence: the set of keys on which two databases disagree is finite. -/ private theorem iInter_nonempty_of_antitone {D : Set Key} (hD : D.Finite) {T : ℕ → Set Key} (hT : ∀ n, (T n).Nonempty) (hsub : ∀ n, T n ⊆ D) (hmono : ∀ n, T (n + 1) ⊆ T n) : ∃ x, x ∈ ⋂ n, T n := by classical have hle : ∀ {m n : ℕ}, m ≤ n → T n ⊆ T m := by intro m n hmn induction hmn with | refl => exact subset_rfl | step _ ih => exact (hmono _).trans ih obtain ⟨N, hN⟩ : ∃ N, (T N).ncard = sInf (Set.range fun n => (T n).ncard) := by have hmem := Nat.sInf_mem (s := Set.range fun n => (T n).ncard) ⟨(T 0).ncard, ⟨0, rfl⟩⟩ rwa [Set.mem_range] at hmem obtain ⟨x, hx⟩ := hT N refine ⟨x, ?_⟩ rw [Set.mem_iInter] intro n by_cases h : N ≤ n · have hsub' : T n ⊆ T N := hle h have heqc : (T n).ncard = (T N).ncard := le_antisymm (Set.ncard_le_ncard hsub' (hD.subset (hsub N))) (by rw [hN]; exact Nat.sInf_le ⟨n, rfl⟩) have heq : T n = T N := Set.eq_of_subset_of_ncard_le hsub' (le_of_eq heqc.symm) (hD.subset (hsub N)) rw [heq]; exact hx · exact Set.mem_of_subset_of_mem (hle (le_of_lt (Nat.lt_of_not_le h))) hx /-- **The intersection of a nonincreasing sequence of sound key sets is sound.** The key set on which two databases disagree is finite, so along a descending sequence of sound sets the disagreements cannot all be discarded: the sequence of disagreement sets, being a descending sequence of nonempty subsets of a finite set, stabilizes, and its eventual value lies in the intersection. Hence taking a cofinal descending sequence of the sound ranges, their set intersection is sound; a minimal range exists exactly when that intersection is realized by a conflict range. This isolates the obstruction to the existence headline as representability of the sound filter's intersection. -/ theorem soundSet_iInter_antitone {r : RangeRead} {res : Result} {S : ℕ → Set Key} (hS : ∀ n, SoundSet r res (S n)) (hmono : ∀ n, S (n + 1) ⊆ S n) : SoundSet r res (⋂ n, S n) := by classical intro db₁ db₂ hagree by_contra hne set D : Set Key := {k | (k ∈ db₁.keys) ≠ (k ∈ db₂.keys)} with hD_def have hDfin : D.Finite := by refine ((List.finite_toSet db₁.keys).union (List.finite_toSet db₂.keys)).subset ?_ intro k hk by_cases h1 : k ∈ db₁.keys · exact Or.inl h1 · by_cases h2 : k ∈ db₂.keys · exact Or.inr h2 · exact absurd hk (by simp [hD_def, h1, h2]) have hTn : ∀ n, (D ∩ S n).Nonempty := by intro n by_contra hemp have hpoint : ∀ k, k ∈ S n → (k ∈ db₁.keys ↔ k ∈ db₂.keys) := by intro k hk by_contra hiff exact hemp ⟨k, (fun he => hiff (Iff.of_eq he)), hk⟩ exact hne (hS n db₁ db₂ hpoint) obtain ⟨k, hk⟩ := iInter_nonempty_of_antitone hDfin hTn (fun n => Set.inter_subset_left) (fun n => Set.inter_subset_inter subset_rfl (hmono n)) rw [Set.mem_iInter] at hk have hkD : k ∈ D := (hk 0).1 have hkS : k ∈ ⋂ n, S n := Set.mem_iInter.mpr (fun n => (hk n).2) exact hkD (propext (hagree k hkS)) /-- The full conflict range `[⊥, ⊤)` contains every key, so agreement on it is equality of the stored keys; hence it is sound for every read and result. This is the base case of the finite-intersection argument. -/ theorem sound_fullRange (r : RangeRead) (res : Result) : Sound r res (⟨((↑([] : Key)) : WithTop Key), (⊤ : WithTop Key)⟩ : ConflictRange) := by have hkey (db : DB) : (⟨((↑([] : Key)) : WithTop Key), (⊤ : WithTop Key)⟩ : ConflictRange).keys db = db.keys := by rw [ConflictRange.keys_eq_inRange] exact RangeRead.inRange_unbounded db.keys intro db₁ db₂ hagree have hkeys : db₁.keys = db₂.keys := by have h := hagree unfold AgreeOn at h rw [hkey db₁, hkey db₂] at h exact h exact RangeRead.compatible_congr (RangeRead.completeKeys_congr hkeys r) /-- A finite set of keys, each omitted by some sound range, is omitted by one sound range: intersect the finitely many witnesses. This is the step that turns the finiteness of the disagreement set into soundness of the intersection of *all* sound ranges, and it needs only that sound ranges are closed under binary intersection, not that the whole filter is closed under arbitrary intersections. -/ theorem exists_sound_avoiding_finset (r : RangeRead) (res : Result) (D : Finset Key) (h : ∀ d ∈ D, ∃ cr : ConflictRange, Sound r res cr ∧ d ∉ cr) : ∃ cr : ConflictRange, Sound r res cr ∧ ∀ d ∈ D, d ∉ cr := by classical induction D using Finset.induction with | empty => exact ⟨⟨((↑([] : Key)) : WithTop Key), ⊤⟩, sound_fullRange r res, by simp⟩ | insert a s _ha ih => obtain ⟨cra, hsa, hda⟩ := h a (Finset.mem_insert_self a s) obtain ⟨crs, hss, hds⟩ := ih fun d hd => h d (Finset.mem_insert_of_mem hd) refine ⟨ConflictRange.inter cra crs, hsa.inter hss, ?_⟩ intro d hd hmem rcases Finset.mem_insert.mp hd with rfl | hd · exact hda (ConflictRange.mem_inter_iff.mp hmem).1 · exact hds d hd (ConflictRange.mem_inter_iff.mp hmem).2 /-- **The necessary keys, as a key set, are sound: the intersection of *all* sound ranges is sound.** Any two databases that agree on exactly the necessary keys agree on compatibility. The set of keys on which two databases disagree is finite; each disagreement key is omitted by some sound range, and finitely many such witnesses intersect (by `Sound.inter`) to a single sound range the two databases agree on. This removes the cofinal-descending-sequence caveat of `soundSet_iInter_antitone`: the intersection is over every sound range, with no countability or cofinality assumption. -/ theorem soundSet_necessarySet {r : RangeRead} {res : Result} : SoundSet r res (necessarySet r res) := by classical intro db₁ db₂ hagree set D : Finset Key := (db₁.keys ++ db₂.keys).toFinset.filter (fun k => ¬ (k ∈ db₁.keys ↔ k ∈ db₂.keys)) with hD have hDmem (k : Key) : k ∈ D ↔ ¬ (k ∈ db₁.keys ↔ k ∈ db₂.keys) := by rw [hD, Finset.mem_filter, List.mem_toFinset, List.mem_append] constructor · rintro ⟨_, h⟩; exact h · intro h refine ⟨?_, h⟩ by_cases h1 : k ∈ db₁.keys · exact Or.inl h1 · refine Or.inr ?_ by_contra h2 exact h ⟨fun a => absurd a h1, fun b => absurd b h2⟩ have avoid : ∀ d ∈ D, ∃ cr : ConflictRange, Sound r res cr ∧ d ∉ cr := by intro d hd have hdiff : ¬ (d ∈ db₁.keys ↔ d ∈ db₂.keys) := (hDmem d).mp hd have hnotnec : ¬ Necessary r res d := fun hnec => hdiff (hagree d hnec) by_contra hcon exact hnotnec fun cr hs => by by_contra hd' exact hcon ⟨cr, hs, hd'⟩ obtain ⟨cr, hsound, hcr⟩ := exists_sound_avoiding_finset r res D avoid have hag : AgreeOn cr db₁ db₂ := by rw [agreeOn_iff] intro k hkcr by_contra hiff exact hcr k ((hDmem k).mpr hiff) hkcr exact ⟨fun h => (hsound db₁ db₂ hag).mp h, fun h => (hsound db₁ db₂ hag).mpr h⟩ /-- The necessary keys are exactly the intersection of every sound range, made explicit as a set intersection over the sound ranges. This is the object whose representability by an interval is the headline. -/ theorem necessarySet_eq_iInter (r : RangeRead) (res : Result) : necessarySet r res = ⋂ cr : {cr : ConflictRange // Sound r res cr}, cr.1.toSet := by ext k simp only [necessarySet, Set.mem_ofPred_eq, Set.mem_iInter] constructor · intro h cr exact h cr.1 cr.2 · intro h cr hs exact h ⟨cr, hs⟩ /-- Set-level soundness is monotone under enlargement: a superset of a sound key set is sound, because agreement on the superset implies agreement on the subset. This is the key-set form of `Sound.mono`. -/ theorem soundSet_mono {r : RangeRead} {res : Result} {S T : Set Key} (hST : S ⊆ T) (hS : SoundSet r res S) : SoundSet r res T := fun db₁ db₂ hagree => hS db₁ db₂ fun k hkS => hagree k (hST hkS) /-- **A range is sound exactly when it contains every necessary key.** The forward direction is the definition of necessity; the reverse holds because the necessary set is sound (`soundSet_necessarySet`) and soundness is monotone under enlargement (`soundSet_mono`). This exhibits the sound filter as the principal up-set of the necessary set: the headline is exactly that this up-set has a least interval element. -/ theorem sound_iff_necessarySet_subset {r : RangeRead} {res : Result} {cr : ConflictRange} : Sound r res cr ↔ necessarySet r res ⊆ cr.toSet := by constructor · intro hs k hk exact hk cr hs · intro hsub rw [sound_iff_soundSet] exact soundSet_mono hsub soundSet_necessarySet /-- Every key of a minimal sound conflict range is necessary: intersecting a minimal range with any sound range keeps soundness, and minimality forbids the intersection from dropping keys, so the sound range contains the whole minimal range. An inference sees only `(r, res)`, so any one witness database suffices. -/ theorem necessary_of_minimal {r : RangeRead} {res : Result} {cr : ConflictRange} (h : Minimal r res cr) {k : Key} (hk : k ∈ cr) : Necessary r res k := by intro cr' hs' have hs : Sound r res (ConflictRange.inter cr cr') := h.sound.inter hs' have hle : Subrange (ConflictRange.inter cr cr') cr := subrange_of_le (le_max_left _ _) (min_le_left _ _) have hge : Subrange cr (ConflictRange.inter cr cr') := by by_contra hnot exact h.not_sound_of_proper ⟨hle, hnot⟩ hs exact subrange_of_le (le_max_right _ _) (min_le_right _ _) k (hge k hk) /-- **A minimal range denotes exactly the necessary set.** The keys of a minimal sound range are all necessary (`necessary_of_minimal`) and, being sound, the range contains every necessary key; so its key set is the necessary set. This is the concrete form of the forward direction of `exists_minimal_iff_necessarySet_representable`, and the bridge that turns a `Minimal` witness into a representability witness for the headline. -/ theorem necessarySet_eq_of_minimal {r : RangeRead} {res : Result} {cr : ConflictRange} (h : Minimal r res cr) : necessarySet r res = cr.toSet := by ext k exact ⟨fun hk => hk cr h.sound, fun hk => necessary_of_minimal h hk⟩ /-- The geometric definition of minimality is equivalent to soundness together with every key of the range being necessary. `necessary_of_minimal` gives one direction; conversely, if a sound range's keys are all necessary then any proper subrange omits a necessary key and hence cannot be sound. This is the form that matches the algorithm's output: a range tracking exactly the necessary keys. -/ theorem minimal_iff_sound_and_necessary {r : RangeRead} {res : Result} {cr : ConflictRange} : Minimal r res cr ↔ Sound r res cr ∧ ∀ k, k ∈ cr → Necessary r res k := by constructor · intro h exact ⟨h.sound, fun k hk => necessary_of_minimal h hk⟩ · intro ⟨hs, hnec⟩ refine ⟨hs, fun cr' hsub => ?_⟩ by_contra hsound obtain ⟨hle, hnle⟩ := hsub have hex : ∃ k, k ∈ cr ∧ k ∉ cr' := by by_contra h exact hnle fun k hk => by_contra fun hk' => h ⟨k, hk, hk'⟩ obtain ⟨k, hk, hk'⟩ := hex exact hk' (hnec k hk cr' hsound) /-- A sound range whose keys are all necessary is minimal, phrased through `NecessaryRange`: this is `minimal_iff_sound_and_necessary` with the pointwise necessity unfolded into the range's endpoints. It is the form the interval perturbations match, since those establish a whole `[a, b)` at once. -/ theorem minimal_iff_sound_and_necessaryRange {r : RangeRead} {res : Result} {cr : ConflictRange} : Minimal r res cr ↔ Sound r res cr ∧ NecessaryRange r res cr.begin cr.end_ := by rw [minimal_iff_sound_and_necessary] constructor · rintro ⟨hs, hnec⟩ exact ⟨hs, fun k hlo hhi => hnec k (ConflictRange.mem_iff.mpr ⟨hlo, hhi⟩)⟩ · rintro ⟨hs, hnec⟩ exact ⟨hs, fun k hk => hnec k (ConflictRange.mem_iff.mp hk).1 (ConflictRange.mem_iff.mp hk).2⟩ /-- A minimal sound range is contained in every sound range: intersecting it with another sound range stays sound and is a subrange, so minimality forbids the intersection from being proper. This is the least-element half of the least-sound-range statement, and it is unconditional — no nonemptiness or realizability hypothesis is needed. -/ theorem Minimal.subrange_of_sound {r : RangeRead} {res : Result} {cr : ConflictRange} (h : Minimal r res cr) {cr' : ConflictRange} (hs : Sound r res cr') : Subrange cr cr' := by have hs' : Sound r res (ConflictRange.inter cr cr') := h.sound.inter hs have hle1 : Subrange (ConflictRange.inter cr cr') cr := subrange_of_le (le_max_left _ _) (min_le_left _ _) have hle2 : Subrange (ConflictRange.inter cr cr') cr' := subrange_of_le (le_max_right _ _) (min_le_right _ _) have hge : Subrange cr (ConflictRange.inter cr cr') := by by_contra hnot exact h.not_sound_of_proper ⟨hle1, hnot⟩ hs' exact hge.trans hle2 /-- **Existence of a minimal range is exactly principality of the sound filter.** A minimal sound range is precisely a sound range contained in every sound range, so the open existence headline is equivalent to the filter of sound ranges having a least element under key-set containment. This is the sharpened form of the goal: a minimal range exists iff the intersection of all sound ranges — which is sound as a key set by `soundSet_necessarySet` — is realized by a conflict range. -/ theorem exists_minimal_iff_exists_least_sound {r : RangeRead} {res : Result} : (∃ cr : ConflictRange, Minimal r res cr) ↔ ∃ cr : ConflictRange, Sound r res cr ∧ ∀ cr' : ConflictRange, Sound r res cr' → Subrange cr cr' := by constructor · rintro ⟨cr, h⟩ exact ⟨cr, h.sound, fun cr' hs => Minimal.subrange_of_sound h hs⟩ · rintro ⟨cr, hs, hleast⟩ exact ⟨cr, hs, fun cr' hsub => fun hs' => hsub.2 (hleast cr' hs')⟩ /-- **The headline, conditional only on representability of the necessary keys.** If the set of necessary keys is realized by some conflict range, then a minimal range exists: that range is sound by `soundSet_necessarySet`, and it is contained in every sound range because every necessary key lies in every sound range. This isolates the whole existence headline to the single set-theoretic question of whether the sound filter's intersection is an interval whose lower end is an attained key. -/ theorem exists_minimal_of_necessarySet_representable {r : RangeRead} {res : Result} (h : ∃ cr : ConflictRange, cr.toSet = necessarySet r res) : ∃ cr : ConflictRange, Minimal r res cr := by obtain ⟨cr, hcr⟩ := h refine (exists_minimal_iff_exists_least_sound (r := r) (res := res)).mpr ⟨cr, ?_, fun cr' hs' => ?_⟩ · rw [sound_iff_soundSet, hcr]; exact soundSet_necessarySet · rw [subrange_iff_subset, hcr] intro k hk exact hk cr' hs' /-- **The headline is exactly representability of the necessary set.** A minimal range exists for a read and result precisely when the set of necessary keys — sound as a key set by `soundSet_necessarySet` — is the key set of some conflict range. A minimal range's keys are all necessary (`necessary_of_minimal`) and contain the necessary keys because it is sound, so the forward direction is set equality; the reverse is `exists_minimal_of_necessarySet_representable`. -/ theorem exists_minimal_iff_necessarySet_representable {r : RangeRead} {res : Result} : (∃ cr : ConflictRange, Minimal r res cr) ↔ ∃ cr : ConflictRange, cr.toSet = necessarySet r res := by constructor · rintro ⟨cr, hmin⟩ refine ⟨cr, Set.Subset.antisymm ?_ ?_⟩ · intro k hk exact necessary_of_minimal hmin hk · intro k hk exact hk cr hmin.sound · exact exists_minimal_of_necessarySet_representable /-- Any two minimal sound ranges for the same read and result denote the same set of keys. Both are sound, so the intersection is sound and contained in each; minimality of each then forces the two to contain each other. This is unconditional: it needs neither a nonempty result nor a realizability witness, so uniqueness is a theorem rather than a conjecture. -/ theorem Minimal.toSet_eq {r : RangeRead} {res : Result} {cr cr' : ConflictRange} (h : Minimal r res cr) (h' : Minimal r res cr') : cr.toSet = cr'.toSet := by have hs : Sound r res (ConflictRange.inter cr cr') := h.sound.inter h'.sound have hle1 : Subrange (ConflictRange.inter cr cr') cr := subrange_of_le (le_max_left _ _) (min_le_left _ _) have hle2 : Subrange (ConflictRange.inter cr cr') cr' := subrange_of_le (le_max_right _ _) (min_le_right _ _) have hge1 : Subrange cr (ConflictRange.inter cr cr') := by by_contra hnot exact h.not_sound_of_proper ⟨hle1, hnot⟩ hs have hge2 : Subrange cr' (ConflictRange.inter cr cr') := by by_contra hnot exact h'.not_sound_of_proper ⟨hle2, hnot⟩ hs exact Set.Subset.antisymm (subrange_iff_subset.mp (hge1.trans hle2)) (subrange_iff_subset.mp (hge2.trans hle1)) /-- A minimal range packages into the unique-minimal-range statement, with `cr` itself as the canonical witness: any other minimal range denotes the same set by `Minimal.toSet_eq`. This is the shared shape of the concrete uniqueness theorems. -/ theorem exists_unique_minimal_of_minimal {r : RangeRead} {res : Result} {cr : ConflictRange} (h : Minimal r res cr) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := ⟨cr, h, fun _ hmin' => Minimal.toSet_eq hmin' h⟩ /-! ## The canonical range at offset one The first concrete instance of the minimal-range theorem: when both selectors have `offset = 1` and the result is complete (`more = false`), the minimal sound conflict range is the canonical range `[begin.key, end.key)` named directly by the read. At offset one the resolved window `[resolve begin, resolve end)` cuts a key exactly when the canonical interval does, so the two filters agree; soundness is then immediate from `compatible_congr`, and a canonical key is necessary because toggling it changes the complete keys that a complete result must equal. -/ /-- The canonical conflict range named directly by the read's selector keys. -/ def canonicalRange (r : RangeRead) : ConflictRange := ⟨r.begin.key, r.end_.key⟩ /-- The canonical range is minimal exactly when it is sound and every key in `[begin.key, end.key)` is necessary. This is the target the interval perturbations address: `exists_db_resolve_chain_of_disjoint` drives the begin resolution to any `chain (begin.key) j` inside `[begin.key, end.key)`, so a run of keys can be shown necessary in one step rather than one toggle at a time. -/ theorem minimal_canonicalRange_iff {r : RangeRead} {res : Result} : Minimal r res (canonicalRange r) ↔ Sound r res (canonicalRange r) ∧ NecessaryRange r res r.begin.key r.end_.key := by rw [minimal_iff_sound_and_necessaryRange] rfl /-- At a positive offset the selector key is at or below its resolution: the anchor lands at index `count (· < key) + offset - 1`, and every stored key at or after the count of keys strictly below `key` is at or above `key`. -/ theorem key_le_resolve_of_one_le {db : DB} {s : Selector} (hoff : 1 ≤ s.offset) : s.key ≤ resolve db s := by rcases eq_or_ne (resolve db s) (⊤ : WithTop Key) with htop | hne · rw [htop]; exact le_top · cases hkey : s.key with | top => exact absurd (resolve_eq_top_of_key_eq_top hkey hoff) hne | coe k₀ => obtain ⟨k, hk⟩ : ∃ k : Key, resolve db s = (↑k : WithTop Key) := by cases h : resolve db s with | top => exact absurd h hne | coe k => exact ⟨k, rfl⟩ rw [hk] exact WithTop.coe_le_coe.mpr (le_trans (chain_le k₀ (s.offset - 1).toNat) (chain_le_of_resolve hkey hoff hk)) /-- At offset one the selector key is at or below its resolution. -/ private theorem key_le_resolve_of_offset_one {db : DB} {s : Selector} (hoff : s.offset = 1) : s.key ≤ resolve db s := key_le_resolve_of_one_le (by omega) /-- **A positive begin offset is cross-free.** When `begin.offset ≥ 1` the begin selector resolves at or above `begin.key` (`key_le_resolve_of_one_le`), and the reported head is a complete key, hence lies at or above the resolution: so `begin.key ≤ res.keys.head`. This is the general fact that rules out the crossed subcases (`begin.key` above the least reported key) at every positive begin offset, leaving them only at nonpositive offsets. -/ theorem begin_key_le_head_of_one_le_offset {r : RangeRead} {res : Result} (hread : Readable r res) (hne : res.keys ≠ []) (hoff : 1 ≤ r.begin.offset) : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by obtain ⟨db₀, hcomp⟩ := hread have hhead_mem : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp).subset (List.head_mem hne) exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hoff) (RangeRead.mem_completeKeys.mp hhead_mem).2.1 /-- At offset one, for a stored key, lying at or above the selector key is the same as lying at or above its resolution: both cut at the first stored key at or above `s.key`. -/ theorem key_le_resolve_iff_of_offset_one {db : DB} {s : Selector} (hoff : s.offset = 1) {k : Key} (hk : k ∈ db.keys) : s.key ≤ (↑k : WithTop Key) ↔ resolve db s ≤ (↑k : WithTop Key) := by refine ⟨?_, fun hr => le_trans (key_le_resolve_of_offset_one hoff) hr⟩ intro hsk have h1 : 1 ≤ s.offset := by omega have h0 := anchor_nonneg_of_one_le (db := db) (s := s) h1 obtain ⟨i, hi, hik⟩ := List.mem_iff_getElem.mp hk set c := db.keys.countP (fun (x : Key) => decide ((↑x : WithTop Key) < s.key)) with hc have hc_le : c ≤ i := by cases hkey : s.key with | top => exfalso; rw [hkey] at hsk; exact absurd hsk (not_le.mpr (WithTop.coe_lt_top k)) | coe v => rw [hkey] at hsk have hvk : v ≤ k := WithTop.coe_le_coe.mp hsk have hcv : c = db.keys.countP (fun (x : Key) => decide (x < v)) := by rw [hc, hkey, countP_lt_coe] rw [hcv] have hm : db.keys.countP (fun (x : Key) => decide (x < v)) ≤ db.keys.countP (fun (x : Key) => decide (x < k)) := List.countP_mono_left fun x _ hx => by rw [decide_eq_true_eq] at hx ⊢; exact lt_of_lt_of_le hx hvk have he : db.keys.countP (fun (x : Key) => decide (x < k)) = i := countP_lt_eq_of_getElem db.sorted (x := k) hi hik omega have htoNat : (s.anchor db).toNat = c := by rw [anchor_toNat_eq h1, hoff] simp only [Int.reduceSub, Int.toNat_zero, Nat.add_zero] exact hc.symm have hclt : c < db.keys.length := lt_of_le_of_lt hc_le hi rw [resolve_eq_ite, ite_eq_right (not_lt.mpr h0), htoNat, List.getElem?_eq_getElem hclt] refine WithTop.coe_le_coe.mpr ?_ have hle : db.keys[c]'(lt_of_le_of_lt hc_le hi) ≤ db.keys[i]'hi := (db.sorted.getElem_le_getElem_iff).mpr hc_le simpa only [hik] using hle /-- At offset one, a stored key lies strictly below the resolution exactly when it lies strictly below the selector key. -/ private theorem resolve_lt_iff_of_offset_one {db : DB} {s : Selector} (hoff : s.offset = 1) {k : Key} (hk : k ∈ db.keys) : (↑k : WithTop Key) < resolve db s ↔ (↑k : WithTop Key) < s.key := by rw [lt_iff_not_ge, lt_iff_not_ge, (key_le_resolve_iff_of_offset_one hoff hk)] /-- At offset one the resolved in-range keys are exactly the canonical range's keys: the two filters agree on every stored key by the two cut lemmas. -/ private theorem inRange_eq_canonical_keys {db : DB} {r : RangeRead} (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = (canonicalRange r).keys db := by refine List.filter_congr fun k hk => ?_ rw [decide_eq_decide] change (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < resolve db r.end_) ↔ (r.begin.key ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key) rw [key_le_resolve_iff_of_offset_one hbegin hk, resolve_lt_iff_of_offset_one hend hk] /-- At offset one the complete keys are the canonical range's keys, reversed when the read is. -/ private theorem completeKeys_eq_canonical {db : DB} {r : RangeRead} (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : RangeRead.completeKeys db r = (if r.reverse then ((canonicalRange r).keys db).reverse else (canonicalRange r).keys db) := by simp only [RangeRead.completeKeys] rw [inRange_eq_canonical_keys hbegin hend] /-! ### Filters and counts, keyed at `Key` The generic list lemmas are stated for an abstract element type, so the elaborator can instantiate their element variable with `WithTop Key` and their predicate with the coerced one. These wrappers pin both to `Key`. -/ /-- Counting an ascending list below a threshold, with the head below it. -/ private theorem countP_lt_cons_pos {a : Key} {rest : List Key} {t : WithTop Key} (ha : (↑a : WithTop Key) < t) : (a :: rest).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = rest.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) + 1 := List.countP_cons_of_pos (p := fun (k : Key) => decide ((↑k : WithTop Key) < t)) (a := a) (by simpa using ha) /-- Counting an ascending list below a threshold, with the head not below it. -/ private theorem countP_lt_cons_neg {a : Key} {rest : List Key} {t : WithTop Key} (ha : ¬ ((↑a : WithTop Key) < t)) : (a :: rest).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = rest.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) := List.countP_cons_of_neg (p := fun (k : Key) => decide ((↑k : WithTop Key) < t)) (a := a) (by simpa using ha) /-- Filtering below a threshold, with the head below it. -/ private theorem filter_lt_cons_pos {a : Key} {rest : List Key} {t : WithTop Key} (ha : (↑a : WithTop Key) < t) : (a :: rest).filter (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = a :: rest.filter (fun (k : Key) => decide ((↑k : WithTop Key) < t)) := List.filter_cons_of_pos (p := fun (k : Key) => decide ((↑k : WithTop Key) < t)) (a := a) (by simpa using ha) /-- Filtering below a threshold, with the head not below it. -/ private theorem filter_lt_cons_neg {a : Key} {rest : List Key} {t : WithTop Key} (ha : ¬ ((↑a : WithTop Key) < t)) : (a :: rest).filter (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = rest.filter (fun (k : Key) => decide ((↑k : WithTop Key) < t)) := List.filter_cons_of_neg (p := fun (k : Key) => decide ((↑k : WithTop Key) < t)) (a := a) (by simpa using ha) /-- Filtering at or above a threshold, with the head below it. -/ private theorem filter_not_lt_cons_pos {a : Key} {rest : List Key} {t : WithTop Key} (ha : (↑a : WithTop Key) < t) : (a :: rest).filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) = rest.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) := List.filter_cons_of_neg (p := fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) (a := a) (by simpa using ha) /-- Filtering at or above a threshold, with the head not below it. -/ private theorem filter_not_lt_cons_neg {a : Key} {rest : List Key} {t : WithTop Key} (ha : ¬ ((↑a : WithTop Key) < t)) : (a :: rest).filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) = a :: rest.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) := List.filter_cons_of_pos (p := fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) (a := a) (by simpa using ha) /-- A list with nothing below a threshold filters below it to nothing. -/ private theorem filter_lt_eq_nil_of_forall {l : List Key} {t : WithTop Key} (h : ∀ k ∈ l, ¬ ((↑k : WithTop Key) < t)) : l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = [] := by rw [List.filter_eq_nil_iff] intro k hk simpa using h k hk /-- A list with nothing below a threshold counts nothing below it. -/ private theorem countP_lt_eq_zero_of_forall {l : List Key} {t : WithTop Key} (h : ∀ k ∈ l, ¬ ((↑k : WithTop Key) < t)) : l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = 0 := by rw [List.countP_eq_zero] intro k hk simpa using h k hk /-- A list with nothing below a threshold filters at or above it to itself. -/ private theorem filter_not_lt_eq_self_of_forall {l : List Key} {t : WithTop Key} (h : ∀ k ∈ l, ¬ ((↑k : WithTop Key) < t)) : l.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) = l := by rw [List.filter_eq_self] intro k hk simpa using h k hk /-- Filtering an ascending list at a threshold yields its take at the count of elements below the threshold. -/ theorem filter_lt_eq_take_countP {l : List Key} (hs : l.SortedLT) (t : WithTop Key) : l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = l.take (l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t))) := by induction l with | nil => rfl | cons a rest ih => have hs' : rest.SortedLT := List.sortedLT_iff_pairwise.mpr (List.pairwise_cons.mp hs.pairwise).2 by_cases ha : (↑a : WithTop Key) < t · rw [filter_lt_cons_pos ha, countP_lt_cons_pos ha, List.take_succ_cons] exact congrArg (a :: ·) (ih hs') · have hnp : ∀ k ∈ rest, ¬ ((↑k : WithTop Key) < t) := by intro k hk hklt exact ha (lt_trans (WithTop.coe_lt_coe.mpr ((List.pairwise_cons.mp hs.pairwise).1 k hk)) hklt) rw [filter_lt_cons_neg ha, filter_lt_eq_nil_of_forall hnp, countP_lt_cons_neg ha, countP_lt_eq_zero_of_forall hnp] rfl /-- Filtering an ascending list at or above a threshold yields its drop at the count of elements below the threshold. -/ theorem filter_not_lt_eq_drop_countP {l : List Key} (hs : l.SortedLT) (t : WithTop Key) : l.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < t))) = l.drop (l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t))) := by induction l with | nil => rfl | cons a rest ih => have hs' : rest.SortedLT := List.sortedLT_iff_pairwise.mpr (List.pairwise_cons.mp hs.pairwise).2 by_cases ha : (↑a : WithTop Key) < t · rw [filter_not_lt_cons_pos ha, countP_lt_cons_pos ha, List.drop_succ_cons] exact ih hs' · have hnp : ∀ k ∈ rest, ¬ ((↑k : WithTop Key) < t) := by intro k hk hklt exact ha (lt_trans (WithTop.coe_lt_coe.mpr ((List.pairwise_cons.mp hs.pairwise).1 k hk)) hklt) rw [filter_not_lt_cons_neg ha, filter_not_lt_eq_self_of_forall hnp, countP_lt_cons_neg ha, countP_lt_eq_zero_of_forall hnp, List.drop_zero] /-- At a positive offset the resolution is the `(offset - 1)`-th stored key at or above the selector key: the keys at or above `s.key` are exactly the drop at the count of keys strictly below it, and the anchor lands `offset - 1` places into that drop. -/ theorem resolve_eq_filter_getElem? {db : DB} {s : Selector} (hoff : 1 ≤ s.offset) : resolve db s = (match (db.keys.filter (fun (k : Key) => decide (s.key ≤ (k : WithTop Key))))[(s.offset - 1).toNat]? with | some k => (↑k : WithTop Key) | none => ⊤) := by cases hk : s.key with | top => rw [resolve_eq_top_of_key_eq_top hk hoff] have hnil : db.keys.filter (fun (k : Key) => decide ((⊤ : WithTop Key) ≤ (k : WithTop Key))) = [] := by rw [List.filter_eq_nil_iff] intro k _ simp rw [hnil, List.getElem?_nil] | coe k₀ => have hp : (fun (k : Key) => decide ((↑k₀ : WithTop Key) ≤ (k : WithTop Key))) = (fun (k : Key) => decide (¬ ((k : WithTop Key) < (↑k₀ : WithTop Key)))) := by funext k exact decide_eq_decide.mpr ⟨fun h hlt => absurd hlt (not_lt.mpr h), fun h => le_of_not_gt h⟩ rw [hp, filter_not_lt_eq_drop_countP db.sorted (↑k₀ : WithTop Key), List.getElem?_drop] have h0 : 0 ≤ s.anchor db := by rw [anchor_of_coe hk] have := Int.natCast_nonneg (db.keys.countP (fun (k : Key) => decide (k < k₀))) omega rw [resolve_eq_ite, ite_eq_right (not_lt.mpr h0), anchor_toNat_eq hoff, hk] rfl /-- **At a positive offset, resolution depends only on the stored keys at or above the selector key.** If two databases agree on every stored key at or above `s.key`, then at offset `≥ 1` the anchor index is `offset - 1` places into the keys at or above `s.key` (`resolve_eq_filter_getElem?`), and those keys coincide, so `resolve` is the same. This is the database-relative counterpart of `mem_footprint_iff`'s positive-offset case, and the key tool for proving soundness of the top range `[begin.key, ⊤)` at positive begin offset. -/ theorem resolve_eq_of_agree_ge {db₁ db₂ : DB} {s : Selector} (hoff : 1 ≤ s.offset) (hagree : ∀ (k : Key), s.key ≤ (k : WithTop Key) → (k ∈ db₁.keys ↔ k ∈ db₂.keys)) : resolve db₁ s = resolve db₂ s := by have hL : db₁.keys.filter (fun (k : Key) => decide (s.key ≤ (k : WithTop Key))) = db₂.keys.filter (fun (k : Key) => decide (s.key ≤ (k : WithTop Key))) := by apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db₁.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _) · intro k rw [List.mem_filter, List.mem_filter] exact ⟨fun hk => ⟨(hagree k (of_decide_eq_true hk.2)).mp hk.1, hk.2⟩, fun hk => ⟨(hagree k (of_decide_eq_true hk.2)).mpr hk.1, hk.2⟩⟩ rw [resolve_eq_filter_getElem? hoff (db := db₁), resolve_eq_filter_getElem? hoff (db := db₂), hL] /-- Agreement on the top range `[begin.key, ⊤)` is exactly agreement on every stored key at or above `begin.key`: the top range contains every such key and no other. -/ theorem agreeOn_topRange_iff {db₁ db₂ : DB} {r : RangeRead} : AgreeOn ⟨r.begin.key, ⊤⟩ db₁ db₂ ↔ ∀ (k : Key), r.begin.key ≤ (k : WithTop Key) → (k ∈ db₁.keys ↔ k ∈ db₂.keys) := by rw [AgreeOn] constructor · intro h k hk have h1 := congrArg (fun l : List Key => k ∈ l) h have hcr : k ∈ (⟨r.begin.key, ⊤⟩ : ConflictRange) := ⟨hk, WithTop.coe_lt_top k⟩ rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff] at h1 exact ⟨fun hk1 => (h1.mp ⟨hk1, hcr⟩).1, fun hk2 => (h1.mpr ⟨hk2, hcr⟩).1⟩ · intro h apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db₁.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _) · intro k rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff] exact ⟨fun hk => ⟨(h k hk.2.1).mp hk.1, hk.2⟩, fun hk => ⟨(h k hk.2.1).mpr hk.1, hk.2⟩⟩ /-- **The top range is sound at positive offsets when `begin.key ≤ end_.key`.** Agreement on `[begin.key, ⊤)` fixes `resolve begin` (`resolve_eq_of_agree_ge`) and, since `begin.key ≤ end_.key`, also fixes `resolve end_`; the resolved window lies at or above `begin.key` (`key_le_resolve_of_one_le`), so its stored contents are fixed as well, and the complete keys coincide. -/ theorem sound_topRange_of_one_le_le {r : RangeRead} {res : Result} (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hk : r.begin.key ≤ r.end_.key) : Sound r res ⟨r.begin.key, ⊤⟩ := by intro db₁ db₂ hag have hagree : ∀ (k : Key), r.begin.key ≤ (k : WithTop Key) → (k ∈ db₁.keys ↔ k ∈ db₂.keys) := agreeOn_topRange_iff.mp hag have hrb : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_agree_ge hbegin hagree have hre : resolve db₁ r.end_ = resolve db₂ r.end_ := resolve_eq_of_agree_ge hend fun k hk' => hagree k (le_trans hk hk') have hwin : (db₁.keys.filter (fun (k : Key) => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_))) = (db₂.keys.filter (fun (k : Key) => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_))) := by apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db₁.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _) · intro k rw [List.mem_filter, List.mem_filter] refine ⟨fun hk1 => ⟨?_, hk1.2⟩, fun hk2 => ⟨?_, hk2.2⟩⟩ · exact (hagree k (le_trans (key_le_resolve_of_one_le (db := db₁) (s := r.begin) hbegin) (of_decide_eq_true hk1.2).1)).mp hk1.1 · exact (hagree k (le_trans (key_le_resolve_of_one_le (db := db₁) (s := r.begin) hbegin) (of_decide_eq_true hk2.2).1)).mpr hk2.1 have hin : RangeRead.inRange db₁.keys (resolve db₁ r.begin) (resolve db₁ r.end_) = RangeRead.inRange db₂.keys (resolve db₂ r.begin) (resolve db₂ r.end_) := by unfold RangeRead.inRange rw [hwin, hrb, hre] have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by unfold RangeRead.completeKeys rw [hin] exact RangeRead.compatible_congr hck /-- **Lower endpoint attained at positive offsets when `begin.key ≤ end_.key`.** For a realizable forward read with a nonempty result, `1 ≤ begin.offset`, `1 ≤ end_.offset`, and `begin.key ≤ end_.key`, the least necessary key is `begin.key`: it is necessary (`necessary_begin_key`) and lies below every necessary key, since the top range `[begin.key, ⊤)` is sound (`sound_topRange_of_one_le_le`) and hence contains them all. -/ theorem exists_least_necessary_of_one_le_le {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hk : r.begin.key ≤ r.end_.key) : ∃ A : Key, Necessary r res A ∧ ∀ k : Key, Necessary r res k → A ≤ k := by have htop : Sound r res ⟨r.begin.key, ⊤⟩ := sound_topRange_of_one_le_le hbegin hend hk have hhead : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := begin_key_le_head_of_one_le_offset hread hne hbegin have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := fun h => by rw [h] at hhead exact absurd hhead (not_le.mpr (WithTop.coe_lt_top (res.keys.head hne))) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top refine ⟨v, necessary_begin_key hread hrev (List.length_pos_of_ne_nil hne) hbegin hv, ?_⟩ intro k hk' have hmem := (sound_iff_necessarySet_subset.mp htop) hk' have hle : r.begin.key ≤ (k : WithTop Key) := hmem.1 rw [hv] at hle exact WithTop.coe_le_coe.mp hle /-- **Lower endpoint attained at positive offsets for a complete read, in either traversal order.** This drops the `reverse = false` hypothesis of `exists_least_necessary_of_one_le_le`: a complete reversed read is flipped to a complete forward one (`necessary_flip`), where the same least key `begin.key` is found, and necessity is carried back across the flip. The value is unchanged because flipping preserves `begin.key`. -/ theorem exists_least_necessary_of_one_le_le_complete {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hk : r.begin.key ≤ r.end_.key) : ∃ A : Key, Necessary r res A ∧ ∀ k : Key, Necessary r res k → A ≤ k := by cases hr : r.reverse · exact exists_least_necessary_of_one_le_le hread hr hne hbegin hend hk · obtain ⟨db₀, hcomp⟩ := hread have hread' : Readable {r with reverse := false} {keys := res.keys.reverse, more := false} := ⟨db₀, (compatible_flip (db := db₀) (b := true) hr hmore).mpr hcomp⟩ obtain ⟨A, hnec', hminimal'⟩ := exists_least_necessary_of_one_le_le (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) hread' rfl (by simpa using hne) hbegin hend hk refine ⟨A, (necessary_flip (k := A) (b := true) hr hmore).mp hnec', ?_⟩ intro k hk' exact hminimal' k ((necessary_flip (k := k) (b := true) hr hmore).mpr hk') /-- The count of elements below a threshold in a prefix of an ascending list is the minimum of the prefix length and the whole-list count. -/ theorem countP_take_eq_min {l : List Key} (hs : l.SortedLT) (t : WithTop Key) (c : Nat) : (l.take c).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = min c (l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t))) := by induction l generalizing c with | nil => simp | cons a rest ih => have hs' : rest.SortedLT := List.sortedLT_iff_pairwise.mpr (List.pairwise_cons.mp hs.pairwise).2 rcases c with _ | c' · simp · rw [List.take_succ_cons] by_cases ha : (↑a : WithTop Key) < t · rw [countP_lt_cons_pos ha, ih hs' c', countP_lt_cons_pos ha] rw [Nat.min_def] split <;> omega · have hnp : ∀ k ∈ rest, ¬ ((↑k : WithTop Key) < t) := by intro k hk hklt exact ha (lt_trans (WithTop.coe_lt_coe.mpr ((List.pairwise_cons.mp hs.pairwise).1 k hk)) hklt) rw [countP_lt_cons_neg ha, ih hs' c', countP_lt_eq_zero_of_forall hnp, countP_lt_cons_neg ha, countP_lt_eq_zero_of_forall hnp, Nat.min_eq_right (Nat.zero_le c'), Nat.min_eq_right (Nat.zero_le (c' + 1))] /-- A prefix long enough to contain every element below the threshold counts them all. -/ private theorem countP_take_eq_of_le {l : List Key} (hs : l.SortedLT) {t : WithTop Key} {c : Nat} (hc : l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) ≤ c) : (l.take c).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) := by rw [countP_take_eq_min hs t c, Nat.min_eq_right hc] /-- The count of elements below a threshold in a suffix of an ascending list. -/ theorem countP_drop_eq {l : List Key} (hs : l.SortedLT) (t : WithTop Key) (c : Nat) : (l.drop c).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) - min c (l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t))) := by have hsplit : l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) = (l.take c).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) + (l.drop c).countP (fun (k : Key) => decide ((↑k : WithTop Key) < t)) := by conv_lhs => rw [← List.take_append_drop c l] rw [List.countP_append] rw [countP_take_eq_min hs t c] at hsplit omega /-- Truncated subtraction ignores a larger minuend. -/ private theorem nat_sub_min_right (a b : Nat) : a - min b a = a - b := by rcases le_total b a with h | h · rw [Nat.min_eq_left h] · rw [Nat.min_eq_right h, Nat.sub_eq_zero_of_le h, Nat.sub_self] /-- Taking a prefix and dropping a prefix gives the same as dropping the larger. -/ private theorem take_drop_min {α : Type*} {l : List α} (A B : Nat) : (l.take A).drop (min A B) = (l.drop B).take (A - B) := by rcases le_total A B with h | h · rw [Nat.min_eq_left h, List.drop_take_self, Nat.sub_eq_zero_of_le h, List.take_zero] · rw [Nat.min_eq_right h, List.drop_take] /-- In a strictly increasing list, if a suffix `l.drop b` is nonempty and all its elements are at most `m`, then all the elements of `l` are at most `m`: the dropped prefix sits below the first surviving element. -/ private theorem forall_le_of_drop_eq {l g : List Key} (hs : l.SortedLT) {m : Key} {b : Nat} (h : l.drop b = g) (hgne : g ≠ []) (hg : ∀ k ∈ g, k ≤ m) : ∀ k ∈ l, k ≤ m := by intro k hk have hdrop_ne : l.drop b ≠ [] := h ▸ hgne obtain ⟨x, rest, hx⟩ := List.exists_cons_of_ne_nil hdrop_ne have hxdrop : x ∈ l.drop b := by rw [hx]; exact List.mem_cons_self have hxmem : x ∈ g := by rw [← h]; exact hxdrop have hpw : (l.take b ++ l.drop b).Pairwise (· < ·) := by rw [List.take_append_drop]; exact hs.pairwise rw [List.pairwise_append] at hpw obtain ⟨_, _, hcross⟩ := hpw rw [← List.take_append_drop b l] at hk rcases List.mem_append.mp hk with hk | hk · exact le_trans (le_of_lt (hcross k hk x hxdrop)) (hg x hxmem) · exact hg k (h ▸ hk) /-- The count of stored keys strictly below a selector's resolution is the resolved index, clamped to the database length. -/ theorem countP_lt_resolve {db : DB} {s : Selector} : db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < resolve db s)) = min (s.anchor db).toNat db.keys.length := by by_cases h0 : 0 ≤ s.anchor db · by_cases hlt : (s.anchor db).toNat < db.keys.length · rw [resolve_eq_getElem h0 hlt, countP_lt_coe, countP_lt_eq_of_getElem db.sorted hlt rfl, Nat.min_eq_left (le_of_lt hlt)] · have hge : db.keys.length ≤ (s.anchor db).toNat := le_of_not_gt hlt rw [resolve_eq_top h0 hge, countP_lt_top, Nat.min_eq_right hge] · have hneg : s.anchor db < 0 := lt_of_not_ge h0 rw [resolve_eq_nil hneg, countP_lt_nil, Int.toNat_of_nonpos (le_of_lt hneg)] simp /-- Nothing at all lies at or above `⊤` in `WithTop Key`. -/ private theorem filter_top_le_eq_nil {l : List Key} : l.filter (fun (k : Key) => decide ((⊤ : WithTop Key) ≤ (↑k : WithTop Key))) = [] := by rw [List.filter_eq_nil_iff] intro k _ simp only [decide_eq_true_eq, not_le] exact WithTop.coe_lt_top k /-- The empty key is at or below every `WithTop Key` bound. -/ private theorem coe_nil_le (t : WithTop Key) : ((([] : Key) : WithTop Key)) ≤ t := by cases t with | top => exact le_top | coe k => exact WithTop.coe_le_coe.mpr (nil_le_key k) /-- Filtering an ascending list at the bottom of `WithTop Key` keeps it all. -/ private theorem filter_coe_nil_le_eq_self {l : List Key} : l.filter (fun (k : Key) => decide ((([] : Key) : WithTop Key) ≤ (↑k : WithTop Key))) = l := by rw [List.filter_eq_self] intro k _ rw [decide_eq_true_eq] exact WithTop.coe_le_coe.mpr (nil_le_key k) /-- The stored keys at or above a selector's resolution are the stored keys from the resolved index on. -/ theorem filter_resolve_le_eq_drop {db : DB} {s : Selector} : db.keys.filter (fun (k : Key) => decide (resolve db s ≤ (↑k : WithTop Key))) = db.keys.drop (s.anchor db).toNat := by by_cases h0 : 0 ≤ s.anchor db · by_cases hlt : (s.anchor db).toNat < db.keys.length · rw [resolve_eq_getElem h0 hlt] have hcongr : db.keys.filter (fun (k : Key) => decide ((↑db.keys[(s.anchor db).toNat] : WithTop Key) ≤ (↑k : WithTop Key))) = db.keys.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < (↑db.keys[(s.anchor db).toNat] : WithTop Key)))) := List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt] rw [hcongr, filter_not_lt_eq_drop_countP db.sorted, countP_lt_coe, countP_lt_eq_of_getElem db.sorted hlt rfl] · have hge : db.keys.length ≤ (s.anchor db).toNat := le_of_not_gt hlt rw [resolve_eq_top h0 hge, filter_top_le_eq_nil, List.drop_eq_nil_of_le hge] · have hneg : s.anchor db < 0 := lt_of_not_ge h0 rw [resolve_eq_nil hneg, Int.toNat_of_nonpos (le_of_lt hneg), filter_coe_nil_le_eq_self, List.drop_zero] /-- A selector at a nonpositive offset resolves at or below its own key. -/ theorem resolve_le_key_of_offset_nonpos {db : DB} {s : Selector} (hoff : s.offset ≤ 0) : resolve db s ≤ s.key := by rcases lt_or_ge (s.anchor db) 0 with hneg | hpos · rw [resolve_eq_nil hneg] exact coe_nil_le s.key · have hcnt : (s.anchor db).toNat < db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := (Int.toNat_lt hpos).mpr (by simp only [Selector.anchor]; omega) have hlt : (s.anchor db).toNat < db.keys.length := lt_of_lt_of_le hcnt (List.countP_le_length) rw [resolve_eq_getElem hpos hlt] exact le_of_lt (getElem_lt_of_lt_countP_top db.sorted hlt hcnt) /-- **The end-offset-at-most-one window.** A non-reversed read whose begin is at offset one and whose end offset is at most one has complete keys equal to the canonical keys with a fixed number of trailing keys removed: exactly `(1 - end_.offset).toNat` of them. That count depends only on `end_.offset`, and the length it truncates to does not mention the database, so the complete keys are determined by the canonical keys alone. -/ private theorem completeKeys_eq_canonical_take {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : RangeRead.completeKeys db r = ((canonicalRange r).keys db).take (((canonicalRange r).keys db).length - (1 - r.end_.offset).toNat) := by set l := db.keys with hl set p := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) with hp set c₀ := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) with hc₀ set k := (1 - r.end_.offset).toNat with hk set d := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < resolve db r.end_)) with hd have hls : l.SortedLT := by rw [hl]; exact db.sorted have hc₀_le : c₀ ≤ l.length := by rw [hc₀]; exact List.countP_le_length have hp_anchor : (r.begin.anchor db).toNat = p := by rw [anchor_toNat_eq (s := r.begin) (by omega : 1 ≤ r.begin.offset), hbegin, hp, hl] norm_num have hk_int : ((k : Nat) : Int) = 1 - r.end_.offset := by rw [hk] exact Int.toNat_of_nonneg (by omega) have ha : r.end_.anchor db = (c₀ : Int) - k := by unfold Selector.anchor rw [← hl, ← hc₀, hk_int] ring have hd_eq : d = c₀ - k := by have hmin : d = min (r.end_.anchor db).toNat l.length := by rw [hd, hl] exact countP_lt_resolve have htoNat : (r.end_.anchor db).toNat = c₀ - k := by rw [ha] exact Int.toNat_sub c₀ k rw [hmin, htoNat, Nat.min_eq_left (le_trans (Nat.sub_le _ _) hc₀_le)] have hA : l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key))) = l.drop p := by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hp_anchor] have hB₀ : l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = l.take c₀ := by rw [hc₀] exact filter_lt_eq_take_countP hls r.end_.key have hcanon : (canonicalRange r).keys db = (l.drop p).take (c₀ - p) := by have hsplit : (canonicalRange r).keys db = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key)) && decide ((↑k : WithTop Key) < r.end_.key)) := by rw [canonicalRange, ConflictRange.keys, ← hl] have hstep : l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key)) = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key)) && decide ((↑k : WithTop Key) < r.end_.key)) := List.filter_congr fun k _ => by rw [Bool.decide_and] rw [hstep, ← List.filter_filter] have htake : (l.take c₀).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := c₀) hls.pairwise) have hct : (l.take c₀).countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) = min c₀ p := by rw [countP_take_eq_min hls r.begin.key c₀, ← hp] rw [hsplit, ← List.filter_filter, hB₀] rw [show (l.take c₀).filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) = (l.take c₀).filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < r.begin.key))) from List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt]] rw [filter_not_lt_eq_drop_countP htake r.begin.key, hct, take_drop_min] have hLHS : RangeRead.completeKeys db r = (l.drop p).take (d - p) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop p).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < resolve db r.end_)) = l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (↑k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) p, ← hd, nat_sub_min_right] rw [hLHS, hcanon] have hlen : ((l.drop p).take (c₀ - p)).length = c₀ - p := by rw [List.length_take, List.length_drop, Nat.min_eq_left (Nat.sub_le_sub_right hc₀_le p)] rw [hlen, List.take_take, Nat.min_eq_left (Nat.sub_le (c₀ - p) k), hd_eq] congr 1 omega /-- **The end-offset-at-most-one window at a general positive begin offset.** A non-reversed read with `begin.offset ≥ 1` and `end_.offset ≤ 1` has complete keys equal to a left-and-right truncation of the canonical keys: drop the first `(begin.offset - 1).toNat` canonical keys (the begin selector overshoots that many keys past its own key) and keep only the first `length - (1 - end_.offset).toNat` of what remains. Both counts depend only on the offsets, so the complete keys are determined by the canonical keys alone. This generalizes `completeKeys_eq_canonical_take` (the `begin.offset = 1` case, where the left drop is zero). -/ theorem completeKeys_eq_canonical_slice {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbeginB : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : RangeRead.completeKeys db r = (((canonicalRange r).keys db).drop (r.begin.offset - 1).toNat).take ((((canonicalRange r).keys db).length - (r.begin.offset - 1).toNat) - (1 - r.end_.offset).toNat) := by set l := db.keys with hl set p := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) with hp set c₀ := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) with hc₀ set b := (r.begin.offset - 1).toNat with hb set k := (1 - r.end_.offset).toNat with hk set d := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < resolve db r.end_)) with hd have hls : l.SortedLT := by rw [hl]; exact db.sorted have hc₀_le : c₀ ≤ l.length := by rw [hc₀]; exact List.countP_le_length have hp_anchor : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbeginB, hp, hb, hl] have hk_int : ((k : Nat) : Int) = 1 - r.end_.offset := by rw [hk]; exact Int.toNat_of_nonneg (by omega) have ha : r.end_.anchor db = (c₀ : Int) - k := by unfold Selector.anchor rw [← hl, ← hc₀, hk_int] ring have hd_eq : d = c₀ - k := by have hmin : d = min (r.end_.anchor db).toNat l.length := by rw [hd, hl]; exact countP_lt_resolve have htoNat : (r.end_.anchor db).toNat = c₀ - k := by rw [ha]; exact Int.toNat_sub c₀ k rw [hmin, htoNat, Nat.min_eq_left (le_trans (Nat.sub_le _ _) hc₀_le)] have hA : l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key))) = l.drop (p + b) := by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hp_anchor] have hB₀ : l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = l.take c₀ := by rw [hc₀]; exact filter_lt_eq_take_countP hls r.end_.key have hcanon : (canonicalRange r).keys db = (l.drop p).take (c₀ - p) := by have hsplit : (canonicalRange r).keys db = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key)) && decide ((↑k : WithTop Key) < r.end_.key)) := by rw [canonicalRange, ConflictRange.keys, ← hl] have hstep : l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key)) = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key)) && decide ((↑k : WithTop Key) < r.end_.key)) := List.filter_congr fun k _ => by rw [Bool.decide_and] rw [hstep, ← List.filter_filter] have htake : (l.take c₀).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := c₀) hls.pairwise) have hct : (l.take c₀).countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) = min c₀ p := by rw [countP_take_eq_min hls r.begin.key c₀, ← hp] rw [hsplit, ← List.filter_filter, hB₀] rw [show (l.take c₀).filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) = (l.take c₀).filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < r.begin.key))) from List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt]] rw [filter_not_lt_eq_drop_countP htake r.begin.key, hct, take_drop_min] have hLHS : RangeRead.completeKeys db r = (l.drop (p + b)).take (d - (p + b)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop (p + b)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p + b) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < resolve db r.end_)) = l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (↑k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) (p + b), ← hd, nat_sub_min_right] rw [hLHS, hcanon] have hlen : ((l.drop p).take (c₀ - p)).length = c₀ - p := by rw [List.length_take, List.length_drop, Nat.min_eq_left (Nat.sub_le_sub_right hc₀_le p)] rw [hlen, hd_eq, List.drop_take, List.drop_drop, List.take_take] congr 1 omega /-- **The end-offset-at-most-one window, reversed, general positive begin offset.** A reversed read with `begin.offset ≥ 1` and `end_.offset ≤ 1` has complete keys equal to the *reverse* of the non-reversed slice of `completeKeys_eq_canonical_slice`: reversal only reverses the in-range keys, so the same left-and-right truncation of the canonical keys determines the complete keys in descending order. -/ theorem completeKeys_eq_canonical_slice_rev {db : DB} {r : RangeRead} (hrev : r.reverse = true) (hbeginB : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : RangeRead.completeKeys db r = ((((canonicalRange r).keys db).drop (r.begin.offset - 1).toNat).take ((((canonicalRange r).keys db).length - (r.begin.offset - 1).toNat) - (1 - r.end_.offset).toNat)).reverse := by have hck : RangeRead.completeKeys db r = (RangeRead.completeKeys db {r with reverse := false}).reverse := by simp [RangeRead.completeKeys, hrev] rw [hck, completeKeys_eq_canonical_slice (db := db) (r := {r with reverse := false}) rfl hbeginB hend] rfl /-- **Soundness of the canonical range at end offsets at most one.** A non-reversed read whose begin is at offset one and whose end offset is at most one has complete keys equal to a fixed-length truncation of the canonical keys (`completeKeys_eq_canonical_take`), so databases agreeing on `[begin.key, end.key)` have identical complete keys and hence identical compatibility with every result. -/ theorem sound_canonicalRange_of_end_offset_le_one {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : Sound r res (canonicalRange r) := by intro db₁ db₂ hagree have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by rw [completeKeys_eq_canonical_take (db := db₁) hrev hbegin hend, completeKeys_eq_canonical_take (db := db₂) hrev hbegin hend, show (canonicalRange r).keys db₁ = (canonicalRange r).keys db₂ from hagree] exact RangeRead.compatible_congr hck /-- **The empty result at end offsets at most one.** A non-reversed read whose begin is at offset one and whose end offset is at most one is compatible with the empty complete result exactly when the canonical keys number at most `(1 - end_.offset).toNat`: the complete keys are a truncation of the canonical keys to `length - (1 - end_.offset).toNat` (`completeKeys_eq_canonical_take`), and an empty result demands that truncation be empty. -/ theorem compatible_empty_iff_length_le {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : RangeRead.Compatible db r { keys := [], more := false } ↔ ((canonicalRange r).keys db).length ≤ (1 - r.end_.offset).toNat := by unfold RangeRead.Compatible RangeRead.withinLimit rw [completeKeys_eq_canonical_take (db := db) hrev hbegin hend] constructor · intro hc obtain ⟨-, h2⟩ := hc rcases h2 with ⟨hm, -⟩ | ⟨-, heq⟩ · simp at hm · rw [eq_comm, List.take_eq_nil_iff] at heq rcases heq with h | h · exact Nat.le_of_sub_eq_zero h · simp [h] · intro h refine ⟨?_, Or.inr ⟨rfl, ?_⟩⟩ · cases r.limit <;> simp rw [eq_comm, List.take_eq_nil_iff] exact Or.inl (Nat.sub_eq_zero_of_le h) /-- A compatible result is the empty one exactly when the complete keys are empty. -/ theorem compatible_empty_iff_complete_nil {db : DB} {r : RangeRead} : RangeRead.Compatible db r { keys := [], more := false } ↔ RangeRead.completeKeys db r = [] := by unfold RangeRead.Compatible RangeRead.withinLimit constructor · rintro ⟨-, h | h⟩ · exact absurd h.1 (by simp) · exact h.2.symm · intro h exact ⟨by cases r.limit <;> simp, Or.inr ⟨rfl, h.symm⟩⟩ /-- **The empty result, any traversal.** At begin offset one and end offset at most one, compatibility with the empty result is equivalent to the canonical keys numbering at most `(1 - end_.offset).toNat`, for both traversal orders: reversal only reverses the complete keys, which are empty on the same databases. -/ theorem compatible_empty_iff_length_le_any {db : DB} {r : RangeRead} (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : RangeRead.Compatible db r { keys := [], more := false } ↔ ((canonicalRange r).keys db).length ≤ (1 - r.end_.offset).toNat := by cases hrev : r.reverse with | false => exact compatible_empty_iff_length_le hrev hbegin hend | true => have hcomm : RangeRead.completeKeys db r = (RangeRead.completeKeys db {r with reverse := false}).reverse := by simp [RangeRead.completeKeys, hrev] rw [compatible_empty_iff_complete_nil, hcomm, List.reverse_eq_nil_iff, ← compatible_empty_iff_complete_nil] exact compatible_empty_iff_length_le (r := {r with reverse := false}) rfl hbegin hend /-- **The empty result at end offsets at most one, general positive begin offset.** A non-reversed read with `begin.offset ≥ 1` and `end_.offset ≤ 1` is compatible with the empty complete result exactly when the canonical keys, after dropping the `(begin.offset - 1).toNat` keys the begin selector overshoots, number at most `(1 - end_.offset).toNat`. This is the off-one analogue of `compatible_empty_iff_length_le`. -/ theorem compatible_empty_iff_length_sub_le {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : RangeRead.Compatible db r { keys := [], more := false } ↔ ((canonicalRange r).keys db).length - (r.begin.offset - 1).toNat ≤ (1 - r.end_.offset).toNat := by rw [compatible_empty_iff_complete_nil, completeKeys_eq_canonical_slice (db := db) hrev hbegin hend, List.take_eq_nil_iff, List.drop_eq_nil_iff] constructor · rintro (h | h) <;> omega · intro h; left; omega /-- **The empty result at end offsets at most one, general positive begin offset, any traversal.** Reversal only reverses the complete keys, which are empty on the same databases, so the forward bound equivalence transfers. -/ theorem compatible_empty_iff_length_sub_le_any {db : DB} {r : RangeRead} (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : RangeRead.Compatible db r { keys := [], more := false } ↔ ((canonicalRange r).keys db).length - (r.begin.offset - 1).toNat ≤ (1 - r.end_.offset).toNat := by cases hrev : r.reverse with | false => exact compatible_empty_iff_length_sub_le hrev hbegin hend | true => have hcomm : RangeRead.completeKeys db r = (RangeRead.completeKeys db {r with reverse := false}).reverse := by simp [RangeRead.completeKeys, hrev] rw [compatible_empty_iff_complete_nil, hcomm, List.reverse_eq_nil_iff, ← compatible_empty_iff_complete_nil] exact compatible_empty_iff_length_sub_le (r := {r with reverse := false}) rfl hbegin hend /-- **Soundness of the canonical range at end offsets at most one, general positive begin offset.** A non-reversed read with `begin.offset ≥ 1` and `end_.offset ≤ 1` has complete keys equal to a left-and-right truncation of the canonical keys (`completeKeys_eq_canonical_slice`), fixed by the two offsets, so databases agreeing on `[begin.key, end.key)` have identical complete keys. -/ theorem sound_canonicalRange_of_end_offset_le_one_general {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : Sound r res (canonicalRange r) := by intro db₁ db₂ hagree have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by rw [completeKeys_eq_canonical_slice (db := db₁) hrev hbegin hend, completeKeys_eq_canonical_slice (db := db₂) hrev hbegin hend, show (canonicalRange r).keys db₁ = (canonicalRange r).keys db₂ from hagree] exact RangeRead.compatible_congr hck /-- **Soundness of the canonical range at end offsets at most one, reversed, general positive begin offset.** A reversed read with `begin.offset ≥ 1` and `end_.offset ≤ 1` has complete keys equal to a fixed-length reversed truncation of the canonical keys (`completeKeys_eq_canonical_slice_rev`), fixed by the two offsets, so databases agreeing on `[begin.key, end.key)` have identical complete keys. -/ theorem sound_canonicalRange_of_end_offset_le_one_rev {r : RangeRead} {res : Result} (hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : Sound r res (canonicalRange r) := by intro db₁ db₂ hagree have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by rw [completeKeys_eq_canonical_slice_rev (db := db₁) hrev hbegin hend, completeKeys_eq_canonical_slice_rev (db := db₂) hrev hbegin hend, show (canonicalRange r).keys db₁ = (canonicalRange r).keys db₂ from hagree] exact RangeRead.compatible_congr hck /-- If every stored key lies in the canonical range, the canonical keys are all the stored keys. -/ theorem canonicalRange_keys_eq_self_of_forall {db : DB} {r : RangeRead} (h : ∀ x ∈ db.keys, x ∈ canonicalRange r) : (canonicalRange r).keys db = db.keys := by unfold canonicalRange ConflictRange.keys rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact h x hx /-- **The forward case.** At begin offset one, a complete nonempty non-reversed result whose end offset is at most one has the canonical range as its minimal sound conflict range. Soundness is `sound_canonicalRange_of_end_offset_le_one`; necessity splits at the reported last, using `necessary_of_mem_result`, `necessary_begin_key` with convexity below it, and `necessary_last_to_end_key` above it. -/ private theorem minimal_canonicalRange_of_end_offset_le_one_forward {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : Minimal r res (canonicalRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · exact sound_canonicalRange_of_end_offset_le_one hrev hbegin hend · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkle : k ≤ res.keys.getLast hne · -- At or below the reported last: the begin key's necessity and convexity. have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil (db := db₀) hrev (by rw [← hres₀]; exact hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs · -- Above the reported last: the last-to-end rule applies. exact necessary_last_to_end_key (r := r) (res := res) ⟨db₀, hcomp⟩ hrev hmore hne hend cr hs (le_of_lt (lt_of_not_ge hkle)) hk.2 /-- **The forward case at a general positive begin offset.** A non-reversed read with `begin.offset ≥ 1`, a complete nonempty result, and `end_.offset ≤ 1` has the canonical range `[begin.key, end.key)` as its minimal sound conflict range. Soundness is the general `sound_canonicalRange_of_end_offset_le_one_general`; necessity is the same split as the offset-one case — the reported last is necessary, the begin key is necessary with convexity up to the last, and `necessary_last_to_end_key` covers the keys above it. -/ private theorem minimal_canonicalRange_of_end_offset_le_one_forward_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : Minimal r res (canonicalRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · exact sound_canonicalRange_of_end_offset_le_one_general hrev hbegin hend · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkle : k ≤ res.keys.getLast hne · -- At or below the reported last: the begin key's necessity and convexity. have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil (db := db₀) hrev (by rw [← hres₀]; exact hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs · -- Above the reported last: the last-to-end rule applies. exact necessary_last_to_end_key (r := r) (res := res) ⟨db₀, hcomp⟩ hrev hmore hne hend cr hs (le_of_lt (lt_of_not_ge hkle)) hk.2 /-- **At end offsets at most one, a general positive begin offset: the canonical range is minimal.** A non-reversed complete nonempty realizable read with `begin.offset ≥ 1` and `end_.offset ≤ 1` has `[begin.key, end.key)` as its minimal sound conflict range. Soundness is the general `sound_canonicalRange_of_end_offset_le_one_general`; necessity is the forward split, and the reversed case flips via `minimal_flip`. -/ theorem minimal_canonicalRange_of_end_offset_le_one_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : Minimal r res (canonicalRange r) := by cases hrev : r.reverse with | false => exact minimal_canonicalRange_of_end_offset_le_one_forward_general hread hmore hrev hne hbegin hend | true => obtain ⟨db₀, hcomp⟩ := hread have hflip : Readable {r with reverse := false} {keys := res.keys.reverse, more := false} := ⟨db₀, (compatible_flip (db := db₀) (b := true) hrev hmore).mpr hcomp⟩ exact (minimal_flip (b := true) hrev hmore).mp (minimal_canonicalRange_of_end_offset_le_one_forward_general (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) hflip (by simp) (by simp) (by simpa using hne) hbegin hend) /-- At end offsets at most one and a general positive begin offset, the canonical range `[begin.key, end.key)` is *the* minimal sound conflict range up to set equality: it is minimal by `minimal_canonicalRange_of_end_offset_le_one_general`, and every minimal range denotes the same set by the unconditional `Minimal.toSet_eq`. -/ theorem unique_minimal_canonicalRange_of_end_offset_le_one_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend) /-- **The endpoint bridge in a certified region.** For a complete nonempty realizable read with `begin.offset ≥ 1` and `end_.offset ≤ 1`, the necessary set is exactly the canonical range's keys `[begin.key, end.key)`. This instantiates `necessarySet_eq_of_minimal` with `minimal_canonicalRange_of_end_offset_le_one_general`: the lower endpoint is the attained key `begin.key` and the upper endpoint the key `end_.key`, and the interval between them is exactly the necessary set. It is the headline's set-theoretic content in this region, and the shape the endpoint-attainment route produces whenever both ends are attained. -/ theorem necessarySet_eq_canonicalRange_of_end_offset_le_one_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : necessarySet r res = (canonicalRange r).toSet := necessarySet_eq_of_minimal (minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend) /-- Erasing a stored key of the canonical range changes its canonical keys. -/ private theorem canonical_keys_erase_ne {r : RangeRead} {db : DB} {k : Key} (hk : k ∈ canonicalRange r) (hdb : k ∈ db.keys) : (canonicalRange r).keys (db.erase k) ≠ (canonicalRange r).keys db := by intro heq have hmem : k ∈ (canonicalRange r).keys db := ConflictRange.mem_keys_iff.mpr ⟨hdb, hk⟩ have hnot : k ∉ (canonicalRange r).keys (db.erase k) := by rw [ConflictRange.mem_keys_iff] exact fun h => DB.not_mem_erase_self db k h.1 rw [heq] at hnot exact hnot hmem /-- Inserting an unstored key of the canonical range changes its canonical keys. -/ private theorem canonical_keys_insert_ne {r : RangeRead} {db : DB} {k : Key} (hk : k ∈ canonicalRange r) (hdb : k ∉ db.keys) : (canonicalRange r).keys (db.insert k hdb) ≠ (canonicalRange r).keys db := by intro heq have hmem : k ∈ (canonicalRange r).keys (db.insert k hdb) := ConflictRange.mem_keys_iff.mpr ⟨DB.mem_insert_self db k hdb, hk⟩ have hnot : k ∉ (canonicalRange r).keys db := by rw [ConflictRange.mem_keys_iff]; exact fun h => hdb h.1 rw [heq] at hmem exact hnot hmem /-- Differing canonical keys at offset one force differing complete keys. -/ private theorem completeKeys_ne_of_canonical_ne {db₁ db₂ : DB} {r : RangeRead} (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) (hne : (canonicalRange r).keys db₁ ≠ (canonicalRange r).keys db₂) : RangeRead.completeKeys db₁ r ≠ RangeRead.completeKeys db₂ r := by rw [completeKeys_eq_canonical hbegin hend, completeKeys_eq_canonical hbegin hend] cases hrev : r.reverse with | false => simpa only [hrev, Bool.false_eq_true, ite_false] using hne | true => simpa only [hrev, ite_true] using fun h => hne (List.reverse_inj.mp h) /-- For a complete result and selectors at offset one, the minimal sound conflict range is the canonical range `[begin.key, end.key)`: the resolved window `[resolve begin, resolve end)` cuts a key exactly when the canonical interval does. Soundness follows since compatibility depends only on the canonical keys; necessity follows since toggling a canonical key changes the complete keys and so breaks a complete result. -/ theorem minimal_canonicalRange_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : Minimal r res (canonicalRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · -- Agreement on the canonical range gives equal complete keys. intro db₁ db₂ hagree have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by rw [completeKeys_eq_canonical hbegin hend, completeKeys_eq_canonical hbegin hend, show (canonicalRange r).keys db₁ = (canonicalRange r).keys db₂ from hagree] exact RangeRead.compatible_congr hck · intro k hk cr hs by_contra hcr by_cases hmem : k ∈ db₀.keys · -- Erasing the stored key preserves agreement on `cr` but changes complete keys. have hagree : AgreeOn cr db₀ (db₀.erase k) := (ConflictRange.keys_erase_of_not_mem cr db₀ hcr).symm have hcompat' : RangeRead.Compatible (db₀.erase k) r res := (hs db₀ _ hagree).mp hcomp have hres' : res.keys = RangeRead.completeKeys (db₀.erase k) r := by rcases hcompat'.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq exact completeKeys_ne_of_canonical_ne hbegin hend (canonical_keys_erase_ne hk hmem) (by rw [← hres, ← hres']) · -- Inserting the unstored key likewise. have hagree : AgreeOn cr db₀ (db₀.insert k hmem) := (ConflictRange.keys_insert_of_not_mem cr db₀ hmem hcr).symm have hcompat' : RangeRead.Compatible (db₀.insert k hmem) r res := (hs db₀ _ hagree).mp hcomp have hres' : res.keys = RangeRead.completeKeys (db₀.insert k hmem) r := by rcases hcompat'.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq exact completeKeys_ne_of_canonical_ne hbegin hend (canonical_keys_insert_ne hk hmem) (by rw [← hres, ← hres']) /-- At offset one with a complete result, the canonical range is *the* minimal sound conflict range up to set equality: it is minimal by `minimal_canonicalRange_of_offset_one`, and every minimal range denotes the same set by the unconditional `Minimal.toSet_eq`. -/ theorem unique_minimal_canonicalRange_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_canonicalRange_of_offset_one hread hmore hbegin hend) /-- At begin offset one, a complete nonempty result whose end offset is at most one has the canonical range `[begin.key, end.key)` as its minimal sound conflict range. At end offset one this is `minimal_canonicalRange_of_offset_one`. At end offset at most zero the resolved end targets a stored key `1 - offset` positions below the last stored key strictly below `end_.key`, so the complete keys are the canonical keys with the trailing `(1 - end_.offset).toNat` keys removed — a truncation to a length depending only on `end_.offset`, hence database-independent. Those trailing keys are outside the resolved window and so are not directly reported, but they are necessary all the same: the reported keys are necessary by `necessary_of_mem_result`, the beginning by `necessary_begin_key`, and the rest by convexity up to the last stored key below `end_.key`, above which `necessary_last_to_end_key` applies. Soundness survives because the complete keys are that fixed-length truncation of the canonical keys. `canonicalRange` ignores `reverse`, so the reversed case flips via `minimal_flip`. -/ theorem minimal_canonicalRange_of_end_offset_le_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : Minimal r res (canonicalRange r) := by cases hrev : r.reverse with | false => by_cases hend1 : r.end_.offset = 1 · exact minimal_canonicalRange_of_offset_one hread hmore hbegin hend1 · exact minimal_canonicalRange_of_end_offset_le_one_forward hread hmore hrev hne hbegin hend | true => obtain ⟨db₀, hcomp⟩ := hread have hflip : Readable {r with reverse := false} {keys := res.keys.reverse, more := false} := ⟨db₀, (compatible_flip (db := db₀) (b := true) hrev hmore).mpr hcomp⟩ exact (minimal_flip (b := true) hrev hmore).mp (minimal_canonicalRange_of_end_offset_le_one_forward (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) hflip (by simp) (by simp) (by simpa using hne) hbegin hend) /-- The minimal canonical range at end offsets at most one is unique up to set equality. -/ theorem unique_minimal_canonicalRange_of_end_offset_le_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 1) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_canonicalRange_of_end_offset_le_one hread hmore hne hbegin hend) /-! ## The canonical range at offset one, truncated When the result is truncated (`more = true`), a compatible result only reports a prefix of the complete keys, so the read gives no information past the last reported key: the minimal sound range runs from `begin.key` up to just past that key, `keyAfter (res.keys.getLast hne)`. The reported keys themselves stay necessary (`necessary_of_mem_result`), the begin key stays necessary (`necessary_begin_key`), and keys between them are necessary by convexity; no key at or beyond `keyAfter (res.keys.getLast hne)` is necessary, because agreement on the truncated range fixes exactly the reported prefix and the limit — enough for compatibility whether or not `more` remains. -/ /-- Filtering an ascending list at or below a key yields a prefix. -/ private theorem filter_le_prefix {α : Type*} [LinearOrder α] {l : List α} (hs : l.Pairwise (· < ·)) (b : α) : (l.filter (fun k => decide (k ≤ b))) <+: l := by induction l with | nil => exact List.nil_prefix | cons a t ih => rw [List.pairwise_cons] at hs obtain ⟨hhead, htail⟩ := hs by_cases ha : a ≤ b · rw [List.filter_cons_of_pos (by simpa using ha), List.cons_prefix_cons] exact ⟨rfl, ih htail⟩ · have hb : b < a := lt_of_not_ge ha rw [List.filter_cons_of_neg (by simpa using ha)] have hnil : t.filter (fun k => decide (k ≤ b)) = [] := by rw [List.filter_eq_nil_iff] intro k hk hkb exact absurd (lt_of_lt_of_le hb (le_of_lt (hhead k hk))) (not_lt.mpr (of_decide_eq_true hkb)) rw [hnil] exact List.nil_prefix /-- For a prefix whose last element bounds everything after it, filtering the whole ascending list at or below that last element recovers the prefix. -/ theorem filter_le_getLast_eq_of_prefix {α : Type*} [LinearOrder α] {g W : List α} (hW : W.Pairwise (· < ·)) (hpre : g <+: W) (hne : g ≠ []) : W.filter (fun k => decide (k ≤ g.getLast hne)) = g := by obtain ⟨rest, rfl⟩ := hpre have hpw : (g ++ rest).Pairwise (· < ·) := hW rw [List.pairwise_append] at hpw obtain ⟨hgasc, _, hcross⟩ := hpw rw [List.filter_append] have hg : g.filter (fun k => decide (k ≤ g.getLast hne)) = g := by rw [List.filter_eq_self] intro k hk rw [decide_eq_true_eq] exact (hgasc.imp le_of_lt).rel_getLast hk have hr : rest.filter (fun k => decide (k ≤ g.getLast hne)) = [] := by rw [List.filter_eq_nil_iff] intro k hk hkb exact absurd (hcross (g.getLast hne) (List.getLast_mem hne) k hk) (not_lt.mpr (of_decide_eq_true hkb)) rw [hg, hr, List.append_nil] /-- Conversely, an ascending list whose filter at or below `g`'s last element equals `g` has `g` as a prefix, so that filter determines `g`. -/ private theorem prefix_of_filter_le_getLast_eq {α : Type*} [LinearOrder α] {g W : List α} (hW : W.Pairwise (· < ·)) (hne : g ≠ []) (heq : W.filter (fun k => decide (k ≤ g.getLast hne)) = g) : g <+: W := by rw [← heq] exact filter_le_prefix hW (g.getLast hne) /-- The truncated conflict range: the begin key unchanged, ending just past the last reported key. -/ def truncatedRange (r : RangeRead) (last : Key) : ConflictRange := ⟨r.begin.key, (keyAfter last : WithTop Key)⟩ /-- At begin offset one, the truncated range's stored keys are exactly the complete keys at or below the last reported key, whenever the truncated range's successor end lies at or below the resolved end. This is the offset-free form of `truncatedRange_keys_eq`: only the begin offset is needed to identify `resolve begin` with the first stored key at or above `begin.key`. -/ private theorem truncatedRange_keys_eq_of_resolve {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hle : (keyAfter last : WithTop Key) ≤ resolve db r.end_) : (truncatedRange r last).keys db = (RangeRead.completeKeys db r).filter (fun (k : Key) => decide (k ≤ last)) := by unfold truncatedRange ConflictRange.keys rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] unfold RangeRead.inRange rw [List.filter_filter] apply List.filter_congr intro k hk rw [← Bool.decide_and, decide_eq_decide] constructor · rintro ⟨hb, hlt⟩ have hkle := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp hlt) exact ⟨hkle, (key_le_resolve_iff_of_offset_one hbegin hk).mp hb, lt_of_lt_of_le hlt hle⟩ · rintro ⟨hkle, hb, _⟩ exact ⟨(key_le_resolve_iff_of_offset_one hbegin hk).mpr hb, WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k last).mpr hkle)⟩ /-- At offset one and non-reversed, the truncated range's stored keys are exactly the canonical keys at or below the last reported key. This is the offset-one instance of `truncatedRange_keys_eq_of_resolve`: the end offset one puts `end_.key` at or below `resolve end_`, so the successor bound transfers. -/ private theorem truncatedRange_keys_eq {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) (hle : (keyAfter last : WithTop Key) ≤ r.end_.key) : (truncatedRange r last).keys db = (RangeRead.completeKeys db r).filter (fun (k : Key) => decide (k ≤ last)) := truncatedRange_keys_eq_of_resolve hrev hbegin (le_trans hle (key_le_resolve_of_one_le (by omega))) /-- For a truncated non-reversed offset-one read, compatibility is equivalent to fitting the limit and having exactly the truncated range's stored keys: agreement on the range fixes the reported prefix, and nothing past the last reported key can be inferred. -/ theorem compatible_iff_truncated_keys {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ (RangeRead.completeKeys db r).filter (fun (k : Key) => decide (k ≤ res.keys.getLast hne)) = res.keys := by have hW : (RangeRead.completeKeys db r).Pairwise (· < ·) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] exact RangeRead.inRange_pairwise db _ _ constructor · rintro ⟨hlim, hdisj⟩ rcases hdisj with ⟨_, hpre, _⟩ | ⟨hm, _⟩ · exact ⟨hlim, filter_le_getLast_eq_of_prefix hW hpre hne⟩ · simp [hmore] at hm · rintro ⟨hlim, heq⟩ exact ⟨hlim, Or.inl ⟨hmore, prefix_of_filter_le_getLast_eq hW hne heq, hne⟩⟩ /-- At offset one with a truncated non-reversed result, the minimal sound conflict range is `[begin.key, keyAfter (last reported key))`. The reported keys and the begin key are necessary, convexity fills the gap, and no key at or past the successor of the last reported key is necessary because the truncated range already pins down the reported prefix. A `more = true` result is nonempty, so the `getLastD` fallback is never reached. -/ theorem minimal_truncatedRange_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := hpre₀.subset (List.getLast_mem hne) have hlast_stored : res.keys.getLast hne ∈ db₀.keys := (RangeRead.mem_completeKeys.mp hlast_ck).1 have hlast_lt_res : (res.keys.getLast hne : WithTop Key) < resolve db₀ r.end_ := (RangeRead.mem_completeKeys.mp hlast_ck).2.2 -- The last reported key lies strictly below `end_.key`, so its successor does too. have hlast_end : res.keys.getLast hne < r.end_.key := by by_contra hcon have hge : r.end_.key ≤ (↑(res.keys.getLast hne) : WithTop Key) := not_lt.mp hcon have hrle : resolve db₀ r.end_ ≤ (↑(res.keys.getLast hne) : WithTop Key) := (key_le_resolve_iff_of_offset_one hend hlast_stored).mp hge exact absurd hlast_lt_res (not_lt.mpr hrle) have hka_le : (keyAfter (res.keys.getLast hne) : WithTop Key) ≤ r.end_.key := keyAfter_le_of_lt hlast_end refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have hf₁ := truncatedRange_keys_eq (db := db₁) hrev hbegin hend hka_le have hf₂ := truncatedRange_keys_eq (db := db₂) hrev hbegin hend hka_le rw [compatible_iff_truncated_keys hrev hmore hne, compatible_iff_truncated_keys (db := db₂) hrev hmore hne, ← hf₁, ← hf₂, hagree] · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) -- A nonempty result forces the begin key to be a genuine key, not `⊤`. have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- **The canonical range at a nonpositive end offset, truncated, general begin offset.** A truncated non-reversed realizable read with `1 ≤ begin.offset` and `end_.offset ≤ 0` has the canonical range `[begin.key, end.key)` as its minimal sound conflict range. Putting `b = (begin.offset - 1).toNat` and `m = (1 - end_.offset).toNat`, the complete keys are `(C.drop b).take (|C| - b - m)` where `C` is the canonical keys (`completeKeys_eq_canonical_slice`); soundness is `sound_canonicalRange_of_end_offset_le_one_general`. Necessity below the reported last is the begin key's necessity and convexity. For a key `k` strictly above the reported last we build a witness whose canonical keys are `C.take b ++ res.keys ++ F`, `F` a filler of exactly `m` canonical keys above the reported last: dropping the first `b` and the last `m` leaves exactly the reported keys (compatible), while erasing one filler drops that below the reported prefix. The `m` filler keys exist because the reported last sits among the complete keys, `m` above it. At `b = 0` this is the offset-one statement. -/ theorem minimal_canonicalRange_of_truncated_end_offset_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 0) : Minimal r res (canonicalRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp set b : ℕ := (r.begin.offset - 1).toNat with hb set m : ℕ := (1 - r.end_.offset).toNat with hm have hm1 : 1 ≤ m := by rw [hm]; omega have hsub : (1 - r.end_.offset).toNat = m := hm have hbsub : (r.begin.offset - 1).toNat = b := hb -- Every reported key lies in the canonical range. have hres_canon : ∀ x ∈ res.keys, x ∈ canonicalRange r := by intro x hx have hx' : x ∈ RangeRead.completeKeys db₀ r := hpre₀.subset hx rw [completeKeys_eq_canonical_slice (db := db₀) (r := r) hrev hbegin (by omega)] at hx' exact (ConflictRange.mem_keys_iff.mp (List.mem_of_mem_drop (List.mem_of_mem_take hx'))).2 refine (minimal_iff_sound_and_necessary).mpr ⟨sound_canonicalRange_of_end_offset_le_one_general hrev hbegin (by omega), ?_⟩ intro k hk by_cases hkle : k ≤ res.keys.getLast hne · -- At or below the reported last: convex between the begin key and the last. have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle · -- Strictly above the reported last (and below `end_.key`). have hkgt : res.keys.getLast hne < k := lt_of_not_ge hkle have hknotmem : k ∉ res.keys := fun hm' => absurd ((hsort.pairwise.imp le_of_lt).rel_getLast hm') (not_le.mpr hkgt) set C : List Key := (canonicalRange r).keys db₀ with hC have hCsort : C.SortedLT := List.sortedLT_iff_pairwise.mpr (by rw [hC]; exact ConflictRange.keys_pairwise _ _) have hCcanon : ∀ x ∈ C, x ∈ canonicalRange r := fun x hx => (ConflictRange.mem_keys_iff.mp (by rw [hC] at hx; exact hx)).2 have hck_eq : RangeRead.completeKeys db₀ r = (C.drop b).take (C.length - b - m) := by rw [completeKeys_eq_canonical_slice (db := db₀) (r := r) hrev hbegin (by omega), hbsub, hsub, hC] have hlastmem : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := hpre₀.subset (List.getLast_mem hne) rw [hck_eq] at hlastmem obtain ⟨j', hj', hjk'⟩ := List.mem_take_iff_getElem.mp hlastmem have hj'lt : j' < C.length - b - m := lt_of_lt_of_le hj' (Nat.min_le_left _ _) set j : ℕ := b + j' with hj have hjC : j < C.length := by rw [hj]; omega have hjk : C[j] = res.keys.getLast hne := by change C[b + j'] = res.keys.getLast hne rw [← List.getElem_drop (i := b) (j := j')] exact hjk' -- The reported keys are a prefix of the complete keys, so their head is `C[b]`. have hbC : b < C.length := by omega have hhead_res : res.keys.head hne = C[b] := by have hpre_b : res.keys <+: (C.drop b).take (C.length - b - m) := hck_eq ▸ hpre₀ have hne_take : (C.drop b).take (C.length - b - m) ≠ [] := hpre_b.ne_nil hne rw [hpre_b.head hne, List.head_eq_getElem hne_take] simpa only [List.getElem_take, Nat.add_zero] using (List.getElem_drop (i := b) (j := 0) (h := by rw [List.length_drop]; omega)) -- The `m` filler keys above the reported last, all below `end_.key`. have hGlen : m ≤ (C.drop (j + 1)).length := by rw [List.length_drop]; omega have hGsort : (C.drop (j + 1)).SortedLT := by rw [List.sortedLT_iff_pairwise] exact List.Pairwise.drop (i := j + 1) (List.sortedLT_iff_pairwise.mp hCsort) have hGgt : ∀ x ∈ C.drop (j + 1), res.keys.getLast hne < x := by intro x hx obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hx rw [List.length_drop] at hi have hxeq : x = C[j + 1 + i] := by rw [← hix, List.getElem_drop] rw [hxeq, ← hjk] exact hCsort.getElem_lt_getElem_iff.mpr (by omega) have hGerase_sub : (C.drop (j + 1)).erase k ⊆ C := fun x hx => List.drop_subset (j + 1) C (List.erase_subset (a := k) (l := C.drop (j + 1)) hx) have hGerase_gt : ∀ x ∈ (C.drop (j + 1)).erase k, res.keys.getLast hne < x := fun x hx => hGgt x ((List.erase_subset (a := k) (l := C.drop (j + 1))) hx) have hcons_nodup : (k :: (C.drop (j + 1)).erase k).Nodup := List.nodup_cons.mpr ⟨hGsort.nodup.not_mem_erase, hGsort.nodup.sublist (List.erase_sublist (a := k))⟩ have hcons_len : m ≤ (k :: (C.drop (j + 1)).erase k).length := by rw [List.length_cons] by_cases hkG : k ∈ C.drop (j + 1) · rw [List.length_erase_of_mem hkG]; omega · rw [List.erase_of_not_mem hkG]; omega -- assemble the filler: `k` together with enough of `k`'s canonical successors. let raw : List Key := (k :: (C.drop (j + 1)).erase k).take m have hrawlen : raw.length = m := by rw [List.length_take, Nat.min_eq_left hcons_len] have hraw_sub : ∀ x ∈ raw, x = k ∨ x ∈ (C.drop (j + 1)).erase k := by intro x hx rcases List.mem_cons.mp (List.mem_of_mem_take hx) with h | h · exact Or.inl h · exact Or.inr h have hrawk : k ∈ raw := by have hm1' : m = (m - 1) + 1 := by omega change k ∈ List.take m (k :: (C.drop (j + 1)).erase k) rw [hm1', List.take_succ_cons] exact List.mem_cons_self .. have hrawCanon : ∀ x ∈ raw, x ∈ canonicalRange r := by intro x hx rcases hraw_sub x hx with rfl | hx · exact hk · exact hCcanon x (hGerase_sub hx) have hrawGt : ∀ x ∈ raw, res.keys.getLast hne < x := by intro x hx rcases hraw_sub x hx with rfl | hx · exact hkgt · exact hGerase_gt x hx let F : List Key := raw.insertionSort (· ≤ ·) have hFperm : raw.Perm F := (List.perm_insertionSort (· ≤ ·) raw).symm have hFsorted : F.SortedLT := by rw [List.sortedLT_iff_pairwise] exact DB.pairwise_lt_of_le_of_nodup (List.pairwise_insertionSort (r := (· ≤ ·)) raw) (hFperm.nodup_iff.mp (hcons_nodup.sublist (List.take_sublist _ _))) have hFlen : F.length = m := by rw [List.length_insertionSort, hrawlen] have hFk : k ∈ F := hFperm.mem_iff.mp hrawk have hFmem : ∀ x ∈ F, x ∈ canonicalRange r ∧ res.keys.getLast hne < x := fun x hx => let hx' := hFperm.mem_iff.mpr hx ⟨hrawCanon x hx', hrawGt x hx'⟩ have hFF : (res.keys ++ F).SortedLT := by refine List.sortedLT_append.mpr ⟨hsort, hFsorted, ?_⟩ intro a ha b hb exact lt_of_le_of_lt ((hsort.pairwise.imp le_of_lt).rel_getLast ha) (hFmem b hb).2 -- The witness's canonical list: the `b` canonical keys below the reported prefix, -- then the reported keys and the filler. set D : List Key := C.take b ++ (res.keys ++ F) with hD have hCb_sort : (C.take b).SortedLT := List.sortedLT_iff_pairwise.mpr ((List.sortedLT_iff_pairwise.mp hCsort).sublist (List.take_prefix b C).sublist) have hCb_lt : ∀ x ∈ C.take b, x < res.keys.head hne := by intro x hx obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hx have hib : i < b := by rw [List.length_take] at hi; omega rw [← hix, hhead_res, List.getElem_take] exact hCsort.getElem_lt_getElem_iff.mpr hib have hhead_le : ∀ x ∈ res.keys, res.keys.head hne ≤ x := by intro x hx obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hx rw [← hix, List.head_eq_getElem hne] exact hsort.getElem_le_getElem_iff.mpr (Nat.zero_le i) have hheadF_le : ∀ c ∈ F, res.keys.head hne ≤ c := fun c hc => le_of_lt (lt_of_le_of_lt (hhead_le _ (List.getLast_mem hne)) (hFmem c hc).2) have hDP : D.SortedLT := by refine List.sortedLT_append.mpr ⟨hCb_sort, hFF, ?_⟩ intro a ha c hc exact lt_of_lt_of_le (hCb_lt a ha) (by rcases List.mem_append.mp hc with hc | hc · exact hhead_le c hc · exact hheadF_le c hc) have hDcanon : ∀ x ∈ D, x ∈ canonicalRange r := fun x hx => by rw [hD, List.mem_append, List.mem_append] at hx rcases hx with hx | hx | hx · exact hCcanon x (List.take_subset _ _ hx) · exact hres_canon x hx · exact (hFmem x hx).1 let dbw : DB := ⟨D, hDP⟩ have hlenP : (C.take b).length = b := by rw [List.length_take, Nat.min_eq_left (by omega)] have hlenD : D.length = b + (res.keys.length + m) := by rw [hD, List.length_append, List.length_append, hlenP, hFlen] have hdropD : D.drop b = res.keys ++ F := by rw [hD, List.drop_left' hlenP] have hcanw : (canonicalRange r).keys dbw = D := canonicalRange_keys_eq_self_of_forall (db := dbw) (r := r) hDcanon have hlen : D.length - b - m = res.keys.length := by rw [hlenD]; omega have hckw : RangeRead.completeKeys dbw r = res.keys := by rw [completeKeys_eq_canonical_slice (db := dbw) (r := r) hrev hbegin (by omega), hcanw, hbsub, hsub, hlen, hdropD, List.take_left] have hcompw : RangeRead.Compatible dbw r res := ⟨hcomp.1, Or.inl ⟨hmore, by rw [hckw], hne⟩⟩ -- Erasing `k` removes one filler key, dropping the complete keys below the prefix. have hkCb : k ∉ C.take b := fun hx => absurd (hCb_lt k hx) (not_lt.mpr (le_trans (hhead_le _ (List.getLast_mem hne)) (le_of_lt hkgt))) have hkeys_erase : (dbw.erase k).keys = D.erase k := DB.erase_keys dbw k have hcan_erase : (canonicalRange r).keys (dbw.erase k) = D.erase k := by rw [← hkeys_erase] exact canonicalRange_keys_eq_self_of_forall (db := dbw.erase k) (r := r) (fun x hx => hDcanon x (List.erase_subset hx)) have hD_erase : D.erase k = C.take b ++ (res.keys ++ F.erase k) := by rw [hD, List.erase_append_right _ hkCb, List.erase_append_right _ hknotmem] have hFlener : (F.erase k).length = m - 1 := by have := List.length_erase_of_mem hFk; omega have hdropD_erase : (D.erase k).drop b = res.keys ++ F.erase k := by rw [hD_erase, List.drop_left' hlenP] have hlenD_erase : (D.erase k).length = b + (res.keys.length + (m - 1)) := by rw [hD_erase, List.length_append, List.length_append, hlenP, hFlener] have hck_erase : RangeRead.completeKeys (dbw.erase k) r = res.keys.take (res.keys.length - 1) := by rw [completeKeys_eq_canonical_slice (db := dbw.erase k) (r := r) hrev hbegin (by omega), hcan_erase, hbsub, hsub, hdropD_erase] have hidx : (D.erase k).length - b - m = res.keys.length - 1 := by rw [hlenD_erase]; omega rw [hidx, List.take_append_of_le_length (by omega : res.keys.length - 1 ≤ res.keys.length)] have hnot_erase : ¬ RangeRead.Compatible (dbw.erase k) r res := by intro hc have hlen := (RangeRead.compatible_keys_prefix hc).length_le rw [hck_erase, List.length_take, Nat.min_eq_left (Nat.sub_le _ _)] at hlen have hlt : res.keys.length - 1 < res.keys.length := Nat.sub_lt (List.length_pos_of_ne_nil hne) (by norm_num) omega intro cr hs by_contra hkcr exact hnot_erase ((hs dbw (dbw.erase k) (ConflictRange.keys_erase_of_not_mem cr dbw hkcr).symm).mp hcompw) /-- At offset one with a truncated non-reversed result, the truncated range is *the* minimal sound conflict range up to set equality: it is minimal by `minimal_truncatedRange_of_offset_one`, and every minimal range denotes the same set by the unconditional `Minimal.toSet_eq`. -/ theorem unique_minimal_truncatedRange_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRange_of_offset_one hread hmore hrev hbegin hend) /-! ### The reversed truncated case A reversed truncated result reports the top of the window downward, so the known side is the end: the minimal sound range runs from the last reported key up to `end.key`, dually to the non-reversed case. The descending-order filter lemmas below mirror the ascending ones. -/ /-- The descending-order twin of `filter_le_prefix`, obtained by reversing the order: `(· > ·)` is `(· < ·)` and `b ≤ ·` is `· ≤ b` under `OrderDual`. -/ private theorem filter_ge_prefix {α : Type*} [LinearOrder α] {l : List α} (hs : l.Pairwise (· > ·)) (b : α) : (l.filter (fun k => decide (b ≤ k))) <+: l := filter_le_prefix (α := αᵒᵈ) (l := l) hs b /-- The descending-order twin of `filter_le_getLast_eq_of_prefix`. -/ private theorem filter_ge_getLast_eq_of_prefix {α : Type*} [LinearOrder α] {g W : List α} (hW : W.Pairwise (· > ·)) (hpre : g <+: W) (hne : g ≠ []) : W.filter (fun k => decide (g.getLast hne ≤ k)) = g := filter_le_getLast_eq_of_prefix (α := αᵒᵈ) (g := g) (W := W) hW hpre hne /-- The descending-order twin of `prefix_of_filter_le_getLast_eq`. -/ private theorem prefix_of_filter_ge_getLast_eq {α : Type*} [LinearOrder α] {g W : List α} (hW : W.Pairwise (· > ·)) (hne : g ≠ []) (heq : W.filter (fun k => decide (g.getLast hne ≤ k)) = g) : g <+: W := prefix_of_filter_le_getLast_eq (α := αᵒᵈ) (g := g) (W := W) hW hne heq /-- For an ascending list, filtering a threshold `last ≤ ·` commutes with dropping the largest `m` elements: the kept keys of `take (length - m)` are the kept keys with the largest `m` removed, because the kept keys form a suffix of the list. -/ private theorem filter_ge_take {α : Type*} [LinearOrder α] (l : List α) (hs : l.Pairwise (· < ·)) (last : α) (m : ℕ) : (l.take (l.length - m)).filter (fun k => decide (last ≤ k)) = (l.filter (fun k => decide (last ≤ k))).take ((l.filter (fun k => decide (last ≤ k))).length - m) := by induction l with | nil => simp | cons a t ih => rw [List.pairwise_cons] at hs obtain ⟨hhead, htail⟩ := hs by_cases ha : last ≤ a · have hall : ∀ k ∈ a :: t, decide (last ≤ k) = true := by intro k hk rw [decide_eq_true_eq] rcases List.mem_cons.mp hk with rfl | hk · exact ha · exact le_trans ha (le_of_lt (hhead k hk)) have hfil : (a :: t).filter (fun k => decide (last ≤ k)) = (a :: t) := List.filter_eq_self.mpr hall rw [hfil] have htake : ((a :: t).take ((a :: t).length - m)).filter (fun k => decide (last ≤ k)) = (a :: t).take ((a :: t).length - m) := List.filter_eq_self.mpr (fun k hk => hall k (List.mem_of_mem_take hk)) rw [htake] · have haf : decide (last ≤ a) = false := decide_eq_false_iff_not.mpr ha have hfil : (a :: t).filter (fun k => decide (last ≤ k)) = t.filter (fun k => decide (last ≤ k)) := by rw [List.filter_cons, haf]; simp rw [hfil] by_cases hle : (a :: t).length - m = 0 · have hflen : (t.filter (fun k => decide (last ≤ k))).length ≤ m := by have h := List.length_filter_le (fun k => decide (last ≤ k)) t rw [List.length_cons] at hle omega rw [hle, List.take_zero, List.filter_nil, Nat.sub_eq_zero_of_le hflen, List.take_zero] · have hpos : 0 < (a :: t).length - m := Nat.pos_of_ne_zero hle rw [List.take_cons hpos, List.filter_cons, haf] have harg : (a :: t).length - m - 1 = t.length - m := by rw [List.length_cons]; omega simp only [harg, Bool.false_eq_true, ite_false] rw [ih htail] /-- The reversed truncated conflict range: from the last reported key to the end key unchanged. -/ def truncatedRangeRev (r : RangeRead) (last : Key) : ConflictRange := ⟨(last : WithTop Key), r.end_.key⟩ /-- The reversed truncated range's stored keys are the canonical keys at or above the last reported key. -/ private theorem truncatedRangeRev_keys_eq {db : DB} {r : RangeRead} {last : Key} (hbl : (r.begin.key : WithTop Key) ≤ (last : WithTop Key)) : (truncatedRangeRev r last).keys db = ((canonicalRange r).keys db).filter (fun (k : Key) => decide (last ≤ k)) := by unfold truncatedRangeRev canonicalRange ConflictRange.keys rw [List.filter_filter] apply List.filter_congr intro k _ rw [← Bool.decide_and, decide_eq_decide] constructor · rintro ⟨hlk, hke⟩ exact ⟨WithTop.coe_le_coe.mp hlk, le_trans hbl hlk, hke⟩ · rintro ⟨hlk, _, hke⟩ exact ⟨WithTop.coe_le_coe.mpr hlk, hke⟩ /-- At offset one and reversed, filtering the complete keys at or above the last reported key gives the reversed truncated range's stored keys, reversed. -/ private theorem truncatedRangeRev_filter_eq {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) (hbl : (r.begin.key : WithTop Key) ≤ (last : WithTop Key)) : (RangeRead.completeKeys db r).filter (fun (k : Key) => decide (last ≤ k)) = ((truncatedRangeRev r last).keys db).reverse := by rw [RangeRead.completeKeys]; simp only [hrev, ite_true] rw [inRange_eq_canonical_keys hbegin hend, truncatedRangeRev_keys_eq hbl, List.filter_reverse] /-- For a truncated reversed offset-one read, compatibility is equivalent to fitting the limit and having exactly the reversed truncated range's stored keys: agreement on the range fixes the reported prefix, and nothing past the last reported key can be inferred. -/ theorem compatible_iff_truncated_keys_rev {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = true) (hmore : res.more = true) (hne : res.keys ≠ []) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ (RangeRead.completeKeys db r).filter (fun (k : Key) => decide (res.keys.getLast hne ≤ k)) = res.keys := by have hW : (RangeRead.completeKeys db r).Pairwise (· > ·) := by have h := RangeRead.completeKeys_pairwise (db := db) (r := r) rw [hrev] at h exact h constructor · rintro ⟨hlim, hdisj⟩ rcases hdisj with ⟨_, hpre, _⟩ | ⟨hm, _⟩ · exact ⟨hlim, filter_ge_getLast_eq_of_prefix hW hpre hne⟩ · simp [hmore] at hm · rintro ⟨hlim, heq⟩ exact ⟨hlim, Or.inl ⟨hmore, prefix_of_filter_ge_getLast_eq hW hne heq, hne⟩⟩ /-- At begin offset one and a nonpositive end offset, agreement on `[last, end.key)` fixes the reversed truncated range's stored keys with the largest `(1 - end.offset)` canonical keys removed. The complete keys are the canonical keys with the largest `(1 - end.offset)` removed, reversed (`completeKeys_eq_canonical_slice_rev`); filtering at or above the last reported key then selects the kept suffix, which `filter_ge_take` turns into the truncated range's stored keys with the largest `(1 - end.offset)` keys removed. The begin offset is one, so no canonical key below `begin.key` is dropped and `begin.key ≤ last` makes the result a function of `[last, end.key)`. -/ private theorem completeKeys_filter_ge_eq {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 0) (hbl : (r.begin.key : WithTop Key) ≤ (last : WithTop Key)) : (RangeRead.completeKeys db r).filter (fun k => decide (last ≤ k)) = (((truncatedRangeRev r last).keys db).take (((truncatedRangeRev r last).keys db).length - (1 - r.end_.offset).toNat)).reverse := by have hslice := completeKeys_eq_canonical_slice_rev (db := db) (r := r) hrev (by omega) (by omega) have hb0 : (r.begin.offset - 1).toNat = 0 := by rw [hbegin]; rfl rw [hb0] at hslice have hslice' : RangeRead.completeKeys db r = (((canonicalRange r).keys db).take (((canonicalRange r).keys db).length - (1 - r.end_.offset).toNat)).reverse := by simpa using hslice rw [hslice', List.filter_reverse, truncatedRangeRev_keys_eq hbl] congr 1 exact filter_ge_take ((canonicalRange r).keys db) (ConflictRange.keys_pairwise _ db) last (1 - r.end_.offset).toNat /-- A nonempty complete-keys list forces the begin selector's key to be genuine, not `⊤`, for a reversed read. -/ private theorem begin_key_ne_top_of_completeKeys_ne_nil_rev {db : DB} {r : RangeRead} (hrev : r.reverse = true) (hne : RangeRead.completeKeys db r ≠ []) (hoff : 1 ≤ r.begin.offset) : r.begin.key ≠ (⊤ : WithTop Key) := by intro htop have hresolve : resolve db r.begin = (⊤ : WithTop Key) := resolve_eq_top_of_key_eq_top htop hoff have hnil : RangeRead.completeKeys db r = [] := by rw [RangeRead.completeKeys, ite_eq_left (by simp [hrev])] simp only [RangeRead.inRange, hresolve] rw [List.reverse_eq_nil_iff, List.filter_eq_nil_iff] intro x _ hx exact absurd (of_decide_eq_true hx).1 (not_le.mpr (WithTop.coe_lt_top x)) exact hne hnil /-- **Begin-key necessity for a truncated reversed result.** -/ private theorem necessary_begin_key_rev_more {r : RangeRead} {res : Result} {v : Key} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = true) (hlen : 0 < res.keys.length) (hbegin : 2 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) (hkey : r.begin.key = (↑v : WithTop Key)) : Necessary r res v := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := List.ne_nil_of_length_pos hlen have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp set C : List Key := (canonicalRange r).keys db₀ with hC have hCsort : C.SortedLT := by rw [hC]; exact List.sortedLT_iff_pairwise.mpr (ConflictRange.keys_pairwise _ _) have hCcanon : ∀ x ∈ C, x ∈ canonicalRange r := fun x hx => (ConflictRange.mem_keys_iff.mp (hC ▸ hx)).2 set b : ℕ := (r.begin.offset - 1).toNat with hb set m : ℕ := (1 - r.end_.offset).toNat with hm have hbpos : 1 ≤ b := by rw [hb]; omega set W : List Key := (C.drop b).take (C.length - b - m) with hW have hslice : RangeRead.completeKeys db₀ r = W.reverse := by rw [completeKeys_eq_canonical_slice_rev (db := db₀) (r := r) hrev (by omega) hend, ← hC, ← hb, ← hm, ← hW] have hpre₀' : res.keys <+: RangeRead.completeKeys db₀ r := hpre₀ obtain ⟨t, ht⟩ := hpre₀' have hWrev : W.reverse = res.keys ++ t := by rw [hslice] at ht; exact ht.symm have hWdecomp : W = t.reverse ++ res.keys.reverse := by have h := congrArg List.reverse hWrev simpa [List.reverse_append] using h have hWlen : W.length = C.length - b - m := by rw [hW, List.length_take, List.length_drop] exact Nat.min_eq_left (Nat.sub_le _ _) have hres_le_W : res.keys.length ≤ W.length := by have h := hpre₀.length_le rwa [hslice, List.length_reverse] at h have hClen : b + m + res.keys.length ≤ C.length := by rw [hWlen] at hres_le_W; omega have hdrop : (C.drop b).drop (C.length - b - m) = C.drop (C.length - m) := by rw [List.drop_drop]; congr 1; omega have hsplit : W ++ C.drop (C.length - m) = C.drop b := by rw [hW]; rw [← hdrop]; exact List.take_append_drop _ _ set G : List Key := C.drop (C.length - m) with hG have hGlen : G.length = m := by rw [hG, List.length_drop]; omega have hGs : G.SortedLT := by rw [hG, List.sortedLT_iff_pairwise] exact List.Pairwise.drop (List.sortedLT_iff_pairwise.mp hCsort) have hGcanon : ∀ x ∈ G, x ∈ canonicalRange r := fun x hx => hCcanon x (List.drop_subset _ _ hx) have hCdecomp : C = (C.take b ++ W) ++ G := by calc C = C.take b ++ C.drop b := (List.take_append_drop b C).symm _ = C.take b ++ (W ++ G) := by rw [hsplit] _ = (C.take b ++ W) ++ G := (List.append_assoc _ _ _).symm have hlastW : res.keys.getLast hne ∈ W := by rw [hWdecomp] exact List.mem_append_right _ (List.mem_reverse.mpr (List.getLast_mem hne)) have hWG : ∀ x ∈ W, ∀ y ∈ G, x < y := by have hA : ((C.take b ++ W) ++ G).SortedLT := hCdecomp ▸ hCsort have hcross := (List.sortedLT_append.mp hA).2.2 intro x hx y hy exact hcross x (List.mem_append_right _ hx) y hy have hG_gt_last : ∀ x ∈ G, res.keys.getLast hne < x := fun x hx => hWG _ hlastW x hx have hlast_end : (↑(res.keys.getLast hne) : WithTop Key) < r.end_.key := (ConflictRange.mem_iff.mp (hCcanon (res.keys.getLast hne) (List.drop_subset b C (List.take_subset _ _ (hW ▸ hlastW))))).2 -- chain bound have hresolve_coe : ∃ k : Key, resolve db₀ r.begin = (↑k : WithTop Key) := by rcases resolve_eq_nil_or_eq_top_or_mem (db := db₀) (s := r.begin) with h | h | h · exact ⟨[], h⟩ · exfalso have hnil : RangeRead.completeKeys db₀ r = [] := by rw [RangeRead.completeKeys, ite_eq_left (by simp [hrev])] simp only [RangeRead.inRange, h] rw [List.reverse_eq_nil_iff, List.filter_eq_nil_iff] intro x _ hx exact absurd (of_decide_eq_true hx).1 (not_le.mpr (WithTop.coe_lt_top x)) exact List.IsPrefix.ne_nil hpre₀ hne hnil · obtain ⟨k, _, hk⟩ := h; exact ⟨k, hk⟩ obtain ⟨k, hk⟩ := hresolve_coe have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := List.IsPrefix.subset hpre₀ (List.getLast_mem hne) have hk_le_last : k ≤ res.keys.getLast hne := by have h := (RangeRead.mem_completeKeys.mp hlast_ck).2.1 rw [hk] at h exact WithTop.coe_le_coe.mp h have hchain_b_le_k : chain v b ≤ k := by have h := chain_le_of_resolve (s := r.begin) (k₀ := v) (k := k) hkey (by omega) hk rwa [show (r.begin.offset - 1).toNat = b from hb] at h have hchain_b_le_last : chain v b ≤ res.keys.getLast hne := le_trans hchain_b_le_k hk_le_last have hchain_lt_last : ∀ i < b, chain v i < res.keys.getLast hne := by intro i hi exact lt_of_lt_of_le (chain_lt_mono (b := v) (by omega)) hchain_b_le_last -- Fp set Fp : List Key := (List.range b).map (chain v) with hFp have hFplen : Fp.length = b := by rw [hFp, List.length_map, List.length_range] have hFpsort : Fp.SortedLT := by rw [hFp]; exact sortedLT_map_chain v b have hFp_lt_last : ∀ x ∈ Fp, x < res.keys.getLast hne := by intro x hx rw [hFp, List.mem_map] at hx obtain ⟨i, hi, rfl⟩ := hx exact hchain_lt_last i (List.mem_range.mp hi) have hFp_v : v ∈ Fp := by rw [hFp, List.mem_map] exact ⟨0, List.mem_range.mpr (by omega), chain_zero v⟩ have hFp_canon : ∀ x ∈ Fp, x ∈ canonicalRange r := by intro x hx have hxlt := hFp_lt_last x hx rw [hFp, List.mem_map] at hx obtain ⟨i, _, rfl⟩ := hx exact ⟨le_trans (le_of_eq hkey) (WithTop.coe_le_coe.mpr (chain_le v i)), lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hxlt) (le_of_lt hlast_end)⟩ have hresrev_canon : ∀ y ∈ res.keys.reverse, y ∈ canonicalRange r := by intro y hy have hyW : y ∈ W := by rw [hWdecomp] exact List.mem_append_right _ hy exact hCcanon y (List.drop_subset b C (List.take_subset _ _ (hW ▸ hyW))) have hresrev_sort : res.keys.reverse.SortedLT := (RangeRead.compatible_sortedGT hcomp hrev).reverse have hlast_le : ∀ y ∈ res.keys.reverse, res.keys.getLast hne ≤ y := by intro y hy have hb : y ∈ res.keys := List.mem_reverse.mp hy have hge : res.keys.Pairwise (fun a b => a ≥ b) := (RangeRead.compatible_pairwise hcomp).2 hrev |>.imp (fun h => le_of_lt h) exact hge.rel_getLast hb -- D set D : List Key := Fp ++ res.keys.reverse ++ G with hD have hDcanon : ∀ x ∈ D, x ∈ canonicalRange r := by intro x hx rw [hD, List.mem_append, List.mem_append] at hx rcases hx with (hx | hx) | hx · exact hFp_canon x hx · exact hresrev_canon x hx · exact hGcanon x hx have hDsort : D.SortedLT := by rw [hD] refine List.sortedLT_append.mpr ⟨?_, hGs, ?_⟩ · refine List.sortedLT_append.mpr ⟨hFpsort, hresrev_sort, ?_⟩ intro a ha b hb exact lt_of_lt_of_le (hFp_lt_last a ha) (hlast_le b hb) · intro a ha b hb rw [List.mem_append] at ha rcases ha with ha | ha · exact lt_of_lt_of_le (hFp_lt_last a ha) (le_of_lt (hG_gt_last b hb)) · have haW : a ∈ W := by rw [hWdecomp]; exact List.mem_append_right _ ha exact hWG a haW b hb let dbw : DB := ⟨D, hDsort⟩ have hcanw : (canonicalRange r).keys dbw = D := canonicalRange_keys_eq_self_of_forall (db := dbw) (r := r) hDcanon have hDdrop : D.drop b = res.keys.reverse ++ G := by rw [hD, List.append_assoc, List.drop_left' hFplen] have hDlen : D.length = b + res.keys.length + m := by rw [hD, List.length_append, List.length_append, hFplen, hGlen, List.length_reverse] have hidx : D.length - b - m = res.keys.length := by rw [hDlen]; omega have hckw : RangeRead.completeKeys dbw r = res.keys := by rw [completeKeys_eq_canonical_slice_rev (db := dbw) (r := r) hrev (by omega) hend, hcanw, hDdrop, hidx, List.take_append_of_le_length (by simp), List.take_of_length_le (by simp), List.reverse_reverse] have hcompw : RangeRead.Compatible dbw r res := ⟨hcomp.1, Or.inl ⟨hmore, by rw [hckw], hne⟩⟩ -- erase v have hcan_erase : (canonicalRange r).keys (dbw.erase v) = D.erase v := by have h1 := canonicalRange_keys_eq_self_of_forall (db := dbw.erase v) (r := r) (fun x hx => by rw [DB.erase_keys] at hx exact hDcanon x (List.erase_subset hx)) rwa [DB.erase_keys] at h1 have hDerase : D.erase v = Fp.erase v ++ res.keys.reverse ++ G := by rw [hD, List.erase_append_left G (List.mem_append_left res.keys.reverse hFp_v), List.erase_append_left res.keys.reverse hFp_v] have hFperase_len : (Fp.erase v).length = b - 1 := by rw [List.length_erase_of_mem hFp_v, hFplen] have hnot_erase : ¬ RangeRead.Compatible (dbw.erase v) r res := by intro hc have hpre := RangeRead.compatible_keys_prefix hc have hck_erase : RangeRead.completeKeys (dbw.erase v) r = res.keys.dropLast := by rw [completeKeys_eq_canonical_slice_rev (db := dbw.erase v) (r := r) hrev (by omega) hend, hcan_erase, hDerase] rw [show Fp.erase v ++ res.keys.reverse ++ G = Fp.erase v ++ (res.keys.reverse ++ G) from List.append_assoc _ _ _] have hdrop1 : (Fp.erase v ++ (res.keys.reverse ++ G)).drop b = (res.keys.reverse ++ G).drop 1 := by rw [show b = (b - 1) + 1 by omega, ← List.drop_drop] rw [List.drop_left' hFperase_len] rw [hdrop1] have hidx' : (Fp.erase v ++ (res.keys.reverse ++ G)).length - b - m = res.keys.length - 1 := by rw [List.length_append, List.length_append, hFperase_len, hGlen, List.length_reverse] omega rw [hidx'] have hda : (res.keys.reverse ++ G).drop 1 = res.keys.reverse.drop 1 ++ G := List.drop_append_of_le_length (by rw [List.length_reverse]; exact hlen) rw [hda, List.take_append_of_le_length (by rw [List.length_drop, List.length_reverse]), List.take_of_length_le (by rw [List.length_drop, List.length_reverse]), List.drop_reverse, List.reverse_reverse, List.dropLast_eq_take] rw [hck_erase] at hpre have hle := hpre.length_le rw [List.length_dropLast] at hle omega intro cr hs by_contra hvcr exact hnot_erase ((hs dbw (dbw.erase v) (ConflictRange.keys_erase_of_not_mem cr dbw hvcr).symm).mp hcompw) /-- **The reversed truncated cell at `begin.offset ≥ 2`, `end.offset ≤ 1`.** -/ theorem minimal_canonicalRange_of_end_offset_le_one_rev_more {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : 2 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : Minimal r res (canonicalRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hckne : RangeRead.completeKeys db₀ r ≠ [] := List.IsPrefix.ne_nil (RangeRead.compatible_keys_prefix hcomp) hne have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil_rev hrev hckne (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top refine (minimal_iff_sound_and_necessary).mpr ⟨sound_canonicalRange_of_end_offset_le_one_rev hrev (by omega) hend, ?_⟩ intro k hk have hk' := ConflictRange.mem_iff.mp hk have h1 : r.begin.key ≤ (↑k : WithTop Key) := hk'.1 have hvk : v ≤ k := by rw [hv] at h1 exact WithTop.coe_le_coe.mp h1 have hlast_mem : res.keys.getLast hne ∈ res.keys := List.getLast_mem hne have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ hlast_mem by_cases hkl : k ≤ res.keys.getLast hne · have hv_nec : Necessary r res v := necessary_begin_key_rev_more ⟨db₀, hcomp⟩ hrev hmore (List.length_pos_of_ne_nil hne) hbegin hend hv exact hv_nec.of_between hlast_nec hvk hkl · have hkgt : res.keys.getLast hne < k := lt_of_not_ge hkl by_cases hkh : k ≤ res.keys.head hne · exact necessary_of_between_result ⟨db₀, hcomp⟩ hlast_mem hhead_mem (le_of_lt hkgt) hkh · exact fun cr hs => necessary_head_to_end_key ⟨db₀, hcomp⟩ hrev hne hend cr hs (le_of_lt (lt_of_not_ge hkh)) hk'.2 /-- At begin offset one with a truncated reversed result and a *nonpositive* end offset, the minimal sound conflict range is `[last reported key, end.key)`, the same value as at end offset one. Soundness: agreement on `[last, end.key)` fixes the truncated range's stored keys with the largest `(1 - end.offset)` canonical keys removed (`completeKeys_filter_ge_eq`), hence fixes `filter (completeKeys) (· ≥ last)`, which `compatible_iff_truncated_keys_rev` shows is equivalent to compatibility. Necessity is the same convexity-and-end-side argument as `minimal_truncatedRangeRev_of_offset_one`. -/ theorem minimal_truncatedRangeRev_of_end_offset_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : r.end_.offset ≤ 0) : Minimal r res (truncatedRangeRev r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne) have hbl : (r.begin.key : WithTop Key) ≤ (↑(res.keys.getLast hne) : WithTop Key) := le_trans (key_le_resolve_of_offset_one hbegin) ((RangeRead.mem_completeKeys.mp hlast_ck).2.1) have hf₁ := completeKeys_filter_ge_eq (db := db₁) hrev hbegin hend hbl have hf₂ := completeKeys_filter_ge_eq (db := db₂) hrev hbegin hend hbl rw [compatible_iff_truncated_keys_rev hrev hmore hne, compatible_iff_truncated_keys_rev (db := db₂) hrev hmore hne, hf₁, hf₂, hagree] · intro k hk cr hs have hkend : (k : WithTop Key) < r.end_.key := hk.2 have hklast : res.keys.getLast hne ≤ k := WithTop.coe_le_coe.mp hk.1 by_cases hkhead : k ≤ res.keys.head hne · exact necessary_of_between_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) (List.head_mem hne) hklast hkhead cr hs · have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead) exact necessary_head_to_end_key ⟨db₀, hcomp⟩ hrev hne (by omega) cr hs hheadk hkend /-- At offset one with a truncated reversed result, the minimal sound conflict range is `[last reported key, end.key)`. The reported keys and the end side are necessary, and no key below the last reported key is necessary because the truncated range already pins down the reported prefix. -/ theorem minimal_truncatedRangeRev_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : Minimal r res (truncatedRangeRev r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hlast_mem : res.keys.getLast hne ∈ res.keys := List.getLast_mem hne have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp).subset hlast_mem -- The begin key lies at or below the last reported key, so it bounds the range. have hbl : (r.begin.key : WithTop Key) ≤ (↑(res.keys.getLast hne) : WithTop Key) := le_trans (key_le_resolve_of_offset_one hbegin) ((RangeRead.mem_completeKeys.mp hlast_ck).2.1) refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have hf₁ := truncatedRangeRev_filter_eq (db := db₁) hrev hbegin hend hbl have hf₂ := truncatedRangeRev_filter_eq (db := db₂) hrev hbegin hend hbl rw [compatible_iff_truncated_keys_rev hrev hmore hne, compatible_iff_truncated_keys_rev (db := db₂) hrev hmore hne] rw [hf₁, hf₂, hagree] · intro k hk cr hs have hkend : (k : WithTop Key) < r.end_.key := hk.2 have hklast : res.keys.getLast hne ≤ k := WithTop.coe_le_coe.mp hk.1 by_cases hkhead : k ≤ res.keys.head hne · -- A key between the last and the head is convex between two reported keys. exact necessary_of_between_result ⟨db₀, hcomp⟩ hlast_mem (List.head_mem hne) hklast hkhead cr hs · -- A key at or above the head and below `end_.key` is necessary by the -- reversed head-to-end rule. have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead) exact necessary_head_to_end_key ⟨db₀, hcomp⟩ hrev hne (by omega) cr hs hheadk hkend /-- At offset one with a truncated reversed result, the reversed truncated range is *the* minimal sound conflict range up to set equality. -/ theorem unique_minimal_truncatedRangeRev_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRangeRev_of_offset_one hread hmore hrev hbegin hend) /-- The offset-one algorithm's value. For a truncated result it cuts just past the last reported key on the side the traversal has already left behind: non-reversed it is `[begin.key, keyAfter (last reported key))`, reversed it is `[last reported key, end.key)`. Otherwise it is the canonical range `[begin.key, end.key)`. This is a plain `def` with no proof packed in, so it is computable and `#eval`-able; the correctness certificates are the separate `conflictRangeOffsetOne_spec`, `conflictRangeOffsetOne_spec_truncated`, and `conflictRangeOffsetOne_spec_truncated_rev`, which may reason classically. Keeping the value free of the proof is what makes the algorithm runnable: Lean's noncomputability check taints any term that embeds a choice-using proof, so a subtype-valued definition would be noncomputable as a whole even though the proof component is propositionally irrelevant. The empty fallback in `getLastD` is never used by the certified cases, where the result is nonempty. -/ def conflictRangeOffsetOne (r : RangeRead) (res : Result) : ConflictRange := if res.more = true then if r.reverse = true then truncatedRangeRev r (res.keys.getLastD ([] : Key)) else truncatedRange r (res.keys.getLastD ([] : Key)) else canonicalRange r /-- The offset-one algorithm is correct on a complete result: with `more = false` the reported keys are all the complete keys, so the canonical range `[begin.key, end.key)` is minimal, whatever the traversal order. The proof is allowed to use classical logic — only the value must be choice-free. -/ theorem conflictRangeOffsetOne_spec {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : Minimal r res (conflictRangeOffsetOne r res) := by simp only [conflictRangeOffsetOne, hmore, Bool.false_eq_true, ite_false] exact minimal_canonicalRange_of_offset_one hread hmore hbegin hend /-- The offset-one algorithm is correct on a truncated non-reversed result: with `more = true` only a prefix of the complete keys is reported, so the minimal sound range runs from `begin.key` up to just past the last reported key. -/ theorem conflictRangeOffsetOne_spec_truncated {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : Minimal r res (conflictRangeOffsetOne r res) := by simp only [conflictRangeOffsetOne, hmore, hrev, ite_true, Bool.false_eq_true, ite_false] exact minimal_truncatedRange_of_offset_one hread hmore hrev hbegin hend /-- The offset-one algorithm is correct on a truncated reversed result: with `more = true` only a prefix of the complete keys is reported, so the minimal sound range runs from the last reported key up to `end.key`. -/ theorem conflictRangeOffsetOne_spec_truncated_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : r.end_.offset = 1) : Minimal r res (conflictRangeOffsetOne r res) := by simp only [conflictRangeOffsetOne, hmore, hrev, ite_true] exact minimal_truncatedRangeRev_of_offset_one hread hmore hrev hbegin hend /-! ## The unbounded top at end offsets beyond one At offset one the resolved window cuts a key exactly when the canonical interval does. Beyond offset one the end selector overshoots past the first stored key at or above `end_.key`, so a complete result that never reaches `end_.key` can only be reading a window that ends at the sentinel: every key of the witness database lies below `end_.key`, and then `resolve end_` is `⊤` (`resolve_end_eq_top_of_hhi`). The minimal sound range is the unbounded top `[begin.key, ⊤)`. Soundness holds because agreement on the range fixes the database's keys at or above `begin.key`, which is all the read's window depends on; necessity chains the reported keys, the begin key, convexity, and `necessary_of_end_offset_ge_two` for the keys beyond the reported last. -/ /-- The conflict range from the begin key up to the sentinel `⊤`. -/ def topRange (r : RangeRead) : ConflictRange := ⟨r.begin.key, ⊤⟩ /-- At begin offset one, when the window ends at the sentinel the complete keys are exactly the top range's stored keys: the resolved begin is the first stored key at or above `begin.key`, so restricting the canonical keys to the window changes nothing. -/ private theorem completeKeys_eq_topRange_keys {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hE : resolve db r.end_ = (⊤ : WithTop Key)) : RangeRead.completeKeys db r = (topRange r).keys db := by have hbl := key_le_resolve_of_offset_one (db := db) (s := r.begin) hbegin rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev]), hE] unfold topRange ConflictRange.keys RangeRead.inRange apply List.filter_congr intro k hk rw [decide_eq_decide] constructor · rintro ⟨h1, _⟩ exact ⟨le_trans hbl h1, WithTop.coe_lt_top k⟩ · rintro ⟨h1, _⟩ exact ⟨(key_le_resolve_iff_of_offset_one hbegin hk).mp h1, WithTop.coe_lt_top k⟩ /-- When the window ends at the sentinel, the complete keys are the top range's stored keys dropped by `(begin.offset - 1).toNat`: the begin selector overshoots that many stored keys past the first key at or above `begin.key`. -/ theorem completeKeys_eq_topRange_keys_drop {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hE : resolve db r.end_ = (⊤ : WithTop Key)) : RangeRead.completeKeys db r = ((topRange r).keys db).drop (r.begin.offset - 1).toNat := by set l := db.keys with hl set p := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) with hp set b := (r.begin.offset - 1).toNat with hb have hls : l.SortedLT := by rw [hl]; exact db.sorted have hanchor : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbegin, hp, hb, hl] have hLHS : RangeRead.completeKeys db r = l.drop (p + b) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev]), hE] unfold RangeRead.inRange rw [show l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < (⊤ : WithTop Key))) = l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key))) from List.filter_congr fun k _ => by rw [decide_eq_decide]; exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩] rw [filter_resolve_le_eq_drop (db := db) (s := r.begin), hanchor] have hRHS : (topRange r).keys db = l.drop p := by unfold topRange ConflictRange.keys rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < (⊤ : WithTop Key))) = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) from List.filter_congr fun k _ => by rw [decide_eq_decide]; exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩] rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) = l.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < r.begin.key))) from List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt]] rw [filter_not_lt_eq_drop_countP hls r.begin.key, hp] rw [hLHS, hRHS, List.drop_drop] /-- When the window ends at the sentinel, the *reversed* complete keys are the reversal of the top range's stored keys dropped by `(begin.offset - 1).toNat`: the begin selector overshoots that many stored keys past the first key at or above `begin.key`, and reversal only reorders the window. This is the reversal companion of `completeKeys_eq_topRange_keys_drop`. -/ private theorem completeKeys_eq_topRange_keys_drop_rev {db : DB} {r : RangeRead} (hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset) (hE : resolve db r.end_ = (⊤ : WithTop Key)) : RangeRead.completeKeys db r = (((topRange r).keys db).drop (r.begin.offset - 1).toNat).reverse := by set l := db.keys with hl set p := l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) with hp set b := (r.begin.offset - 1).toNat with hb have hls : l.SortedLT := by rw [hl]; exact db.sorted have hanchor : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbegin, hp, hb, hl] have hLHS : RangeRead.completeKeys db r = (l.drop (p + b)).reverse := by rw [RangeRead.completeKeys, ite_eq_left (by simp [hrev]), hE] unfold RangeRead.inRange rw [show l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < (⊤ : WithTop Key))) = l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key))) from List.filter_congr fun k _ => by rw [decide_eq_decide]; exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩] rw [filter_resolve_le_eq_drop (db := db) (s := r.begin), hanchor] have hRHS : (topRange r).keys db = l.drop p := by unfold topRange ConflictRange.keys rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < (⊤ : WithTop Key))) = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) from List.filter_congr fun k _ => by rw [decide_eq_decide]; exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩] rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) = l.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < r.begin.key))) from List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt]] rw [filter_not_lt_eq_drop_countP hls r.begin.key, hp] rw [hLHS, hRHS, List.drop_drop] /-- At begin offset one and end offset at least two, a complete non-reversed result whose reported keys all lie below `end_.key` has the unbounded top `[begin.key, ⊤)` as its minimal sound conflict range. The overshoot forces the witness window to end at the sentinel, and then compatibility depends only on the keys at or above `begin.key`; the begin key, the reported keys, and everything convexly between them are necessary, as is every key at or above the reported last by `necessary_of_end_offset_ge_two`. -/ theorem minimal_topRange_of_end_offset_ge_two {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq -- The begin key is strictly below `end_.key`, witnessed by any reported key. have hbegk_end : r.begin.key < r.end_.key := by obtain ⟨k₀, hk₀⟩ := List.exists_mem_of_ne_nil _ hne have h1 : r.begin.key ≤ resolve db₀ r.begin := key_le_resolve_of_offset_one hbegin have h2 : resolve db₀ r.begin ≤ (k₀ : WithTop Key) := by have : k₀ ∈ RangeRead.completeKeys db₀ r := hres₀ ▸ hk₀ exact (RangeRead.mem_completeKeys.mp this).2.1 exact lt_of_le_of_lt (le_trans h1 h2) (hhi k₀ hk₀) refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · -- Agreement on the top range fixes the keys the read's window can observe. intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (topRange r) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq -- A compatible witness has every key below `end_.key`, so its window ends -- at the sentinel. have hmaxm : ∀ k ∈ RangeRead.completeKeys db r, k ≤ res.keys.getLast hne := by intro k hk rw [← hres] at hk exact ((RangeRead.compatible_sortedLT hcomp_db hrev).pairwise.imp le_of_lt).rel_getLast hk have hE : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hcomp_db hend hhi (res.keys.getLast hne) (List.getLast_mem hne) hmaxm have hck : RangeRead.completeKeys db r = (topRange r).keys db := completeKeys_eq_topRange_keys hrev hbegin hE have hS : (topRange r).keys db = res.keys := by rw [← hck, hres] have hall : ∀ k ∈ db.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hbk : r.begin.key ≤ (k : WithTop Key) · exact hhi k (hS ▸ ConflictRange.mem_keys_iff.mpr ⟨hk, hbk, WithTop.coe_lt_top k⟩) · exact lt_of_lt_of_le (lt_of_not_ge hbk) (le_of_lt hbegk_end) -- The agreeing database shares those keys, so it also overshoots. have hall' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hbk : r.begin.key ≤ (k : WithTop Key) · have hkmem : k ∈ (topRange r).keys db' := ConflictRange.mem_keys_iff.mpr ⟨hk, hbk, WithTop.coe_lt_top k⟩ rw [← hag'] at hkmem rw [hS] at hkmem exact hhi k hkmem · exact lt_of_lt_of_le (lt_of_not_ge hbk) (le_of_lt hbegk_end) have hE' : resolve db' r.end_ = (⊤ : WithTop Key) := by have hcnt : db'.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) = db'.keys.length := List.countP_eq_length.mpr fun k hk => by rw [decide_eq_true_eq]; exact hall' k hk have hann : r.end_.anchor db' = (db'.keys.length : Int) + r.end_.offset - 1 := by unfold Selector.anchor rw [hcnt] refine resolve_eq_top ?_ ?_ · rw [hann]; omega · have htoNat : (r.end_.anchor db').toNat = db'.keys.length + (r.end_.offset - 1).toNat := by rw [hann, show ((db'.keys.length : Int) + r.end_.offset - 1) = ((db'.keys.length : Int) + (r.end_.offset - 1)) by ring, Int.toNat_add (Int.natCast_nonneg _) (by omega), Int.toNat_natCast] rw [htoNat] omega have hck' : RangeRead.completeKeys db' r = (topRange r).keys db' := completeKeys_eq_topRange_keys hrev hbegin hE' refine ⟨hlim, Or.inr ⟨hmore, ?_⟩⟩ rw [hck', ← hag', hS] exact ⟨fun h => step db₁ db₂ hagree h, fun h => step db₂ db₁ hagree.symm h⟩ · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkle : k ≤ res.keys.getLast hne · -- Between the begin key and the reported last: the begin key's necessity -- and convexity supply the gap. have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil (db := db₀) hrev (by rw [← hres₀]; exact hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs · -- At or above the reported last: the end-overrun rule applies. exact necessary_of_end_offset_ge_two ⟨db₀, hcomp⟩ hrev hmore hne hend hhi (le_of_lt (lt_of_not_ge hkle)) cr hs /-- **The overshoot top range, general positive begin offset.** A complete non-reversed result whose reported keys all lie below `end_.key` and whose end offset is at least two has the unbounded top `[begin.key, ⊤)` as its minimal sound conflict range, for any `begin.offset ≥ 1`. The resolved begin is `(begin.offset - 1)` stored keys past the first key at or above `begin.key`, so the complete keys are the top range's keys with that many dropped; agreement on the top range therefore fixes them (both databases overshoot, so both drops are the same reported keys), and the begin key, the reported keys, and every key above the reported last are necessary. -/ theorem minimal_topRange_of_end_offset_ge_two_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev -- The begin key is strictly below `end_.key`, witnessed by any reported key. have hbegk_end : r.begin.key < r.end_.key := by obtain ⟨k₀, hk₀⟩ := List.exists_mem_of_ne_nil _ hne have h1 : r.begin.key ≤ resolve db₀ r.begin := key_le_resolve_of_one_le hbegin have h2 : resolve db₀ r.begin ≤ (k₀ : WithTop Key) := by have : k₀ ∈ RangeRead.completeKeys db₀ r := hres₀ ▸ hk₀ exact (RangeRead.mem_completeKeys.mp this).2.1 exact lt_of_le_of_lt (le_trans h1 h2) (hhi k₀ hk₀) refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (topRange r) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hmaxm : ∀ k ∈ RangeRead.completeKeys db r, k ≤ res.keys.getLast hne := by intro k hk rw [← hres] at hk exact ((RangeRead.compatible_sortedLT hcomp_db hrev).pairwise.imp le_of_lt).rel_getLast hk have hE : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hcomp_db hend hhi (res.keys.getLast hne) (List.getLast_mem hne) hmaxm have hck : RangeRead.completeKeys db r = ((topRange r).keys db).drop (r.begin.offset - 1).toNat := completeKeys_eq_topRange_keys_drop hrev hbegin hE have hdrop : ((topRange r).keys db).drop (r.begin.offset - 1).toNat = res.keys := by rw [← hck, ← hres] have hdrop' : ((topRange r).keys db').drop (r.begin.offset - 1).toNat = res.keys := by rw [← hag', hdrop] have hpk : ((topRange r).keys db).Pairwise (· < ·) := ConflictRange.keys_pairwise _ _ have hpk' : ((topRange r).keys db').Pairwise (· < ·) := ConflictRange.keys_pairwise _ _ have hall : ∀ k ∈ db.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hbk : r.begin.key ≤ (k : WithTop Key) · have hkmem : k ∈ (topRange r).keys db := ConflictRange.mem_keys_iff.mpr ⟨hk, hbk, WithTop.coe_lt_top k⟩ have hle' : k ≤ res.keys.getLast hne := forall_le_of_drop_eq (List.sortedLT_iff_pairwise.mpr hpk) hdrop hne (fun y hy => (hsort.pairwise.imp le_of_lt).rel_getLast hy) k hkmem exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle') (hhi _ (List.getLast_mem hne)) · exact lt_of_lt_of_le (lt_of_not_ge hbk) (le_of_lt hbegk_end) have hall' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hbk : r.begin.key ≤ (k : WithTop Key) · have hkmem : k ∈ (topRange r).keys db' := ConflictRange.mem_keys_iff.mpr ⟨hk, hbk, WithTop.coe_lt_top k⟩ have hle' : k ≤ res.keys.getLast hne := forall_le_of_drop_eq (List.sortedLT_iff_pairwise.mpr hpk') hdrop' hne (fun y hy => (hsort.pairwise.imp le_of_lt).rel_getLast hy) k hkmem exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle') (hhi _ (List.getLast_mem hne)) · exact lt_of_lt_of_le (lt_of_not_ge hbk) (le_of_lt hbegk_end) have hE' : resolve db' r.end_ = (⊤ : WithTop Key) := by have hcnt : db'.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) = db'.keys.length := List.countP_eq_length.mpr fun k hk => by rw [decide_eq_true_eq]; exact hall' k hk have hann : r.end_.anchor db' = (db'.keys.length : Int) + r.end_.offset - 1 := by unfold Selector.anchor rw [hcnt] refine resolve_eq_top ?_ ?_ · rw [hann]; omega · have htoNat : (r.end_.anchor db').toNat = db'.keys.length + (r.end_.offset - 1).toNat := by rw [hann, show ((db'.keys.length : Int) + r.end_.offset - 1) = ((db'.keys.length : Int) + (r.end_.offset - 1)) by ring, Int.toNat_add (Int.natCast_nonneg _) (by omega), Int.toNat_natCast] rw [htoNat] omega have hck' : RangeRead.completeKeys db' r = ((topRange r).keys db').drop (r.begin.offset - 1).toNat := completeKeys_eq_topRange_keys_drop hrev hbegin hE' refine ⟨hlim, Or.inr ⟨hmore, ?_⟩⟩ exact (hck'.trans hdrop').symm exact ⟨fun h => step db₁ db₂ hagree h, fun h => step db₂ db₁ hagree.symm h⟩ · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkle : k ≤ res.keys.getLast hne · have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil (db := db₀) hrev (by rw [← hres₀]; exact hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs · exact necessary_of_end_offset_ge_two ⟨db₀, hcomp⟩ hrev hmore hne hend hhi (le_of_lt (lt_of_not_ge hkle)) cr hs /-- At begin offset one and end offset at least two, the unbounded top range is *the* minimal sound conflict range up to set equality: it is minimal by `minimal_topRange_of_end_offset_ge_two`, and every minimal range denotes the same set by the unconditional `Minimal.toSet_eq`. -/ theorem unique_minimal_topRange_of_end_offset_ge_two {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topRange_of_end_offset_ge_two hread hmore hrev hne hbegin hend hhi) /-- At begin offset one and end offset at least two, a complete reversed result whose reported keys all lie below `end_.key` has the same unbounded top `[begin.key, ⊤)` as the non-reversed case: reversal only reorders the reported keys, so flipping to the forward read and applying `minimal_topRange_of_end_offset_ge_two` gives the result. -/ theorem minimal_topRange_of_end_offset_ge_two_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hflip : Readable {r with reverse := false} {keys := res.keys.reverse, more := false} := ⟨db₀, (compatible_flip (db := db₀) (b := true) hrev hmore).mpr hcomp⟩ exact (minimal_flip (b := true) hrev hmore).mp (minimal_topRange_of_end_offset_ge_two (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) hflip rfl rfl (by simpa using hne) hbegin hend (by simpa using hhi)) /-- **The overshoot top range, general positive begin offset, reversed.** The reversal-symmetric twin of `minimal_topRange_of_end_offset_ge_two_general`, obtained by flipping the traversal with `minimal_flip`. -/ theorem minimal_topRange_of_end_offset_ge_two_rev_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hflip : Readable {r with reverse := false} {keys := res.keys.reverse, more := false} := ⟨db₀, (compatible_flip (db := db₀) (b := true) hrev hmore).mpr hcomp⟩ exact (minimal_flip (b := true) hrev hmore).mp (minimal_topRange_of_end_offset_ge_two_general (r := {r with reverse := false}) (res := {keys := res.keys.reverse, more := false}) hflip rfl rfl (by simpa using hne) hbegin hend (by simpa using hhi)) /-- **The overshoot top range, general positive begin offset, unique.** The unbounded top `[begin.key, ⊤)` is *the* minimal sound conflict range up to set equality, by `minimal_topRange_of_end_offset_ge_two_general` and `Minimal.toSet_eq`. -/ theorem unique_minimal_topRange_of_end_offset_ge_two_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topRange_of_end_offset_ge_two_general hread hmore hrev hne hbegin hend hhi) /-- **The overshoot top range, general positive begin offset, reversed, unique.** The reversal-symmetric twin of `unique_minimal_topRange_of_end_offset_ge_two_general`. -/ theorem unique_minimal_topRange_of_end_offset_ge_two_rev_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topRange_of_end_offset_ge_two_rev_general hread hmore hrev hne hbegin hend hhi) /-- At begin offset one and end offset at least two, the unbounded top range is *the* minimal sound conflict range up to set equality for a complete reversed result as well. -/ theorem unique_minimal_topRange_of_end_offset_ge_two_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topRange_of_end_offset_ge_two_rev hread hmore hrev hne hbegin hend hhi) /-- At begin offset one and a positive end offset, a truncated non-reversed result whose reported keys all lie below `end_.key` is compatible exactly when it fits the limit and equals the truncated range's stored keys. The overshoot hypothesis keeps the successor of the last reported key below `resolve end_`, so the truncated range coincides with the complete keys up to the reported last. -/ private theorem compatible_iff_truncatedRange_keys {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hend : 1 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ (truncatedRange r (res.keys.getLast hne)).keys db = res.keys := by have hka : (keyAfter (res.keys.getLast hne) : WithTop Key) ≤ resolve db r.end_ := keyAfter_le_of_lt (lt_of_lt_of_le (hhi _ (List.getLast_mem hne)) (key_le_resolve_of_one_le hend)) rw [compatible_iff_truncated_keys hrev hmore hne, truncatedRange_keys_eq_of_resolve hrev hbegin hka] /-- At begin offset one and end offset at least two, a truncated non-reversed result whose reported keys all lie below `end_.key` has the truncated range `[begin.key, keyAfter (last reported key))` as its minimal sound conflict range, just as at offset one. The overshoot hypothesis is what keeps this sound: it forces `resolve end_` above the successor of the last reported key, so keys beyond the reported last cannot creep into the window. -/ theorem minimal_truncatedRange_of_end_offset_ge_two {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree rw [compatible_iff_truncatedRange_keys (db := db₁) hrev hmore hne hbegin (by omega) hhi, compatible_iff_truncatedRange_keys (db := db₂) hrev hmore hne hbegin (by omega) hhi, hagree] · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- At begin offset one and end offset at least two, the truncated range is *the* minimal sound conflict range up to set equality for a truncated non-reversed result. -/ theorem unique_minimal_truncatedRange_of_end_offset_ge_two {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRange_of_end_offset_ge_two hread hmore hrev hbegin hend hhi) /-- Dropping a prefix before filtering by a downward-closed predicate is the same as filtering first: for a strictly increasing list, `(l.drop m).filter (· ≤ t)` is `(l.filter (· ≤ t)).drop m`. -/ private theorem filter_le_drop_eq {l : List Key} (hs : l.SortedLT) (t : Key) (m : Nat) : (l.drop m).filter (fun k => decide (k ≤ t)) = (l.filter (fun k => decide (k ≤ t))).drop m := by induction l generalizing m with | nil => simp | cons a rest ih => have hs' : rest.SortedLT := List.sortedLT_iff_pairwise.mpr (List.pairwise_cons.mp hs.pairwise).2 rcases m with _ | m · rfl · simp only [List.drop_succ_cons] by_cases ha : a ≤ t · rw [List.filter_cons_of_pos (by simpa using ha)] exact ih hs' m · have hrest : ∀ k ∈ rest, ¬ (k ≤ t) := by intro k hk hklt exact ha (le_trans (le_of_lt ((List.pairwise_cons.mp hs.pairwise).1 k hk)) hklt) have hfilnil : List.filter (fun k => decide (k ≤ t)) rest = [] := List.filter_eq_nil_iff.mpr (fun k hk => by simpa using hrest k hk) rw [List.filter_cons_of_neg (by simpa using ha), hfilnil, List.drop_nil] rw [List.filter_eq_nil_iff] intro k hk exact fun hc => hrest k (List.mem_of_mem_drop hk) (of_decide_eq_true hc) /-- **Count bound from an overshooting resolved end.** If the reported `last` lies strictly below `resolve end_`, then at most `(end_.offset - 1).toNat` stored keys lie in `[end_.key, last]`. At positive end offset the resolution is the `(end_.offset - 1)`-th stored key at or above `end_.key` (`resolve_eq_filter_getElem?`), so fewer than `end_.offset` such keys can be at or below `last`. -/ theorem filter_length_le_offset_of_resolve_end_gt {db : DB} {r : RangeRead} {last : Key} (hend : 1 ≤ r.end_.offset) (hlr : (last : WithTop Key) < resolve db r.end_) : ((db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by set L := db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hL set M := L.filter (fun k : Key => decide (k ≤ last)) with hM set c := (r.end_.offset - 1).toNat with hc have hLs : L.SortedLT := by rw [hL] exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) have hMlen : M.length = L.countP (fun k : Key => decide (k < keyAfter last)) := by rw [hM, ← List.countP_eq_length_filter] apply List.countP_congr intro k _ simp [lt_keyAfter_iff] have hiff : ∀ (i : Nat) (hi : i < L.length), (L[i] < keyAfter last ↔ i < M.length) := by intro i hi rw [hMlen] exact ⟨lt_countP_of_getElem_lt hLs hi, getElem_lt_of_lt_countP hLs hi⟩ have hres := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend rw [hres] at hlr by_cases hcL : c < L.length · rw [List.getElem?_eq_getElem hcL] at hlr have hlt : last < L[c] := WithTop.coe_lt_coe.mp hlr have hnlt : ¬ L[c] < keyAfter last := by rw [lt_keyAfter_iff] exact not_le.mpr hlt have hnc : ¬ c < M.length := fun hcm => hnlt ((hiff c hcL).mpr hcm) have hMc : M.length ≤ c := not_lt.mp hnc simpa [hM, hL, hc] using hMc · have hle : M.length ≤ L.length := by rw [hM] exact List.length_filter_le .. have hMc : M.length ≤ c := le_trans hle (le_of_not_gt hcL) simpa [hM, hL, hc] using hMc /-- **Overshooting resolved end from a count bound.** If at most `(end_.offset - 1).toNat` stored keys lie in `[end_.key, last]`, then `last` lies strictly below `resolve end_`. This is the converse of `filter_length_le_offset_of_resolve_end_gt`: the resolution is the `(end_.offset - 1)`-th key at or above `end_.key`, so a short interval below `last` cannot reach it. -/ theorem resolve_end_gt_of_filter_length_le {db : DB} {r : RangeRead} {last : Key} (hend : 1 ≤ r.end_.offset) (hcnt : ((db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat) : (last : WithTop Key) < resolve db r.end_ := by set L := db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hL set M := L.filter (fun k : Key => decide (k ≤ last)) with hM set c := (r.end_.offset - 1).toNat with hc have hLs : L.SortedLT := by rw [hL] exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) have hMlen : M.length = L.countP (fun k : Key => decide (k < keyAfter last)) := by rw [hM, ← List.countP_eq_length_filter] apply List.countP_congr intro k _ simp [lt_keyAfter_iff] have hiff : ∀ (i : Nat) (hi : i < L.length), (L[i] < keyAfter last ↔ i < M.length) := by intro i hi rw [hMlen] exact ⟨lt_countP_of_getElem_lt hLs hi, getElem_lt_of_lt_countP hLs hi⟩ have hcnt' : M.length ≤ c := by simpa [hM, hL, hc] using hcnt have hres := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend rw [hres] by_cases hcL : c < L.length · rw [List.getElem?_eq_getElem hcL] have hnot : ¬ L[c] < keyAfter last := by intro hlt have hcm : c < M.length := (hiff c hcL).mp hlt omega have hlt : last < L[c] := by rw [lt_keyAfter_iff] at hnot exact not_le.mp hnot exact WithTop.coe_lt_coe.mpr hlt · rw [List.getElem?_eq_none (le_of_not_gt hcL)] exact WithTop.coe_lt_top last /-- Monotonicity of `countP` under a pointwise implication. -/ theorem countP_le_countP_of_imp {l : List Key} {p q : Key → Bool} (h : ∀ k ∈ l, p k = true → q k = true) : l.countP p ≤ l.countP q := by induction l with | nil => simp | cons a rest ih => have h' : ∀ k ∈ rest, p k = true → q k = true := fun k hk => h k (by simp [hk]) by_cases hp : p a = true · rw [List.countP_cons_of_pos hp] have hq : q a = true := h a (by simp) hp rw [List.countP_cons_of_pos hq] exact Nat.succ_le_succ (ih h') · rw [List.countP_cons_of_neg hp] have hqle : rest.countP q ≤ (a :: rest).countP q := by by_cases hq : q a = true · rw [List.countP_cons_of_pos hq]; omega · rw [List.countP_cons_of_neg hq] exact le_trans (ih h') hqle /-- **The end-count bound at any begin offset and either traversal.** The number of complete keys at or above `end_.key` is at most `(end_.offset - 1).toNat`. The end resolution is the `end_.offset`-th stored key at or above `end_.key`, so the window contains at most the first `(end_.offset - 1)` such keys; a higher begin resolution only removes more of them. Unlike `completeKeys_count_ge_le_general`, no hypothesis on the begin selector or the traversal order is needed. -/ theorem completeKeys_count_ge_le_end_offset {db : DB} {r : RangeRead} (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by set l := db.keys with hl set Q := l.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hQ set e := (r.end_.offset - 1).toNat with he have hQs : Q.SortedLT := by rw [hQ] exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) have hperm := RangeRead.completeKeys_perm_inRange db r have hcount : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := hperm.countP_eq _ rw [hcount] have hcnt : (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_))).length := by rw [RangeRead.inRange, List.countP_filter] rw [← List.countP_eq_length_filter] rw [hQ] rw [List.countP_filter] apply countP_le_countP_of_imp intro k _ hp simp only [Bool.and_eq_true] at hp ⊢ exact ⟨decide_eq_true (of_decide_eq_true hp.2).2, hp.1⟩ have hQle : (Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_))).length ≤ e := by have hres := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend rw [← hl, ← hQ] at hres by_cases hQe : e < Q.length · rw [List.getElem?_eq_getElem hQe] at hres rw [hres] have htake : Q.filter (fun k : Key => decide ((k : WithTop Key) < (↑(Q[e]) : WithTop Key))) = Q.take e := by rw [filter_lt_eq_take_countP hQs (↑(Q[e]) : WithTop Key)] congr 1 rw [show Q.countP (fun (k : Key) => decide ((k : WithTop Key) < (↑(Q[e]) : WithTop Key))) = Q.countP (fun k : Key => decide (k < Q[e])) from by apply List.countP_congr intro k _ rw [decide_eq_true_eq, decide_eq_true_eq, WithTop.coe_lt_coe]] exact countP_lt_eq_of_getElem hQs hQe rfl rw [htake, List.length_take, Nat.min_eq_left (le_of_lt hQe)] · rw [List.getElem?_eq_none (le_of_not_gt hQe)] at hres rw [hres] have hall : Q.filter (fun k : Key => decide ((k : WithTop Key) < (⊤ : WithTop Key))) = Q := by rw [List.filter_eq_self] intro k _ simp rw [hall] exact le_of_not_gt hQe exact le_trans hcnt hQle /-- The number of *reported* keys at or above `end_.key` is at most `(end_.offset - 1).toNat`, for a truncated result and any read whose end offset is positive. -/ theorem reported_count_ge_le_end_offset {r : RangeRead} {res : Result} (hread : Readable r res) (_hmore : res.more = true) (_hne : res.keys ≠ []) (hend : 1 ≤ r.end_.offset) : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by obtain ⟨db, hcomp⟩ := hread have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp exact le_trans (List.Sublist.countP_le hpre.sublist) (completeKeys_count_ge_le_end_offset (db := db) (r := r) hend) /-- Agreement on the truncated range fixes the stored keys in `[end_.key, last]`, because `begin.key ≤ end_.key` puts that interval inside `[begin.key, last]`. -/ private theorem filter_end_ge_le_eq_of_agree {db₁ db₂ : DB} {r : RangeRead} {last : Key} (hcross : r.begin.key ≤ r.end_.key) (hagree : AgreeOn (truncatedRange r last) db₁ db₂) : (db₁.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) = (db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) := by have hT : (truncatedRange r last).keys db₁ = (truncatedRange r last).keys db₂ := hagree have hkeys_of : ∀ (dbA dbB : DB), (truncatedRange r last).keys dbA = (truncatedRange r last).keys dbB → ∀ {k : Key}, r.end_.key ≤ (k : WithTop Key) → k ≤ last → (k ∈ dbA.keys ↔ k ∈ dbB.keys) := by intro dbA dbB hTAB k hEk hkle have hmemT : ∀ (db : DB), k ∈ db.keys → k ∈ (truncatedRange r last).keys db := by intro db hk rw [ConflictRange.mem_keys_iff] exact ⟨hk, ConflictRange.mem_iff.mpr ⟨le_trans hcross hEk, WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k last).mpr hkle)⟩⟩ constructor · intro hk have h1 : k ∈ (truncatedRange r last).keys dbA := hmemT dbA hk have h2 : k ∈ (truncatedRange r last).keys dbB := hTAB ▸ h1 exact (ConflictRange.mem_keys_iff.mp h2).1 · intro hk have h1 : k ∈ (truncatedRange r last).keys dbB := hmemT dbB hk have h2 : k ∈ (truncatedRange r last).keys dbA := hTAB.symm ▸ h1 exact (ConflictRange.mem_keys_iff.mp h2).1 apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr ((db₁.sorted.pairwise.filter _).filter _) · exact List.sortedLT_iff_pairwise.mpr ((db₂.sorted.pairwise.filter _).filter _) · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨⟨hk₁, hEk⟩, hkle⟩ exact ⟨⟨(hkeys_of db₁ db₂ hT hEk hkle).mp hk₁, hEk⟩, hkle⟩ · rintro ⟨⟨hk₂, hEk⟩, hkle⟩ exact ⟨⟨(hkeys_of db₁ db₂ hT hEk hkle).mpr hk₂, hEk⟩, hkle⟩ /-- **The resolved end overshoots exactly when agreement does.** With `begin.key ≤ end_.key`, agreement on the truncated range fixes the count of stored keys in `[end_.key, last]`, so the condition `last < resolve end_` holds for one database exactly when it holds for the other. -/ private theorem lt_resolve_end_iff_of_agree {db₁ db₂ : DB} {r : RangeRead} {last : Key} (hend : 1 ≤ r.end_.offset) (hcross : r.begin.key ≤ r.end_.key) (hagree : AgreeOn (truncatedRange r last) db₁ db₂) : ((last : WithTop Key) < resolve db₁ r.end_) ↔ ((last : WithTop Key) < resolve db₂ r.end_) := by have heq := filter_end_ge_le_eq_of_agree (r := r) (last := last) hcross hagree constructor · intro h1 have hc1 := filter_length_le_offset_of_resolve_end_gt (db := db₁) hend h1 have hc2 : ((db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by rw [← heq] exact hc1 exact resolve_end_gt_of_filter_length_le (db := db₂) hend hc2 · intro h2 have hc2 := filter_length_le_offset_of_resolve_end_gt (db := db₂) hend h2 have hc1 : ((db₁.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by rw [heq] exact hc2 exact resolve_end_gt_of_filter_length_le (db := db₁) hend hc1 /-- **The truncated window at a general positive begin offset.** For a non-reversed read with `begin.offset ≥ 1` and a reported `last` below `end_.key`, filtering the complete keys at or below `last` is the truncated range's stored keys with the first `(begin.offset - 1).toNat` dropped. The begin selector skips that many stored keys at or above `begin.key`, so `completeKeys` is the stored keys at or above `begin.key` dropped by that count (`filter_ge_...`), and `last < end_.key` puts `last` below `resolve end_` (`key_le_resolve_of_one_le`), so the upper window cut is inactive on the keys at or below `last`. -/ theorem completeKeys_filter_le_drop {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hlr : (last : WithTop Key) < resolve db r.end_) : (RangeRead.completeKeys db r).filter (fun k => decide (k ≤ last)) = ((truncatedRange r last).keys db).drop (r.begin.offset - 1).toNat := by set l := db.keys with hl set p := l.countP (fun k => decide ((k : Key) < r.begin.key)) with hp set b := (r.begin.offset - 1).toNat with hb have hls : l.SortedLT := by rw [hl]; exact db.sorted have hA : l.filter (fun (k : Key) => decide (r.begin.key ≤ (k : WithTop Key))) = l.drop p := by have hcongr : l.filter (fun (k : Key) => decide (r.begin.key ≤ (k : WithTop Key))) = l.filter (fun (k : Key) => decide (¬ ((k : Key) : WithTop Key) < r.begin.key)) := List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt] rw [hcongr, filter_not_lt_eq_drop_countP hls r.begin.key, hp] have hR : l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (k : WithTop Key))) = l.drop (p + b) := by rw [filter_resolve_le_eq_drop (db := db) (s := r.begin), anchor_toNat_eq (s := r.begin) hbegin, ← hp, ← hb] have hC : (truncatedRange r last).keys db = (l.drop p).filter (fun k => decide (k ≤ last)) := by unfold truncatedRange ConflictRange.keys rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < (keyAfter last : Key))) = l.filter (fun (k : Key) => decide ((k : WithTop Key) < (keyAfter last : Key)) && decide (r.begin.key ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, show (fun (k : Key) => decide ((k : WithTop Key) < (keyAfter last : Key))) = (fun (k : Key) => decide (k ≤ last)) from funext fun k => by rw [decide_eq_decide, WithTop.coe_lt_coe]; exact lt_keyAfter_iff k last] have hck : RangeRead.completeKeys db r = (l.drop (p + b)).filter (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] unfold RangeRead.inRange rw [show l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hR] calc (RangeRead.completeKeys db r).filter (fun k => decide (k ≤ last)) = ((l.drop (p + b)).filter (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_))).filter (fun k => decide (k ≤ last)) := by rw [hck] _ = (l.drop (p + b)).filter (fun (k : Key) => decide (k ≤ last) && decide ((k : WithTop Key) < resolve db r.end_)) := by rw [List.filter_filter] _ = (l.drop (p + b)).filter (fun k => decide (k ≤ last)) := by apply List.filter_congr intro k _ by_cases hle : k ≤ last · rw [decide_eq_true hle, decide_eq_true (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlr)] rfl · rw [decide_eq_false hle, Bool.false_and] _ = ((l.drop p).filter (fun k => decide (k ≤ last))).drop b := by rw [show l.drop (p + b) = (l.drop p).drop b from (List.drop_drop (i := b) (j := p)).symm] exact filter_le_drop_eq (by rw [List.sortedLT_iff_pairwise] exact List.Pairwise.drop (i := p) (List.sortedLT_iff_pairwise.mp hls)) last b _ = ((truncatedRange r last).keys db).drop b := by rw [hC] /-- **The truncated forward value at a general positive begin offset.** A truncated non-reversed result whose reported keys all lie below `end_.key` is compatible exactly when it fits the limit and its keys are the truncated range's stored keys with the begin selector's skipped prefix dropped. The overshoot hypothesis keeps every reported key below `resolve end_`, and the begin selector at offset `1 + b` skips the first `b` stored keys at or above `begin.key`; agreement on the truncated range fixes the rest. -/ private theorem compatible_iff_truncatedRange_keys_general {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ ((truncatedRange r (res.keys.getLast hne)).keys db).drop (r.begin.offset - 1).toNat = res.keys := by rw [compatible_iff_truncated_keys hrev hmore hne, completeKeys_filter_le_drop (db := db) hrev hbegin (lt_of_lt_of_le (hhi _ (List.getLast_mem hne)) (key_le_resolve_of_one_le hend))] /-- **The truncated forward overshoot range, general positive begin offset.** A truncated non-reversed result whose reported keys all lie below `end_.key` has the truncated range `[begin.key, keyAfter (last reported key))` as its minimal sound conflict range, for any `begin.offset ≥ 1` and `end.offset ≥ 2`. At begin offset one this is `minimal_truncatedRange_of_end_offset_ge_two`; at higher offsets the begin selector skips the first `(begin.offset - 1).toNat` stored keys at or above `begin.key`, but those keys lie between `begin.key` and the reported last and so are necessary by convexity, while agreement on the truncated range still fixes `completeKeys` up to the reported last (`compatible_iff_truncatedRange_keys_general`). -/ theorem minimal_truncatedRange_of_end_offset_ge_two_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree rw [compatible_iff_truncatedRange_keys_general (db := db₁) hrev hmore hne hbegin (by omega) hhi, compatible_iff_truncatedRange_keys_general (db := db₂) hrev hmore hne hbegin (by omega) hhi, hagree] · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- At a general positive begin offset and end offset at least two, the truncated range is *the* minimal sound conflict range up to set equality for a truncated non-reversed result. -/ theorem unique_minimal_truncatedRange_of_end_offset_ge_two_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRange_of_end_offset_ge_two_general hread hmore hrev hbegin hend hhi) /-- **The truncated forward `end.offset = 1` cell at a general positive begin offset.** A truncated non-reversed result with `1 ≤ begin.offset` and `end_.offset = 1` has the truncated range `[begin.key, keyAfter (last reported key))` as its minimal sound conflict range. The end offset one puts the window end at the first stored key at or above `end_.key`, so the reported last lies strictly below `end_.key` (else `resolve end_` would not exceed it), and `keyAfter last ≤ resolve end_` follows; agreement on the truncated range then fixes the complete keys up to the reported last (`completeKeys_filter_le_drop`, dropping the begin selector's skipped prefix), so soundness holds exactly as in the overshoot case. Necessity is the begin key's necessity and convexity up to the reported last. This certifies the boundary case at `end_.offset = 1` and `begin.offset ≥ 2`, where the resolved begin can land above `begin.key`. -/ theorem minimal_truncatedRange_of_end_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset = 1) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := hpre₀.subset (List.getLast_mem hne) have hlast_stored : res.keys.getLast hne ∈ db₀.keys := (RangeRead.mem_completeKeys.mp hlast_ck).1 have hlast_lt_res : (res.keys.getLast hne : WithTop Key) < resolve db₀ r.end_ := (RangeRead.mem_completeKeys.mp hlast_ck).2.2 -- At offset one the resolved end is the first stored key at or above `end_.key`, so -- the reported last (which the result reaches) must lie strictly below it. have hlast_end : (res.keys.getLast hne : WithTop Key) < r.end_.key := by by_contra hcon have hge : r.end_.key ≤ (↑(res.keys.getLast hne) : WithTop Key) := not_lt.mp hcon have hrle : resolve db₀ r.end_ ≤ (↑(res.keys.getLast hne) : WithTop Key) := (key_le_resolve_iff_of_offset_one hend hlast_stored).mp hge exact absurd hlast_lt_res (not_lt.mpr hrle) -- Compatibility is decided by the truncated range's stored keys with the begin -- selector's skipped prefix dropped, for any database with the same `(r, res)`. have hac : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ ((truncatedRange r (res.keys.getLast hne)).keys db).drop (r.begin.offset - 1).toNat = res.keys := fun db => by rw [compatible_iff_truncated_keys (db := db) hrev hmore hne, completeKeys_filter_le_drop (db := db) hrev hbegin (lt_of_lt_of_le hlast_end (key_le_resolve_of_one_le (by omega)))] refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree rw [hac db₁, hac db₂, hagree] · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- At a general positive begin offset and `end.offset = 1`, the truncated range is *the* minimal sound conflict range up to set equality for a truncated non-reversed result. -/ theorem unique_minimal_truncatedRange_of_end_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset = 1) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRange_of_end_offset_one hread hmore hrev hbegin hend) /-- **The truncated forward value, cross-free, at any positive end offset.** For a non-reversed truncated result with `begin.key ≤ end_.key`, `begin.offset ≥ 1` and `end.offset ≥ 1`, the minimal sound conflict range is `[begin.key, keyAfter (last reported))`. This unifies the overshoot cell (`minimal_truncatedRange_of_end_offset_ge_two_general`) and the offset-one cell; the new content is the non-overshooting cell `end_.key ≤ last` at `begin.offset ≥ 2`. Agreement on the truncated range fixes the stored keys in `[end_.key, last]`, which is exactly the count deciding whether `resolve end_` overshoots `last` (`lt_resolve_end_iff_of_agree`), so compatibility is agreement-stable. -/ theorem minimal_truncatedRange_of_more_crossfree {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp -- The complete-keys filter is determined by the truncated range together with the -- overshoot condition `last < resolve end_`. have keyF : ∀ db : DB, ((RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = res.keys) ↔ (((truncatedRange r (res.keys.getLast hne)).keys db).drop (r.begin.offset - 1).toNat = res.keys ∧ (res.keys.getLast hne : WithTop Key) < resolve db r.end_) := by intro db constructor · intro hF have hmem : res.keys.getLast hne ∈ (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by rw [hF]; exact List.getLast_mem hne have hlr : (res.keys.getLast hne : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp (List.mem_of_mem_filter hmem)).2.2 have hT := completeKeys_filter_le_drop (db := db) hrev hbegin hlr rw [hF] at hT exact ⟨hT.symm, hlr⟩ · rintro ⟨hT, hlr⟩ have hF := completeKeys_filter_le_drop (db := db) hrev hbegin hlr rw [hF] exact hT refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have hT : (truncatedRange r (res.keys.getLast hne)).keys db₁ = (truncatedRange r (res.keys.getLast hne)).keys db₂ := hagree have hlrIff := lt_resolve_end_iff_of_agree (db₁ := db₁) (db₂ := db₂) (r := r) (last := res.keys.getLast hne) hend hcross hagree rw [compatible_iff_truncated_keys hrev hmore hne, compatible_iff_truncated_keys (db := db₂) hrev hmore hne, keyF db₁, keyF db₂, hT] exact ⟨fun h => ⟨h.1, h.2.1, hlrIff.mp h.2.2⟩, fun h => ⟨h.1, h.2.1, hlrIff.mpr h.2.2⟩⟩ · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- **The forward-truncated closed form for every positive begin offset.** A non-reversed truncated result with `begin.offset ≥ 1`, `begin.key ≤ end_.key` and `end.offset ≥ 1` has the truncated range `[begin.key, keyAfter (last reported))` as its minimal sound conflict range, with no residual cell in the cross-free forward-truncated region. -/ theorem minimal_truncatedRange_of_more_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := minimal_truncatedRange_of_more_crossfree hread hmore hrev hbegin hend hcross /-- The cross-free forward-truncated value is unique up to the key set of a minimal sound range. -/ theorem unique_minimal_truncatedRange_of_more_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hcross : r.begin.key ≤ r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRange_of_more_general hread hmore hrev hbegin hend hcross) /-- If every stored key lies strictly below `end_.key` and the end offset is at least two, the end selector resolves to the sentinel: the anchor lands past every stored key. This is the offset hypothesis form of the argument in `minimal_topRange_of_end_offset_ge_two`. -/ theorem resolve_eq_top_of_all_lt {db : DB} {r : RangeRead} (hall : ∀ k ∈ db.keys, ((k : Key) : WithTop Key) < r.end_.key) (hoff : 2 ≤ r.end_.offset) : resolve db r.end_ = (⊤ : WithTop Key) := by have hcnt : db.keys.countP (fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) = db.keys.length := List.countP_eq_length.mpr fun k hk => by rw [decide_eq_true_eq]; exact hall k hk have hann : r.end_.anchor db = (db.keys.length : Int) + r.end_.offset - 1 := by unfold Selector.anchor rw [hcnt] refine resolve_eq_top ?_ ?_ · rw [hann]; omega · have htoNat : (r.end_.anchor db).toNat = db.keys.length + (r.end_.offset - 1).toNat := by rw [hann, show ((db.keys.length : Int) + r.end_.offset - 1) = ((db.keys.length : Int) + (r.end_.offset - 1)) by ring, Int.toNat_add (Int.natCast_nonneg _) (by omega), Int.toNat_natCast] rw [htoNat] omega /-- The reversed overshoot range at `begin.offset = 1`: from the last (smallest) reported key up to the sentinel `⊤`. -/ def topOfLast (last : Key) : ConflictRange := ⟨(last : WithTop Key), ⊤⟩ /-- The top-of-last range's stored keys are exactly the stored keys at or above `last`. -/ theorem topOfLast_keys (last : Key) (db : DB) : (topOfLast last).keys db = db.keys.filter (fun k => decide (last ≤ k)) := by unfold topOfLast ConflictRange.keys apply List.filter_congr intro k _ rw [decide_eq_decide] exact ⟨fun h => WithTop.coe_le_coe.mp h.1, fun h => ⟨WithTop.coe_le_coe.mpr h, WithTop.coe_lt_top k⟩⟩ /-- With an unbounded window, filtering the reversed complete keys at or above the last reported key is the reversal of the stored keys at or above it. -/ private theorem completeKeys_filter_ge_rev {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = true) (hE : resolve db r.end_ = (⊤ : WithTop Key)) (hL : resolve db r.begin ≤ (last : WithTop Key)) : (RangeRead.completeKeys db r).filter (fun k => decide (last ≤ k)) = (db.keys.filter (fun k => decide (last ≤ k))).reverse := by have hin : RangeRead.inRange db.keys (resolve db r.begin) (⊤ : WithTop Key) = db.keys.filter (fun (k : Key) => decide (resolve db r.begin ≤ (k : WithTop Key))) := by unfold RangeRead.inRange apply List.filter_congr intro k _ rw [decide_eq_decide] exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩ rw [RangeRead.completeKeys] simp only [hrev, hE, ite_true, hin] rw [List.filter_reverse, List.filter_filter] congr 1 apply List.filter_congr intro k _ by_cases hLk : last ≤ k · have hbeg : resolve db r.begin ≤ (k : WithTop Key) := le_trans hL (by exact_mod_cast hLk) simp [hLk, hbeg] · simp [hLk] /-- At begin offset one and end offset at least two, a truncated reversed result whose reported keys all lie below `end_.key` has the unbounded top from its last (smallest) reported key, `[last, ⊤)`, as its minimal sound conflict range. The overshoot forces every witness window to end at the sentinel (`resolve_end_eq_top_of_hhi`), so compatibility depends only on the stored keys at or above the last reported key; those keys, the reported ones, and everything convexly between them are necessary, as is every key at or above the reported head by `necessary_of_end_offset_ge_two_rev`. -/ theorem minimal_topOfLast_of_end_offset_ge_two_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topOfLast (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp₀⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · -- Agreement on `[last, ⊤)` fixes exactly the stored keys the reversed prefix -- can observe. intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (topOfLast (res.keys.getLast hne)) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp_db have hL : resolve db r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp (hpre.subset (List.getLast_mem hne))).2.1 have hE : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hcomp_db hend hhi (res.keys.head hne) (List.head_mem hne) fun k hk => le_head_of_mem_completeKeys_rev hrev hpre hne hk have hfilter : (RangeRead.completeKeys db r).filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys := ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp_db).2 have hdbEq : db.keys.filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys.reverse := by have h := completeKeys_filter_ge_rev (db := db) hrev hE hL rw [hfilter] at h have hrevh := congrArg List.reverse h simpa only [List.reverse_reverse] using hrevh.symm have hag'' : (topOfLast (res.keys.getLast hne)).keys db = (topOfLast (res.keys.getLast hne)).keys db' := hag' rw [topOfLast_keys, topOfLast_keys] at hag'' have hdbEq' : db'.keys.filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys.reverse := by rw [← hag'', hdbEq] -- The last reported key is stored in `db'`, so `resolve begin ≤ last`. have hlast_mem : res.keys.getLast hne ∈ db'.keys := by have h1 : res.keys.getLast hne ∈ res.keys.reverse := List.mem_reverse.mpr (List.getLast_mem hne) rw [← hdbEq'] at h1 exact (List.mem_filter.mp h1).1 have hkble : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := le_trans (key_le_resolve_of_offset_one hbegin) hL have hL' : resolve db' r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (key_le_resolve_iff_of_offset_one hbegin hlast_mem).mp hkble -- Every stored key of `db'` lies below `end_.key`, so the window is unbounded. have hall' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hklast : res.keys.getLast hne ≤ k · have hkf : k ∈ db'.keys.filter (fun k => decide (res.keys.getLast hne ≤ k)) := List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq]; exact hklast⟩ rw [hdbEq'] at hkf exact hhi k (List.mem_reverse.mp hkf) · have hklt : k < res.keys.getLast hne := lt_of_not_ge hklast exact lt_trans (by exact_mod_cast hklt) (hhi _ (List.getLast_mem hne)) have hE' : resolve db' r.end_ = (⊤ : WithTop Key) := resolve_eq_top_of_all_lt hall' hend have hfilter' : (RangeRead.completeKeys db' r).filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys := by rw [completeKeys_filter_ge_rev (db := db') hrev hE' hL', hdbEq', List.reverse_reverse] exact (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hlim, hfilter'⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hk have hklast : res.keys.getLast hne ≤ k := WithTop.coe_le_coe.mp (show ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key) from hk.1) by_cases hkhead : k ≤ res.keys.head hne · exact necessary_of_between_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne) (List.head_mem hne) hklast hkhead · have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead) exact necessary_of_end_offset_ge_two_rev ⟨db₀, hcomp₀⟩ hrev hne hend hhi hheadk /-- At begin offset one and end offset at least two, the top-from-last range is *the* minimal sound conflict range up to set equality for a truncated reversed result. -/ theorem unique_minimal_topOfLast_of_end_offset_ge_two_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topOfLast_of_end_offset_ge_two_rev hread hmore hrev hbegin hend hhi) /-- **The cross-free nonpositive-begin reversed truncated overshoot.** A reversed truncated result at a *nonpositive* begin offset whose begin key lies at or below the least (last) reported key and whose end overshoots (`2 ≤ end_.offset`, every reported key strictly below `end_.key`) has the unbounded top from its least reported key, `[last, ⊤)`, as its minimal sound conflict range. This is the nonpositive-begin companion of `minimal_topOfLast_of_end_offset_ge_two_rev`: instead of a positive begin offset resolving onto the reported block, the cross-free hypothesis `begin.key ≤ last` gives `resolve begin ≤ last` directly (`resolve_le_key_of_offset_nonpos`), and the overshoot still forces every witness window to end at the sentinel (`resolve_end_eq_top_of_hhi`). The reported keys and everything between them are necessary (`necessary_of_between_result`), and every key at or above the reported head by `necessary_of_end_offset_ge_two_rev`. -/ theorem minimal_topOfLast_of_end_offset_ge_two_rev_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : 2 ≤ r.end_.offset) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topOfLast (res.keys.getLast hne)) := by obtain ⟨db₀, hcomp₀⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp₀⟩ refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (topOfLast (res.keys.getLast hne)) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp_db have hL : resolve db r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp (hpre.subset (List.getLast_mem hne))).2.1 have hE : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hcomp_db hend hhi (res.keys.head hne) (List.head_mem hne) fun k hk => le_head_of_mem_completeKeys_rev hrev hpre hne hk have hfilter : (RangeRead.completeKeys db r).filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys := ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp_db).2 have hdbEq : db.keys.filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys.reverse := by have h := completeKeys_filter_ge_rev (db := db) hrev hE hL rw [hfilter] at h have hrevh := congrArg List.reverse h simpa only [List.reverse_reverse] using hrevh.symm have hag'' : (topOfLast (res.keys.getLast hne)).keys db = (topOfLast (res.keys.getLast hne)).keys db' := hag' rw [topOfLast_keys, topOfLast_keys] at hag'' have hdbEq' : db'.keys.filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys.reverse := by rw [← hag'', hdbEq] -- A nonpositive begin offset resolves at or below the begin key, which the -- cross-free hypothesis puts at or below the last reported key. have hL' : resolve db' r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := le_trans (resolve_le_key_of_offset_nonpos hbegin) hlo -- Every stored key of `db'` lies below `end_.key`, so the window is unbounded. have hall' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hklast : res.keys.getLast hne ≤ k · have hkf : k ∈ db'.keys.filter (fun k => decide (res.keys.getLast hne ≤ k)) := List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq]; exact hklast⟩ rw [hdbEq'] at hkf exact hhi k (List.mem_reverse.mp hkf) · have hklt : k < res.keys.getLast hne := lt_of_not_ge hklast exact lt_trans (by exact_mod_cast hklt) (hhi _ (List.getLast_mem hne)) have hE' : resolve db' r.end_ = (⊤ : WithTop Key) := resolve_eq_top_of_all_lt hall' hend have hfilter' : (RangeRead.completeKeys db' r).filter (fun k => decide (res.keys.getLast hne ≤ k)) = res.keys := by rw [completeKeys_filter_ge_rev (db := db') hrev hE' hL', hdbEq', List.reverse_reverse] exact (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hlim, hfilter'⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hk have hklast : res.keys.getLast hne ≤ k := WithTop.coe_le_coe.mp (show ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key) from hk.1) by_cases hkhead : k ≤ res.keys.head hne · exact necessary_of_between_result hreadable (List.getLast_mem hne) (List.head_mem hne) hklast hkhead · have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead) exact necessary_of_end_offset_ge_two_rev hreadable hrev hne hend hhi hheadk /-- At a nonpositive begin offset, the top-from-last range is *the* minimal sound conflict range up to set equality for a cross-free truncated reversed overshoot. -/ theorem unique_minimal_topOfLast_of_end_offset_ge_two_rev_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : 2 ≤ r.end_.offset) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topOfLast_of_end_offset_ge_two_rev_nonpos hread hmore hrev hne hbegin hend hlo hhi) /-! ## The nonpositive-begin truncated reversed under-end cell A truncated reversed result at a nonpositive begin offset, cross-free (`begin.key` at or below the reported last) and with `end_.offset = 1`, has the reversed truncated range `[last reported, end_.key)` as its minimal sound conflict range. This is the under-end companion of `minimal_topOfLast_of_end_offset_ge_two_rev_nonpos`: instead of an overshooting end forcing the window to the sentinel, the end resolves at `end_.key`, and the cut at `resolve end_` is the cut at `end_.key` (`resolve_lt_iff_of_offset_one`), so agreement on `[last, end_.key)` fixes exactly the stored keys the reversed prefix can observe. The reported keys and everything between them are necessary by convexity, and every key at or above the reported head by `necessary_head_to_end_key`. -/ /-- **The nonpositive-begin reversed truncated filter identity at `end_.offset = 1`.** For a reversed read at a nonpositive begin offset with `end_.offset = 1` and `begin.key ≤ last`, filtering the complete keys at or above `last` is the reversal of the stored keys at or above `last` and below `end_.key`. A nonpositive begin offset resolves at or below `begin.key ≤ last` (`resolve_le_key_of_offset_nonpos`), so the lower cut drops out, and at `end_.offset = 1` the cut at `resolve end_` is the cut at `end_.key` (`resolve_lt_iff_of_offset_one`). -/ private theorem completeKeys_filter_ge_eq_end_one_nonpos {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = true) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset = 1) (hbl : (r.begin.key : WithTop Key) ≤ (last : WithTop Key)) : (RangeRead.completeKeys db r).filter (fun k => decide (last ≤ k)) = ((truncatedRangeRev r last).keys db).reverse := by have hL : resolve db r.begin ≤ (last : WithTop Key) := le_trans (resolve_le_key_of_offset_nonpos hbegin) hbl simp only [RangeRead.completeKeys, hrev, ite_true] rw [List.filter_reverse, List.reverse_inj] unfold RangeRead.inRange truncatedRangeRev ConflictRange.keys rw [List.filter_filter] apply List.filter_congr intro k hk have hSE : ((k : WithTop Key) < resolve db r.end_) ↔ ((k : WithTop Key) < r.end_.key) := resolve_lt_iff_of_offset_one hend hk by_cases hlast : last ≤ (k : WithTop Key) · have hlastK : last ≤ k := WithTop.coe_le_coe.mp hlast have hbeg : resolve db r.begin ≤ (k : WithTop Key) := le_trans hL hlast have hdec : decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_) = decide ((k : WithTop Key) < r.end_.key) := by rw [decide_eq_decide] exact ⟨fun h => hSE.mp h.2, fun h => ⟨hbeg, hSE.mpr h⟩⟩ rw [decide_eq_true hlastK, Bool.true_and, hdec] rw [show decide ((last : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key) = decide ((k : WithTop Key) < r.end_.key) by rw [decide_eq_decide] exact ⟨fun h => h.2, fun h => ⟨WithTop.coe_le_coe.mpr hlastK, h⟩⟩] · have hlastK : ¬ last ≤ k := fun h => hlast (WithTop.coe_le_coe.mpr h) rw [decide_eq_false_iff_not.mpr hlastK, Bool.false_and] rw [show decide ((last : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key) = false by rw [Bool.decide_and, decide_eq_false_iff_not.mpr hlast, Bool.false_and]] /-- **The cross-free nonpositive-begin reversed truncated under-end.** A reversed truncated result at a *nonpositive* begin offset whose begin key lies at or below the least (last) reported key and whose end is at offset one has the reversed truncated range `[last reported, end_.key)` as its minimal sound conflict range. This is the under-end companion of `minimal_topOfLast_of_end_offset_ge_two_rev_nonpos` and the nonpositive-begin companion of `minimal_truncatedRangeRev_of_offset_one`. -/ theorem minimal_truncatedRangeRev_of_end_offset_one_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset = 1) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : Minimal r res (truncatedRangeRev r (res.keys.getLast hne)) := by obtain ⟨db₀, hcomp⟩ := hread refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have hbl : (r.begin.key : WithTop Key) ≤ (↑(res.keys.getLast hne) : WithTop Key) := hlo have hf₁ := completeKeys_filter_ge_eq_end_one_nonpos (db := db₁) hrev hbegin hend hbl have hf₂ := completeKeys_filter_ge_eq_end_one_nonpos (db := db₂) hrev hbegin hend hbl rw [compatible_iff_truncated_keys_rev hrev hmore hne, compatible_iff_truncated_keys_rev (db := db₂) hrev hmore hne] rw [hf₁, hf₂, hagree] · intro k hk cr hs have hkend : (k : WithTop Key) < r.end_.key := hk.2 have hklast : res.keys.getLast hne ≤ k := WithTop.coe_le_coe.mp hk.1 by_cases hkhead : k ≤ res.keys.head hne · exact necessary_of_between_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) (List.head_mem hne) hklast hkhead cr hs · have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead) exact necessary_head_to_end_key ⟨db₀, hcomp⟩ hrev hne (by omega) cr hs hheadk hkend /-- At a nonpositive begin offset, the reversed truncated range is *the* minimal sound conflict range up to set equality for a cross-free truncated reversed under-end. -/ theorem unique_minimal_truncatedRangeRev_of_end_offset_one_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset = 1) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_truncatedRangeRev_of_end_offset_one_nonpos hread hmore hrev hne hbegin hend hlo) /-! ## The crossed nonpositive-begin complete overshoot at begin offset zero A forward complete result at `begin.offset = 0` whose `begin.key` lies strictly above the least reported key (the crossed subcase) and whose end overshoots has the top range from the least reported key, `[head, ⊤)`, as its minimal sound conflict range. At offset zero the begin selector resolves onto the greatest stored key strictly below `begin.key`; compatibility forces that key to be the reported head, so the window is `[head, ⊤)` and agreement on `[head, ⊤)` fixes the complete keys. Convexity from the empty key is not available, but the head itself is the lower end; everything at or above the reported last is necessary by `necessary_of_end_offset_ge_two` and convexity fills the gap between the head and the last. This is the crossed companion of `minimal_fullRange_of_nonpos_overshoot_nonempty`. -/ /-- For a forward read whose window ends at the sentinel, if the begin selector resolves exactly to `last` then the complete keys are the stored keys at or above `last`. -/ theorem completeKeys_eq_topOfLast_keys {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hE : resolve db r.end_ = (⊤ : WithTop Key)) (hL : resolve db r.begin = (last : WithTop Key)) : RangeRead.completeKeys db r = db.keys.filter (fun k => decide (last ≤ k)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev]), hE] unfold RangeRead.inRange apply List.filter_congr intro k _ rw [hL, decide_eq_decide] exact ⟨fun h => WithTop.coe_le_coe.mp h.1, fun h => ⟨WithTop.coe_le_coe.mpr h, WithTop.coe_lt_top k⟩⟩ /-- At begin offset zero, with some stored key strictly below `begin.key`, every stored key strictly below `begin.key` is at or below the begin resolution: the begin selector targets the greatest stored key below `begin.key`. -/ theorem resolve_zero_begin_le_of_mem_below {db : DB} {r : RangeRead} (h0 : r.begin.offset = 0) {b : Key} (hb : b ∈ db.keys) (hb_lt : (b : WithTop Key) < r.begin.key) : ∀ a ∈ db.keys, ((a : Key) : WithTop Key) < r.begin.key → ((a : Key) : WithTop Key) ≤ resolve db r.begin := by intro a ha ha_lt set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) with hc have hcanch : r.begin.anchor db = (c : ℤ) + 0 - 1 := by unfold Selector.anchor rw [← hc, h0] have hcpos : 0 < c := countP_pos_of_mem hb (by rw [decide_eq_true_eq]; exact hb_lt) have hanc0 : 0 ≤ r.begin.anchor db := by rw [hcanch]; omega have htoNat : (r.begin.anchor db).toNat = c - 1 := by rw [hcanch] have hz : ((c : ℤ) + 0 - 1) = ((c : ℤ) - 1) := by ring rw [hz, toNat_sub_one (by omega : (1 : ℤ) ≤ (c : ℤ)), Int.toNat_natCast] have hltlen : (r.begin.anchor db).toNat < db.keys.length := by rw [htoNat] have hcle : c ≤ db.keys.length := List.countP_le_length omega rw [resolve_eq_getElem hanc0 hltlen] obtain ⟨i, hi, hieq⟩ := List.mem_iff_getElem.mp ha have hic : i < c := by rw [hc] refine lt_countP_of_getElem_lt_top db.sorted hi ?_ rw [hieq]; exact ha_lt have hile : i ≤ (r.begin.anchor db).toNat := by rw [htoNat]; omega rw [← hieq] exact WithTop.coe_le_coe.mpr ((db.sorted.getElem_le_getElem_iff).mpr hile) /-- At begin offset zero, with some stored key strictly below `begin.key`, the begin resolution is strictly below `begin.key`. -/ theorem resolve_zero_begin_lt_key {db : DB} {r : RangeRead} (h0 : r.begin.offset = 0) {b : Key} (hb : b ∈ db.keys) (hb_lt : (b : WithTop Key) < r.begin.key) : resolve db r.begin < r.begin.key := by set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.begin.key)) with hc have hcanch : r.begin.anchor db = (c : ℤ) + 0 - 1 := by unfold Selector.anchor rw [← hc, h0] have hcpos : 0 < c := countP_pos_of_mem hb (by rw [decide_eq_true_eq]; exact hb_lt) have hanc0 : 0 ≤ r.begin.anchor db := by rw [hcanch]; omega have htoNat : (r.begin.anchor db).toNat = c - 1 := by rw [hcanch] have hz : ((c : ℤ) + 0 - 1) = ((c : ℤ) - 1) := by ring rw [hz, toNat_sub_one (by omega : (1 : ℤ) ≤ (c : ℤ)), Int.toNat_natCast] have hltlen : (r.begin.anchor db).toNat < db.keys.length := by rw [htoNat] have hcle : c ≤ db.keys.length := List.countP_le_length omega have hltc : (r.begin.anchor db).toNat < c := by rw [htoNat]; omega rw [resolve_eq_getElem hanc0 hltlen] exact getElem_lt_of_lt_countP_top db.sorted hltlen (by rw [← hc]; exact hltc) /-- **The crossed nonpositive-begin complete overshoot at begin offset zero.** A forward complete result at `begin.offset = 0` whose `begin.key` lies strictly above the least reported key and whose end overshoots has the top range from the least reported key, `[head, ⊤)`, as its minimal sound conflict range. -/ theorem minimal_topOfHead_of_zero_begin_crossed_overshoot {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topOfLast (res.keys.head hne)) := by obtain ⟨db₀, hcomp₀⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp₀⟩ refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (topOfLast (res.keys.head hne)) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hres_eq : res.keys = RangeRead.completeKeys db r := by rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp_db hrev have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hE : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hcomp_db hend hhi (res.keys.getLast hne) (List.getLast_mem hne) (fun k hk => hmaxres k (by rw [hres_eq]; exact hk)) have hhead_stored : res.keys.head hne ∈ db.keys := RangeRead.compatible_keys_subset hcomp_db hhead_mem have hagree_keys : db.keys.filter (fun k => decide (res.keys.head hne ≤ k)) = db'.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := by have h := hag' rw [AgreeOn, topOfLast_keys, topOfLast_keys] at h exact h have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact (RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem)).2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross (res.keys.head hne) hhead_stored hcross have hhead_stored' : res.keys.head hne ∈ db'.keys := by have hmf : res.keys.head hne ∈ db'.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := by rw [← hagree_keys] exact List.mem_filter.mpr ⟨hhead_stored, by rw [decide_eq_true_eq]⟩ exact List.mem_of_mem_filter hmf have hck : RangeRead.completeKeys db r = db.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := completeKeys_eq_topOfLast_keys hrev hE hL have hres_filter : res.keys = db.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := hres_eq.trans hck have hnoE' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hkh : res.keys.head hne ≤ k · have hmf : k ∈ db'.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq]; exact hkh⟩ rw [← hagree_keys] at hmf have hkdb : k ∈ db.keys := List.mem_of_mem_filter hmf have hkres : k ∈ res.keys := by rw [hres_filter] exact List.mem_filter.mpr ⟨hkdb, by rw [decide_eq_true_eq]; exact hkh⟩ exact hhi k hkres · exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (lt_of_not_ge hkh)) (le_of_lt (hhi _ hhead_mem)) have hE' : resolve db' r.end_ = (⊤ : WithTop Key) := by have hcp : db'.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = db'.keys.length := by rw [List.countP_eq_length] intro k hk rw [decide_eq_true_eq] exact hnoE' k hk refine resolve_eq_top ?_ ?_ · unfold Selector.anchor; rw [hcp]; omega · rw [anchor_toNat_eq (by omega : 1 ≤ r.end_.offset), hcp]; omega have hL' : resolve db' r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · by_contra hcon have hgt : ((res.keys.head hne : Key) : WithTop Key) < resolve db' r.begin := lt_of_not_ge hcon have hlt' : resolve db' r.begin < r.begin.key := resolve_zero_begin_lt_key (db := db') hbegin hhead_stored' hcross rcases resolve_eq_nil_or_eq_top_or_mem (db := db') (s := r.begin) with hn | ht | ⟨k, hkdb', hkres⟩ · rw [hn] at hgt exact absurd hgt (not_lt.mpr (coe_nil_le ((res.keys.head hne : Key) : WithTop Key))) · rw [ht] at hlt' exact absurd hlt' (not_lt.mpr le_top) · have hkgt : res.keys.head hne < k := by rw [hkres] at hgt exact WithTop.coe_lt_coe.mp hgt have hk_ge : res.keys.head hne ≤ k := le_of_lt hkgt have hk_in : k ∈ db'.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := List.mem_filter.mpr ⟨hkdb', by rw [decide_eq_true_eq]; exact hk_ge⟩ rw [← hagree_keys] at hk_in have hkdb : k ∈ db.keys := List.mem_of_mem_filter hk_in have hk_lt_begin : (k : WithTop Key) < r.begin.key := by rw [hkres] at hlt' exact hlt' have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k hkdb hk_lt_begin rw [hL] at hb exact absurd hb (not_le.mpr (WithTop.coe_lt_coe.mpr hkgt)) · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored' hcross (res.keys.head hne) hhead_stored' hcross have hck' : RangeRead.completeKeys db' r = db'.keys.filter (fun k => decide (res.keys.head hne ≤ k)) := completeKeys_eq_topOfLast_keys hrev hE' hL' exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_filter, hagree_keys, ← hck']⟩⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hk have hheadk : res.keys.head hne ≤ k := WithTop.coe_le_coe.mp hk.1 by_cases hklast : k ≤ res.keys.getLast hne · exact necessary_of_between_result hreadable (List.head_mem hne) (List.getLast_mem hne) hheadk hklast · exact necessary_of_end_offset_ge_two hreadable hrev hmore hne hend hhi (le_of_lt (lt_of_not_ge hklast)) /-- At begin offset zero, the top-from-head range is *the* minimal sound conflict range up to set equality for a crossed complete overshoot. -/ theorem unique_minimal_topOfHead_of_zero_begin_crossed_overshoot {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topOfHead_of_zero_begin_crossed_overshoot hread hrev hmore hne hbegin hcross hend hhi) /-- **Soundness of the top range for a truncated reversed overshoot at a positive begin offset.** A reversed read with `begin.offset ≥ 1`, `end.offset ≥ 2` and every reported key below `end_.key` has complete keys equal to a reversal of the top range's stored keys dropped by `(begin.offset - 1).toNat` (`completeKeys_eq_topRange_keys_drop_rev`), a function of the top range's key set alone, so databases agreeing on `[begin.key, ⊤)` have identical complete keys and hence identical compatibility with every result. -/ theorem sound_topRange_of_end_offset_ge_two_rev_more {r : RangeRead} {res : Result} (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Sound r res (topRange r) := by intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (topRange r) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp_db hmore have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp_db have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne have hmax : ∀ k ∈ RangeRead.completeKeys db r, k ≤ res.keys.head hne := fun k hk => le_head_of_mem_completeKeys_rev hrev hpre hne hk have hE : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_hhi hcomp_db hend hhi (res.keys.head hne) hhead_mem hmax have hbk_le_head : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := le_trans (key_le_resolve_of_one_le hbegin) (RangeRead.mem_completeKeys.mp (hpre.subset hhead_mem)).2.1 have hbk_lt_end : r.begin.key < r.end_.key := lt_of_le_of_lt hbk_le_head (hhi _ hhead_mem) -- No stored key of `db` reaches `end_.key`: a stored key at or above `end_.key` -- lies strictly above `begin.key`, and the resolved begin sits at or below the -- reported head, so the key is either inside the window (contradicting the head -- being its maximum) or below the resolved begin (contradicting `end_.key`). have hall : ∀ k ∈ db.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_contra hge have hge' : r.end_.key ≤ ((k : Key) : WithTop Key) := not_lt.mp hge by_cases hle : resolve db r.begin ≤ ((k : Key) : WithTop Key) · have hkin : k ∈ RangeRead.completeKeys db r := RangeRead.mem_completeKeys.mpr ⟨hk, hle, by rw [hE]; exact WithTop.coe_lt_top k⟩ exact absurd (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hmax k hkin)) (hhi _ hhead_mem)) (not_lt.mpr hge') · have h1 : ((k : Key) : WithTop Key) < r.end_.key := lt_of_lt_of_le (lt_of_not_ge hle) (le_of_lt (lt_of_le_of_lt (RangeRead.mem_completeKeys.mp (hpre.subset hhead_mem)).2.1 (hhi _ hhead_mem))) exact absurd h1 (not_lt.mpr hge') have hall' : ∀ k ∈ db'.keys, ((k : Key) : WithTop Key) < r.end_.key := by intro k hk by_cases hkb : r.begin.key ≤ ((k : Key) : WithTop Key) · have hkmem : k ∈ db.keys := ((agreeOn_iff (topRange r) db db').mp hag' k (ConflictRange.mem_iff.mpr ⟨hkb, WithTop.coe_lt_top k⟩)).mpr hk exact hall k hkmem · exact lt_of_lt_of_le (lt_of_not_ge hkb) (le_of_lt hbk_lt_end) have hE' : resolve db' r.end_ = (⊤ : WithTop Key) := resolve_eq_top_of_all_lt hall' hend have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db' r := by rw [completeKeys_eq_topRange_keys_drop_rev (db := db) hrev hbegin hE, completeKeys_eq_topRange_keys_drop_rev (db := db') hrev hbegin hE', show (topRange r).keys db = (topRange r).keys db' from hag'] exact (RangeRead.compatible_congr hck).mp hcomp_db exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ /-- **Begin-key necessity for a truncated reversed overshoot.** With `begin.offset ≥ 2` and an overshooting end (`end.offset ≥ 2`, every reported key below `end_.key`), the begin key is necessary. The witness database stores the `begin.offset - 1` keys the begin selector skips, starting at the begin key, followed by the reported keys ascending; its complete keys are exactly the reported ones, while erasing the begin key drops one skipped key and shifts the resolved begin up, so the reported keys are no longer a prefix. -/ private theorem necessary_begin_key_rev_top_of_end_offset_ge_two {r : RangeRead} {res : Result} {v : Key} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = true) (hlen : 0 < res.keys.length) (hbegin : 2 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) (hkey : r.begin.key = (↑v : WithTop Key)) : Necessary r res v := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := List.ne_nil_of_length_pos hlen set b : ℕ := (r.begin.offset - 1).toNat with hb have hbpos : 1 ≤ b := by rw [hb]; omega have hresrev_sort : res.keys.reverse.SortedLT := (RangeRead.compatible_sortedGT hcomp hrev).reverse have hlast_le : ∀ y ∈ res.keys.reverse, res.keys.getLast hne ≤ y := by intro y hy have hy' : y ∈ res.keys := List.mem_reverse.mp hy have hge : res.keys.Pairwise (fun a b => a ≥ b) := (RangeRead.compatible_pairwise hcomp).2 hrev |>.imp (fun h => le_of_lt h) exact hge.rel_getLast hy' have hresolve_coe : ∃ k : Key, resolve db₀ r.begin = (↑k : WithTop Key) := by rcases resolve_eq_nil_or_eq_top_or_mem (db := db₀) (s := r.begin) with h | h | h · exact ⟨[], h⟩ · exfalso have hnil : RangeRead.completeKeys db₀ r = [] := by rw [RangeRead.completeKeys, ite_eq_left (by simp [hrev])] simp only [RangeRead.inRange, h] rw [List.reverse_eq_nil_iff, List.filter_eq_nil_iff] intro x _ hx exact absurd (of_decide_eq_true hx).1 (not_le.mpr (WithTop.coe_lt_top x)) exact List.IsPrefix.ne_nil (RangeRead.compatible_keys_prefix hcomp) hne hnil · obtain ⟨k, _, hk⟩ := h; exact ⟨k, hk⟩ obtain ⟨k, hk⟩ := hresolve_coe have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := (RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne) have hk_le_last : k ≤ res.keys.getLast hne := by have h := (RangeRead.mem_completeKeys.mp hlast_ck).2.1 rw [hk] at h exact WithTop.coe_le_coe.mp h have hchain_b_le_k : chain v b ≤ k := by have h := chain_le_of_resolve (s := r.begin) (k₀ := v) (k := k) hkey (by omega) hk rwa [show (r.begin.offset - 1).toNat = b from hb] at h have hchain_lt_last : ∀ i < b, chain v i < res.keys.getLast hne := fun i _ => lt_of_lt_of_le (chain_lt_mono (b := v) (by omega)) (le_trans hchain_b_le_k hk_le_last) set Fp : List Key := (List.range b).map (chain v) with hFp have hFplen : Fp.length = b := by rw [hFp, List.length_map, List.length_range] have hFpsort : Fp.SortedLT := by rw [hFp]; exact sortedLT_map_chain v b have hFp_lt_last : ∀ x ∈ Fp, x < res.keys.getLast hne := by intro x hx rw [hFp, List.mem_map] at hx obtain ⟨i, hi, rfl⟩ := hx exact hchain_lt_last i (List.mem_range.mp hi) have hFp_ge_v : ∀ x ∈ Fp, v ≤ x := by intro x hx rw [hFp, List.mem_map] at hx obtain ⟨i, _, rfl⟩ := hx exact chain_le v i have hFp_v : v ∈ Fp := by rw [hFp, List.mem_map]; exact ⟨0, List.mem_range.mpr (by omega), chain_zero v⟩ set D : List Key := Fp ++ res.keys.reverse with hD have hDs : D.SortedLT := by rw [hD] refine List.sortedLT_append.mpr ⟨hFpsort, hresrev_sort, ?_⟩ intro a ha c hc exact lt_of_lt_of_le (hFp_lt_last a ha) (hlast_le c hc) let dbw : DB := ⟨D, hDs⟩ have hD_ge_v : ∀ x ∈ D, v ≤ x := by intro x hx rw [hD, List.mem_append] at hx rcases hx with hx | hx · exact hFp_ge_v x hx · exact le_trans (le_of_lt (hFp_lt_last _ hFp_v)) (hlast_le x hx) have htopw : (topRange r).keys dbw = D := by unfold topRange ConflictRange.keys rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact ⟨by rw [hkey]; exact WithTop.coe_le_coe.mpr (hD_ge_v x hx), WithTop.coe_lt_top x⟩ have hD_lt_end : ∀ x ∈ D, ((x : Key) : WithTop Key) < r.end_.key := by intro x hx rw [hD, List.mem_append] at hx rcases hx with hx | hx · exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (hFp_lt_last x hx)) (le_of_lt (hhi _ (List.getLast_mem hne))) · exact hhi x (List.mem_reverse.mp hx) have hEw : resolve dbw r.end_ = (⊤ : WithTop Key) := resolve_eq_top_of_all_lt hD_lt_end hend have hckw : RangeRead.completeKeys dbw r = res.keys := by rw [completeKeys_eq_topRange_keys_drop_rev (db := dbw) hrev (by omega) hEw, htopw, hD, List.drop_left' hFplen, List.reverse_reverse] have hcompw : RangeRead.Compatible dbw r res := ⟨hcomp.1, Or.inl ⟨hmore, by rw [hckw], hne⟩⟩ have herase_top : (topRange r).keys (dbw.erase v) = D.erase v := by unfold topRange ConflictRange.keys rw [DB.erase_keys] rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact ⟨by rw [hkey]; exact WithTop.coe_le_coe.mpr (hD_ge_v x (List.erase_subset hx)), WithTop.coe_lt_top x⟩ have hDerase : D.erase v = Fp.erase v ++ res.keys.reverse := by rw [hD, List.erase_append_left res.keys.reverse hFp_v] have hD_erase_lt_end : ∀ x ∈ (dbw.erase v).keys, ((x : Key) : WithTop Key) < r.end_.key := by rw [DB.erase_keys] exact fun x hx => hD_lt_end x (List.erase_subset hx) have hEerase : resolve (dbw.erase v) r.end_ = (⊤ : WithTop Key) := resolve_eq_top_of_all_lt hD_erase_lt_end hend have hnot : ¬ RangeRead.Compatible (dbw.erase v) r res := by intro hc have hpre := RangeRead.compatible_keys_prefix hc have hck_erase : RangeRead.completeKeys (dbw.erase v) r = res.keys.dropLast := by rw [completeKeys_eq_topRange_keys_drop_rev (db := dbw.erase v) hrev (by omega) hEerase, herase_top, hDerase, show (r.begin.offset - 1).toNat = ((r.begin.offset - 1).toNat - 1) + 1 by omega, ← List.drop_drop] rw [show ((r.begin.offset - 1).toNat - 1) = (Fp.erase v).length by rw [List.length_erase_of_mem hFp_v, hFplen, hb]] rw [List.drop_left' rfl, List.drop_reverse, List.reverse_reverse, ← List.dropLast_eq_take] rw [hck_erase] at hpre have hle := hpre.length_le rw [List.length_dropLast] at hle omega intro cr hs by_contra hvcr exact hnot ((hs dbw (dbw.erase v) (ConflictRange.keys_erase_of_not_mem cr dbw hvcr).symm).mp hcompw) /-- **The truncated reversed overshoot cell at `begin.offset ≥ 2`.** A reversed truncated result with `begin.offset ≥ 2`, `end.offset ≥ 2` and every reported key below `end_.key` has the unbounded top `[begin.key, ⊤)` as its minimal sound conflict range. The top range is sound (`sound_topRange_of_end_offset_ge_two_rev_more`); for necessity, the begin key is necessary (`necessary_begin_key_rev_top_of_end_offset_ge_two`), as is the least reported key, and convexity fills `[begin.key, head]`, while `necessary_of_end_offset_ge_two_rev` covers everything at or above the reported head. Unlike the offset-one cell (`minimal_topOfLast_of_end_offset_ge_two_rev`, value `[last, ⊤)`), the begin selector's skip here forces the whole interval from the begin key up. -/ theorem minimal_topRange_of_end_offset_ge_two_rev_more {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : 2 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hckne : RangeRead.completeKeys db₀ r ≠ [] := List.IsPrefix.ne_nil (RangeRead.compatible_keys_prefix hcomp) hne refine (minimal_iff_sound_and_necessary).mpr ⟨sound_topRange_of_end_offset_ge_two_rev_more hmore hrev (by omega) hend hhi, ?_⟩ intro k hk have hk' := ConflictRange.mem_iff.mp hk have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil_rev hrev hckne (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hvk : v ≤ k := by have h1 : r.begin.key ≤ (↑k : WithTop Key) := hk'.1 rw [hv] at h1 exact WithTop.coe_le_coe.mp h1 have hv_nec : Necessary r res v := necessary_begin_key_rev_top_of_end_offset_ge_two ⟨db₀, hcomp⟩ hrev hmore (List.length_pos_of_ne_nil hne) hbegin hend hhi hv have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkl : k ≤ res.keys.getLast hne · exact hv_nec.of_between hlast_nec hvk hkl · have hkgt : res.keys.getLast hne < k := lt_of_not_ge hkl by_cases hkh : k ≤ res.keys.head hne · exact necessary_of_between_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) (List.head_mem hne) (le_of_lt hkgt) hkh · exact necessary_of_end_offset_ge_two_rev ⟨db₀, hcomp⟩ hrev hne hend hhi (le_of_lt (lt_of_not_ge hkh)) /-- At begin offset at least two and end offset at least two, the top range is *the* minimal sound conflict range up to set equality for a truncated reversed overshoot. -/ theorem unique_minimal_topRange_of_end_offset_ge_two_rev_more {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : 2 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_topRange_of_end_offset_ge_two_rev_more hread hmore hrev hbegin hend hhi) /-! ### The nonpositive begin offset, nonempty complete result At a nonpositive begin offset the begin anchor can clamp, so the resolved begin may land below `begin.key`, and the empty key can be forced into every sound range. In the cross-free overshoot region — every reported key below `end_.key` and `begin.key` at or below the least reported key — the necessary keys are *all* keys: the empty key by `necessary_nil_of_begin_offset_nonpos` (or its reversed twin), the reported keys and everything between them by convexity, and every key at or above the least reported key by the overshoot necessity `necessary_of_end_offset_ge_two` (or its reversed twin). Since `[⊥, ⊤)` is unconditionally sound (`sound_fullRange`), it is minimal there. -/ /-- **The nonpositive-begin overshoot case, nonempty complete result, cross-free.** A read with `begin.offset ≤ 0`, `end.offset ≥ 2` whose reported keys all lie below `end_.key`, `begin.key ≤ head`, and a nonempty complete result has `[⊥, ⊤)` as its minimal sound conflict range. -/ theorem minimal_fullRange_of_nonpos_overshoot_nonempty {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : Minimal r res ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_fullRange r res, ?_⟩ intro k _ _ by_cases hk_last : res.keys.getLast hne ≤ k · exact necessary_of_end_offset_ge_two hread hrev hmore hne hend hhi hk_last · have hklt : k < res.keys.getLast hne := not_le.mp hk_last by_cases hk_head : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key) · exact (necessary_nil_of_begin_offset_nonpos hread hrev hne hbegin hlo).of_between (necessary_of_mem_result hread (List.head_mem hne)) (nil_le_key k) (le_of_lt (WithTop.coe_lt_coe.mp hk_head)) · exact necessary_of_between_result hread (List.head_mem hne) (List.getLast_mem hne) (WithTop.coe_le_coe.mp (not_lt.mp hk_head)) (le_of_lt hklt) /-- **The nonpositive-begin overshoot case, nonempty complete reversed result.** A read with `begin.offset ≤ 0`, `end.offset ≥ 2` whose reported keys all lie below `end_.key`, `begin.key ≤ last`, and a nonempty complete reversed result has `[⊥, ⊤)` as its minimal sound conflict range. The reversal-symmetric twin of `minimal_fullRange_of_nonpos_overshoot_nonempty`, with `necessary_nil_of_begin_offset_nonpos_rev` and `necessary_of_end_offset_ge_two_rev` in place of their forward forms and the roles of head and last exchanged. -/ theorem minimal_fullRange_of_nonpos_overshoot_nonempty_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : Minimal r res ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_fullRange r res, ?_⟩ intro k _ _ by_cases hk_last : res.keys.getLast hne ≤ k · by_cases hk_head : res.keys.head hne ≤ k · exact necessary_of_end_offset_ge_two_rev hread hrev hne hend hhi hk_head · exact necessary_of_between_result hread (List.getLast_mem hne) (List.head_mem hne) hk_last (le_of_lt (not_le.mp hk_head)) · have hklt : k < res.keys.getLast hne := not_le.mp hk_last exact (necessary_nil_of_begin_offset_nonpos_rev hread hrev hmore hne hbegin hlo).of_between (necessary_of_mem_result hread (List.getLast_mem hne)) (nil_le_key k) (le_of_lt hklt) /-! ### The nonpositive begin offset, complete result at end offset at most one At a nonpositive begin offset the begin anchor can clamp, so the resolved begin may land below `begin.key` and the empty key can be forced into every sound range. In the cross-free region — `begin.key` at or below the reported head — a nonempty *complete* result with `end_.offset ≤ 1` has `[⊥, end_.key)` as its minimal sound conflict range. The empty key is forced by `necessary_nil_of_begin_offset_nonpos`, the reported keys and everything between them by convexity, and every key from the reported last up to (but not including) `end_.key` by `necessary_last_to_end_key`. Soundness is `sound_bottomRange_of_nonpos_underEnd_nonempty`: agreement on `[⊥, end_.key)` fixes the stored keys below `end_.key`, hence both resolved selectors and the complete keys. -/ /-- The keys of the bottom range `[⊥, E)` are the stored keys strictly below `E`. -/ theorem keys_bottomRange_eq_filter (db : DB) (E : WithTop Key) : (⟨(([] : Key) : WithTop Key), E⟩ : ConflictRange).keys db = db.keys.filter (fun (k : Key) => decide ((k : WithTop Key) < E)) := by unfold ConflictRange.keys apply List.filter_congr intro k _ rw [decide_eq_decide] exact ⟨fun h => h.2, fun h => ⟨WithTop.coe_le_coe.mpr (nil_le_key k), h⟩⟩ /-- Counting the stored keys below `w` agrees between `db` and its projection to the keys below `E`, when `w ≤ E`. -/ theorem countP_lt_eq_countP_filter {db : DB} {E w : WithTop Key} (hw : w ≤ E) : db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < w)) = (db.keys.filter (fun (k : Key) => decide ((k : WithTop Key) < E))).countP (fun (k : Key) => decide ((k : WithTop Key) < w)) := by have hfilter : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E))).filter (fun (k : Key) => decide ((↑k : WithTop Key) < w)) = db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < w)) := by rw [List.filter_filter] apply List.filter_congr intro k _ by_cases hkw : (k : WithTop Key) < w · have hkE : (k : WithTop Key) < E := lt_of_lt_of_le hkw hw simp [hkw, hkE] · simp [hkw] rw [List.countP_eq_length_filter, List.countP_eq_length_filter] exact (congrArg List.length hfilter).symm /-- The key at an index below the count of keys below `E` is unchanged by projecting the list to the keys below `E`. -/ theorem getElem?_filter_of_lt_countP {l : List Key} (hs : l.SortedLT) {E : WithTop Key} {i : ℕ} (hi : i < l.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E))) : (l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E)))[i]? = l[i]? := by rw [filter_lt_eq_take_countP hs E, List.getElem?_take, ite_eq_left hi] /-- A nonpositive-offset selector keyed at or below `E` resolves identically against databases agreeing on the keys below `E`. -/ theorem resolve_eq_of_keys_below {db₁ db₂ : DB} {E : WithTop Key} {s : Selector} (hoff : s.offset ≤ 0) (hskey : s.key ≤ E) (hb : db₁.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E)) = db₂.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E))) : resolve db₁ s = resolve db₂ s := by have hcnt : db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) = db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := by rw [countP_lt_eq_countP_filter (db := db₁) (E := E) hskey, countP_lt_eq_countP_filter (db := db₂) (E := E) hskey, hb] have hanchor : s.anchor db₁ = s.anchor db₂ := by unfold Selector.anchor rw [hcnt] have hcE : db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) = db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := by rw [List.countP_eq_length_filter, List.countP_eq_length_filter] exact congrArg List.length hb have hcount_le₁ : db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) ≤ db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := by calc db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) = (db₁.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E))).countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := countP_lt_eq_countP_filter (db := db₁) (E := E) hskey _ ≤ (db₁.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E))).length := List.countP_le_length _ = db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := List.countP_eq_length_filter.symm rw [resolve_eq_ite, resolve_eq_ite, hanchor] by_cases hneg : s.anchor db₂ < 0 · rw [ite_eq_left hneg, ite_eq_left hneg] · rw [ite_eq_right hneg, ite_eq_right hneg] have hpos : 0 ≤ s.anchor db₂ := not_lt.mp hneg have hbase : (s.anchor db₂).toNat < db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := (Int.toNat_lt hpos).mpr (by unfold Selector.anchor; omega) have ha₁ : (s.anchor db₂).toNat < db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := by refine lt_of_lt_of_le hbase ?_ calc db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) = db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := hcnt.symm _ ≤ db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := hcount_le₁ have ha₂ : (s.anchor db₂).toNat < db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := by refine lt_of_lt_of_le hbase ?_ calc db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) = db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) := hcnt.symm _ ≤ db₁.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := hcount_le₁ _ = db₂.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < E)) := hcE rw [← getElem?_filter_of_lt_countP db₁.sorted ha₁, ← getElem?_filter_of_lt_countP db₂.sorted ha₂, hb] /-- For `end_.offset = 1`, a stored key strictly below `resolve end_` is strictly below `end_.key`: the window ends at the first stored key at or above `end_.key`. -/ theorem lt_end_key_of_lt_resolve_end_one {db : DB} {r : RangeRead} (hend : r.end_.offset = 1) {k : Key} (hk : k ∈ db.keys) (h : (k : WithTop Key) < resolve db r.end_) : (k : WithTop Key) < r.end_.key := by set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) with hc have hanc : r.end_.anchor db = (c : ℤ) := by unfold Selector.anchor; rw [hc]; omega by_cases hlt : c < db.keys.length · have hres : resolve db r.end_ = (((db.keys[c]'hlt : Key)) : WithTop Key) := by rw [resolve_eq_ite, ite_eq_right (by rw [hanc]; exact not_lt.mpr (Int.natCast_nonneg _)), hanc, Int.toNat_natCast, List.getElem?_eq_getElem hlt] rw [hres] at h by_contra hkE push Not at hkE obtain ⟨j, hj, hjx⟩ := List.mem_iff_getElem.mp hk have hcj : c ≤ j := by by_contra hcon have hjc : j < c := not_le.mp hcon have hklt := getElem_lt_of_lt_countP_top (w := r.end_.key) db.sorted hj (by rw [← hc]; exact hjc) rw [hjx] at hklt exact absurd hkE (not_le.mpr hklt) have hle0 : db.keys[c] ≤ db.keys[j] := (db.sorted.getElem_le_getElem_iff).mpr hcj rw [hjx] at hle0 exact absurd h (not_lt.mpr (WithTop.coe_le_coe.mpr hle0)) · have hclen : c = db.keys.length := le_antisymm (by rw [hc]; exact List.countP_le_length) (not_lt.mp hlt) have : decide ((k : WithTop Key) < r.end_.key) = true := (List.countP_eq_length.mp hclen) k hk exact of_decide_eq_true this /-- For `end_.offset = 1`, every stored key strictly below `end_.key` is strictly below `resolve end_`: the window ends at or past `end_.key`. -/ theorem lt_resolve_end_of_end_one {db : DB} {r : RangeRead} (hend : r.end_.offset = 1) {k : Key} (hk : (k : WithTop Key) < r.end_.key) : (k : WithTop Key) < resolve db r.end_ := by set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) with hc have hanc : r.end_.anchor db = (c : ℤ) := by unfold Selector.anchor; rw [hc]; omega by_cases hlt : c < db.keys.length · have hres : resolve db r.end_ = (((db.keys[c]'hlt : Key)) : WithTop Key) := by rw [resolve_eq_ite, ite_eq_right (by rw [hanc]; exact not_lt.mpr (Int.natCast_nonneg _)), hanc, Int.toNat_natCast, List.getElem?_eq_getElem hlt] have hEnetop : r.end_.key ≠ (⊤ : WithTop Key) := by intro htop rw [htop, countP_lt_top] at hc omega obtain ⟨e, he⟩ := WithTop.ne_top_iff_exists.mp hEnetop have hcc : c = db.keys.countP (fun k => decide (k < e)) := by rw [hc, ← he, countP_lt_coe] have hEc : r.end_.key ≤ (((db.keys[c]'hlt : Key)) : WithTop Key) := by rw [← he] exact WithTop.coe_le_coe.mpr (le_getElem_of_countP_le db.sorted (le_of_eq hcc.symm) hlt) rw [hres] exact lt_of_lt_of_le hk hEc · have htop : resolve db r.end_ = (⊤ : WithTop Key) := resolve_eq_top (by rw [hanc]; exact Int.natCast_nonneg _) (by rw [hanc, Int.toNat_natCast]; exact not_lt.mp hlt) rw [htop]; exact WithTop.coe_lt_top k /-- For `end_.offset ≤ 0`, a stored key strictly below `resolve end_` is strictly below `end_.key`: the window ends at a stored key strictly below `end_.key`. -/ theorem lt_end_key_of_lt_resolve_end_nonpos {db : DB} {r : RangeRead} (hend : r.end_.offset ≤ 0) {k : Key} (_hk : k ∈ db.keys) (h : (k : WithTop Key) < resolve db r.end_) : (k : WithTop Key) < r.end_.key := by set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) with hc have hanc : r.end_.anchor db ≤ (c : ℤ) - 1 := by unfold Selector.anchor; rw [hc]; omega by_cases hneg : r.end_.anchor db < 0 · rw [resolve_eq_nil hneg] at h exact absurd h (not_lt.mpr (WithTop.coe_le_coe.mpr (nil_le_key k))) · have hpos : 0 ≤ r.end_.anchor db := not_lt.mp hneg have hcpos : 1 ≤ c := by have hle0 : (r.end_.anchor db).toNat ≤ c - 1 := by rw [Int.toNat_le, Nat.cast_sub (by omega : 1 ≤ c)]; exact hanc omega have hlt : (r.end_.anchor db).toNat ≤ c - 1 := by rw [Int.toNat_le, Nat.cast_sub hcpos]; exact hanc have hclen : c ≤ db.keys.length := by rw [hc]; exact List.countP_le_length have hlen : (r.end_.anchor db).toNat < db.keys.length := by omega have hic : (r.end_.anchor db).toNat < db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) := by omega rw [resolve_eq_getElem hpos hlen] at h exact lt_trans h (getElem_lt_of_lt_countP_top (w := r.end_.key) db.sorted hlen hic) /-- **The complete-key window at `end_.offset = 1`, nonpositive begin offset.** The complete keys are the stored keys below `end_.key` at or above `resolve begin`. The end selector reaches at or past `end_.key`, so the window never includes a key at or above it. -/ theorem completeKeys_eq_filter_of_end_one {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hend : r.end_.offset = 1) : RangeRead.completeKeys db r = (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))).filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key))) := by have hiff : ∀ k ∈ db.keys, ((k : WithTop Key) < resolve db r.end_ ↔ (k : WithTop Key) < r.end_.key) := fun k hk => ⟨lt_end_key_of_lt_resolve_end_one hend hk, lt_resolve_end_of_end_one hend⟩ unfold RangeRead.completeKeys rw [ite_eq_right (by simp [hrev])] unfold RangeRead.inRange rw [List.filter_filter] apply List.filter_congr intro k hk have hd : decide ((k : WithTop Key) < resolve db r.end_) = decide ((k : WithTop Key) < r.end_.key) := decide_eq_decide.mpr (hiff k hk) rw [Bool.decide_and, hd] /-- **The complete-key window at `end_.offset ≤ 0`, nonpositive begin offset.** The complete keys are the stored keys below `end_.key` in `[resolve begin, resolve end)`. The end selector stops at a stored key strictly below `end_.key`, so the window is a prefix of the keys below `end_.key`. -/ theorem completeKeys_eq_filter_of_end_nonpos {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hend : r.end_.offset ≤ 0) : RangeRead.completeKeys db r = (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))).filter (fun (k : Key) => decide (resolve db r.begin ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < resolve db r.end_)) := by unfold RangeRead.completeKeys rw [ite_eq_right (by simp [hrev])] unfold RangeRead.inRange rw [List.filter_filter] apply List.filter_congr intro k hk by_cases hP : resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_ · have hE : (k : WithTop Key) < r.end_.key := lt_end_key_of_lt_resolve_end_nonpos hend hk hP.2 simp [hP, hE] · simp [hP] /-- **Soundness of `[⊥, end_.key)` for the nonpositive-begin complete under-end case.** Agreement on `[⊥, end_.key)` fixes the stored keys below `end_.key`, hence the begin resolution (by `resolve_eq_of_keys_below`) and the complete keys (`completeKeys_eq_filter_of_end_one`/`_of_end_nonpos`). -/ theorem sound_bottomRange_of_nonpos_underEnd_nonempty {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 1) (hle : r.begin.key ≤ r.end_.key) : Sound r res ⟨(([] : Key) : WithTop Key), r.end_.key⟩ := by intro db₁ db₂ hagree have hb : db₁.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = db₂.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) := by have h : (⟨(([] : Key) : WithTop Key), r.end_.key⟩ : ConflictRange).keys db₁ = (⟨(([] : Key) : WithTop Key), r.end_.key⟩ : ConflictRange).keys db₂ := hagree rwa [keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h have hlo : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_keys_below hbegin hle hb have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by by_cases hend1 : r.end_.offset = 1 · rw [completeKeys_eq_filter_of_end_one hrev hend1, completeKeys_eq_filter_of_end_one (db := db₂) hrev hend1, hlo, hb] · have hend0 : r.end_.offset ≤ 0 := by omega have hV : resolve db₁ r.end_ = resolve db₂ r.end_ := resolve_eq_of_keys_below hend0 (le_refl _) hb rw [completeKeys_eq_filter_of_end_nonpos hrev hend0, completeKeys_eq_filter_of_end_nonpos (db := db₂) hrev hend0, hlo, hb, hV] exact RangeRead.compatible_congr hck /-- **The nonpositive-begin complete under-end case, cross-free.** A read with `begin.offset ≤ 0`, `end_.offset ≤ 1`, `begin.key` at or below the reported head, and a nonempty complete result has `[⊥, end_.key)` as its minimal sound conflict range. The empty key is `necessary_nil_of_begin_offset_nonpos`, the reported keys and everything between them `necessary_of_between_result`, and the keys from the reported last up to `end_.key` `necessary_last_to_end_key`. -/ theorem minimal_bottomRange_of_nonpos_underEnd_nonempty {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 1) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) : Minimal r res ⟨(([] : Key) : WithTop Key), r.end_.key⟩ := by obtain ⟨db₀, hcomp⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp⟩ have hck_eq : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨hm, heq⟩ · simp [hmore] at hm · exact heq have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := by rw [← hck_eq]; exact List.head_mem hne have hhead_mem : res.keys.head hne ∈ db₀.keys := (RangeRead.mem_completeKeys.mp hhead_ck).1 have hhead_hi := (RangeRead.mem_completeKeys.mp hhead_ck).2.2 have hheadE : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key := by by_cases hend1 : r.end_.offset = 1 · exact lt_end_key_of_lt_resolve_end_one hend1 hhead_mem hhead_hi · exact lt_end_key_of_lt_resolve_end_nonpos (by omega) hhead_mem hhead_hi have hle : r.begin.key ≤ r.end_.key := le_trans hlo (le_of_lt hheadE) refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_bottomRange_of_nonpos_underEnd_nonempty hrev hbegin hend hle, ?_⟩ intro k _ hk by_cases hk_last : res.keys.getLast hne ≤ k · exact fun cr hs => necessary_last_to_end_key hreadable hrev hmore hne hend cr hs hk_last hk · have hklt : k < res.keys.getLast hne := not_le.mp hk_last by_cases hk_head : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key) · exact (necessary_nil_of_begin_offset_nonpos hreadable hrev hne hbegin hlo).of_between (necessary_of_mem_result hreadable (List.head_mem hne)) (nil_le_key k) (le_of_lt (WithTop.coe_lt_coe.mp hk_head)) · exact necessary_of_between_result hreadable (List.head_mem hne) (List.getLast_mem hne) (WithTop.coe_le_coe.mp (not_lt.mp hk_head)) (le_of_lt hklt) /-- **Soundness of `[⊥, end_.key)` for the nonpositive-begin complete under-end case, reversed.** Reversal only reverses the complete keys, so agreement on `[⊥, end_.key)` fixes the non-reversed complete keys and hence the reversed ones. -/ theorem sound_bottomRange_of_nonpos_underEnd_nonempty_rev {r : RangeRead} {res : Result} (hrev : r.reverse = true) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 1) (hle : r.begin.key ≤ r.end_.key) : Sound r res ⟨(([] : Key) : WithTop Key), r.end_.key⟩ := by intro db₁ db₂ hagree have hb : db₁.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) = db₂.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) := by have h : (⟨(([] : Key) : WithTop Key), r.end_.key⟩ : ConflictRange).keys db₁ = (⟨(([] : Key) : WithTop Key), r.end_.key⟩ : ConflictRange).keys db₂ := hagree rwa [keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h have hlo : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_keys_below hbegin hle hb have hfw : RangeRead.completeKeys db₁ {r with reverse := false} = RangeRead.completeKeys db₂ {r with reverse := false} := by by_cases hend1 : r.end_.offset = 1 · rw [completeKeys_eq_filter_of_end_one (r := {r with reverse := false}) rfl hend1, completeKeys_eq_filter_of_end_one (r := {r with reverse := false}) (db := db₂) rfl hend1, hlo, hb] · have hend0 : r.end_.offset ≤ 0 := by omega have hV : resolve db₁ r.end_ = resolve db₂ r.end_ := resolve_eq_of_keys_below hend0 (le_refl _) hb rw [completeKeys_eq_filter_of_end_nonpos (r := {r with reverse := false}) rfl hend0, completeKeys_eq_filter_of_end_nonpos (r := {r with reverse := false}) (db := db₂) rfl hend0, hlo, hb, hV] have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by have h₁ : RangeRead.completeKeys db₁ r = (RangeRead.completeKeys db₁ {r with reverse := false}).reverse := by simp [RangeRead.completeKeys, hrev] have h₂ : RangeRead.completeKeys db₂ r = (RangeRead.completeKeys db₂ {r with reverse := false}).reverse := by simp [RangeRead.completeKeys, hrev] rw [h₁, h₂, hfw] exact RangeRead.compatible_congr hck /-- **The nonpositive-begin complete under-end case, cross-free, reversed.** The reversal-symmetric twin of `minimal_bottomRange_of_nonpos_underEnd_nonempty`, with `necessary_nil_of_begin_offset_nonpos_rev` and `necessary_head_to_end_key` in place of their forward forms and the roles of head and last exchanged. -/ theorem minimal_bottomRange_of_nonpos_underEnd_nonempty_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = true) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 1) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) : Minimal r res ⟨(([] : Key) : WithTop Key), r.end_.key⟩ := by obtain ⟨db₀, hcomp⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp⟩ have hck_eq : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨hm, heq⟩ · simp [hmore] at hm · exact heq have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db₀ r := by rw [← hck_eq]; exact List.getLast_mem hne have hlast_mem : res.keys.getLast hne ∈ db₀.keys := (RangeRead.mem_completeKeys.mp hlast_ck).1 have hlast_hi := (RangeRead.mem_completeKeys.mp hlast_ck).2.2 have hlastE : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key := by by_cases hend1 : r.end_.offset = 1 · exact lt_end_key_of_lt_resolve_end_one hend1 hlast_mem hlast_hi · exact lt_end_key_of_lt_resolve_end_nonpos (by omega) hlast_mem hlast_hi have hle : r.begin.key ≤ r.end_.key := le_trans hlo (le_of_lt hlastE) refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_bottomRange_of_nonpos_underEnd_nonempty_rev hrev hbegin hend hle, ?_⟩ intro k _ hk by_cases hk_last : res.keys.getLast hne ≤ k · by_cases hk_head : k ≤ res.keys.head hne · exact necessary_of_between_result hreadable (List.getLast_mem hne) (List.head_mem hne) hk_last hk_head · have hhead_lt : res.keys.head hne < k := lt_of_not_ge hk_head exact fun cr hs => necessary_head_to_end_key hreadable hrev hne hend cr hs (le_of_lt hhead_lt) hk · have hklt : k < res.keys.getLast hne := not_le.mp hk_last exact (necessary_nil_of_begin_offset_nonpos_rev hreadable hrev hmore hne hbegin hlo).of_between (necessary_of_mem_result hreadable (List.getLast_mem hne)) (nil_le_key k) (le_of_lt hklt) /-! ### The crossed nonpositive begin offset, complete result at end offset one At `begin.offset = 0` the begin anchor is `c - 1`, one below the count of stored keys under `begin.key`, so the begin selector lands on the greatest stored key strictly below `begin.key`. When that key is the reported head — the *crossed* subcase, `begin.key` above the head — the window begins at the head, and with `end.offset = 1` the end selector stops at the first stored key at or above `end_.key`, so the complete keys are exactly the stored keys in `[head, end_.key)`. Unlike the cross-free under-end cell, the empty key is *not* forced (the begin selector never reaches `⊥`), so the value is `[head, end_.key)` rather than `[⊥, end_.key)`. This needs `begin.key ≤ end_.key`: otherwise a compatible database can store keys between `end_.key` and `begin.key` that agreement on `[head, end_.key)` cannot see, and `[head, end_.key)` is not sound. -/ /-- **The crossed nonpositive-begin complete under-end at `begin.offset = 0`, `end.offset = 1`.** A forward complete result at `begin.offset = 0` whose `begin.key` lies strictly above the least reported key, with `end.offset = 1` and `begin.key ≤ end_.key`, has the range from the least reported key up to `end_.key`, `[head, end_.key)`, as its minimal sound conflict range. -/ theorem minimal_headToEnd_of_zero_begin_crossed_endOne {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : r.end_.offset = 1) (hkey_le : r.begin.key ≤ r.end_.key) : Minimal r res ⟨((res.keys.head hne : Key) : WithTop Key), r.end_.key⟩ := by obtain ⟨db₀, hcomp₀⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp₀⟩ have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn ⟨((res.keys.head hne : Key) : WithTop Key), r.end_.key⟩ db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hres_eq : res.keys = RangeRead.completeKeys db r := by rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hhead_stored : res.keys.head hne ∈ db.keys := RangeRead.compatible_keys_subset hcomp_db hhead_mem have hhead_lt_end : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key := by have hmem := RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem) exact lt_end_key_of_lt_resolve_end_one hend hhead_stored hmem.2.2 have hfilter : db.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) = db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := hag' have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact (RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem)).2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross (res.keys.head hne) hhead_stored hcross have hhead_stored' : res.keys.head hne ∈ db'.keys := by have hmf : res.keys.head hne ∈ db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := by rw [← hfilter] exact List.mem_filter.mpr ⟨hhead_stored, by rw [decide_eq_true_eq]; exact ⟨le_refl _, hhead_lt_end⟩⟩ exact List.mem_of_mem_filter hmf have hL' : resolve db' r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · by_contra hcon have hgt : ((res.keys.head hne : Key) : WithTop Key) < resolve db' r.begin := lt_of_not_ge hcon have hlt' : resolve db' r.begin < r.begin.key := resolve_zero_begin_lt_key (db := db') hbegin hhead_stored' hcross rcases resolve_eq_nil_or_eq_top_or_mem (db := db') (s := r.begin) with hn | ht | ⟨k, hkdb', hkres⟩ · rw [hn] at hgt exact absurd hgt (not_lt.mpr (coe_nil_le ((res.keys.head hne : Key) : WithTop Key))) · rw [ht] at hlt' exact absurd hlt' (not_lt.mpr le_top) · have hkgt : res.keys.head hne < k := by rw [hkres] at hgt exact WithTop.coe_lt_coe.mp hgt have hk_lt_begin : (k : WithTop Key) < r.begin.key := by rw [hkres] at hlt' exact hlt' have hk_lt_end : (k : WithTop Key) < r.end_.key := lt_of_lt_of_le hk_lt_begin hkey_le have hk_in : k ∈ db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := List.mem_filter.mpr ⟨hkdb', by rw [decide_eq_true_eq] exact ⟨WithTop.coe_le_coe.mpr (le_of_lt hkgt), hk_lt_end⟩⟩ rw [← hfilter] at hk_in have hkdb : k ∈ db.keys := List.mem_of_mem_filter hk_in have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k hkdb hk_lt_begin rw [hL] at hb exact absurd hb (not_le.mpr (WithTop.coe_lt_coe.mpr hkgt)) · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored' hcross (res.keys.head hne) hhead_stored' hcross have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db' r := by rw [completeKeys_eq_filter_of_end_one hrev hend, completeKeys_eq_filter_of_end_one (db := db') hrev hend, hL, hL', List.filter_filter, List.filter_filter] simpa only [Bool.decide_and] using hfilter exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hlo hhi have hk_le : res.keys.head hne ≤ k := WithTop.coe_le_coe.mp hlo by_cases hklast : k ≤ res.keys.getLast hne · exact necessary_of_between_result hreadable (List.head_mem hne) (List.getLast_mem hne) hk_le hklast · exact fun cr hs => necessary_last_to_end_key hreadable hrev hmore hne (le_of_eq hend) cr hs (le_of_lt (lt_of_not_ge hklast)) hhi /-- At `begin.offset = 0`, the head-to-`end_.key` range is *the* minimal sound conflict range up to set equality for a crossed complete under-end result at `end.offset = 1`. -/ theorem unique_minimal_headToEnd_of_zero_begin_crossed_endOne {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : r.end_.offset = 1) (hkey_le : r.begin.key ≤ r.end_.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_headToEnd_of_zero_begin_crossed_endOne hread hrev hmore hne hbegin hcross hend hkey_le) /-- **The crossed nonpositive-begin complete long under-end at `begin.offset = 0`, `end.offset = 1`.** The `end_.key < begin.key` companion of `minimal_headToEnd_of_zero_begin_crossed_endOne`. A forward complete result at `begin.offset = 0` whose `begin.key` lies strictly above both the least reported key and `end_.key` has the range from the least reported key up to `begin.key`, `[head, begin.key)`, as its minimal sound conflict range. The keys between `end_.key` and `begin.key` are forced: storing one lifts the begin resolution above the reported head, so the value ends at `begin.key` rather than `end_.key`. -/ theorem minimal_headToBeginKey_of_zero_begin_crossed_endOne_long {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : r.end_.offset = 1) (hlong : r.end_.key < r.begin.key) : Minimal r res ⟨((res.keys.head hne : Key) : WithTop Key), r.begin.key⟩ := by obtain ⟨db₀, hcomp₀⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp₀⟩ have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn ⟨((res.keys.head hne : Key) : WithTop Key), r.begin.key⟩ db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hres_eq : res.keys = RangeRead.completeKeys db r := by rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hhead_stored : res.keys.head hne ∈ db.keys := RangeRead.compatible_keys_subset hcomp_db hhead_mem have hfilter : db.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) = db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) := hag' have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact (RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem)).2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross (res.keys.head hne) hhead_stored hcross have hhead_stored' : res.keys.head hne ∈ db'.keys := by have hmf : res.keys.head hne ∈ db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) := by rw [← hfilter] exact List.mem_filter.mpr ⟨hhead_stored, by rw [decide_eq_true_eq]; exact ⟨le_refl _, hcross⟩⟩ exact List.mem_of_mem_filter hmf have hL' : resolve db' r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · by_contra hcon have hgt : ((res.keys.head hne : Key) : WithTop Key) < resolve db' r.begin := lt_of_not_ge hcon have hlt' : resolve db' r.begin < r.begin.key := resolve_zero_begin_lt_key (db := db') hbegin hhead_stored' hcross rcases resolve_eq_nil_or_eq_top_or_mem (db := db') (s := r.begin) with hn | ht | ⟨k, hkdb', hkres⟩ · rw [hn] at hgt exact absurd hgt (not_lt.mpr (coe_nil_le ((res.keys.head hne : Key) : WithTop Key))) · rw [ht] at hlt' exact absurd hlt' (not_lt.mpr le_top) · have hkgt : res.keys.head hne < k := by rw [hkres] at hgt exact WithTop.coe_lt_coe.mp hgt have hk_lt_begin : (k : WithTop Key) < r.begin.key := by rw [hkres] at hlt' exact hlt' have hk_in : k ∈ db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) := List.mem_filter.mpr ⟨hkdb', by rw [decide_eq_true_eq] exact ⟨WithTop.coe_le_coe.mpr (le_of_lt hkgt), hk_lt_begin⟩⟩ rw [← hfilter] at hk_in have hkdb : k ∈ db.keys := List.mem_of_mem_filter hk_in have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k hkdb hk_lt_begin rw [hL] at hb exact absurd hb (not_le.mpr (WithTop.coe_lt_coe.mpr hkgt)) · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored' hcross (res.keys.head hne) hhead_stored' hcross have hmemP : ∀ k : Key, (k ∈ db.keys ∧ (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) ↔ (k ∈ db'.keys ∧ (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) := by intro k have h := congrArg (fun l : List Key => k ∈ l) hfilter exact iff_of_eq (by simpa only [List.mem_filter, decide_eq_true_eq] using h) have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db' r := by have hckd : RangeRead.completeKeys db r = (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))).filter (fun (k : Key) => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key))) := by rw [completeKeys_eq_filter_of_end_one hrev hend, hL] rw [hckd, completeKeys_eq_filter_of_end_one (db := db') hrev hend, hL'] apply eq_of_forall_mem_iff_of_pairwise · exact db.sorted.pairwise.sublist (List.filter_sublist.trans List.filter_sublist) · exact db'.sorted.pairwise.sublist (List.filter_sublist.trans List.filter_sublist) · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨⟨hk, hkE⟩, hkh⟩ exact ⟨⟨((hmemP k).mp ⟨hk, hkh, lt_of_lt_of_le hkE (le_of_lt hlong)⟩).1, hkE⟩, hkh⟩ · rintro ⟨⟨hk, hkE⟩, hkh⟩ exact ⟨⟨((hmemP k).mpr ⟨hk, hkh, lt_of_lt_of_le hkE (le_of_lt hlong)⟩).1, hkE⟩, hkh⟩ exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hlo hhi have hk_le : res.keys.head hne ≤ k := WithTop.coe_le_coe.mp hlo by_cases hk : k ∈ res.keys · exact necessary_of_mem_result hreadable hk · have hk_gt : res.keys.head hne < k := lt_of_le_of_ne hk_le (fun h => hk (h ▸ hhead_mem)) intro cr hs by_contra hcr have hres_eq₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hhead_stored₀ : res.keys.head hne ∈ db₀.keys := RangeRead.compatible_keys_subset hcomp₀ hhead_mem have hL₀ : resolve db₀ r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact (RangeRead.mem_completeKeys.mp (by rw [← hres_eq₀]; exact hhead_mem)).2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored₀ hcross (res.keys.head hne) hhead_stored₀ hcross have hk0 : k ∉ db₀.keys := by intro hkdb have hle := resolve_zero_begin_le_of_mem_below (db := db₀) hbegin hhead_stored₀ hcross k hkdb hhi rw [hL₀] at hle exact absurd hle (not_le.mpr (WithTop.coe_lt_coe.mpr hk_gt)) have hagree : AgreeOn cr db₀ (db₀.insert k hk0) := (ConflictRange.keys_insert_of_not_mem cr db₀ hk0 hcr).symm have hcomp₁ : RangeRead.Compatible (db₀.insert k hk0) r res := (hs db₀ _ hagree).mp hcomp₀ have hk_in : k ∈ (db₀.insert k hk0).keys := DB.mem_insert_self db₀ k hk0 have hk_le_res : (k : WithTop Key) ≤ resolve (db₀.insert k hk0) r.begin := resolve_zero_begin_le_of_mem_below hbegin hk_in hhi k hk_in hhi have hhead_notin : res.keys.head hne ∉ RangeRead.completeKeys (db₀.insert k hk0) r := by rw [RangeRead.mem_completeKeys] rintro ⟨-, hlo', -⟩ exact absurd hlo' (not_le.mpr (lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hk_gt) hk_le_res)) have hneq : res.keys ≠ RangeRead.completeKeys (db₀.insert k hk0) r := fun heq => hhead_notin (heq ▸ hhead_mem) rcases hcomp₁.2 with ⟨hm', _, _⟩ | ⟨hm', heq'⟩ · rw [hmore] at hm'; exact absurd hm' (by simp) · exact hneq heq' /-- At `begin.offset = 0`, the head-to-`begin.key` range is *the* minimal sound conflict range up to set equality for a crossed complete under-end result at `end.offset = 1` with `begin.key` strictly above `end_.key`. -/ theorem unique_minimal_headToBeginKey_of_zero_begin_crossed_endOne_long {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : r.end_.offset = 1) (hlong : r.end_.key < r.begin.key) : ∃ cr : ConflictRange, Minimal r res cr ∧ ∀ cr' : ConflictRange, Minimal r res cr' → cr'.toSet = cr.toSet := exists_unique_minimal_of_minimal (minimal_headToBeginKey_of_zero_begin_crossed_endOne_long hread hrev hmore hne hbegin hcross hend hlong) /-! ## The nonpositive-begin truncated forward cell A truncated forward result at a nonpositive begin offset, cross-free (`begin.key` at or below the reported last) and with the end pinned above the reported keys (`1 ≤ end_.offset` and every reported key strictly below `end_.key`), has the bottom truncated range `[⊥, keyAfter (last reported))` as its minimal sound conflict range. The lower end is the empty key rather than `begin.key`, because the resolved begin can land below `begin.key`; the empty key is `necessary_nil_of_begin_offset_nonpos`, the reported keys and everything between them `necessary_of_between_result`, and nothing past the successor of the reported last because the result reports a prefix. Soundness: agreement on `[⊥, keyAfter last)` fixes the stored keys at or below the reported last, hence the begin resolution (`resolve_eq_of_keys_below`) and the complete keys up to the reported last, since `end_.key ≤ resolve end_`. -/ /-- The bottom truncated range `[⊥, keyAfter last)`: the truncated forward value at a nonpositive begin offset, where the lower end is the empty key rather than `begin.key`. -/ def truncatedRangeBottom (last : Key) : ConflictRange := ⟨(([] : Key) : WithTop Key), (keyAfter last : WithTop Key)⟩ /-- **Dropping the end bound from the filtered complete keys.** When the reported last lies strictly below `resolve end_`, filtering the complete keys at or below `last` is the stored keys at or above `resolve begin` and at or below `last`: every key at or below `last` is automatically below `resolve end_`. -/ theorem completeKeys_filter_le_eq {db : DB} {r : RangeRead} {last : Key} (hrev : r.reverse = false) (hlt : (last : WithTop Key) < resolve db r.end_) : (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ k ≤ last)) := by apply eq_of_forall_mem_iff_of_pairwise · have hcp : (RangeRead.completeKeys db r).Pairwise (· < ·) := by have h := RangeRead.completeKeys_pairwise (db := db) (r := r) rw [hrev] at h exact h exact hcp.sublist List.filter_sublist · exact db.sorted.pairwise.sublist List.filter_sublist · intro k simp only [List.mem_filter, decide_eq_true_eq] rw [RangeRead.mem_completeKeys] constructor · rintro ⟨⟨hk, hb, _⟩, hlast⟩ exact ⟨hk, hb, hlast⟩ · rintro ⟨hk, hb, hlast⟩ exact ⟨⟨hk, hb, lt_of_le_of_lt (WithTop.coe_le_coe.mpr hlast) hlt⟩, hlast⟩ /-- **Soundness of `[⊥, keyAfter last)` for the nonpositive-begin truncated forward case.** Agreement on `[⊥, keyAfter last)` fixes the stored keys at or below the reported last, hence the begin resolution (`resolve_eq_of_keys_below`) and the complete keys up to the reported last (`completeKeys_filter_le_eq`), because `end_.key ≤ resolve end_` puts every key at or below the reported last below `resolve end_`. -/ theorem sound_truncatedRangeBottom_of_nonpos {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : r.begin.offset ≤ 0) (hmore : res.more = true) (hne : res.keys ≠ []) (hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) (hge : 1 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Sound r res (truncatedRangeBottom (res.keys.getLast hne)) := by intro db₁ db₂ hagree -- Agreement on the bottom truncated range is equality of the stored keys at or below -- the reported last, since `< keyAfter last` is `≤ last`. have hbE : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter (res.keys.getLast hne) : WithTop Key))) = db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter (res.keys.getLast hne) : WithTop Key))) := by have h : (truncatedRangeBottom (res.keys.getLast hne)).keys db₁ = (truncatedRangeBottom (res.keys.getLast hne)).keys db₂ := hagree unfold truncatedRangeBottom at h rwa [keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h have hb : db₁.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = db₂.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by have hc : ∀ db : DB, db.keys.filter (fun k : Key => decide ((k : WithTop Key) < (keyAfter (res.keys.getLast hne) : WithTop Key))) = db.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by intro db apply List.filter_congr intro k _ rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] rwa [hc db₁, hc db₂] at hbE -- The begin resolution agrees: `begin.key ≤ last < keyAfter last`. have hkey_ka : r.begin.key ≤ (keyAfter (res.keys.getLast hne) : WithTop Key) := le_trans hlo (WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt (res.keys.getLast hne)))) have hres : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_keys_below hbegin hkey_ka hbE -- Every key at or below the reported last lies below `resolve end_`, since -- `last < end_.key ≤ resolve end_`. have hlast_end : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key := hhi _ (List.getLast_mem hne) have hlt : ∀ db : DB, ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := fun db => lt_of_lt_of_le hlast_end (key_le_resolve_of_one_le (db := db) (s := r.end_) hge) have hA : ∀ db : DB, db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ k ≤ res.keys.getLast hne)) = (db.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne))).filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) := by intro db rw [List.filter_filter] apply List.filter_congr intro k _ rw [Bool.decide_and] have hck : (RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) := by rw [completeKeys_filter_le_eq (db := db₁) hrev (hlt db₁), completeKeys_filter_le_eq (db := db₂) hrev (hlt db₂)] rw [hA db₁, hA db₂, hres, hb] rw [compatible_iff_truncated_keys hrev hmore hne, compatible_iff_truncated_keys (db := db₂) hrev hmore hne, hck] /-- **The nonpositive-begin truncated forward case, cross-free and end-pinned.** A read with `begin.offset ≤ 0`, `begin.key` at or below the reported head, `1 ≤ end_.offset` and every reported key strictly below `end_.key`, and a nonempty truncated forward result has `[⊥, keyAfter (last reported))` as its minimal sound conflict range. The empty key is `necessary_nil_of_begin_offset_nonpos`, the reported keys and everything between them `necessary_of_between_result`, and nothing past the reported last's successor because the result reports a prefix. -/ theorem minimal_truncatedRangeBottom_of_nonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) (hge : 1 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (truncatedRangeBottom (res.keys.getLast hne)) := by obtain ⟨db₀, hcomp⟩ := hread have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hhead_last : res.keys.head hne ≤ res.keys.getLast hne := (hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne) have hlo' : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := le_trans hlo (WithTop.coe_le_coe.mpr hhead_last) refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_truncatedRangeBottom_of_nonpos hrev hbegin hmore hne hlo' hge hhi, ?_⟩ intro k _ hk have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk) exact (necessary_nil_of_begin_offset_nonpos ⟨db₀, hcomp⟩ hrev hne hbegin hlo).of_between (necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne)) (nil_le_key k) hkle /-! ## The empty conflict range The empty interval has no keys to track. It is the certificate for reads that are always empty: `FormalConflictRange.Empty` proves it sound and minimal for any `AlwaysEmpty` read, using the exact database-free characterization developed there. -/ /-- The empty conflict range: no keys, nothing to track. -/ def emptyRange (r : RangeRead) : ConflictRange := ⟨r.begin.key, r.begin.key⟩ /-- The empty range contains no keys. -/ theorem not_mem_emptyRange (r : RangeRead) (k : Key) : k ∉ emptyRange r := ConflictRange.not_mem_of_isEmpty (cr := emptyRange r) (le_refl r.begin.key) k /-! ## The compact closed form at `begin.offset = 1` This section proves the closed form for a complete non-reversed result at `begin.offset = 1` and a cross-free read `begin.key ≤ end_.key`. Writing `e = end_.offset` and `t = reportedAtOrAbove end_.key res`, the minimal range is * `[begin.key, end_.key)` when `e ≤ 1`; * `[begin.key, keyAfter (last reported))` when `e = t + 1`; * `[begin.key, ⊤)` when `t + 1 < e`. The key observation is that the complete keys are the stored keys at or above `begin.key`, cut after the first `(e - 1)` stored keys at or above `end_.key`. -/ /-- Filtering an ascending list at or below a threshold gives its take at the count of elements at or below the threshold. -/ theorem filter_le_eq_take_countP {l : List Key} (hs : l.SortedLT) (t : Key) : l.filter (fun k : Key => decide (k ≤ t)) = l.take (l.countP (fun k : Key => decide (k ≤ t))) := by have hkey : (fun k : Key => decide (k ≤ t)) = (fun k : Key => decide ((k : WithTop Key) < ((keyAfter t : Key) : WithTop Key))) := by funext k rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] conv_lhs => rw [hkey] rw [filter_lt_eq_take_countP hs ((keyAfter t : Key) : WithTop Key)] congr 1 apply List.countP_congr intro k _ simp only [decide_eq_true_eq, WithTop.coe_lt_coe, lt_keyAfter_iff] /-- Filtering a strictly increasing list at or below its `n`-th key gives the first `n + 1` elements. -/ theorem filter_le_eq_take_succ_of_getElem {l : List Key} (hs : l.SortedLT) {x : Key} {n : Nat} (hn : n < l.length) (hnx : l[n] = x) : l.filter (fun k : Key => decide (k ≤ x)) = l.take (n + 1) := by have hcnt : l.countP (fun k : Key => decide (k ≤ x)) = n + 1 := by have hlt : l.countP (fun k : Key => decide (k < keyAfter x)) = l.countP (fun k : Key => decide (k ≤ x)) := by apply List.countP_congr intro k _ rw [decide_eq_true_eq, decide_eq_true_eq, lt_keyAfter_iff] have hlow : n < l.countP (fun k : Key => decide (k < keyAfter x)) := lt_countP_of_getElem_lt hs hn (by rw [hnx]; exact keyAfter_self_lt x) have hhigh : l.countP (fun k : Key => decide (k < keyAfter x)) ≤ n + 1 := by by_contra hle have hgt : n + 1 < l.countP (fun k : Key => decide (k < keyAfter x)) := by omega have hi : n + 1 < l.length := lt_of_lt_of_le hgt (List.countP_le_length) have hltn := getElem_lt_of_lt_countP hs hi (x := keyAfter x) hgt have hxlt : x < l[n + 1] := by rw [← hnx] exact hs.getElem_lt_getElem_iff.mpr (by omega) have hxle : l[n + 1] ≤ x := (lt_keyAfter_iff (l[n + 1]) x).mp hltn exact absurd hxlt (not_lt.mpr hxle) omega rw [filter_le_eq_take_countP hs x, hcnt] /-- At begin offset one and end offset at least one, the complete keys of a forward read are the stored keys at or above `begin.key`, truncated after the first `(end.offset - 1)` stored keys at or above `end_.key`. -/ theorem completeKeys_eq_filter_take_of_offset_one {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : 1 ≤ r.end_.offset) : RangeRead.completeKeys db r = (db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).take (min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key))) := by set l := db.keys with hl set p := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key)) with hcE set e' := (r.end_.offset - 1).toNat with he' set d := l.countP (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_)) with hd have hls : l.SortedLT := by rw [hl]; exact db.sorted have hp_anchor : (r.begin.anchor db).toNat = p := by rw [anchor_toNat_eq (s := r.begin) (by omega), hbegin, hp] rw [← hl] simp have hd_eq : d = min (cE + e') l.length := by rw [hd, hl, countP_lt_resolve, anchor_toNat_eq (s := r.end_) hend, hcE, he'] have hA : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.drop p := by have hdrop : l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) = l.drop p := by rw [hp] exact filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hLHS : RangeRead.completeKeys db r = (l.drop p).take (d - p) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] dsimp only [RangeRead.inRange] rw [show l.filter (fun (k : Key) => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, filter_resolve_le_eq_drop (db := db) (s := r.begin), hp_anchor] have hdrop : (l.drop p).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) rw [filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) p, ← hd, nat_sub_min_right] rw [hLHS] rw [← hA] rw [hd_eq] /-- Among a list of keys, the number at or above `E` and the number below `E` add up to the length. -/ theorem countP_ge_add_countP_lt {l : List Key} (E : WithTop Key) : l.countP (fun k : Key => decide (E ≤ (k : WithTop Key))) + l.countP (fun k : Key => decide ((k : WithTop Key) < E)) = l.length := by induction l with | nil => rfl | cons a rest ih => by_cases h : ((a : Key) : WithTop Key) < E · have hge : ¬ E ≤ ((a : Key) : WithTop Key) := not_le.mpr h rw [List.countP_cons_of_neg (by simpa using hge), List.countP_cons_of_pos (by simpa using h)] simp only [List.length_cons] omega · have hge : E ≤ ((a : Key) : WithTop Key) := le_of_not_gt h rw [List.countP_cons_of_pos (by simpa using hge), List.countP_cons_of_neg (by simpa using h)] simp only [List.length_cons] omega /-- Among the first `M` elements of an ascending key list, the number at or above `E` is `M` minus the number below `E` that survive truncation. -/ theorem countP_ge_take {l : List Key} (hs : l.SortedLT) (E : WithTop Key) {M : Nat} (hM : M ≤ l.length) : (l.take M).countP (fun k : Key => decide (E ≤ (k : WithTop Key))) = M - min M (l.countP (fun k : Key => decide ((k : WithTop Key) < E))) := by have hsum := countP_ge_add_countP_lt (l := l.take M) E have hlen : (l.take M).length = M := by rw [List.length_take, Nat.min_eq_left hM] rw [hlen] at hsum have hlt : (l.take M).countP (fun k : Key => decide ((k : WithTop Key) < E)) = min M (l.countP (fun k : Key => decide ((k : WithTop Key) < E))) := countP_take_eq_min hs E M omega /-- The number of complete keys at or above `end_.key` is at most `(end_.offset - 1)`. -/ theorem completeKeys_count_ge_le {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by set l := db.keys with hl set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef set p := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key)) with hcE set e' := (r.end_.offset - 1).toNat with he' have hls : l.SortedLT := by rw [hl]; exact db.sorted have hp_le_cE : p ≤ cE := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk hcross have hA_eq : A = l.drop p := by rw [hAdef] have hdrop : l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) = l.drop p := by rw [hp] exact filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hAs : A.SortedLT := by rw [hA_eq] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) have hA_len : A.length = l.length - p := by rw [hA_eq, List.length_drop] have hq : A.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE - p := by rw [hA_eq, countP_drop_eq hls r.end_.key p, ← hcE, Nat.min_eq_left hp_le_cE] -- Rewrite the complete keys into a prefix of `A`. have hck : RangeRead.completeKeys db r = A.take (min (cE + e') l.length - p) := by rw [completeKeys_eq_filter_take_of_offset_one (db := db) hrev hbegin hend] have hM_le : min (cE + e') l.length - p ≤ A.length := by rw [hA_len] exact Nat.sub_le_sub_right (Nat.min_le_right _ _) p have hcount : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (min (cE + e') l.length - p) - min (min (cE + e') l.length - p) (cE - p) := by rw [hck] have := countP_ge_take hAs r.end_.key hM_le rwa [hq] at this have hpL : p ≤ l.length := by rw [hp]; exact List.countP_le_length have hcEL : cE ≤ l.length := by rw [hcE]; exact List.countP_le_length by_cases hcase : cE + e' ≤ l.length · have hmin : min (cE + e') l.length = cE + e' := Nat.min_eq_left hcase have hM : min (cE + e') l.length - p = (cE - p) + e' := by rw [hmin] omega rw [hcount, hM] rw [Nat.min_eq_right (Nat.le_add_right (cE - p) e'), Nat.add_sub_cancel_left] · have hmin : min (cE + e') l.length = l.length := Nat.min_eq_right (le_of_not_ge hcase) have hM : min (cE + e') l.length - p = l.length - p := by rw [hmin] have hqle : cE - p ≤ l.length - p := by omega rw [hcount, hM, Nat.min_eq_right hqle] have heq : l.length - p - (cE - p) = l.length - cE := by omega rw [heq] omega /-- **The count bound at any positive begin offset.** The number of complete keys at or above `end_.key` is at most `(end_.offset - 1).toNat`, for every `begin.offset ≥ 1`. The end resolution is the `(end_.offset)`-th stored key at or above `end_.key`, so the window contains at most the first `(end_.offset - 1)` such keys; a higher begin resolution only removes more of them. -/ theorem completeKeys_count_ge_le_general {db : DB} {r : RangeRead} (hrev : r.reverse = false) (_hbegin : 1 ≤ r.begin.offset) (_hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by set l := db.keys with hl set Q := l.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hQ set e := (r.end_.offset - 1).toNat with he have hQs : Q.SortedLT := by rw [hQ] exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) -- The complete keys, then their filter at or above `end_.key`. have hW : RangeRead.completeKeys db r = l.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) := by unfold RangeRead.completeKeys RangeRead.inRange rw [ite_eq_right (by simp [hrev])] have hcnt : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_))).length := by rw [hW, List.countP_filter] rw [← List.countP_eq_length_filter] rw [hQ] rw [List.countP_filter] apply countP_le_countP_of_imp intro k _ hp simp only [Bool.and_eq_true] at hp ⊢ exact ⟨decide_eq_true (of_decide_eq_true hp.2).2, hp.1⟩ -- Bound the filtered `Q` by `e`. have hQle : (Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_))).length ≤ e := by have hres := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend rw [← hl, ← hQ] at hres by_cases hQe : e < Q.length · rw [List.getElem?_eq_getElem hQe] at hres rw [hres] have htake : Q.filter (fun k : Key => decide ((k : WithTop Key) < (↑(Q[e]) : WithTop Key))) = Q.take e := by rw [filter_lt_eq_take_countP hQs (↑(Q[e]) : WithTop Key)] congr 1 rw [show Q.countP (fun (k : Key) => decide ((k : WithTop Key) < (↑(Q[e]) : WithTop Key))) = Q.countP (fun k : Key => decide (k < Q[e])) from by apply List.countP_congr intro k _ rw [decide_eq_true_eq, decide_eq_true_eq, WithTop.coe_lt_coe]] exact countP_lt_eq_of_getElem hQs hQe rfl rw [htake, List.length_take, Nat.min_eq_left (le_of_lt hQe)] · rw [List.getElem?_eq_none (le_of_not_gt hQe)] at hres rw [hres] have hall : Q.filter (fun k : Key => decide ((k : WithTop Key) < (⊤ : WithTop Key))) = Q := by rw [List.filter_eq_self] intro k _ simp rw [hall] exact le_of_not_gt hQe exact le_trans hcnt hQle /-- **Exact count of complete keys at or above `end_.key`.** For a non-reversed cross-free read at any positive begin offset, the number of complete keys at or above `end_.key` is the size of the top window `[end_.key, …)` truncated to `end.offset - 1` keys, with the begin offset's overshoot past the interval gap removed. Writing `p = #{keys < begin.key}`, `cE = #{keys < end_.key}` and `b = begin.offset - 1`, the window begins at stored index `p + b` and the count is `min e (#stored at or above end_.key) - (b - (cE - p))`. In particular the existing upper bound `completeKeys_count_ge_le_general` is the same identity capped at `e`. -/ theorem completeKeys_count_ge_eq_general {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = min ((r.end_.offset - 1).toNat) (db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) - ((r.begin.offset - 1).toNat - (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)))) := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hls : l.SortedLT := by rw [hl]; exact db.sorted have hp_le_cE : p ≤ cE := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk hcross have hcE_le : cE ≤ l.length := by rw [hcE]; exact List.countP_le_length have hanB : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbegin, hp, hb, hl] have hA : l.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) = l.drop (p + b) := by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hanB] set d := l.countP (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) with hd have hd_eq : d = min (cE + e) l.length := by rw [hd, countP_lt_resolve] rw [anchor_toNat_eq (s := r.end_) hend, hcE, he, hl] have hck : RangeRead.completeKeys db r = (l.drop (p + b)).take (d - (p + b)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop (p + b)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p + b) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) (p + b), ← hd, nat_sub_min_right] set A := l.length - cE with hAdef set N := cE - p with hNdef have hMle : d - (p + b) ≤ (l.drop (p + b)).length := by rw [List.length_drop] have : d ≤ l.length := by rw [hd_eq]; exact Nat.min_le_right _ _ omega have hQ : (l.drop (p + b)).countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = N - min b N := by rw [countP_drop_eq hls r.end_.key (p + b)] have hmin : min (p + b) cE = p + min b N := by omega rw [hmin] omega rw [hck, countP_ge_take (List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p + b) hls.pairwise)) r.end_.key hMle, hQ] have hAeq : A = l.length - cE := rfl by_cases hbN : b ≤ N · have hM : d - (p + b) = min e A + (N - b) := by rw [hd_eq] have hmin : min (cE + e) l.length = cE + min e A := by rw [hAeq]; omega rw [hmin]; omega have hQ0 : N - min b N = N - b := by rw [Nat.min_eq_left hbN] rw [hM, hQ0] have hQle : N - b ≤ min e A + (N - b) := Nat.le_add_left _ _ rw [Nat.min_eq_right hQle] omega · have hbN' : N < b := Nat.lt_of_not_le hbN have hM : d - (p + b) = min e A - (b - N) := by rw [hd_eq] have hmin : min (cE + e) l.length = cE + min e A := by rw [hAeq]; omega rw [hmin]; omega have hQ0 : N - min b N = 0 := by rw [Nat.min_eq_right (le_of_lt hbN'), Nat.sub_self] rw [hM, hQ0] simp /-- **The complete window as a shifted slice above `end_.key`.** When the begin selector does not start past the top window (`N ≤ b`) and the top window is long enough (`e ≤ #stored at or above end_.key`), the complete keys are exactly the first `e` stored keys at or above `end_.key`, with the begin overshoot `b - N` dropped from the front. This is the list-level form of `completeKeys_count_ge_eq_general`; it makes the window depend only on the stored keys at or above `end_.key` and on the two counts. -/ theorem completeKeys_eq_above_take_drop {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hbN : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤ (r.begin.offset - 1).toNat) (hAle : (r.end_.offset - 1).toNat ≤ db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) : RangeRead.completeKeys db r = ((db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).take (r.end_.offset - 1).toNat).drop ((r.begin.offset - 1).toNat - (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)))) := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he set N := cE - p with hN have hls : l.SortedLT := by rw [hl]; exact db.sorted have hp_le_cE : p ≤ cE := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk hcross have hbN' : N ≤ b := by rw [hN]; exact hbN have hAle' : e ≤ l.length - cE := hAle have hcE_le : cE ≤ l.length := by rw [hcE]; exact List.countP_le_length have hanB : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbegin, hp, hb, hl] have hA : l.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) = l.drop (p + b) := by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hanB] set d := l.countP (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) with hd have hd_eq : d = min (cE + e) l.length := by rw [hd, countP_lt_resolve] rw [anchor_toNat_eq (s := r.end_) hend, hcE, he, hl] have hck : RangeRead.completeKeys db r = (l.drop (p + b)).take (d - (p + b)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop (p + b)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p + b) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) (p + b), ← hd, nat_sub_min_right] have hAE : l.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = l.drop cE := by have h := filter_not_lt_eq_drop_countP hls r.end_.key rw [show l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE from hcE.symm] at h rw [← h] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hmin : min (cE + e) l.length = cE + e := by omega have hdrop : l.drop (p + b) = (l.drop cE).drop (b - N) := by rw [List.drop_drop] congr 1 omega rw [hck, hAE, hdrop, hd_eq, hmin] rw [show cE + e - (p + b) = e - (b - N) by omega] rw [← List.drop_take] /-- **Nothing lies above the reported last in the finite branch.** If the complete keys filtered at or below the reported `last` are exactly the reported keys, and the number of reported keys at or above `end_.key` is `end_.offset - 1`, then the complete keys *are* the reported keys. Any complete key above `last` would be at or above `end_.key` and would push the count past the bound `completeKeys_count_ge_le_general`. -/ private theorem completeKeys_eq_of_filter_le_eq {db : DB} {r : RangeRead} {res : Result} {last : Key} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (hlast : last = res.keys.getLast hne) (hres : (RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) = res.keys) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : RangeRead.completeKeys db r = res.keys := by set W := RangeRead.completeKeys db r with hW set P : Key → Bool := fun k => decide (r.end_.key ≤ (k : WithTop Key)) with hP set e := (r.end_.offset - 1).toNat with he have hW_sorted : W.SortedLT := by rw [hW] unfold RangeRead.completeKeys RangeRead.inRange rw [ite_eq_right (by simp [hrev])] exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) have hres_sorted : res.keys.SortedLT := by rw [← hres] exact List.sortedLT_iff_pairwise.mpr (hW_sorted.pairwise.filter _) have hepos : 0 < e := by rw [he] omega have hresP : res.keys.countP P = e := by rw [hP]; exact ht -- The reported last is at or above `end_.key`. have hlast_ge : r.end_.key ≤ (last : WithTop Key) := by rw [hlast] by_contra hnot have hzero : res.keys.countP P = 0 := by apply List.countP_eq_zero.mpr intro k hk by_contra hpk have htrue : P k = true := by cases h : P k <;> simp_all have hk_le_last : k ≤ res.keys.getLast hne := (hres_sorted.pairwise.imp le_of_lt).rel_getLast hk exact hnot (le_trans (of_decide_eq_true htrue) (by exact_mod_cast hk_le_last)) rw [hresP] at hzero omega -- If any complete key exceeded `last`, the count bound would be violated. have hno : ∀ k ∈ W, k ≤ last := by intro k hk by_contra hkle have hlt : last < k := lt_of_not_ge hkle have hk_ge : r.end_.key ≤ (k : WithTop Key) := le_trans hlast_ge (by exact_mod_cast le_of_lt hlt) have hk_fil : k ∈ W.filter P := List.mem_filter.mpr ⟨hk, by simp [hP, hk_ge]⟩ have hk_not_le : k ∉ W.filter (fun k : Key => decide (k ≤ last)) := by intro hmem exact (not_le.mpr hlt) (of_decide_eq_true (List.mem_filter.mp hmem).2) have hlen_le : ((W.filter (fun k : Key => decide (k ≤ last))).filter P).length ≤ (W.filter P).length := (List.Sublist.filter P List.filter_sublist).length_le have hneq : ((W.filter (fun k : Key => decide (k ≤ last))).filter P).length ≠ (W.filter P).length := by intro heq have heqlist := (List.Sublist.filter P List.filter_sublist).eq_of_length heq have : k ∈ (W.filter (fun k : Key => decide (k ≤ last))).filter P := by rw [heqlist]; exact hk_fil exact hk_not_le (List.mem_of_mem_filter this) have hlt_len : ((W.filter (fun k : Key => decide (k ≤ last))).filter P).length < (W.filter P).length := lt_of_le_of_ne hlen_le hneq have hWcnt : (W.filter P).length ≤ e := by rw [← List.countP_eq_length_filter] rw [hW] have hbound := completeKeys_count_ge_le_general (db := db) (r := r) hrev hbegin hcross (by omega) simpa [hP, he] using hbound have hrescnt : (List.filter P (List.filter (fun k : Key => decide (k ≤ last)) W)).length = e := by rw [hres, ← List.countP_eq_length_filter] exact hresP omega rw [← hres] exact (List.filter_eq_self.mpr (fun k hk => decide_eq_true (hno k hk))).symm /-- **Finite-branch soundness at any positive begin offset.** In the finite branch of the complete closed form, agreement on `[begin.key, keyAfter last)` fixes the complete keys. The key new input is `completeKeys_eq_of_filter_le_eq`: the overshoot condition is decided by agreement, and the count bound then rules out any complete key above the reported last. -/ theorem sound_truncatedRange_of_finite_general {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp₀⟩ := hread have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] intro db₁ db₂ hagree have hlast_fil : res.keys.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = res.keys := filter_le_getLast_eq_of_prefix hsort.pairwise (List.prefix_refl _) hne have hcomp : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ RangeRead.completeKeys db r = res.keys := by intro db constructor · rintro ⟨hlim, hdisj | ⟨_, heq⟩⟩ · rw [hmore] at hdisj exact absurd hdisj.1 (by simp) · exact ⟨hlim, heq.symm⟩ · rintro ⟨hlim, heq⟩ exact ⟨hlim, Or.inr ⟨hmore, heq.symm⟩⟩ rw [hcomp db₁, hcomp db₂] have hlr := lt_resolve_end_iff_of_agree (db₁ := db₁) (db₂ := db₂) (r := r) (last := res.keys.getLast hne) (by omega) hcross hagree have hdrop : (truncatedRange r (res.keys.getLast hne)).keys db₁ = (truncatedRange r (res.keys.getLast hne)).keys db₂ := hagree have hlast_mem : res.keys.getLast hne ∈ res.keys := List.getLast_mem hne constructor · rintro ⟨hlim, hck₁⟩ refine ⟨hlim, ?_⟩ have hlt₁ : (res.keys.getLast hne : WithTop Key) < resolve db₁ r.end_ := (RangeRead.mem_completeKeys.mp (by rw [hck₁]; exact hlast_mem)).2.2 have hlt₂ : (res.keys.getLast hne : WithTop Key) < resolve db₂ r.end_ := hlr.mp hlt₁ have hF₁ := completeKeys_filter_le_drop (db := db₁) (r := r) hrev hbegin hlt₁ have hF₂ := completeKeys_filter_le_drop (db := db₂) (r := r) hrev hbegin hlt₂ rw [hck₁, hlast_fil, hdrop] at hF₁ exact completeKeys_eq_of_filter_le_eq (db := db₂) hrev hbegin hcross hend hne rfl (by rw [hF₂, ← hF₁]) ht · rintro ⟨hlim, hck₂⟩ refine ⟨hlim, ?_⟩ have hlt₂ : (res.keys.getLast hne : WithTop Key) < resolve db₂ r.end_ := (RangeRead.mem_completeKeys.mp (by rw [hck₂]; exact hlast_mem)).2.2 have hlt₁ : (res.keys.getLast hne : WithTop Key) < resolve db₁ r.end_ := hlr.mpr hlt₂ have hF₁ := completeKeys_filter_le_drop (db := db₁) (r := r) hrev hbegin hlt₁ have hF₂ := completeKeys_filter_le_drop (db := db₂) (r := r) hrev hbegin hlt₂ rw [hck₂, hlast_fil, ← hdrop] at hF₂ exact completeKeys_eq_of_filter_le_eq (db := db₁) hrev hbegin hcross hend hne rfl (by rw [hF₁, ← hF₂]) ht /-- **Finite-branch minimality at any positive begin offset.** The truncated range `[begin.key, keyAfter (last reported))` is the minimal sound conflict range in the finite branch, for every `begin.offset ≥ 1`. Soundness is `sound_truncatedRange_of_finite_general`; necessity is the begin key and the reported last, with convexity filling the interval. -/ theorem minimal_truncatedRange_of_finite_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · rw [← hgetLast] exact sound_truncatedRange_of_finite_general ⟨db₀, hcomp⟩ hrev hmore hne hbegin hcross hend ht · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- At begin offset one, the keys of the truncated range `[begin.key, keyAfter last)` are the stored keys at or above `begin.key` followed by those at or below `last`. -/ theorem truncatedRange_keys_eq_filter_take {db : DB} {r : RangeRead} {last : Key} (_hrev : r.reverse = false) (_hbegin : r.begin.offset = 1) (hBlelast : r.begin.key ≤ (last : WithTop Key)) : (truncatedRange r last).keys db = (db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).take (db.keys.countP (fun k : Key => decide (k ≤ last)) - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key))) := by set l := db.keys with hl set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef set p := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp have hls : l.SortedLT := by rw [hl]; exact db.sorted have hA_eq : A = l.drop p := by rw [hAdef] have hdrop : l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) = l.drop p := by rw [hp] exact filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hAs : A.SortedLT := by rw [hA_eq] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) -- The truncated range's keys are `A` filtered at or below `last`. have hkeys : (truncatedRange r last).keys db = A.filter (fun k : Key => decide (k ≤ last)) := by unfold truncatedRange ConflictRange.keys rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) = l.filter (fun (k : Key) => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) && decide (r.begin.key ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, ← hAdef] apply List.filter_congr intro k _ rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] have hK : A.countP (fun k : Key => decide (k ≤ last)) = l.countP (fun k : Key => decide (k ≤ last)) - p := by have hcongr : (fun k : Key => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) = (fun k : Key => decide (k ≤ last)) := by funext k rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] rw [← hcongr] rw [hA_eq, countP_drop_eq hls ((keyAfter last : Key) : WithTop Key) p] have hpK : p ≤ l.countP (fun k : Key => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) := by rw [hp] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ have hkl : k ≤ last := WithTop.coe_le_coe.mp (le_trans (le_of_lt hk) hBlelast) exact WithTop.coe_lt_coe.mpr (lt_of_le_of_lt hkl (keyAfter_self_lt last)) rw [Nat.min_eq_left hpK] rw [hkeys, filter_le_eq_take_countP hAs last, hK] /-- A positive count yields an element satisfying the predicate. -/ private theorem exists_of_countP_pos {l : List Key} {p : Key → Bool} (h : 0 < l.countP p) : ∃ a ∈ l, p a = true := by by_contra hcon push Not at hcon have hzero : l.countP p = 0 := by rw [List.countP_eq_zero] intro a ha have := hcon a ha simpa using this omega /-- If a list's take equals another list, then taking as many elements as that list has also gives it. -/ private theorem take_of_eq_take {l g : List Key} {K : Nat} (h : l.take K = g) : l.take g.length = g := by have hK : g.length ≤ K := by rw [← h, List.length_take] exact Nat.min_le_left _ _ calc l.take g.length = (l.take K).take g.length := by rw [List.take_take, Nat.min_eq_left hK] _ = (l.take K).take (l.take K).length := by rw [← h] _ = l.take K := List.take_length _ = g := h /-- Elements beyond a prefix ending at `last` are strictly greater than `last`. -/ private theorem lt_of_take_eq_getLast {l g : List Key} (hs : l.SortedLT) {n : Nat} (h : l.take n = g) (hgne : g ≠ []) {last : Key} (hlast : g.getLast hgne = last) : ∀ k ∈ l.drop n, last < k := by intro k hk have hl : l = l.take n ++ l.drop n := (List.take_append_drop n l).symm have hpair : (l.take n ++ l.drop n).Pairwise (· < ·) := by rw [← hl]; exact hs.pairwise rw [List.pairwise_append] at hpair obtain ⟨_, _, hcross⟩ := hpair have hne_take : l.take n ≠ [] := by rw [h]; exact hgne have hx : (l.take n).getLast hne_take ∈ l.take n := List.getLast_mem hne_take have hxlast : (l.take n).getLast hne_take = last := by have h1 : (l.take n).getLast? = some ((l.take n).getLast hne_take) := List.getLast?_eq_getLast_of_ne_nil hne_take have h2 : (l.take n).getLast? = some last := by rw [h, List.getLast?_eq_getLast_of_ne_nil hgne, hlast] rw [h1] at h2 exact Option.some.inj h2 exact hxlast ▸ hcross _ hx k hk /-- Elements past a truncation point do not contribute to the count below `E` when all of them are at or above `E`. -/ private theorem countP_lt_drop_eq_zero {l : List Key} {E : WithTop Key} {n : Nat} (hge : ∀ k ∈ l.drop n, E ≤ (k : WithTop Key)) : l.countP (fun k : Key => decide ((k : WithTop Key) < E)) = (l.take n).countP (fun k : Key => decide ((k : WithTop Key) < E)) := by conv_lhs => rw [← List.take_append_drop n l] rw [List.countP_append] have hzero : (l.drop n).countP (fun k : Key => decide ((k : WithTop Key) < E)) = 0 := by rw [List.countP_eq_zero] intro k hk rw [decide_eq_true_eq] exact not_lt.mpr (hge k hk) rw [hzero, Nat.add_zero] /-- A sorted list whose prefix of length `g.length` is `g` has exactly `g.length - 1` elements strictly below the last element of `g`. -/ private theorem countP_lt_getLast_of_take {l g : List Key} (hs : l.SortedLT) (h : l.take g.length = g) (hne : g ≠ []) : l.countP (fun k : Key => decide (k < g.getLast hne)) = g.length - 1 := by have hlen : 0 < g.length := List.length_pos_of_ne_nil hne have hgt : ∀ k ∈ l.drop g.length, g.getLast hne < k := lt_of_take_eq_getLast hs h hne rfl rw [← List.take_append_drop g.length l, List.countP_append] have hzero : (l.drop g.length).countP (fun k : Key => decide (k < g.getLast hne)) = 0 := by rw [List.countP_eq_zero] intro k hk rw [decide_eq_true_eq] exact not_lt.mpr (le_of_lt (hgt k hk)) rw [hzero, Nat.add_zero, h] have hgs : g.SortedLT := by rw [← h] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := g.length) (List.sortedLT_iff_pairwise.mp hs)) have hlast : g[g.length - 1]'(by omega) = g.getLast hne := by rw [List.getLast_eq_getElem hne] rw [← hlast] exact countP_lt_eq_of_getElem hgs (by omega) rfl /-- A stored key at index `j` lies strictly below the resolution of `s` exactly when `j` is below the clamped anchor index. This is the local form of the same statement in `Empty`; the two modules do not import each other. -/ private theorem getElem_lt_resolve_iff' {db : DB} {s : Selector} {j : ℕ} (hj : j < db.keys.length) : (↑(db.keys[j]) : WithTop Key) < resolve db s ↔ j < min (s.anchor db).toNat db.keys.length := by by_cases hneg : s.anchor db < 0 · have h0 : (s.anchor db).toNat = 0 := by omega rw [resolve_eq_nil hneg, h0, Nat.zero_min] exact iff_of_false (fun hc => List.not_lt_nil (db.keys[j]) (WithTop.coe_lt_coe.mp hc)) (by omega) · have h0 : 0 ≤ s.anchor db := by omega rcases lt_or_ge (s.anchor db).toNat db.keys.length with hlt | hge · rw [resolve_eq_getElem h0 hlt, WithTop.coe_lt_coe, db.sorted.getElem_lt_getElem_iff, Nat.min_eq_left (le_of_lt hlt)] · rw [resolve_eq_top h0 hge, Nat.min_eq_right hge] exact iff_of_true (WithTop.coe_lt_top _) hj /-- **The last reported key of a truncated result lies below the resolved end.** At `begin.offset = 1`, cross-free, and `end.offset ≥ 1`, any database whose truncated range stores exactly the reported keys has the last reported key below `resolve end_`. The count `t` of reported keys at or above `end_.key` is at most `end_.offset - 1`, and the stored keys below `end_.key` are the `p` keys below `begin.key` together with the `n - t` reported keys below `end_.key`, so the resolved end lies past the last reported key. -/ private theorem truncated_keys_last_lt_resolve {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) (hne : res.keys ≠ []) (hT : (truncatedRange r (res.keys.getLast hne)).keys db = res.keys) (ht_le : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat) : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := by have hlast_mem_res : res.keys.getLast hne ∈ res.keys := List.getLast_mem hne have hmem : res.keys.getLast hne ∈ (truncatedRange r (res.keys.getLast hne)).keys db := by rw [hT]; exact hlast_mem_res have hBlelast : r.begin.key ≤ (res.keys.getLast hne : WithTop Key) := (ConflictRange.mem_keys_iff.mp hmem).2.1 have htake₀ := truncatedRange_keys_eq_filter_take (db := db) (r := r) (last := res.keys.getLast hne) hrev hbegin hBlelast rw [hT] at htake₀ set p := db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key)) with hcE set e' := (r.end_.offset - 1).toNat with he' set n := res.keys.length with hn set t := res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with ht have hls : db.keys.SortedLT := db.sorted have hfilter_drop : db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = db.keys.drop p := by have hdrop : db.keys.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) = db.keys.drop p := by rw [hp] exact filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm rw [hfilter_drop] at htake₀ let B : List Key := db.keys.drop p have hBs : B.SortedLT := by dsimp only [B] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) have hBtake : B.take n = res.keys := by dsimp only [B] simpa [hn] using take_of_eq_take htake₀.symm have hp_le_cE : p ≤ cE := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk hcross have hBcount : B.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE - p := by dsimp only [B] rw [countP_drop_eq hls r.end_.key p, ← hcE, Nat.min_eq_left hp_le_cE] -- The reported keys below `end_.key` number `n - t` and are a sublist of `B`. have hres_lt : res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = n - t := by have hsum := countP_ge_add_countP_lt (l := res.keys) r.end_.key rw [← ht, ← hn] at hsum omega have htake_lt : (B.take n).countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = n - t := by rw [hBtake, hres_lt] have hAge : n - t ≤ B.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by rw [← htake_lt] exact List.Sublist.countP_le (List.take_sublist n B) -- The rank of the last reported key inside `B` is at most `n - 1`. have hrank_le : B.countP (fun k : Key => decide (k < res.keys.getLast hne)) ≤ n - 1 := by have hzero : (B.drop n).countP (fun k : Key => decide (k < res.keys.getLast hne)) = 0 := by rw [List.countP_eq_zero] intro k hk rw [decide_eq_true_eq] exact not_lt.mpr (le_of_lt (lt_of_take_eq_getLast hBs hBtake hne rfl k hk)) have hsplit : B.countP (fun k : Key => decide (k < res.keys.getLast hne)) = (B.take n).countP (fun k : Key => decide (k < res.keys.getLast hne)) := by conv_lhs => rw [← List.take_append_drop n B] rw [List.countP_append, hzero, Nat.add_zero] rw [hsplit, hBtake] exact Nat.le_sub_one_of_lt (List.countP_lt_length_iff.mpr ⟨res.keys.getLast hne, List.getLast_mem hne, by simp⟩) -- Locate the last reported key as a stored key of `db`. have hBlast_mem : res.keys.getLast hne ∈ B := by have hmem_take : res.keys.getLast hne ∈ B.take n := by rw [hBtake] exact List.getLast_mem hne exact List.mem_of_mem_take hmem_take let i : Nat := B.countP (fun k : Key => decide (k < res.keys.getLast hne)) have hi_le : i ≤ n - 1 := by dsimp only [i] exact hrank_le have hi_lt : i < B.length := by dsimp only [i] exact List.countP_lt_length_iff.mpr ⟨res.keys.getLast hne, hBlast_mem, by simp⟩ have hBget : B[i] = res.keys.getLast hne := by dsimp only [i] exact getElem_countP_lt hBs hBlast_mem have hj_lt : p + i < db.keys.length := by have : p + i < p + B.length := Nat.add_lt_add_left hi_lt p dsimp only [B] at this rw [List.length_drop] at this omega have hlget : db.keys[p + i] = res.keys.getLast hne := by have hBget' : (db.keys.drop p)[i]'(by rw [List.length_drop]; omega) = res.keys.getLast hne := by dsimp only [B] at hBget exact hBget rw [← List.getElem_drop (i := p) (j := i)] exact hBget' -- Count the stored keys below `end_.key` from below. have hcase : cE ≥ p + (n - t) := by have hc : cE = p + B.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by rw [hBcount] omega rw [hc] omega have he_ge_t : t ≤ e' := by rw [ht, he'] exact ht_le have ht_le_n : t ≤ n := by rw [ht, hn] exact List.countP_le_length have hnpos : 0 < n := by rw [hn]; exact List.length_pos_of_ne_nil hne have hi_lt_n : i < n := Nat.lt_of_le_sub_one hnpos hi_le have hlt : p + i < cE + e' := by have h1 : p + i < p + n := Nat.add_lt_add_left hi_lt_n p have h2 : p + n ≤ cE + t := by omega have h3 : cE + t ≤ cE + e' := by omega omega have hclamp : p + i < min (r.end_.anchor db).toNat db.keys.length := by have hd : (r.end_.anchor db).toNat = cE + e' := by rw [anchor_toNat_eq (s := r.end_) hend, hcE, he'] rw [hd] exact lt_min hlt hj_lt have hres := (getElem_lt_resolve_iff' (db := db) (s := r.end_) hj_lt).mpr hclamp rw [hlget] at hres exact hres /-- **The truncated range at begin offset one, cross-free.** For a non-reversed truncated result at `begin.offset = 1`, `begin.key ≤ end_.key`, and `end_.offset ≥ 1`, the minimal sound conflict range is `[begin.key, keyAfter (last reported))`. Unlike the complete case, no count equality is needed: truncation already fixes the reported prefix, and the last reported key is always below the resolved end. The `end_.offset = 1` case is the earlier theorem; for `end_.offset ≥ 2` the last-key bound is `truncated_keys_last_lt_resolve`. -/ theorem minimal_truncatedRange_of_offset_one_of_more {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by by_cases h1 : r.end_.offset = 1 · exact minimal_truncatedRange_of_offset_one hread hmore hrev hbegin h1 have h2 : 2 ≤ r.end_.offset := by omega obtain ⟨db₀, hcomp⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have ht_le : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by have hpre := RangeRead.compatible_keys_prefix hcomp exact le_trans (List.Sublist.countP_le hpre.sublist) (completeKeys_count_ge_le (db := db₀) hrev hbegin hcross (by omega)) refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have key (db : DB) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ (truncatedRange r (res.keys.getLast hne)).keys db = res.keys := by constructor · intro hc have hlim := hc.1 have hlast_mem : res.keys.getLast hne ∈ RangeRead.completeKeys db r := (RangeRead.compatible_keys_prefix hc).subset (List.getLast_mem hne) have hlt : (res.keys.getLast hne : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hlast_mem).2.2 have hT := truncatedRange_keys_eq_of_resolve (db := db) hrev hbegin (keyAfter_le_of_lt hlt) have hW : (RangeRead.completeKeys db r).Pairwise (· < ·) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] exact RangeRead.inRange_pairwise db _ _ refine ⟨hlim, ?_⟩ rw [hT] exact filter_le_getLast_eq_of_prefix hW (RangeRead.compatible_keys_prefix hc) hne · rintro ⟨hlim, hT⟩ have hlt := truncated_keys_last_lt_resolve (db := db) hrev hbegin hcross (by omega) hne hT ht_le have hT' := truncatedRange_keys_eq_of_resolve (db := db) hrev hbegin (keyAfter_le_of_lt hlt) exact (compatible_iff_truncated_keys (db := db) hrev hmore hne).mpr ⟨hlim, by rw [← hT', hT]⟩ rw [key db₁, key db₂, hagree] · intro k hk cr hs have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- In the finite branch `e = t + 1`, agreement on the truncated range forces the complete keys: it fixes the stored keys at or above `begin.key` through the last reported key, and the `(e - 1)`-count then reaches exactly that prefix. -/ private theorem completeKeys_eq_of_truncated_keys_eq {db : DB} {r : RangeRead} {res : Result} {last : Key} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (hlast : last = res.keys.getLast hne) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) (hT : (truncatedRange r last).keys db = res.keys) : RangeRead.completeKeys db r = res.keys := by set l := db.keys with hl set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef set p := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key)) with hcE set e' := (r.end_.offset - 1).toNat with he' set n := res.keys.length with hn have hls : l.SortedLT := by rw [hl]; exact db.sorted have hA_eq : A = l.drop p := by rw [hAdef] have hdrop : l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) = l.drop p := by rw [hp] exact filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hAs : A.SortedLT := by rw [hA_eq] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) have hp_le_cE : p ≤ cE := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk hcross have ht' : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = e' := ht have he'pos : 0 < e' := by omega have htpos : 0 < res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by rw [ht']; exact he'pos obtain ⟨k₀, hk₀, hk₀ge⟩ := exists_of_countP_pos htpos rw [decide_eq_true_eq] at hk₀ge have hsort_res : res.keys.SortedLT := by rw [← hT] exact List.sortedLT_iff_pairwise.mpr (ConflictRange.keys_pairwise (truncatedRange r last) db) have hlelast : ((k₀ : Key) : WithTop Key) ≤ (last : WithTop Key) := by rw [hlast] exact WithTop.coe_le_coe.mpr ((hsort_res.pairwise.imp le_of_lt).rel_getLast hk₀) have hBlelast : r.begin.key ≤ (last : WithTop Key) := le_trans hcross (le_trans hk₀ge hlelast) have hEle : r.end_.key ≤ (last : WithTop Key) := le_trans hk₀ge hlelast -- The truncated range's keys are a prefix of `A`. have hT' : A.take (l.countP (fun k : Key => decide (k ≤ last)) - p) = res.keys := by have := truncatedRange_keys_eq_filter_take (db := db) (r := r) (last := last) hrev hbegin hBlelast rw [← hl, ← hAdef] at this rw [← this, hT] have hAtake : A.take n = res.keys := take_of_eq_take hT' have hlen_n : A.length = l.length - p := by rw [hA_eq, List.length_drop] have hpL : p ≤ l.length := by rw [hp]; exact List.countP_le_length have hn_le : n ≤ A.length := by have hmin : min n A.length = n := by have := congrArg List.length hAtake rw [List.length_take, hn] at this exact this exact hmin ▸ Nat.min_le_right n A.length have he'_le_n : e' ≤ n := by rw [← ht', hn] exact List.countP_le_length -- Count the keys below `E` in `A`: none occur past the prefix. have hgt : ∀ k ∈ A.drop n, last < k := lt_of_take_eq_getLast hAs hAtake hne (hlast.symm) have hge_drop : ∀ k ∈ A.drop n, r.end_.key ≤ (k : WithTop Key) := by intro k hk exact le_trans hEle (WithTop.coe_le_coe.mpr (le_of_lt (hgt k hk))) have hq : A.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = n - e' := by rw [countP_lt_drop_eq_zero (l := A) (E := r.end_.key) (n := n) hge_drop, hAtake] have hsum := countP_ge_add_countP_lt (l := res.keys) r.end_.key rw [ht'] at hsum omega have hq' : A.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE - p := by rw [hA_eq, countP_drop_eq hls r.end_.key p, ← hcE, Nat.min_eq_left hp_le_cE] have hM : min (cE + e') l.length - p = n := by have hce : cE + e' = n + p := by omega have hL : l.length = A.length + p := by rw [hlen_n]; omega rw [hce, hL, Nat.min_eq_left (by omega)] omega -- Assemble. rw [completeKeys_eq_filter_take_of_offset_one (db := db) hrev hbegin (by omega)] rw [← hl, ← hAdef] rw [hM, hAtake] /-- Conversely, in the finite branch, once the complete keys are the reported keys, the truncated range's stored keys are the reported keys as well: the last reported key is a complete key, so its successor sits at or below the resolved end, and the only keys at or below the last reported key are the reported keys themselves. -/ private theorem truncated_keys_eq_of_completeKeys_eq {db : DB} {r : RangeRead} {res : Result} {last : Key} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hne : res.keys ≠ []) (hlast : last = res.keys.getLast hne) (hck : RangeRead.completeKeys db r = res.keys) : (truncatedRange r last).keys db = res.keys := by have hmem : last ∈ RangeRead.completeKeys db r := by rw [hck, hlast]; exact List.getLast_mem hne have hlt : (last : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hmem).2.2 have hW : res.keys.Pairwise (· < ·) := by rw [← hck, RangeRead.completeKeys, ite_eq_right (by simp [hrev])] exact RangeRead.inRange_pairwise db _ _ rw [truncatedRange_keys_eq_of_resolve hrev hbegin (keyAfter_le_of_lt hlt), hck, hlast] exact filter_le_getLast_eq_of_prefix hW (List.prefix_refl _) hne /-- **The finite branch of the offset-one closed form.** In the finite branch `#{\rm reported} \ge \texttt{end.key} = \texttt{end.offset} - 1`, a complete non-reversed result is compatible with a database exactly when the database stores the reported keys in the truncated range `[begin.key, keyAfter last)`. Both directions are the two lemmas above, so agreement on the truncated range fixes compatibility. -/ theorem compatible_iff_truncatedRange_keys_finite {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) {last : Key} (hlast : last = res.keys.getLast hne) : RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ (truncatedRange r last).keys db = res.keys := by constructor · rintro ⟨hlim, hdisj | ⟨_, heq⟩⟩ · simp [hmore] at hdisj · exact ⟨hlim, truncated_keys_eq_of_completeKeys_eq hrev hbegin hne hlast heq.symm⟩ · rintro ⟨hlim, hT⟩ exact ⟨hlim, Or.inr ⟨hmore, (completeKeys_eq_of_truncated_keys_eq hrev hbegin hcross hend hne hlast ht hT).symm⟩⟩ /-- **Finite-branch soundness.** At `begin.offset = 1`, cross-free, end offset at least two, and in the finite branch of the closed form, the truncated range is sound: agreement on `[begin.key, keyAfter last)` fixes the reported keys. -/ theorem sound_truncatedRange_of_finite {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] intro db₁ db₂ hagree have key := compatible_iff_truncatedRange_keys_finite (db := db₁) hrev hmore hne hbegin hcross hend ht (last := res.keys.getLast hne) rfl have key₂ := compatible_iff_truncatedRange_keys_finite (db := db₂) hrev hmore hne hbegin hcross hend ht (last := res.keys.getLast hne) rfl rw [key, key₂, hagree] /-- **Finite-branch minimality.** In the finite branch of the offset-one closed form, the truncated range `[begin.key, keyAfter (last reported))` is the minimal sound conflict range. Soundness is `sound_truncatedRange_of_finite`; necessity is the begin key and the reported last, with convexity filling the interval. -/ theorem minimal_truncatedRange_of_finite {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · rw [← hgetLast] exact sound_truncatedRange_of_finite hrev hmore hne hbegin hcross hend ht · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- **The number of complete keys at or above `end_.key`.** At begin offset one and end offset at least one, that count is `min (end_.offset - 1) (#stored - #stored below end_.key)`: the window contains the first `(end.offset - 1)` stored keys at or above `end_.key` when there are enough of them, and otherwise every stored key at or above it. -/ private theorem completeKeys_count_ge_eq_min {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = min ((r.end_.offset - 1).toNat) (db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) := by set l := db.keys with hl set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef set p := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key)) with hcE set e' := (r.end_.offset - 1).toNat with he' have hls : l.SortedLT := by rw [hl]; exact db.sorted have hp_le_cE : p ≤ cE := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk hcross have hA_eq : A = l.drop p := by rw [hAdef] have hdrop : l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) = l.drop p := by rw [hp] exact filter_not_lt_eq_drop_countP hls r.begin.key rw [← hdrop] apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm have hAs : A.SortedLT := by rw [hA_eq] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise) have hA_len : A.length = l.length - p := by rw [hA_eq, List.length_drop] have hq : A.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cE - p := by rw [hA_eq, countP_drop_eq hls r.end_.key p, ← hcE, Nat.min_eq_left hp_le_cE] have hck : RangeRead.completeKeys db r = A.take (min (cE + e') l.length - p) := by rw [completeKeys_eq_filter_take_of_offset_one (db := db) hrev hbegin hend] have hM_le : min (cE + e') l.length - p ≤ A.length := by rw [hA_len] exact Nat.sub_le_sub_right (Nat.min_le_right _ _) p have hcount : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (min (cE + e') l.length - p) - min (min (cE + e') l.length - p) (cE - p) := by rw [hck] have := countP_ge_take hAs r.end_.key hM_le rwa [hq] at this by_cases hcase : cE + e' ≤ l.length · have hmin : min (cE + e') l.length = cE + e' := Nat.min_eq_left hcase have hM : min (cE + e') l.length - p = (cE - p) + e' := by rw [hmin]; omega rw [hcount, hM, Nat.min_eq_right (Nat.le_add_right (cE - p) e'), Nat.add_sub_cancel_left] rw [Nat.min_eq_left (by omega)] · have hmin : min (cE + e') l.length = l.length := Nat.min_eq_right (le_of_not_ge hcase) have hM : min (cE + e') l.length - p = l.length - p := by rw [hmin] have hqle : cE - p ≤ l.length - p := by have hcEL : cE ≤ l.length := by rw [hcE]; exact List.countP_le_length omega rw [hcount, hM, Nat.min_eq_right hqle] have heq : l.length - p - (cE - p) = l.length - cE := by omega rw [heq, Nat.min_eq_right (by omega)] /-- In the finite branch of the closed form, the complete keys at or above `end_.key` number exactly `(end_.offset - 1)`, provided the resolved end is a stored key (not the sentinel). This is the counting form used to identify the sentinel. -/ private theorem completeKeys_count_ge_eq_of_resolve_ne_top {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hnotop : resolve db r.end_ ≠ (⊤ : WithTop Key)) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat := by refine (completeKeys_count_ge_eq_min (db := db) hrev hbegin hcross (by omega)).trans ?_ have hann := anchor_toNat_eq (db := db) (s := r.end_) (by omega : 1 ≤ r.end_.offset) have hlt : (r.end_.anchor db).toNat < db.keys.length := by by_contra hge exact hnotop (resolve_eq_top (by omega) (le_of_not_gt hge)) rw [hann] at hlt have hlt' : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat < db.keys.length := hlt rw [Nat.min_eq_left (by omega)] /-- In the top branch of the offset-one closed form, the resolved end of a compatible database is the sentinel `⊤`: otherwise the complete window would contain exactly `(end.offset - 1)` stored keys at or above `end_.key`, contradicting the strict inequality defining the branch. -/ private theorem resolve_end_eq_top_of_top_branch {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (_hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) : resolve db r.end_ = (⊤ : WithTop Key) := by by_contra hnotop have hck : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have heq := completeKeys_count_ge_eq_of_resolve_ne_top (db := db) (r := r) hrev hbegin hcross hend hnotop rw [← hck] at heq omega /-- Inserting a fresh key into a database increases the count of stored keys below a threshold by one exactly when the inserted key is below it. -/ private theorem countP_lt_insert {db : DB} {x : Key} (hx : x ∉ db.keys) (E : WithTop Key) : (db.insert x hx).keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + (if ((x : Key) : WithTop Key) < E then 1 else 0) := by rw [DB.insert_keys, List.Perm.countP_eq _ (List.perm_orderedInsert (· ≤ ·) x db.keys)] by_cases h : ((x : Key) : WithTop Key) < E · rw [List.countP_cons_of_pos (by simpa using h), ite_eq_left h] · rw [List.countP_cons_of_neg (by simpa using h), ite_eq_right h, Nat.add_zero] /-- Inserting a fresh key into a database increases its key count by one. -/ private theorem insert_keys_length {db : DB} {x : Key} (hx : x ∉ db.keys) : (db.insert x hx).keys.length = db.keys.length + 1 := by rw [DB.insert_keys] exact (List.perm_orderedInsert (· ≤ ·) x db.keys).length_eq.trans (by simp) /-- In the top branch, inserting a fresh key above the reported last keeps the resolved end at the sentinel. The strict margin `|db| < #stored below end_.key + (end.offset - 1)` survives the insertion, so the anchor still lands past every key. -/ theorem resolve_end_eq_top_of_insert_top {db₀ : DB} {r : RangeRead} {x : Key} (hx0 : x ∉ db₀.keys) (hL_lt : db₀.keys.length < db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) (hend : 2 ≤ r.end_.offset) : resolve (db₀.insert x hx0) r.end_ = (⊤ : WithTop Key) := by refine resolve_eq_top (anchor_nonneg_of_one_le (by omega)) ?_ rw [anchor_toNat_eq (s := r.end_) (by omega), countP_lt_insert hx0 r.end_.key] rw [insert_keys_length hx0] by_cases h : ((x : Key) : WithTop Key) < r.end_.key · rw [ite_eq_left h]; omega · rw [ite_eq_right h]; omega /-- **Top-branch necessity above the reported last.** In the top branch of the offset-one closed form, every key at or above the last reported key is necessary. The compatible database's window ends at the sentinel, so all its stored keys lie at or below the reported last. Inserting a fresh key above the last keeps the sentinel end and adds the key to the complete window, breaking the complete result. -/ private theorem necessary_of_top_branch {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hcomp⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hcomp⟩ hx cr hs · by_contra hcr have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hE₀ : resolve db₀ r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_top_branch hcomp hmore hrev hne hbegin hcross hend ht -- The strict margin `|db| < cE + e'` supplied by the top branch. have hL_lt : db₀.keys.length < db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by have hcount := completeKeys_count_ge_eq_min (db := db₀) hrev hbegin hcross (by omega) rw [← hres] at hcount have hmin : min ((r.end_.offset - 1).toNat) (db₀.keys.length - db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) < (r.end_.offset - 1).toNat := by rw [← hcount]; exact ht have hcEL : db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) ≤ db₀.keys.length := List.countP_le_length have hm : db₀.keys.length - db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) < (r.end_.offset - 1).toNat := by by_contra hge rw [Nat.min_eq_left (le_of_not_gt hge)] at hmin exact absurd hmin (lt_irrefl _) omega -- Every stored key lies at or below the reported last, hence at or below `x`. have hckTop : RangeRead.completeKeys db₀ r = (topRange r).keys db₀ := completeKeys_eq_topRange_keys hrev hbegin hE₀ have hhead : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := begin_key_le_head_of_one_le_offset ⟨db₀, hcomp⟩ hne (by omega) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (by rw [← hres]; exact hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hBle_last : v ≤ res.keys.getLast hne := by rw [hv] at hhead exact le_trans (WithTop.coe_le_coe.mp hhead) ((hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)) have hall : ∀ k ∈ db₀.keys, k ≤ x := by intro k hk by_cases hbk : r.begin.key ≤ ((k : Key) : WithTop Key) · have hkmem : k ∈ (topRange r).keys db₀ := ConflictRange.mem_keys_iff.mpr ⟨hk, hbk, WithTop.coe_lt_top k⟩ have hkres : k ∈ res.keys := by rw [hres, hckTop]; exact hkmem exact le_trans (hmaxres k hkres) hlo · have hklt : k < v := by have h : ¬ (v ≤ k) := fun hle => hbk (by rw [hv]; exact WithTop.coe_le_coe.mpr hle) exact lt_of_not_ge h exact le_trans (le_of_lt hklt) (le_trans hBle_last hlo) have hx0 : x ∉ db₀.keys := by intro hxm by_cases hbk : r.begin.key ≤ ((x : Key) : WithTop Key) · apply hx rw [hres, hckTop] exact ConflictRange.mem_keys_iff.mpr ⟨hxm, hbk, WithTop.coe_lt_top x⟩ · have hxlt : x < v := by have h : ¬ (v ≤ x) := fun hle => hbk (by rw [hv]; exact WithTop.coe_le_coe.mpr hle) exact lt_of_not_ge h exact absurd (lt_of_lt_of_le hxlt (le_trans hBle_last hlo)) (not_lt.mpr (le_refl x)) have hEins : resolve (db₀.insert x hx0) r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_insert_top hx0 hL_lt hend exact absurd (mem_result_of_insert hcomp hs hcr hmore hne hx0 (fun k hk => WithTop.coe_le_coe.mpr (hall k hk)) hEins) hx /-- **Top-branch minimality.** In the top branch of the offset-one closed form, the unbounded top range `[begin.key, ⊤)` is the minimal sound conflict range. Soundness is `sound_topRange_of_one_le_le`; keys up to the reported last are necessary by the begin key, the reported last, and convexity, while keys above it are `necessary_of_top_branch`. -/ theorem minimal_topRange_of_top_branch {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (by rw [← hres]; exact hne) (by omega) obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · exact sound_topRange_of_one_le_le (by omega) (by omega) hcross · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkle : k ≤ res.keys.getLast hne · have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) (by omega) hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs · exact necessary_of_top_branch ⟨db₀, hcomp⟩ hrev hmore hne hbegin hcross hend ht (le_of_lt (lt_of_not_ge hkle)) cr hs /-- **The compact closed form at begin offset one.** For a complete, nonempty, non-reversed read with `begin.offset = 1` and `begin.key ≤ end_.key`, the minimal conflict range is * `[begin.key, end_.key)` when `end_.offset ≤ 1`; * `[begin.key, keyAfter (last reported))` when the number `t` of reported keys at or above `end_.key` equals `end_.offset - 1`; * `[begin.key, ⊤)` when `t < end_.offset - 1`. The three branches are `minimal_canonicalRange_of_end_offset_le_one_general`, `minimal_truncatedRange_of_finite`, and `minimal_topRange_of_top_branch`. -/ def closedFormOffsetOne (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 1 then canonicalRange r else let t := res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) let e := (r.end_.offset - 1).toNat if t = e then truncatedRange r (res.keys.getLastD ([] : Key)) else topRange r theorem minimal_closedForm_of_offset_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOne r res) := by unfold closedFormOffsetOne by_cases hend1 : r.end_.offset ≤ 1 · rw [ite_eq_left hend1] exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne (by omega) hend1 · rw [ite_eq_right hend1] have hend : 2 ≤ r.end_.offset := by omega by_cases ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat · rw [ite_eq_left ht] exact minimal_truncatedRange_of_finite hread hmore hne hrev hbegin hcross hend ht · rw [ite_eq_right ht] obtain ⟨db₀, hcomp⟩ := hread have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hle : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by rw [hres] exact completeKeys_count_ge_le hrev hbegin hcross (by omega) exact minimal_topRange_of_top_branch ⟨db₀, hcomp⟩ hmore hrev hne hbegin hcross hend (by omega) /-- `getLastD` of a reversed list is the `headD` of the original. -/ theorem getLastD_reverse {α : Type*} (l : List α) (d : α) : l.reverse.getLastD d = l.headD d := by rw [List.getLastD_eq_getLast?, List.getLast?_reverse, List.headD_eq_head?] /-- **The reversed closed form at begin offset one.** A complete reversed result at `begin.offset = 1` and `begin.key ≤ end_.key` reports from the top of the window downward, so the side pinned by a truncated window is the result's *head*. Writing `t = #{reported keys ≥ end_.key}` and `e = (end_.offset - 1).toNat`, the minimal range is `[begin.key, end_.key)` when `end_.offset ≤ 1`, `[begin.key, keyAfter (head reported))` when `t = e`, and `[begin.key, ⊤)` when `t < e`. -/ def closedFormOffsetOneRev (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 1 then canonicalRange r else let t := res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) let e := (r.end_.offset - 1).toNat if t = e then truncatedRange r (res.keys.headD ([] : Key)) else topRange r /-- The reversed closed form is minimal on the offset-one cross-free complete region. Flipping the traversal order and reversing the reported keys turns it into the forward closed form, whose head is the reversed result's last; `minimal_flip` transfers minimality back. -/ theorem minimal_closedForm_of_offset_one_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOneRev r res) := by let r' : RangeRead := { r with reverse := false } let res' : Result := { keys := res.keys.reverse, more := false } have hread' : Readable r' res' := by obtain ⟨db, hcomp⟩ := hread exact ⟨db, (compatible_flip (b := true) hrev hmore).mpr hcomp⟩ have hne' : res'.keys ≠ [] := by simpa [res'] using hne have hmin' : Minimal r' res' (closedFormOffsetOne r' res') := minimal_closedForm_of_offset_one hread' rfl hne' rfl hbegin hcross have hflip : Minimal r' res' (closedFormOffsetOne r' res') ↔ Minimal r res (closedFormOffsetOne r' res') := by simpa [r', res'] using (minimal_flip (r := r) (res := res) (cr := closedFormOffsetOne r' res') (b := true) hrev hmore) have hformula : closedFormOffsetOne r' res' = closedFormOffsetOneRev r res := by unfold closedFormOffsetOne closedFormOffsetOneRev dsimp only [r', res'] rw [List.countP_reverse, getLastD_reverse] rfl simpa [hformula] using hflip.mp hmin' /-- **The traversal-aware compact closed form at begin offset one.** One rule covers both traversal orders of a complete result: use the forward form when the read is not reversed and the reversed form when it is. -/ def closedFormOffsetOneAny (r : RangeRead) (res : Result) : ConflictRange := if r.reverse then closedFormOffsetOneRev r res else closedFormOffsetOne r res /-- The traversal-aware closed form is minimal on the offset-one cross-free complete region, for either traversal order. -/ theorem minimal_closedForm_of_offset_one_any {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOneAny r res) := by unfold closedFormOffsetOneAny by_cases h : r.reverse = true · rw [ite_eq_left h] exact minimal_closedForm_of_offset_one_rev hread hmore hne h hbegin hcross · rw [ite_eq_right h] have hf : r.reverse = false := by cases hr : r.reverse <;> simp_all exact minimal_closedForm_of_offset_one hread hmore hne hf hbegin hcross /-- When `end_.offset ≤ 1`, the traversal-aware closed form reduces to the canonical range and is minimal for every positive begin offset, crossed or not, in either traversal. This widens the certified region of the formula beyond the offset-one cross-free hypotheses on that half-plane. -/ theorem minimal_closedForm_of_end_le_one {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : r.end_.offset ≤ 1) : Minimal r res (closedFormOffsetOneAny r res) := by unfold closedFormOffsetOneAny by_cases h : r.reverse = true · rw [ite_eq_left h] unfold closedFormOffsetOneRev rw [ite_eq_left hend] exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend · rw [ite_eq_right h] unfold closedFormOffsetOne rw [ite_eq_left hend] exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend /-- **The overshoot region whose reported keys lie below `end_.key`.** For a complete result at any positive begin offset and `end_.offset ≥ 2`, if every reported key is strictly below `end_.key` then both forms of the closed rule return the top range, and it is minimal in either traversal. -/ theorem minimal_closedForm_of_reported_below {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset) (hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) : Minimal r res (closedFormOffsetOneAny r res) := by have ht0 : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = 0 := by rw [List.countP_eq_zero] intro k hk hge rw [decide_eq_true_eq] at hge exact absurd hge (not_le.mpr (hhi k hk)) have hepos : 0 < (r.end_.offset - 1).toNat := by omega unfold closedFormOffsetOneAny by_cases h : r.reverse = true · rw [ite_eq_left h] unfold closedFormOffsetOneRev rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ht0, ite_eq_right (by omega : ¬ (0 = (r.end_.offset - 1).toNat))] exact minimal_topRange_of_end_offset_ge_two_rev_general hread hmore h hne hbegin hend hhi · rw [ite_eq_right h] unfold closedFormOffsetOne rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ht0, ite_eq_right (by omega : ¬ (0 = (r.end_.offset - 1).toNat))] have hf : r.reverse = false := by cases hr : r.reverse <;> simp_all exact minimal_topRange_of_end_offset_ge_two_general hread hmore hf hne hbegin hend hhi /-- **The complete-result closed form at any positive begin offset, on the automatic region.** For a non-reversed complete result with `begin.offset ≥ 1` and `begin.key ≤ end_.key`, the three-branch rule is minimal whenever `end.offset ≤ 1`, the finite branch `t = end.offset - 1` holds, or every reported key lies below `end_.key`. The new ingredient is the finite branch at arbitrary begin offset (`minimal_truncatedRange_of_finite_general`); the below-end case is `minimal_closedForm_of_reported_below`. -/ theorem minimal_closedForm_of_complete_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) (hcase : r.end_.offset ≤ 1 ∨ res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat ∨ (∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)) : Minimal r res (closedFormOffsetOne r res) := by unfold closedFormOffsetOne by_cases hend1 : r.end_.offset ≤ 1 · rw [ite_eq_left hend1] exact minimal_canonicalRange_of_end_offset_le_one_general hread hmore hne hbegin hend1 · rw [ite_eq_right hend1] have hend : 2 ≤ r.end_.offset := by omega by_cases ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat · rw [ite_eq_left ht] exact minimal_truncatedRange_of_finite_general hread hmore hne hrev hbegin hcross hend ht · rw [ite_eq_right ht] have hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by rcases hcase with h | h | h · exact absurd h hend1 · exact absurd h ht · exact h have h := minimal_closedForm_of_reported_below hread hmore hne hbegin hend hhi have h' : Minimal r res (topRange r) := by unfold closedFormOffsetOneAny at h rw [ite_eq_right (by simp [hrev])] at h unfold closedFormOffsetOne at h rw [ite_eq_right hend1] at h rw [ite_eq_right (by intro hc exact ht (by rw [hc]))] at h exact h exact h' /-- **The truncated-result closed form at begin offset one.** For a non-reversed truncation with `begin.offset = 1` and `begin.key ≤ end_.key`, the minimal range is `[begin.key, end.key)` when `end.offset ≤ 0` (the complete window has already ended), and `[begin.key, keyAfter (last reported))` when `end.offset ≥ 1`. -/ def closedFormOffsetOneTruncated (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 0 then canonicalRange r else truncatedRange r (res.keys.getLastD ([] : Key)) /-- The truncated closed form is minimal on the offset-one cross-free truncated region. -/ theorem minimal_closedForm_of_offset_one_truncated {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOneTruncated r res) := by unfold closedFormOffsetOneTruncated by_cases hle : r.end_.offset ≤ 0 · rw [ite_eq_left hle] exact minimal_canonicalRange_of_truncated_end_offset_nonpos hread hmore hrev (by omega) hle · rw [ite_eq_right hle] exact minimal_truncatedRange_of_offset_one_of_more hread hmore hrev hbegin hcross (by omega) /-- **The total cross-free forward-truncated rule.** For a non-reversed truncated result with `begin.offset ≥ 1` and `begin.key ≤ end_.key`, the minimal range is `[begin.key, end.key)` when `end.offset ≤ 0` and `[begin.key, keyAfter (last reported))` for every positive end offset. There is no residual cell in the cross-free forward-truncated region. -/ def closedFormTruncatedGeneral (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 0 then canonicalRange r else truncatedRange r (res.keys.getLastD ([] : Key)) /-- The total forward-truncated rule is minimal on the whole cross-free truncated region. -/ theorem minimal_closedForm_of_truncated_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormTruncatedGeneral r res) := by unfold closedFormTruncatedGeneral by_cases hle : r.end_.offset ≤ 0 · rw [ite_eq_left hle] exact minimal_canonicalRange_of_truncated_end_offset_nonpos hread hmore hrev hbegin hle · rw [ite_eq_right hle] exact minimal_truncatedRange_of_more_general hread hmore hrev hbegin (by omega) hcross /-- **A compact closed form for every result at begin offset one.** For a non-reversed read with `begin.offset = 1` and `begin.key ≤ end_.key`, the minimal conflict range is read off from the result in one step: use the truncated rule when `more = true` and the complete three-branch rule otherwise. -/ def closedFormOffsetOneResult (r : RangeRead) (res : Result) : ConflictRange := if res.more = true then closedFormOffsetOneTruncated r res else closedFormOffsetOne r res /-- The result-aware closed form is minimal for every readable result at begin offset one, truncated or complete, on the cross-free region. -/ theorem minimal_closedForm_of_offset_one_result {r : RangeRead} {res : Result} (hread : Readable r res) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOneResult r res) := by unfold closedFormOffsetOneResult by_cases hmore : res.more = true · rw [ite_eq_left hmore] exact minimal_closedForm_of_offset_one_truncated hread hmore hrev hbegin hcross · rw [ite_eq_right hmore] have hfalse : res.more = false := by cases hm : res.more <;> simp_all exact minimal_closedForm_of_offset_one hread hfalse hne hrev hbegin hcross /-- **A compact reversed truncated rule at begin offset one.** When the end offset is at most one, use `[last reported, end.key)`; when the end overshoots and every reported key lies below `end.key`, use `[last reported, ⊤)`. The rule is stated with the disjunction as an explicit hypothesis because the remaining reversed truncated cell---`end.offset ≥ 2` with a reported key at or above `end.key`---is not certified by this formula. -/ def closedFormOffsetOneTruncatedRev (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 1 then truncatedRangeRev r (res.keys.getLastD ([] : Key)) else topOfLast (res.keys.getLastD ([] : Key)) /-- The reversed truncated rule is minimal on the two certified reversed cells. -/ theorem minimal_closedForm_of_offset_one_truncated_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcase : r.end_.offset ≤ 1 ∨ (2 ≤ r.end_.offset ∧ ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)) : Minimal r res (closedFormOffsetOneTruncatedRev r res) := by unfold closedFormOffsetOneTruncatedRev rcases hcase with hle | ⟨hge, hhi⟩ · rw [ite_eq_left hle] by_cases h1 : r.end_.offset = 1 · exact minimal_truncatedRangeRev_of_offset_one hread hmore hrev hbegin h1 · exact minimal_truncatedRangeRev_of_end_offset_nonpos hread hmore hrev hbegin (by omega) · rw [ite_eq_right (by omega)] exact minimal_topOfLast_of_end_offset_ge_two_rev hread hmore hrev hbegin hge hhi /-- **The earlier full reversed truncated rule at begin offset one.** Read off the reported keys in one pass. With `E = end_.key`, `L` the last (least) reported key, `H` the head (greatest) reported key, `t` the number of reported keys at or above `E`, and `e = (end_.offset - 1).toNat`: * if `end_.offset ≤ 1`, the range is `[L, E)`; * otherwise, if `t = e`, it is `[min L E, keyAfter H)`; * otherwise it is `[min L E, ⊤)`. This rule is superseded on the last branch by `closedFormOffsetOneTruncatedRevFullC`; it remains for the under-end and finite branches, where the two agree. -/ def closedFormOffsetOneTruncatedRevFull (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 1 then truncatedRangeRev r (res.keys.getLastD ([] : Key)) else let L : WithTop Key := (res.keys.getLastD ([] : Key) : WithTop Key) let H : Key := res.keys.headD ([] : Key) let t := res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) let e := (r.end_.offset - 1).toNat if t = e then ⟨min L r.end_.key, ((keyAfter H : Key) : WithTop Key)⟩ else ⟨min L r.end_.key, ⊤⟩ /-- Iterating the successor `keyAfter`. -/ def keyAfterN : Nat → Key → Key | 0, k => k | n+1, k => keyAfter (keyAfterN n k) @[simp] theorem keyAfterN_zero (k : Key) : keyAfterN 0 k = k := rfl @[simp] theorem keyAfterN_succ (n : Nat) (k : Key) : keyAfterN (n+1) k = keyAfter (keyAfterN n k) := rfl /-- The iterated successor stays at or above the starting key. -/ theorem keyAfterN_le_self (E : Key) : ∀ n, E ≤ keyAfterN n E := by intro n; induction n with | zero => simp | succ n ih => exact le_trans ih (le_of_lt (keyAfter_self_lt _)) /-- The iterated successor is strictly increasing. -/ theorem keyAfterN_lt_succ (E : Key) (n : Nat) : keyAfterN n E < keyAfterN (n+1) E := by induction n with | zero => simpa using keyAfter_self_lt E | succ n ih => simpa using keyAfter_self_lt (keyAfter (keyAfterN n E)) /-- The keys in `[E, keyAfterN n E)` are exactly the first `n` iterated successors of `E`. This is the combinatorial content of the top-branch closed form: an interval ending at the `n`-th successor has only `n` keys above `E`. -/ theorem chain_of_lt {E k : Key} : ∀ n, E ≤ k → k < keyAfterN n E → ∃ i, i < n ∧ keyAfterN i E = k := by intro n induction n with | zero => intro hE h exact absurd h (not_lt.mpr hE) | succ n ih => intro hE hlt have hle : k ≤ keyAfterN n E := by have h' : k < keyAfter (keyAfterN n E) := by simpa using hlt exact (lt_keyAfter_iff k (keyAfterN n E)).mp h' rcases lt_or_eq_of_le hle with hlt' | heq · obtain ⟨i, hi, hik⟩ := ih hE hlt' exact ⟨i, Nat.lt_succ_of_lt hi, hik⟩ · exact ⟨n, Nat.lt_succ_self n, heq.symm⟩ /-- The iterated successor `keyAfterN` is the zero-run `chain`. -/ theorem chain_eq_keyAfterN (b : Key) : ∀ n, chain b n = keyAfterN n b | 0 => by rw [chain_zero, keyAfterN_zero] | n + 1 => by rw [chain_succ, chain_eq_keyAfterN b n, keyAfterN_succ] /-- `keyAfterN` is strictly increasing in its index. -/ theorem keyAfterN_lt_mono {E : Key} {i j : Nat} (h : i < j) : keyAfterN i E < keyAfterN j E := by rw [← chain_eq_keyAfterN E i, ← chain_eq_keyAfterN E j] exact chain_lt_mono h /-- A database can store at most `n` keys in `[E, keyAfterN n E)`: the interval is enumerated by the first `n` successors of `E`. -/ theorem length_filter_between_le_keyAfterN {l : List Key} (hnd : l.Nodup) (E : Key) (n : Nat) : (l.filter (fun k => decide (E ≤ k ∧ k < keyAfterN n E))).length ≤ n := by have hsub : ((l.filter (fun k => decide (E ≤ k ∧ k < keyAfterN n E))).toFinset : Set Key) ⊆ keysIn (↑E : WithTop Key) (↑(keyAfterN n E) : WithTop Key) := by intro x hx simp only [Finset.mem_coe, List.mem_toFinset, List.mem_filter] at hx have hx' := of_decide_eq_true hx.2 exact ⟨WithTop.coe_le_coe.mpr hx'.1, WithTop.coe_lt_coe.mpr hx'.2⟩ have hnd' : (l.filter (fun k => decide (E ≤ k ∧ k < keyAfterN n E))).Nodup := hnd.filter _ have h1 := Set.encard_le_encard hsub rw [Set.encard_coe_eq_coe_finsetCard, List.toFinset_card_of_nodup hnd'] at h1 have h2 : (keysIn (↑E : WithTop Key) (↑(keyAfterN n E) : WithTop Key)).encard = (n : ℕ∞) := by rw [← chain_eq_keyAfterN, keysIn_chain, chainSet_encard] rw [h2] at h1 exact_mod_cast h1 /-- A stronger Boolean filter is a sublist of a weaker one. -/ theorem filter_sublist_filter_of_imp {α : Type*} {l : List α} {p q : α → Bool} (h : ∀ a, p a = true → q a = true) : List.Sublist (l.filter p) (l.filter q) := by induction l with | nil => simp | cons a l ih => rw [List.filter_cons, List.filter_cons] by_cases hp : p a = true · rw [ite_eq_left hp] have hq : q a = true := h a hp rw [ite_eq_left hq] exact ih.cons_cons a · rw [ite_eq_right hp] by_cases hq : q a = true · rw [ite_eq_left hq] exact ih.cons a · rw [ite_eq_right hq] exact ih /-- If `L ≤ keyAfterN n E`, then a database stores at most `n` keys in `[E, L)`. -/ theorem length_filter_between_le_of_le_keyAfterN {l : List Key} (hnd : l.Nodup) {E L : Key} {n : Nat} (hL : L ≤ keyAfterN n E) : (l.filter (fun k => decide (E ≤ k ∧ k < L))).length ≤ n := by have hsub : List.Sublist (l.filter (fun k => decide (E ≤ k ∧ k < L))) (l.filter (fun k => decide (E ≤ k ∧ k < keyAfterN n E))) := by apply filter_sublist_filter_of_imp intro k hk have hk' := of_decide_eq_true hk exact decide_eq_true ⟨hk'.1, lt_of_lt_of_le hk'.2 hL⟩ exact le_trans hsub.length_le (length_filter_between_le_keyAfterN hnd E n) /-- For a compatible truncated reversed result, the stored keys at or above the reported last and below the resolved end are exactly the reported keys, reversed. This is the unfiltered form of `compatible_iff_truncated_keys_rev`. -/ private theorem compatible_filter_range_rev {db : DB} {r : RangeRead} {res : Result} {L : Key} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) (hL : L = res.keys.getLast hne) : db.keys.filter (fun k : Key => decide (L ≤ k ∧ (k : WithTop Key) < resolve db r.end_)) = res.keys.reverse := by have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp have hLmem : L ∈ RangeRead.completeKeys db r := by rw [hL]; exact hpre.subset (List.getLast_mem hne) have hLlo : resolve db r.begin ≤ (L : WithTop Key) := (RangeRead.mem_completeKeys.mp hLmem).2.1 have hfilter := ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp).2 have hck : RangeRead.completeKeys db r = (db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_))).reverse := by simp [RangeRead.completeKeys, RangeRead.inRange, hrev] rw [hck, List.filter_reverse] at hfilter have hrevEq : (db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_))).filter (fun k : Key => decide (L ≤ k)) = res.keys.reverse := by have := congrArg List.reverse hfilter simpa [hL] using this rw [List.filter_filter] at hrevEq rw [← hrevEq] apply List.filter_congr intro k _ by_cases hLk : L ≤ k · have hlk : resolve db r.begin ≤ (k : WithTop Key) := le_trans hLlo (by exact_mod_cast hLk) simp [hLk, hlk] · simp [hLk] /-- The full reversed truncated rule is minimal on the under-end cell and on the overshoot cell whose reported head lies below `end_.key`. Both reductions are to the already certified partial rules: the first to `truncatedRangeRev`, the second to `topOfLast` (where `t = 0` forced the top branch). -/ theorem minimal_closedForm_of_offset_one_truncated_rev_full {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcase : r.end_.offset ≤ 1 ∨ ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.end_.key) : Minimal r res (closedFormOffsetOneTruncatedRevFull r res) := by obtain ⟨db₀, hcomp₀⟩ := hread have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev have hLH : res.keys.getLast hne ≤ res.keys.head hne := (hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne) unfold closedFormOffsetOneTruncatedRevFull by_cases hle : r.end_.offset ≤ 1 · rw [ite_eq_left hle] by_cases h1 : r.end_.offset = 1 · exact minimal_truncatedRangeRev_of_offset_one ⟨db₀, hcomp₀⟩ hmore hrev hbegin h1 · exact minimal_truncatedRangeRev_of_end_offset_nonpos ⟨db₀, hcomp₀⟩ hmore hrev hbegin (by omega) · have hge : 2 ≤ r.end_.offset := by omega rw [ite_eq_right hle] have hHlt : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.end_.key := by rcases hcase with h | h · exact absurd h hle · exact h have ht0 : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = 0 := by rw [List.countP_eq_zero] intro k hk hgek rw [decide_eq_true_eq] at hgek have hkhead : k ≤ res.keys.headD ([] : Key) := by rw [hhead] exact (hsort.pairwise.imp le_of_lt).rel_head hk exact absurd hgek (not_le.mpr (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkhead) hHlt)) have hepos : 0 < (r.end_.offset - 1).toNat := by omega dsimp only rw [ht0] rw [ite_eq_right (by omega : ¬ (0 = (r.end_.offset - 1).toNat))] have hheadLt : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key := by rw [← hhead]; exact hHlt have hLE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key := by rw [hlast] exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hLH) hheadLt have hmin : min ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.end_.key = ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := min_eq_left (le_of_lt hLE) rw [hmin] exact minimal_topOfLast_of_end_offset_ge_two_rev ⟨db₀, hcomp₀⟩ hmore hrev hbegin hge (fun k hk => by have hkhead : k ≤ res.keys.head hne := (hsort.pairwise.imp le_of_lt).rel_head hk exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkhead) hheadLt) /-- The reversed complete-keys count at or above `end_.key` is the same as the forward count. -/ private theorem completeKeys_count_ge_eq_min_rev {db : DB} {r : RangeRead} (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = min ((r.end_.offset - 1).toNat) (db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key))) := by have h := completeKeys_count_ge_eq_min (db := db) (r := {r with reverse := false}) (by simp) hbegin hcross hend have hck : RangeRead.completeKeys db {r with reverse := false} = (RangeRead.completeKeys db r).reverse := by simp [RangeRead.completeKeys, hrev] rw [hck] at h rw [List.Perm.countP_eq _ (List.reverse_perm _)] at h exact h /-- The number of reported keys at or above `end_.key` is at most `(end_.offset - 1)` for a readable truncated reversed result at begin offset one. -/ private theorem reported_count_ge_le_offset_sub_one_rev {r : RangeRead} {res : Result} (hread : Readable r res) (_hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by obtain ⟨db, hcomp⟩ := hread have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp have hle : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := List.Sublist.countP_le hpre.sublist have hmin := completeKeys_count_ge_eq_min_rev (db := db) hrev hbegin hcross (by omega : 1 ≤ r.end_.offset) have hle2 : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by rw [hmin] exact Nat.min_le_left _ _ exact le_trans hle hle2 private theorem rev_truncated_filter_between {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ []) : db.keys.filter (fun k : Key => decide (res.keys.getLast hne ≤ k ∧ k ≤ res.keys.head hne)) = res.keys.reverse := by have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp have hfilter : (RangeRead.completeKeys db r).filter (fun k : Key => decide (res.keys.getLast hne ≤ k)) = res.keys := ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp).2 have hLres : resolve db r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp (hpre.subset (List.getLast_mem hne))).2.1 have hHlt : ((res.keys.head hne : Key) : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp (hpre.subset (List.head_mem hne))).2.2 have hmax : ∀ k ∈ RangeRead.completeKeys db r, k ≤ res.keys.head hne := fun k hk => le_head_of_mem_completeKeys_rev hrev hpre hne hk have hW : RangeRead.completeKeys db r = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).reverse := by simp [RangeRead.completeKeys, hrev] have h1 : (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).filter (fun k : Key => decide (res.keys.getLast hne ≤ k)) = res.keys.reverse := by have h := hfilter rw [hW, List.filter_reverse] at h simpa using congrArg List.reverse h have h2 : (db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_))).filter (fun k : Key => decide (res.keys.getLast hne ≤ k)) = res.keys.reverse := by simpa [RangeRead.inRange] using h1 rw [← h2, List.filter_filter] apply List.filter_congr intro k hk rw [Bool.decide_and] by_cases hLk : res.keys.getLast hne ≤ k · rw [decide_eq_true hLk, Bool.true_and] apply decide_eq_decide.mpr constructor · intro hkH refine ⟨?_, ?_⟩ · exact le_trans hLres (WithTop.coe_le_coe.mpr hLk) · exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkH) hHlt · rintro ⟨hbeg, hlt⟩ by_contra hkH have hHk : res.keys.head hne < k := lt_of_not_ge hkH have hkD : k ∈ RangeRead.completeKeys db r := by rw [hW, List.mem_reverse] exact List.mem_filter.mpr ⟨hk, decide_eq_true ⟨hbeg, hlt⟩⟩ exact absurd (hmax k hkD) (not_le.mpr hHk) · rw [decide_eq_false hLk] rfl /-- Under the finite reversed-truncated branch (`t = e`, `end.offset ≥ 2`), no stored key of the database lies in `[end_.key, last reported)`. The reported keys are a prefix of the descending complete keys; if a complete key sat below the last reported key but at or above `end_.key`, the complete keys would contain strictly more keys at or above `end_.key` than the count bound allows. -/ private theorem rev_truncated_no_key_between {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (_hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) {k : Key} (hkdb : k ∈ db.keys) (hEk : r.end_.key ≤ (k : WithTop Key)) (hkL : k < res.keys.getLast hne) : False := by set P : Key → Bool := fun k => decide (r.end_.key ≤ (k : WithTop Key)) with hP have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp have hLmem : res.keys.getLast hne ∈ RangeRead.completeKeys db r := hpre.subset (List.getLast_mem hne) have hLlt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := (RangeRead.mem_completeKeys.mp hLmem).2.2 have hkcomp : k ∈ RangeRead.completeKeys db r := by rw [RangeRead.mem_completeKeys] refine ⟨hkdb, ?_, ?_⟩ · exact (key_le_resolve_iff_of_offset_one hbegin hkdb).mp (le_trans hcross hEk) · exact lt_trans (WithTop.coe_lt_coe.mpr hkL) hLlt have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev have hLle : ∀ x ∈ res.keys, res.keys.getLast hne ≤ x := fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx have hEltL : r.end_.key < ((res.keys.getLast hne : Key) : WithTop Key) := lt_of_le_of_lt hEk (WithTop.coe_lt_coe.mpr hkL) have hall : ∀ x ∈ res.keys, P x = true := by intro x hx rw [hP] exact decide_eq_true (le_trans (le_of_lt hEltL) (WithTop.coe_le_coe.mpr (hLle x hx))) have hcount_res : res.keys.countP P = res.keys.length := List.countP_eq_length.mpr hall have hlen_eq : res.keys.length = (r.end_.offset - 1).toNat := by rw [← hcount_res] exact ht have hprefix : res.keys <+: (RangeRead.completeKeys db r).filter P := by have h := hpre.filter P rwa [List.filter_eq_self.mpr hall] at h have hkfilter : k ∈ (RangeRead.completeKeys db r).filter P := List.mem_filter.mpr ⟨hkcomp, by rw [hP]; exact decide_eq_true hEk⟩ have hknot : k ∉ res.keys := fun hkres => absurd (hLle k hkres) (not_le.mpr hkL) have hltlen : res.keys.length < ((RangeRead.completeKeys db r).filter P).length := by by_contra hnot have heq : res.keys.length = ((RangeRead.completeKeys db r).filter P).length := by have hle := hprefix.length_le omega have hEq := hprefix.eq_of_length heq exact hknot (by rw [hEq]; exact hkfilter) have hcount_complete_ge : res.keys.length + 1 ≤ (RangeRead.completeKeys db r).countP P := by rw [List.countP_eq_length_filter] omega have hcount_complete_le : (RangeRead.completeKeys db r).countP P ≤ (r.end_.offset - 1).toNat := by rw [hP, completeKeys_count_ge_eq_min_rev (db := db) hrev hbegin hcross (by omega)] exact Nat.min_le_left _ _ omega /-- In the finite reversed-truncated branch, the candidate `[min L E, keyAfter H)` has exactly the reported keys, reversed, as its stored keys. -/ private theorem rev_truncated_finite_keys_eq {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : (closedFormOffsetOneTruncatedRevFull r res).keys db = res.keys.reverse := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl have hbase := rev_truncated_filter_between (db := db) hcomp hmore hrev hne unfold closedFormOffsetOneTruncatedRevFull rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1)] dsimp only rw [ite_eq_left ht] rw [hlast, hhead, ← hbase] unfold ConflictRange.keys apply List.filter_congr intro k hk rw [decide_eq_decide] constructor · rintro ⟨hmin, hkafter⟩ have hkH : k ≤ res.keys.head hne := (lt_keyAfter_iff k (res.keys.head hne)).mp (WithTop.coe_lt_coe.mp hkafter) have hLk : ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key) := by by_contra hcon have hkL : k < res.keys.getLast hne := lt_of_not_ge (fun h : res.keys.getLast hne ≤ k => hcon (WithTop.coe_le_coe.mpr h)) rcases min_le_iff.mp hmin with h | h · exact hcon h · exact (rev_truncated_no_key_between (db := db) hcomp hmore hrev hbegin hcross hend hne ht hk h hkL).elim exact ⟨WithTop.coe_le_coe.mp hLk, hkH⟩ · rintro ⟨hLk, hkH⟩ exact ⟨le_trans (min_le_left _ _) (WithTop.coe_le_coe.mpr hLk), WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k (res.keys.head hne)).mpr hkH)⟩ /-- In the finite reversed-truncated branch, the candidate equality fixes the complete keys at or above the reported last key, hence compatibility. -/ private theorem rev_finite_filter_eq {db : DB} {r : RangeRead} {res : Result} (hread : Readable r res) (_hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) (hT : (closedFormOffsetOneTruncatedRevFull r res).keys db = res.keys.reverse) : (RangeRead.completeKeys db r).filter (fun k : Key => decide (res.keys.getLast hne ≤ k)) = res.keys := by obtain ⟨db₀, hcomp₀⟩ := hread have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl let L : Key := res.keys.getLast hne let H : Key := res.keys.head hne let E : WithTop Key := r.end_.key let e : Nat := (r.end_.offset - 1).toNat let P : Key → Bool := fun k => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ((H : Key) : WithTop Key)) let Q : Key → Bool := fun k => decide (E ≤ (k : WithTop Key)) let BT : Key → Bool := fun k => decide (min ((L : Key) : WithTop Key) E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < ((keyAfter H : Key) : WithTop Key)) have hT' : db.keys.filter BT = res.keys.reverse := by simpa only [closedFormOffsetOneTruncatedRevFull, ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ite_eq_left ht, hlast, hhead, BT, L, H, E, ConflictRange.keys] using hT have hresnodup : res.keys.Nodup := by have h := db.nodup.filter BT rw [hT'] at h exact List.nodup_reverse.mp h have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev have hLH : L ≤ H := by dsimp only [L, H] exact (hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne) have hepos : 0 < e := by dsimp only [e]; omega -- `H ≥ E`, from a reported key at or above `E`. have htpos : 0 < res.keys.countP Q := by dsimp only [Q] rw [ht] exact hepos obtain ⟨k₀, hk₀mem, hk₀Q⟩ := List.countP_pos_iff.mp htpos have hk₀E : E ≤ (k₀ : WithTop Key) := by dsimp only [Q] at hk₀Q exact of_decide_eq_true hk₀Q have hk₀H : k₀ ≤ H := by dsimp only [H] exact (hsort.pairwise.imp le_of_lt).rel_head hk₀mem have hHE : E ≤ ((H : Key) : WithTop Key) := le_trans hk₀E (WithTop.coe_le_coe.mpr hk₀H) -- `begin.key ≤ L`, using readability. have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp₀ have hLmem₀ : L ∈ RangeRead.completeKeys db₀ r := by dsimp only [L] exact hpre₀.subset (List.getLast_mem hne) have hLdb₀ : L ∈ db₀.keys := (RangeRead.mem_completeKeys.mp hLmem₀).1 have hLres₀ : resolve db₀ r.begin ≤ ((L : Key) : WithTop Key) := (RangeRead.mem_completeKeys.mp hLmem₀).2.1 have hkeyL : r.begin.key ≤ ((L : Key) : WithTop Key) := (key_le_resolve_iff_of_offset_one (db := db₀) hbegin hLdb₀).mpr hLres₀ have hLmemC : L ∈ res.keys.reverse := by dsimp only [L] exact List.mem_reverse.mpr (List.getLast_mem hne) have hLdb : L ∈ db.keys := by have h := hLmemC rw [← hT'] at h exact List.mem_of_mem_filter h have hresL : resolve db r.begin ≤ ((L : Key) : WithTop Key) := (key_le_resolve_iff_of_offset_one hbegin hLdb).mp hkeyL have hHmemC : H ∈ res.keys.reverse := by dsimp only [H] exact List.mem_reverse.mpr (List.head_mem hne) have hHdb : H ∈ db.keys := by have h := hHmemC rw [← hT'] at h exact List.mem_of_mem_filter h -- The number of stored keys in `[E, H]` is `e`. have hcountEH : db.keys.countP P = e := by have h1 : db.keys.countP P = db.keys.countP (fun k => Q k && BT k) := by apply List.countP_congr intro k hk dsimp only [P, Q, BT] simp only [decide_eq_true_eq, Bool.and_eq_true] constructor · rintro ⟨hEk, hkH⟩ refine ⟨hEk, le_trans (min_le_right _ _) hEk, ?_⟩ exact WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k H).mpr (WithTop.coe_le_coe.mp hkH)) · rintro ⟨hEk, -, hkH⟩ exact ⟨hEk, WithTop.coe_le_coe.mpr ((lt_keyAfter_iff k H).mp (WithTop.coe_lt_coe.mp hkH))⟩ have h2 : db.keys.countP (fun k => Q k && BT k) = e := by rw [← List.countP_filter] rw [hT', List.Perm.countP_eq _ (List.reverse_perm res.keys)] dsimp only [Q, e] exact ht rw [h1, h2] -- Split at `E` and `H` to compute the index of `H`. have hEne : E ≠ (⊤ : WithTop Key) := by intro htop rw [htop] at hHE exact absurd hHE (not_le.mpr (WithTop.coe_lt_top H)) obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hEne have hvH : v ≤ H := by rw [← hv] at hHE exact WithTop.coe_le_coe.mp hHE have hcountP_split : db.keys.countP P = (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))).length + 1 := by rw [List.countP_eq_length_filter] have hlist : db.keys.filter P = (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))) ++ [H] := by apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) · apply List.sortedLT_append.mpr refine ⟨List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _), sortedLT_singleton H, ?_⟩ intro a ha b hb rw [List.mem_singleton] at hb subst hb exact (of_decide_eq_true (List.mem_filter.mp ha).2).2 · intro x dsimp only [P] rw [← hv] simp only [List.mem_filter, List.mem_append, List.mem_singleton, decide_eq_true_eq, WithTop.coe_le_coe] constructor · rintro ⟨hx, hvx, hxH⟩ by_cases hxH' : x = H · exact Or.inr hxH' · exact Or.inl ⟨hx, hvx, lt_of_le_of_ne hxH hxH'⟩ · rintro (⟨hx, hvx, hxH⟩ | rfl) · exact ⟨hx, hvx, le_of_lt hxH⟩ · exact ⟨hHdb, hvH, le_refl H⟩ rw [hlist, List.length_append, List.length_singleton] have hfilter_len : (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))).length = e - 1 := by omega have hsplit := countP_lt_eq_add_filter db.keys db.nodup hvH have hcE : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) = db.keys.countP (fun k : Key => decide (k < v)) := by rw [← hv] exact countP_lt_coe v have hcH : db.keys.countP (fun k : Key => decide (k < H)) = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e - 1 := by have h := hsplit rw [← hcE, hfilter_len] at h omega obtain ⟨j, hjlt, hj⟩ := List.mem_iff_getElem.mp hHdb have hcj : db.keys.countP (fun k : Key => decide (k < H)) = j := countP_lt_eq_of_getElem db.sorted hjlt hj have hj_eq : j = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e - 1 := by rw [← hcj] exact hcH have hEanchor : (r.end_.anchor db).toNat = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e := by rw [anchor_toNat_eq (s := r.end_) (by omega)] have hanchor_nonneg : 0 ≤ r.end_.anchor db := by unfold Selector.anchor have hc : (0 : ℤ) ≤ (db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) : ℤ) := by exact_mod_cast Nat.zero_le _ omega -- `H < resolve end_`, so no complete key above `H` survives. have hHlt : ((H : Key) : WithTop Key) < resolve db r.end_ := by by_cases hlt : (r.end_.anchor db).toNat < db.keys.length · rw [resolve_eq_getElem hanchor_nonneg hlt] apply WithTop.coe_lt_coe.mpr have hidx : (r.end_.anchor db).toNat = j + 1 := by rw [hEanchor] omega have hj1 : j + 1 < db.keys.length := by rw [← hidx]; exact hlt have hstep : db.keys[j] < db.keys[j+1] := db.sorted.getElem_lt_getElem_of_lt (i := j) (j := j+1) (hi := hjlt) (hj := hj1) (Nat.lt_succ_self j) rw [hj] at hstep have hget : db.keys[(r.end_.anchor db).toNat]? = some (db.keys[j+1]) := by rw [hidx] exact List.getElem?_eq_getElem hj1 obtain ⟨_, hEq⟩ := List.getElem?_eq_some_iff.mp hget rw [hEq] exact hstep · rw [resolve_eq_top hanchor_nonneg (le_of_not_gt hlt)] exact WithTop.coe_lt_top H -- No stored key lies strictly between `H` and `resolve end_`. have hnoHre : ∀ k ∈ db.keys, ((H : Key) : WithTop Key) < (k : WithTop Key) → (k : WithTop Key) < resolve db r.end_ → False := by intro k hk hHk hkre have hEk : E ≤ (k : WithTop Key) := le_trans hHE (le_of_lt hHk) have hkcomp : k ∈ RangeRead.completeKeys db r := by rw [RangeRead.mem_completeKeys] exact ⟨hk, le_trans hresL (le_trans (WithTop.coe_le_coe.mpr hLH) (le_of_lt hHk)), hkre⟩ have hall_complete : ∀ x ∈ res.keys, x ∈ RangeRead.completeKeys db r := by intro x hx rw [RangeRead.mem_completeKeys] refine ⟨?_, ?_, ?_⟩ · have hxC : x ∈ res.keys.reverse := List.mem_reverse.mpr hx rw [← hT'] at hxC exact List.mem_of_mem_filter hxC · exact le_trans hresL (WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_getLast hx)) · exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx)) hHlt have hknot : k ∉ res.keys := fun hkres => absurd ((hsort.pairwise.imp le_of_lt).rel_head hkres) (not_le.mpr (WithTop.coe_lt_coe.mp hHk)) have hSsub : ((res.keys.filter Q) ++ [k]).Subperm ((RangeRead.completeKeys db r).filter Q) := by apply List.subperm_of_subset · apply List.nodup_append.mpr refine ⟨hresnodup.filter Q, List.nodup_singleton k, ?_⟩ intro a ha b hb rw [List.mem_singleton] at hb subst hb intro hab have ha' := List.mem_filter.mp ha exact hknot (hab ▸ ha'.1) · intro x hx simp only [List.mem_append, List.mem_singleton, List.mem_filter] at hx ⊢ rcases hx with ⟨hxres, hxQ⟩ | rfl · exact ⟨hall_complete x hxres, hxQ⟩ · exact ⟨hkcomp, by dsimp only [Q]; exact decide_eq_true hEk⟩ have hle := List.Subperm.countP_le Q hSsub have hQcomplete : (RangeRead.completeKeys db r).countP Q = ((RangeRead.completeKeys db r).filter Q).length := List.countP_eq_length_filter have hQS : ((res.keys.filter Q) ++ [k]).countP Q = ((res.keys.filter Q) ++ [k]).length := by apply List.countP_eq_length.mpr intro x hx simp only [List.mem_append, List.mem_singleton, List.mem_filter] at hx rcases hx with ⟨_, hxQ⟩ | rfl · exact hxQ · dsimp only [Q]; exact decide_eq_true hEk have hlenS : ((res.keys.filter Q) ++ [k]).length = e + 1 := by rw [List.length_append, List.length_singleton, ← List.countP_eq_length_filter] dsimp only [Q, e] rw [ht] have hrescount : res.keys.countP Q = e := by dsimp only [Q, e] exact ht have hbound : (RangeRead.completeKeys db r).countP Q ≤ e := by dsimp only [Q] rw [completeKeys_count_ge_eq_min_rev (db := db) hrev hbegin hcross (by omega)] refine le_trans (Nat.min_le_left _ _) ?_ rfl rw [hQS] at hle have hQcf : ((RangeRead.completeKeys db r).filter Q).countP Q = ((RangeRead.completeKeys db r).filter Q).length := by apply List.countP_eq_length.mpr intro x hx exact (List.mem_filter.mp hx).2 rw [hQcf] at hle rw [hlenS] at hle have hb : ((RangeRead.completeKeys db r).filter Q).length ≤ e := by rw [← hQcomplete] exact hbound omega -- No stored key lies in `[E, L)`. have hnoEL : ∀ k ∈ db.keys, E ≤ (k : WithTop Key) → (k : WithTop Key) < ((L : Key) : WithTop Key) → False := by intro k hk hEk hkL have hkB : BT k = true := by dsimp only [BT] rw [decide_eq_true_eq] refine ⟨le_trans (min_le_right _ _) hEk, ?_⟩ exact WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k H).mpr (WithTop.coe_le_coe.mp (le_trans (le_of_lt hkL) (WithTop.coe_le_coe.mpr hLH)))) have hkC := List.mem_filter.mpr ⟨hk, hkB⟩ rw [hT'] at hkC have hkres : k ∈ res.keys := List.mem_reverse.mp hkC have hLk : L ≤ k := (hsort.pairwise.imp le_of_lt).rel_getLast hkres exact absurd (WithTop.coe_le_coe.mpr hLk) (not_le.mpr hkL) -- The complete keys at or above `L` are exactly the reported keys. have hfilter : (RangeRead.completeKeys db r).filter (fun k : Key => decide ((L : Key) ≤ k)) = res.keys := by let W : Key → Bool := fun k => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_) have hW : RangeRead.completeKeys db r = (db.keys.filter W).reverse := by unfold RangeRead.completeKeys RangeRead.inRange rw [ite_eq_left hrev] have hstep : (db.keys.filter W).filter (fun k : Key => decide ((L : Key) ≤ k)) = res.keys.reverse := by rw [List.filter_filter, ← hT'] apply List.filter_congr intro k hk apply Bool.eq_iff_iff.mpr dsimp only [W, BT] simp only [Bool.and_eq_true, decide_eq_true_eq] constructor · rintro ⟨hLk, hresb, hkre⟩ refine ⟨le_trans (min_le_left _ _) (WithTop.coe_le_coe.mpr hLk), ?_⟩ have hkH : (k : WithTop Key) ≤ ((H : Key) : WithTop Key) := by by_contra hcon exact (hnoHre k hk (lt_of_not_ge hcon) hkre).elim exact WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k H).mpr (WithTop.coe_le_coe.mp hkH)) · rintro ⟨hmin, hkafter⟩ have hkH : (k : WithTop Key) ≤ ((H : Key) : WithTop Key) := WithTop.coe_le_coe.mpr ((lt_keyAfter_iff k H).mp (WithTop.coe_lt_coe.mp hkafter)) have hLk : (L : Key) ≤ k := by by_cases hLE : ((L : Key) : WithTop Key) ≤ E · exact WithTop.coe_le_coe.mp (min_eq_left hLE ▸ hmin) · have hEL : E < ((L : Key) : WithTop Key) := lt_of_not_ge hLE by_contra hcon have hkL : (k : Key) < L := lt_of_not_ge hcon exact (hnoEL k hk (min_eq_right (le_of_lt hEL) ▸ hmin) (WithTop.coe_lt_coe.mpr hkL)).elim exact ⟨hLk, le_trans hresL (WithTop.coe_le_coe.mpr hLk), lt_of_le_of_lt hkH hHlt⟩ rw [hW, List.filter_reverse, hstep, List.reverse_reverse] simpa only [L] using hfilter /-- In the finite reversed-truncated branch, inserting an unstored key `k` with `end_.key ≤ k < last reported` makes the end selector resolve onto the reported head. The head then leaves the complete keys, so the truncated result can no longer be compatible. -/ private theorem rev_insert_between_incompatible {db : DB} {r : RangeRead} {res : Result} {k : Key} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) (hk0 : k ∉ db.keys) (hEk : r.end_.key ≤ (k : WithTop Key)) (hkL : (k : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) : ¬ RangeRead.Compatible (db.insert k hk0) r res := by have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl let L : Key := res.keys.getLast hne let H : Key := res.keys.head hne let E : WithTop Key := r.end_.key let e : Nat := (r.end_.offset - 1).toNat let P : Key → Bool := fun k => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ((H : Key) : WithTop Key)) let Q : Key → Bool := fun k => decide (E ≤ (k : WithTop Key)) let BT : Key → Bool := fun k => decide (min ((L : Key) : WithTop Key) E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < ((keyAfter H : Key) : WithTop Key)) have hT : (closedFormOffsetOneTruncatedRevFull r res).keys db = res.keys.reverse := rev_truncated_finite_keys_eq (db := db) hcomp hmore hrev hbegin hcross hend hne ht have hT' : db.keys.filter BT = res.keys.reverse := by simpa only [closedFormOffsetOneTruncatedRevFull, ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ite_eq_left ht, hlast, hhead, BT, L, H, E, ConflictRange.keys] using hT have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev have hLH : L ≤ H := by dsimp only [L, H] exact (hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne) have hepos : 0 < e := by dsimp only [e]; omega -- `H ≥ E`, from a reported key at or above `E`. have htpos : 0 < res.keys.countP Q := by dsimp only [Q] rw [ht] exact hepos obtain ⟨k₀, hk₀mem, hk₀Q⟩ := List.countP_pos_iff.mp htpos have hk₀E : E ≤ (k₀ : WithTop Key) := by dsimp only [Q] at hk₀Q exact of_decide_eq_true hk₀Q have hk₀H : k₀ ≤ H := by dsimp only [H] exact (hsort.pairwise.imp le_of_lt).rel_head hk₀mem have hHE : E ≤ ((H : Key) : WithTop Key) := le_trans hk₀E (WithTop.coe_le_coe.mpr hk₀H) have hHmemC : H ∈ res.keys.reverse := by dsimp only [H] exact List.mem_reverse.mpr (List.head_mem hne) have hHdb : H ∈ db.keys := by have h := hHmemC rw [← hT'] at h exact List.mem_of_mem_filter h -- The number of stored keys in `[E, H]` is `e`. have hcountEH : db.keys.countP P = e := by have h1 : db.keys.countP P = db.keys.countP (fun k => Q k && BT k) := by apply List.countP_congr intro k hk dsimp only [P, Q, BT] simp only [decide_eq_true_eq, Bool.and_eq_true] constructor · rintro ⟨hEk, hkH⟩ refine ⟨hEk, le_trans (min_le_right _ _) hEk, ?_⟩ exact WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k H).mpr (WithTop.coe_le_coe.mp hkH)) · rintro ⟨hEk, -, hkH⟩ exact ⟨hEk, WithTop.coe_le_coe.mpr ((lt_keyAfter_iff k H).mp (WithTop.coe_lt_coe.mp hkH))⟩ have h2 : db.keys.countP (fun k => Q k && BT k) = e := by rw [← List.countP_filter] rw [hT', List.Perm.countP_eq _ (List.reverse_perm res.keys)] dsimp only [Q, e] exact ht rw [h1, h2] -- Split at `E` and `H` to compute the index of `H`. have hEne : E ≠ (⊤ : WithTop Key) := by intro htop rw [htop] at hHE exact absurd hHE (not_le.mpr (WithTop.coe_lt_top H)) obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hEne have hvH : v ≤ H := by rw [← hv] at hHE exact WithTop.coe_le_coe.mp hHE have hcountP_split : db.keys.countP P = (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))).length + 1 := by rw [List.countP_eq_length_filter] have hlist : db.keys.filter P = (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))) ++ [H] := by apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) · apply List.sortedLT_append.mpr refine ⟨List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _), sortedLT_singleton H, ?_⟩ intro a ha b hb rw [List.mem_singleton] at hb subst hb exact (of_decide_eq_true (List.mem_filter.mp ha).2).2 · intro x dsimp only [P] rw [← hv] simp only [List.mem_filter, List.mem_append, List.mem_singleton, decide_eq_true_eq, WithTop.coe_le_coe] constructor · rintro ⟨hx, hvx, hxH⟩ by_cases hxH' : x = H · exact Or.inr hxH' · exact Or.inl ⟨hx, hvx, lt_of_le_of_ne hxH hxH'⟩ · rintro (⟨hx, hvx, hxH⟩ | rfl) · exact ⟨hx, hvx, le_of_lt hxH⟩ · exact ⟨hHdb, hvH, le_refl H⟩ rw [hlist, List.length_append, List.length_singleton] have hfilter_len : (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))).length = e - 1 := by omega have hsplit := countP_lt_eq_add_filter db.keys db.nodup hvH have hcE : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) = db.keys.countP (fun k : Key => decide (k < v)) := by rw [← hv] exact countP_lt_coe v have hcH : db.keys.countP (fun k : Key => decide (k < H)) = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e - 1 := by have h := hsplit rw [← hcE, hfilter_len] at h omega obtain ⟨j, hjlt, hj⟩ := List.mem_iff_getElem.mp hHdb have hcj : db.keys.countP (fun k : Key => decide (k < H)) = j := countP_lt_eq_of_getElem db.sorted hjlt hj have hj_eq : j = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e - 1 := by rw [← hcj] exact hcH have hEanchor : (r.end_.anchor db).toNat = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e := by rw [anchor_toNat_eq (s := r.end_) (by omega)] -- Inserting `k` at or above `E` does not change the count below `E`, so the -- anchor still targets the successor of `H`; the new key lies below `H`, which -- shifts `H` into that target index. have hinskeys : (db.insert k hk0).keys = db.keys.insertIdx (db.keys.countP (fun x => decide (x < k))) k := by rw [DB.insert_keys, orderedInsert_eq_insertIdx db.sorted hk0] have hcountnew : (db.insert k hk0).keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := by rw [hinskeys] exact countP_insertIdx _ _ _ (by rw [decide_eq_false_iff_not] exact not_lt.mpr hEk) have hanchornew : (r.end_.anchor (db.insert k hk0)).toNat = db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e := by rw [anchor_toNat_eq (s := r.end_) (by omega), hcountnew] have hJeq : (r.end_.anchor (db.insert k hk0)).toNat = j + 1 := by rw [hanchornew] have hb : db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e = (db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e - 1) + 1 := by omega rw [hb, ← hj_eq] have hpj : db.keys.countP (fun x : Key => decide (x < k)) ≤ j := by rw [← hcj] apply countP_le_countP_of_imp intro x hx hlt rw [decide_eq_true_eq] at hlt ⊢ have hkH : k < H := lt_of_lt_of_le (WithTop.coe_lt_coe.mp hkL) hLH exact lt_trans hlt hkH have hnewlen : (r.end_.anchor (db.insert k hk0)).toNat < (db.insert k hk0).keys.length := by rw [hinskeys, hJeq, List.length_insertIdx_of_le_length List.countP_le_length] omega have hnewget? : (db.insert k hk0).keys[(r.end_.anchor (db.insert k hk0)).toNat]? = some H := by rw [hinskeys, hJeq, List.getElem?_insertIdx] have hlt : ¬ j + 1 < db.keys.countP (fun x => decide (x < k)) := by omega have heq : ¬ j + 1 = db.keys.countP (fun x => decide (x < k)) := by omega rw [ite_eq_right hlt, ite_eq_right heq, Nat.add_sub_cancel, List.getElem?_eq_getElem hjlt, hj] obtain ⟨_, hnewget⟩ := List.getElem?_eq_some_iff.mp hnewget? have hHresolve : resolve (db.insert k hk0) r.end_ = ((H : Key) : WithTop Key) := by rw [resolve_eq_getElem (anchor_nonneg_of_one_le (by omega)) hnewlen] exact congrArg (fun x : Key => (x : WithTop Key)) hnewget intro hcompNew have hpre := RangeRead.compatible_keys_prefix hcompNew have hHmem : H ∈ res.keys := by dsimp only [H] exact List.head_mem hne have hHcomp : H ∈ RangeRead.completeKeys (db.insert k hk0) r := hpre.subset hHmem have hlt := (RangeRead.mem_completeKeys.mp hHcomp).2.2 rw [hHresolve] at hlt exact (lt_irrefl ((H : Key) : WithTop Key)) hlt /-- In the finite reversed-truncated branch, every key in `[end_.key, last reported)` is necessary. A compatible database stores no key in that interval (`rev_truncated_no_key_between`); inserting one, in a range that omits it, moves `resolve end_` down onto the reported head, so the truncated result becomes incompatible (`rev_insert_between_incompatible`). -/ private theorem necessary_finite_below_last_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) {k : Key} (hEk : r.end_.key ≤ (k : WithTop Key)) (hkL : ((k : Key) : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) : Necessary r res k := by obtain ⟨db₀, hcomp₀⟩ := hread intro cr hs by_contra hkcr have hk0 : k ∉ db₀.keys := by intro hkdb exact rev_truncated_no_key_between (db := db₀) hcomp₀ hmore hrev hbegin hcross hend hne ht hkdb hEk (WithTop.coe_lt_coe.mp hkL) have hagree : AgreeOn cr db₀ (db₀.insert k hk0) := (ConflictRange.keys_insert_of_not_mem cr db₀ hk0 hkcr).symm have hcompNew : RangeRead.Compatible (db₀.insert k hk0) r res := (hs db₀ _ hagree).mp hcomp₀ exact rev_insert_between_incompatible (db := db₀) hcomp₀ hmore hrev hbegin hcross hend hne ht hk0 hEk hkL hcompNew /-- **The finite branch of the full reversed offset-one closed form.** When `t = e` with `e ≥ 1`, the candidate `[min last end_.key, keyAfter head)` is minimal. Soundness is the finite-branch filter identity: agreement on the candidate fixes the complete keys at or above the reported last, which is exactly compatibility for a truncated reversed result. Necessity splits at the reported last: keys in `[last, head]` are reported-or-between, and keys in `[end_.key, last)` are supplied by `necessary_finite_below_last_rev`. -/ theorem minimal_closedForm_of_offset_one_truncated_rev_full_finite {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : Minimal r res (closedFormOffsetOneTruncatedRevFull r res) := by obtain ⟨db₀, hcomp₀⟩ := hread have hread' : Readable r res := ⟨db₀, hcomp₀⟩ have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn (closedFormOffsetOneTruncatedRevFull r res) db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hT : (closedFormOffsetOneTruncatedRevFull r res).keys db = res.keys.reverse := rev_truncated_finite_keys_eq (db := db) hcomp_db hmore hrev hbegin hcross hend hne ht have hT' : (closedFormOffsetOneTruncatedRevFull r res).keys db' = res.keys.reverse := by rw [← hag'] exact hT have hfilter := rev_finite_filter_eq (db := db') hread' hmore hrev hbegin hcross hend hne ht hT' exact (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hcomp_db.1, hfilter⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hk have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl unfold closedFormOffsetOneTruncatedRevFull at hk rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1), ite_eq_left ht] at hk rw [hlast, hhead] at hk have hkH : k ≤ res.keys.head hne := (lt_keyAfter_iff k (res.keys.head hne)).mp (WithTop.coe_lt_coe.mp hk.2) by_cases hkL : res.keys.getLast hne ≤ k · exact necessary_of_between_result hread' (List.getLast_mem hne) (List.head_mem hne) hkL hkH · have hkL' : ((k : Key) : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key) := WithTop.coe_lt_coe.mpr (lt_of_not_ge hkL) have hEk : r.end_.key ≤ (k : WithTop Key) := by rcases min_le_iff.mp hk.1 with h | h · exact absurd (WithTop.coe_le_coe.mp h) hkL · exact h exact necessary_finite_below_last_rev hread' hmore hrev hbegin hcross hend hne ht hEk hkL' /-- The full reversed truncated rule is also minimal on the finite branch, and still on the under-end and below-head cells. -/ theorem minimal_closedForm_of_offset_one_truncated_rev_full_of_cases {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hcase : r.end_.offset ≤ 1 ∨ res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat ∨ ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.end_.key) : Minimal r res (closedFormOffsetOneTruncatedRevFull r res) := by by_cases hle : r.end_.offset ≤ 1 · exact minimal_closedForm_of_offset_one_truncated_rev_full hread hmore hrev hbegin (Or.inl hle) · by_cases ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat · exact minimal_closedForm_of_offset_one_truncated_rev_full_finite hread hmore hrev hbegin hcross (by omega : 2 ≤ r.end_.offset) ht · have hH : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.end_.key := by rcases hcase with h | h | h · exact absurd h hle · exact absurd h ht · exact h exact minimal_closedForm_of_offset_one_truncated_rev_full hread hmore hrev hbegin (Or.inr hH) /-- The closed form at begin offset one denotes exactly the necessary set. -/ theorem closedFormOffsetOne_toSet_eq_necessarySet {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : (closedFormOffsetOne r res).toSet = necessarySet r res := (necessarySet_eq_of_minimal (minimal_closedForm_of_offset_one hread hmore hne hrev hbegin hcross)).symm /-! ## The corrected reversed truncated top branch The earlier full reversed truncated rule used `min L E` on the top branch. That is too small when `end_.key ≤ end_.key` and not enough keys lie between them: the resolved begin must then start at the reported last key rather than at `end_.key`. The number of available successor keys in `[E, L)` is exactly what `keyAfterN` measures, and the corrected rule is `begin = E` only when `keyAfterN (e - t - 1) E < L`. -/ /-- The corrected full reversed truncated rule. On the top branch it starts at `end_.key` only when the `(e - t - 1)`-th successor of `end_.key` is still below the reported last key; otherwise it starts at the reported last key. -/ def closedFormOffsetOneTruncatedRevFullC (r : RangeRead) (res : Result) : ConflictRange := if r.end_.offset ≤ 1 then truncatedRangeRev r (res.keys.getLastD ([] : Key)) else let L : WithTop Key := (res.keys.getLastD ([] : Key) : WithTop Key) let H : Key := res.keys.headD ([] : Key) let t := res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) let e := (r.end_.offset - 1).toNat if t = e then ⟨min L r.end_.key, ((keyAfter H : Key) : WithTop Key)⟩ else match r.end_.key with | some E => if keyAfterN (e - t - 1) E < res.keys.getLastD ([] : Key) then ⟨(E : WithTop Key), ⊤⟩ else ⟨L, ⊤⟩ | none => ⟨L, ⊤⟩ /-- **Soundness of the corrected top branch starting at `end_.key`.** When the reported last key lies strictly above `end_.key`, agreement on `[end_.key, ⊤)` fixes `resolve end_` (`resolve_eq_of_agree_ge`), hence the stored keys in `[last, resolve end_)`, which are exactly the reported keys reversed (`compatible_filter_range_rev`). The reported last key is stored, so it also bounds `resolve begin`. -/ theorem sound_topRev_begin_end {r : RangeRead} {res : Result} (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hend : 1 ≤ r.end_.offset) (hcross : r.begin.key ≤ r.end_.key) (hne : res.keys ≠ []) {E₀ : Key} (hE : r.end_.key = (E₀ : WithTop Key)) (hEL : (E₀ : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) : Sound r res ⟨(E₀ : WithTop Key), ⊤⟩ := by intro db₁ db₂ hagree have hEagree : ∀ k : Key, (E₀ : WithTop Key) ≤ (k : WithTop Key) → (k ∈ db₁.keys ↔ k ∈ db₂.keys) := by intro k hk exact (agreeOn_iff ⟨(E₀ : WithTop Key), ⊤⟩ db₁ db₂).mp hagree k (ConflictRange.mem_iff.mpr ⟨hk, WithTop.coe_lt_top k⟩) have step : ∀ db db', AgreeOn ⟨(E₀ : WithTop Key), ⊤⟩ db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp have hEagree' : ∀ k : Key, (E₀ : WithTop Key) ≤ (k : WithTop Key) → (k ∈ db.keys ↔ k ∈ db'.keys) := by intro k hk exact (agreeOn_iff ⟨(E₀ : WithTop Key), ⊤⟩ db db').mp hag' k (ConflictRange.mem_iff.mpr ⟨hk, WithTop.coe_lt_top k⟩) have hlim : RangeRead.withinLimit r res.keys := hcomp.1 have hEL' : r.end_.key < ((res.keys.getLast hne : Key) : WithTop Key) := by rw [hE]; exact hEL have hre : resolve db r.end_ = resolve db' r.end_ := by refine resolve_eq_of_agree_ge (s := r.end_) hend ?_ intro k hk rw [hE] at hk exact hEagree' k hk have hcomp_filter := compatible_filter_range_rev (db := db) hcomp hmore hrev hne rfl have hLfilter : db'.keys.filter (fun k : Key => decide (res.keys.getLast hne ≤ k ∧ (k : WithTop Key) < resolve db' r.end_)) = res.keys.reverse := by rw [← hre, ← hcomp_filter] apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db'.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) · intro k rw [List.mem_filter, List.mem_filter] constructor · rintro ⟨hk', hpred⟩ have hpred' := of_decide_eq_true hpred exact ⟨(hEagree' k (le_trans (le_of_lt hEL) (WithTop.coe_le_coe.mpr hpred'.1))).mpr hk', hpred⟩ · rintro ⟨hk, hpred⟩ have hpred' := of_decide_eq_true hpred exact ⟨(hEagree' k (le_trans (le_of_lt hEL) (WithTop.coe_le_coe.mpr hpred'.1))).mp hk, hpred⟩ have hLmem' : res.keys.getLast hne ∈ db'.keys := by have h := List.mem_reverse.mpr (List.getLast_mem hne) rw [← hLfilter] at h exact List.mem_of_mem_filter h have hrb' : resolve db' r.begin ≤ ((res.keys.getLast hne : Key) : WithTop Key) := (key_le_resolve_iff_of_offset_one hbegin hLmem').mp (le_trans hcross (le_of_lt hEL')) have hfinal : (RangeRead.completeKeys db' r).filter (fun k : Key => decide (res.keys.getLast hne ≤ k)) = res.keys := by have hck : RangeRead.completeKeys db' r = (RangeRead.inRange db'.keys (resolve db' r.begin) (resolve db' r.end_)).reverse := by simp [RangeRead.completeKeys, hrev] rw [hck, List.filter_reverse] unfold RangeRead.inRange rw [List.filter_filter] have hcongr : db'.keys.filter (fun a : Key => decide (res.keys.getLast hne ≤ a) && decide (resolve db' r.begin ≤ (a : WithTop Key) ∧ (a : WithTop Key) < resolve db' r.end_)) = db'.keys.filter (fun a : Key => decide (res.keys.getLast hne ≤ a ∧ (a : WithTop Key) < resolve db' r.end_)) := by apply List.filter_congr intro a _ by_cases hLa : res.keys.getLast hne ≤ a · have hbeg : resolve db' r.begin ≤ (a : WithTop Key) := le_trans hrb' (WithTop.coe_le_coe.mpr hLa) simp [hLa, hbeg] · simp [hLa] rw [hcongr, hLfilter, List.reverse_reverse] exact (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hlim, hfinal⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ /-- **Padding necessity below the reported last in the reversed top branch.** If the `n`-th successor of `end_.key` still lies below the reported last key `L`, then every key `k ∈ [end_.key, L)` is necessary. The witness database pads the successor chain below `L` so that inserting `k` raises the count of keys at or above `end_.key` just enough to make the resolved end land on the reported head `keyAfter H`, while without `k` the window stays unbounded and the extra padding key heads the complete keys. -/ private theorem necessary_pad_top_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) {E : Key} (hE : r.end_.key = (E : WithTop Key)) (hEL : (E : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) {n : Nat} (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) (hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1) (hroom : keyAfterN n E < res.keys.getLast hne) {k : Key} (hEk : E ≤ k) (hkL : k < res.keys.getLast hne) : Necessary r res k := by obtain ⟨db₀, hcomp₀⟩ := hread set L : Key := res.keys.getLast hne with hLdef set H : Key := res.keys.head hne with hHdef set e : Nat := (r.end_.offset - 1).toNat with hedef have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev have hLle : ∀ x ∈ res.keys, L ≤ x := by intro x hx rw [hLdef] exact (hsort.pairwise.imp le_of_lt).rel_getLast hx have hHge : ∀ x ∈ res.keys, x ≤ H := by intro x hx rw [hHdef] exact (hsort.pairwise.imp le_of_lt).rel_head hx have hLH : L ≤ H := hLle H (by rw [hHdef]; exact List.head_mem hne) have hkL' : k < L := by rw [hLdef]; exact hkL have hk_notin_res : k ∉ res.keys := by intro hx exact absurd (hLle k hx) (not_le.mpr hkL') have hk_notin_rev : k ∉ res.keys.reverse := by rw [List.mem_reverse]; exact hk_notin_res have htlen : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq, hE] exact le_trans (le_of_lt hEL) (WithTop.coe_le_coe.mpr (hLle x hx)) have hn_e : e = n + res.keys.length + 1 := by rw [hedef] omega -- the successor chain below `L` set S : List Key := (List.range (n + 1)).map (chain E) with hSdef have hS_len : S.length = n + 1 := by rw [hSdef, List.length_map, List.length_range] have hS_sorted : S.SortedLT := by rw [hSdef]; exact sortedLT_map_chain E (n + 1) have hS_nodup : S.Nodup := hS_sorted.pairwise.nodup have hS_mem : ∀ x, x ∈ S ↔ ∃ i, i < n + 1 ∧ chain E i = x := by intro x rw [hSdef, List.mem_map] constructor · rintro ⟨i, hi, hix⟩; exact ⟨i, List.mem_range.mp hi, hix⟩ · rintro ⟨i, hi, hix⟩; exact ⟨i, List.mem_range.mpr hi, hix⟩ have hS_le : ∀ x ∈ S, x ≤ chain E n := by intro x hx obtain ⟨i, hi, rfl⟩ := (hS_mem x).mp hx rcases lt_or_eq_of_le (by omega : i ≤ n) with h | h · exact le_of_lt (chain_lt_mono h) · rw [h] have hS_lt_L : ∀ x ∈ S, x < L := by intro x hx have h := hS_le x hx rw [chain_eq_keyAfterN E n] at h exact lt_of_le_of_lt h hroom have hS_ge_E : ∀ x ∈ S, E ≤ x := by intro x hx obtain ⟨i, hi, rfl⟩ := (hS_mem x).mp hx exact chain_le E i set P : List Key := (S.erase k).take n with hPdef have hP_len : P.length = n := by rw [hPdef, List.length_take] have hge : n ≤ (S.erase k).length := by by_cases hkS : k ∈ S · rw [List.length_erase_of_mem hkS, hS_len]; omega · rw [List.erase_of_not_mem hkS, hS_len]; omega omega have hP_sorted : P.SortedLT := by rw [hPdef] exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := n) (List.Pairwise.erase k (List.sortedLT_iff_pairwise.mp hS_sorted))) have hP_sub : P ⊆ S := by intro x hx rw [hPdef] at hx exact List.erase_subset ((List.take_sublist n (S.erase k)).subset hx) have hP_lt_L : ∀ x ∈ P, x < L := fun x hx => hS_lt_L x (hP_sub hx) have hP_ge_E : ∀ x ∈ P, E ≤ x := fun x hx => hS_ge_E x (hP_sub hx) have hk_notin_P : k ∉ P := by intro hx have hx' : k ∈ S.erase k := (List.take_sublist n (S.erase k)).subset hx exact (hS_nodup.mem_erase_iff.mp hx').1 rfl set u : Key := keyAfter H with hudef have hHlt_u : H < u := by rw [hudef]; exact keyAfter_self_lt H have hres_lt_u : ∀ x ∈ res.keys.reverse, x < u := by intro x hx exact lt_of_le_of_lt (hHge x (List.mem_reverse.mp hx)) hHlt_u have hk_notin_a : k ∉ P ++ res.keys.reverse ++ [u] := by intro hx rw [List.mem_append, List.mem_append] at hx rcases hx with (hx | hx) | hx · exact hk_notin_P hx · exact hk_notin_rev hx · rw [List.mem_singleton] at hx exact (ne_of_lt (lt_trans (lt_of_lt_of_le hkL' hLH) hHlt_u)) hx set aList : List Key := P ++ res.keys.reverse ++ [u] with hadef have hres_rev_sorted : res.keys.reverse.SortedLT := hsort.reverse have hP_lt_res : ∀ x ∈ P, ∀ y ∈ res.keys.reverse, x < y := by intro x hx y hy exact lt_of_lt_of_le (hP_lt_L x hx) (hLle y (List.mem_reverse.mp hy)) have ha_sorted : aList.SortedLT := by rw [hadef] refine List.sortedLT_append.mpr ⟨?_, ?_, ?_⟩ · exact List.sortedLT_append.mpr ⟨hP_sorted, hres_rev_sorted, hP_lt_res⟩ · exact List.sortedLT_iff_pairwise.mpr (by simp) · intro x hx y hy rw [List.mem_singleton] at hy rw [hy] rw [List.mem_append] at hx rcases hx with hx | hx · exact lt_of_lt_of_le (hP_lt_L x hx) (le_trans hLH (le_of_lt hHlt_u)) · exact hres_lt_u x hx let db_a : DB := ⟨aList, ha_sorted⟩ have hlen_a : aList.length = e := by rw [hadef, List.length_append, List.length_append, hP_len, List.length_reverse, List.length_singleton] omega have ha_ge_E : ∀ x ∈ aList, E ≤ x := by intro x hx rw [hadef, List.mem_append, List.mem_append] at hx rcases hx with (hx | hx) | hx · exact hP_ge_E x hx · exact le_trans (le_of_lt (WithTop.coe_lt_coe.mp hEL)) (hLle x (List.mem_reverse.mp hx)) · rw [List.mem_singleton] at hx rw [hx] exact le_trans (le_of_lt (WithTop.coe_lt_coe.mp hEL)) (le_trans hLH (le_of_lt hHlt_u)) have hcount_a : aList.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = 0 := by rw [List.countP_eq_zero] intro x hx hlt rw [decide_eq_true_eq] at hlt rw [hE] at hlt exact absurd (WithTop.coe_le_coe.mpr (ha_ge_E x hx)) (not_le.mpr hlt) have hanc_a : (r.end_.anchor db_a).toNat = e := by rw [anchor_toNat_eq (db := db_a) (s := r.end_) (by omega), hcount_a] omega have hresend_a : resolve db_a r.end_ = (⊤ : WithTop Key) := resolve_eq_top (anchor_nonneg_of_one_le (db := db_a) (s := r.end_) (by omega)) (by rw [hlen_a, hanc_a]) have hin_a : RangeRead.inRange aList (resolve db_a r.begin) (resolve db_a r.end_) = aList := by rw [hresend_a] unfold RangeRead.inRange rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] have hx' : r.begin.key ≤ (↑x : WithTop Key) := le_trans hcross (by rw [hE]; exact WithTop.coe_le_coe.mpr (ha_ge_E x hx)) exact ⟨(key_le_resolve_iff_of_offset_one (db := db_a) hbegin hx).mp hx', WithTop.coe_lt_top x⟩ have hck_a : RangeRead.completeKeys db_a r = aList.reverse := by unfold RangeRead.completeKeys rw [hrev] simp only [ite_true] change (RangeRead.inRange aList (resolve db_a r.begin) (resolve db_a r.end_)).reverse = aList.reverse rw [hin_a] have hnotcomp_a : ¬ RangeRead.Compatible db_a r res := by intro hc have hpre : res.keys <+: RangeRead.completeKeys db_a r := RangeRead.compatible_keys_prefix hc rw [hck_a] at hpre have hrev_a : aList.reverse = u :: (res.keys ++ P.reverse) := by rw [hadef, List.reverse_append, List.reverse_append, List.reverse_singleton, List.reverse_reverse] rfl have hane : aList.reverse ≠ [] := by rw [hrev_a]; simp have hhead : aList.reverse.head hane = u := by have hh2 : aList.reverse.head? = some u := by rw [hrev_a]; rfl exact Option.some.inj ((List.head?_eq_some_head hane).symm.trans hh2) have hH_eq_u : H = u := hHdef.trans ((hpre.head hne).trans hhead) exact (ne_of_lt hHlt_u) hH_eq_u -- insert the target key let db_b : DB := db_a.insert k hk_notin_a have hb_keys : db_b.keys = aList.orderedInsert (· ≤ ·) k := rfl have hb_mem : ∀ x, x ∈ db_b.keys ↔ x = k ∨ x ∈ aList := by intro x rw [hb_keys, List.mem_orderedInsert] have hb_len : db_b.keys.length = e + 1 := by rw [hb_keys] have hp := List.Perm.length_eq (List.perm_orderedInsert (· ≤ ·) k aList) simp only [List.length_cons] at hp rw [hp, hlen_a] have hb_ge_E : ∀ x ∈ db_b.keys, E ≤ x := by intro x hx rcases (hb_mem x).mp hx with rfl | hx · exact hEk · exact ha_ge_E x hx have hcount_b : db_b.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = 0 := by rw [List.countP_eq_zero] intro x hx hlt rw [decide_eq_true_eq] at hlt rw [hE] at hlt exact absurd (WithTop.coe_le_coe.mpr (hb_ge_E x hx)) (not_le.mpr hlt) have hanc_b : (r.end_.anchor db_b).toNat = e := by rw [anchor_toNat_eq (db := db_b) (s := r.end_) (by omega), hcount_b] omega have hresend_b : resolve db_b r.end_ = (↑u : WithTop Key) := by have h0 := anchor_nonneg_of_one_le (db := db_b) (s := r.end_) (by omega) have hidx : (r.end_.anchor db_b).toNat < db_b.keys.length := by rw [hanc_b, hb_len]; omega have hu_mem : u ∈ db_b.keys := by rw [hb_mem]; exact Or.inr (by rw [hadef]; simp) have hall_le_u : ∀ x ∈ db_b.keys, x ≤ u := by intro x hx rcases (hb_mem x).mp hx with rfl | hx · exact le_of_lt (lt_trans (lt_of_lt_of_le hkL' hLH) hHlt_u) · rw [hadef] at hx rw [List.mem_append, List.mem_append] at hx rcases hx with (hx | hx) | hx · exact le_of_lt (lt_of_lt_of_le (hP_lt_L x hx) (le_trans hLH (le_of_lt hHlt_u))) · exact le_of_lt (hres_lt_u x hx) · rw [List.mem_singleton] at hx rw [hx] have hbne : db_b.keys ≠ [] := List.ne_nil_of_length_pos (by rw [hb_len]; omega) have hlast : db_b.keys.getLast hbne = u := by apply le_antisymm · exact hall_le_u _ (List.getLast_mem hbne) · exact (List.sortedLT_iff_pairwise.mp db_b.sorted).imp le_of_lt |>.rel_getLast hu_mem have hidx3 : db_b.keys.length - 1 = e := by rw [hb_len]; omega have hgl := List.getLast_eq_getElem (l := db_b.keys) (h := hbne) have hidx_e : e < db_b.keys.length := by rw [hb_len]; omega have hkeyu : db_b.keys[e] = u := by rw [List.getElem_eq_iff hidx_e, ← hidx3, List.getElem?_eq_getElem (by omega), ← hgl, hlast] have hkey_anchor : db_b.keys[(r.end_.anchor db_b).toNat] = u := by rw [List.getElem_eq_iff hidx, hanc_b, List.getElem?_eq_getElem hidx_e, hkeyu] rw [resolve_eq_getElem h0 hidx, hkey_anchor] have hcomp_b : RangeRead.Compatible db_b r res := by refine (compatible_iff_truncated_keys_rev (db := db_b) hrev hmore hne).mpr ⟨hcomp₀.1, ?_⟩ have hbegin_le_L : r.begin.key ≤ (↑L : WithTop Key) := by rw [hE] at hcross exact le_trans hcross (le_of_lt hEL) have hL_mem_res : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne have hL_mem_b : L ∈ db_b.keys := by rw [hb_mem]; exact Or.inr (by rw [hadef]; simp [hL_mem_res]) have hrb_b : resolve db_b r.begin ≤ (↑L : WithTop Key) := (key_le_resolve_iff_of_offset_one (db := db_b) hbegin hL_mem_b).mp hbegin_le_L have hck_b : RangeRead.completeKeys db_b r = (RangeRead.inRange db_b.keys (resolve db_b r.begin) (↑u : WithTop Key)).reverse := by simp [RangeRead.completeKeys, hrev, hresend_b] rw [hck_b, List.filter_reverse] unfold RangeRead.inRange rw [List.filter_filter] have hpred : ∀ a ∈ db_b.keys, (decide (L ≤ a) && decide (resolve db_b r.begin ≤ (↑a : WithTop Key) ∧ (↑a : WithTop Key) < (↑u : WithTop Key))) = decide (L ≤ a ∧ a < u) := by intro a _ by_cases hLa : L ≤ a · have hres : resolve db_b r.begin ≤ (↑a : WithTop Key) := le_trans hrb_b (WithTop.coe_le_coe.mpr hLa) rw [decide_eq_true hLa, Bool.true_and, decide_eq_decide] exact ⟨fun h => ⟨hLa, WithTop.coe_lt_coe.mp h.2⟩, fun h => ⟨hres, WithTop.coe_lt_coe.mpr h.2⟩⟩ · rw [decide_eq_false hLa] simp [hLa] rw [List.filter_congr hpred] have hstep : db_b.keys.filter (fun a => decide (L ≤ a ∧ a < u)) = res.keys.reverse := by apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db_b.sorted.pairwise.filter _) · exact hres_rev_sorted · intro x rw [List.mem_filter, List.mem_reverse] constructor · rintro ⟨hx, hpred⟩ have hpred' := of_decide_eq_true hpred rcases (hb_mem x).mp hx with rfl | hx · exact absurd hpred'.1 (not_le.mpr hkL') · rw [hadef] at hx rw [List.mem_append, List.mem_append] at hx rcases hx with (hx | hx) | hx · exact absurd hpred'.1 (not_le.mpr (hP_lt_L x hx)) · exact List.mem_reverse.mp hx · rw [List.mem_singleton] at hx rw [hx] at hpred' exact absurd hpred'.2 (lt_irrefl u) · intro hx refine ⟨?_, ?_⟩ · rw [hb_mem]; exact Or.inr (by rw [hadef]; simp [hx]) · exact decide_eq_true ⟨hLle x hx, hres_lt_u x (List.mem_reverse.mpr hx)⟩ rw [hstep, List.reverse_reverse] intro cr hs by_contra hkcr have hagree : AgreeOn cr db_a db_b := (ConflictRange.keys_insert_of_not_mem cr db_a hk_notin_a hkcr).symm exact hnotcomp_a ((hs db_a db_b hagree).mpr hcomp_b) /-- The number of keys below a `WithTop` threshold plus the number at or above it is the length. -/ private theorem countP_lt_add_countP_ge (l : List Key) (E : WithTop Key) : l.countP (fun k : Key => decide ((k : WithTop Key) < E)) + l.countP (fun k : Key => decide (E ≤ (k : WithTop Key))) = l.length := by induction l with | nil => simp | cons a l ih => by_cases h : ((a : WithTop Key) < E) · have hneg : ¬ E ≤ (a : WithTop Key) := not_le.mpr h rw [List.countP_cons_of_pos (by rw [decide_eq_true_eq]; exact h), List.countP_cons_of_neg (by rw [decide_eq_true_eq]; exact hneg)] simp only [List.length_cons] omega · have hge : E ≤ (a : WithTop Key) := not_lt.mp h rw [List.countP_cons_of_neg (by rw [decide_eq_true_eq]; exact h), List.countP_cons_of_pos (by rw [decide_eq_true_eq]; exact hge)] simp only [List.length_cons] omega /-- Inserting a key strictly above every element of a sorted list appends it. -/ private theorem orderedInsert_append_of_forall_lt {l : List Key} {k : Key} (h : ∀ x ∈ l, x < k) : l.orderedInsert (· ≤ ·) k = l ++ [k] := by induction l with | nil => simp | cons a l ih => have hka : ¬ k ≤ a := not_le.mpr (h a (by simp)) rw [List.orderedInsert_of_not_le (· ≤ ·) l hka, ih (fun x hx => h x (by simp [hx]))] rfl /-- **Above-head necessity in the reversed truncated top branch.** Every key strictly above the reported head is necessary. The database made of the reported keys in ascending order is compatible (its complete keys are exactly `res.keys`); inserting a fresh key above the reported head puts it at the front of the complete keys, so the reported keys are no longer a prefix. This holds in every top-branch subcase and needs only the strict count inequality `t < e`. -/ theorem necessary_above_head_top_rev {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hne : res.keys ≠ []) (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) {k : Key} (hkH : res.keys.head hne < k) : Necessary r res k := by obtain ⟨db₀, hcomp₀⟩ := hread set L : Key := res.keys.getLast hne with hLdef set H : Key := res.keys.head hne with hHdef have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev have hLle : ∀ x ∈ res.keys, L ≤ x := by intro x hx; rw [hLdef] exact (hsort.pairwise.imp le_of_lt).rel_getLast hx have hHge : ∀ x ∈ res.keys, x ≤ H := by intro x hx; rw [hHdef] exact (hsort.pairwise.imp le_of_lt).rel_head hx have hpre : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp₀ have hLmem_ck : L ∈ RangeRead.completeKeys db₀ r := by rw [hLdef]; exact hpre.subset (List.getLast_mem hne) have hbegin_le_L : r.begin.key ≤ (↑L : WithTop Key) := le_trans (key_le_resolve_of_offset_one hbegin) (RangeRead.mem_completeKeys.mp hLmem_ck).2.1 have hLH : L ≤ H := hLle H (List.head_mem hne) have hbegin_le_k : r.begin.key ≤ (↑k : WithTop Key) := le_trans hbegin_le_L (WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hLH hkH))) let db₁ : DB := ⟨res.keys.reverse, hsort.reverse⟩ have hdb₁_keys : db₁.keys = res.keys.reverse := rfl have hcount0 : db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by rw [hdb₁_keys, List.countP_eq_zero] intro x hx hbad rw [decide_eq_true_eq] at hbad have hx' : x ∈ res.keys := List.mem_reverse.mp hx exact absurd (le_trans hbegin_le_L (WithTop.coe_le_coe.mpr (hLle x hx'))) (not_le.mpr hbad) have hne₁ : db₁.keys ≠ [] := by rw [hdb₁_keys] rwa [List.reverse_ne_nil_iff] have hlen₁ : 0 < db₁.keys.length := List.length_pos_of_ne_nil hne₁ have hresb : resolve db₁ r.begin = (↑L : WithTop Key) := by have h0 := anchor_nonneg_of_one_le (db := db₁) (s := r.begin) (by omega) have hancb : (r.begin.anchor db₁).toNat = 0 := by rw [anchor_toNat_eq (db := db₁) (s := r.begin) (by omega), hbegin] simp [hcount0] have hidx : (r.begin.anchor db₁).toNat < db₁.keys.length := by rw [hancb]; exact hlen₁ have hhead : db₁.keys.head hne₁ = L := by change res.keys.reverse.head hne₁ = L rw [List.head_reverse] have hget0 : db₁.keys[0] = L := by rw [List.getElem_zero hlen₁, hhead] have hkey : db₁.keys[(r.begin.anchor db₁).toNat] = L := by rw [List.getElem_eq_iff hidx, hancb, List.getElem?_eq_getElem hlen₁, hget0] rw [resolve_eq_getElem h0 hidx, hkey] have hcountres : res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + res.keys.countP (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key))) = res.keys.length := countP_lt_add_countP_ge res.keys r.end_.key have hcount₁ : db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := by rw [hdb₁_keys] exact List.Perm.countP_eq _ (List.reverse_perm _) have hresend : resolve db₁ r.end_ = (⊤ : WithTop Key) := by have h0 := anchor_nonneg_of_one_le (db := db₁) (s := r.end_) (by omega) rw [resolve_eq_top h0] have hanc : (r.end_.anchor db₁).toNat = db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := anchor_toNat_eq (db := db₁) (s := r.end_) (by omega) rw [hanc, hcount₁, hdb₁_keys, List.length_reverse] omega have hck₁ : RangeRead.completeKeys db₁ r = res.keys := by have hin : RangeRead.inRange db₁.keys (resolve db₁ r.begin) (resolve db₁ r.end_) = db₁.keys := by rw [hresend] unfold RangeRead.inRange rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] have hx' : x ∈ res.keys := List.mem_reverse.mp hx exact ⟨by rw [hresb]; exact WithTop.coe_le_coe.mpr (hLle x hx'), WithTop.coe_lt_top x⟩ unfold RangeRead.completeKeys rw [hrev] simp only [ite_true] rw [hin, hdb₁_keys, List.reverse_reverse] have hcomp₁ : RangeRead.Compatible db₁ r res := by refine (compatible_iff_truncated_keys_rev (db := db₁) hrev hmore hne).mpr ⟨hcomp₀.1, ?_⟩ rw [hck₁, List.filter_eq_self] intro x hx rw [decide_eq_true_eq] exact hLle x hx have hk_notin : k ∉ db₁.keys := by intro hx have hx' : k ∈ res.keys := List.mem_reverse.mp hx exact absurd (hHge k hx') (not_le.mpr hkH) have hnot : ¬ RangeRead.Compatible (db₁.insert k hk_notin) r res := by intro hc have hpre₂ : res.keys <+: RangeRead.completeKeys (db₁.insert k hk_notin) r := RangeRead.compatible_keys_prefix hc have hforall : ∀ x ∈ db₁.keys, x < k := by intro x hx have hx' : x ∈ res.keys := List.mem_reverse.mp hx exact lt_of_le_of_lt (hHge x hx') hkH have hkeys₂ : (db₁.insert k hk_notin).keys = db₁.keys ++ [k] := by rw [DB.insert_keys] exact orderedInsert_append_of_forall_lt hforall have hcount0₂ : (db₁.insert k hk_notin).keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by rw [hkeys₂, List.countP_append, hcount0] have hsingle : (decide ((k : WithTop Key) < r.begin.key)) = false := by rw [decide_eq_false_iff_not] exact not_lt.mpr hbegin_le_k simp [hsingle] have hresb₂ : resolve (db₁.insert k hk_notin) r.begin = (↑L : WithTop Key) := by have h0 := anchor_nonneg_of_one_le (db := db₁.insert k hk_notin) (s := r.begin) (by omega) have hanc : (r.begin.anchor (db₁.insert k hk_notin)).toNat = 0 := by have h1 : 1 ≤ r.begin.offset := by omega rw [anchor_toNat_eq (db := db₁.insert k hk_notin) (s := r.begin) h1, hbegin, hcount0₂] simp have hpos : 0 < (db₁.insert k hk_notin).keys.length := by rw [hkeys₂, List.length_append, List.length_singleton]; omega have hidx : (r.begin.anchor (db₁.insert k hk_notin)).toNat < (db₁.insert k hk_notin).keys.length := by rw [hanc]; exact hpos have hget0₂ : (db₁.insert k hk_notin).keys[0] = L := by have hpos' : 0 < (db₁.insert k hk_notin).keys.length := by rw [hkeys₂, List.length_append, List.length_singleton]; omega have hbase : db₁.keys[0] = L := by have h0 := anchor_nonneg_of_one_le (db := db₁) (s := r.begin) (by omega) have hancb : (r.begin.anchor db₁).toNat = 0 := by have h1 : 1 ≤ r.begin.offset := by omega rw [anchor_toNat_eq (db := db₁) (s := r.begin) h1, hbegin, hcount0] simp have hidx' : (r.begin.anchor db₁).toNat < db₁.keys.length := by rw [hancb]; exact hlen₁ have hres := hresb rw [resolve_eq_getElem h0 hidx'] at hres have hkey' : db₁.keys[(r.begin.anchor db₁).toNat] = L := WithTop.coe_inj.mp hres have hsome : db₁.keys[0]? = some L := by have h1 : db₁.keys[(r.begin.anchor db₁).toNat]? = some L := by rw [List.getElem?_eq_getElem hidx'] exact congrArg some hkey' rwa [hancb] at h1 exact Option.some.inj ((List.getElem?_eq_getElem hlen₁).symm.trans hsome) calc (db₁.insert k hk_notin).keys[0] = (db₁.keys ++ [k])[0] := List.getElem_of_eq hkeys₂ hpos' _ = db₁.keys[0] := List.getElem_append_left (i := 0) hlen₁ _ = L := hbase have hkey : (db₁.insert k hk_notin).keys[(r.begin.anchor (db₁.insert k hk_notin)).toNat] = L := by rw [List.getElem_eq_iff hidx, hanc, List.getElem?_eq_getElem hpos, hget0₂] rw [resolve_eq_getElem h0 hidx, hkey] have hcount₁₂ : db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) ≤ (db₁.insert k hk_notin).keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := by rw [hkeys₂, List.countP_append] exact Nat.le_add_right (db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key))) (List.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) [k]) have hresend₂ : resolve (db₁.insert k hk_notin) r.end_ = (⊤ : WithTop Key) := by have h0 := anchor_nonneg_of_one_le (db := db₁.insert k hk_notin) (s := r.end_) (by omega) rw [resolve_eq_top h0] have hanc := anchor_toNat_eq (db := db₁.insert k hk_notin) (s := r.end_) (by omega) rw [hanc, hkeys₂, List.length_append, List.length_singleton] have hlen1 : db₁.keys.length = res.keys.length := by rw [hdb₁_keys, List.length_reverse] have hcount_le : res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) ≤ (db₁.keys ++ [k]).countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := by rw [List.countP_append] calc res.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := hcount₁.symm _ ≤ db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + [k].countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := Nat.le_add_right _ _ omega have hck₂ : RangeRead.completeKeys (db₁.insert k hk_notin) r = k :: res.keys := by have hin : RangeRead.inRange (db₁.insert k hk_notin).keys (resolve (db₁.insert k hk_notin) r.begin) (resolve (db₁.insert k hk_notin) r.end_) = (db₁.insert k hk_notin).keys := by rw [hresend₂] unfold RangeRead.inRange rw [List.filter_eq_self] intro x hx rw [decide_eq_true_eq] rw [hkeys₂] at hx have hx' : x ∈ db₁.keys ∨ x = k := by rw [List.mem_append, List.mem_singleton] at hx; exact hx refine ⟨?_, WithTop.coe_lt_top x⟩ rcases hx' with hx' | rfl · rw [hresb₂] have hx'' : x ∈ res.keys := List.mem_reverse.mp hx' exact WithTop.coe_le_coe.mpr (hLle x hx'') · rw [hresb₂] exact WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hLH hkH)) unfold RangeRead.completeKeys rw [hrev] simp only [ite_true] rw [hin, hkeys₂, List.reverse_append, List.reverse_singleton, hdb₁_keys, List.reverse_reverse] rfl rw [hck₂] at hpre₂ have hhead_eq : res.keys.head hne = k := hpre₂.head hne have hhead_eq' : H = k := by rw [hHdef]; exact hhead_eq exact (ne_of_lt hkH) hhead_eq' intro cr hs by_contra hkcr have hagree : AgreeOn cr db₁ (db₁.insert k hk_notin) := (ConflictRange.keys_insert_of_not_mem cr db₁ hk_notin hkcr).symm exact hnot ((hs db₁ (db₁.insert k hk_notin) hagree).mp hcomp₁) /-- Restricting a count to a stronger predicate equals counting on the filtered list. -/ private theorem countP_eq_countP_filter_of_imp {α : Type*} {l : List α} {p q : α → Bool} (h : ∀ a, p a = true → q a = true) : l.countP p = (l.filter q).countP p := by rw [List.countP_eq_length_filter, List.countP_eq_length_filter, List.filter_filter] congr 1 apply List.filter_congr intro a _ by_cases hp : p a = true · have hq : q a = true := h a hp simp [hp, hq] · simp [hp] /-- Filtering the complete keys by any predicate cannot increase the number of stored keys satisfying that predicate. -/ private theorem completeKeys_filter_length_le {db : DB} {r : RangeRead} (hrev : r.reverse = true) (q : Key → Bool) : ((RangeRead.completeKeys db r).filter q).length ≤ (db.keys.filter q).length := by have hwin : List.Sublist ((RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).filter q) (db.keys.filter q) := by unfold RangeRead.inRange rw [List.filter_filter] apply filter_sublist_filter_of_imp intro a ha by_cases hq : q a = true · exact hq · exfalso have hqf : q a = false := by simpa using hq rw [hqf] at ha simp at ha rw [RangeRead.completeKeys, hrev] simp only [ite_true] rw [List.filter_reverse, List.length_reverse] exact hwin.length_le /-- **The resolved end is unbounded on the remaining top-branch cells.** If `t < e` and either the reported last key is at or below `end_.key`, or it lies above `end_.key` but at or below the `(e - t - 1)`-th successor of `end_.key`, then every compatible database resolves its end selector to the sentinel. A finite resolution would put exactly `e` stored keys at or above `end_.key`; comparing with the reported keys at or above the reported last leaves `e - t` (or, when the reported keys all lie above `end_.key`, exactly `n + 1`) stored keys in `[end_.key, last)`, too many for the successor count. -/ private theorem resolve_end_eq_top_of_top_branch_rev {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) {E L : Key} (hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne) {n : Nat} (hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1) (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) (hcase : L ≤ E ∨ L ≤ keyAfterN n E) : resolve db r.end_ = (⊤ : WithTop Key) := by by_contra hfin have hanc0 : 0 ≤ r.end_.anchor db := anchor_nonneg_of_one_le (db := db) (s := r.end_) (by omega) have hidx : (r.end_.anchor db).toNat < db.keys.length := by by_contra hge exact hfin (resolve_eq_top hanc0 (not_lt.mp hge)) set e : Nat := (r.end_.offset - 1).toNat with hedef set c : Nat := db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcdef have hanc : (r.end_.anchor db).toNat = c + e := by rw [anchor_toNat_eq (db := db) (s := r.end_) (by omega), hcdef, hedef] have hidx' : c + e < db.keys.length := by rw [← hanc]; exact hidx have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev have hLle : ∀ x ∈ res.keys, L ≤ x := by intro x hx rw [hL] exact (hsort.pairwise.imp le_of_lt).rel_getLast hx have hfilter : (RangeRead.completeKeys db r).filter (fun k : Key => decide (L ≤ k)) = res.keys := by rw [hL] exact ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp).2 have hcntL : (RangeRead.completeKeys db r).countP (fun k : Key => decide (L ≤ k)) = res.keys.length := by rw [List.countP_eq_length_filter, hfilter] have hcntE : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = e := by have h := completeKeys_count_ge_eq_min_rev (db := db) hrev hbegin hcross (by omega : 1 ≤ r.end_.offset) have hle : e ≤ db.keys.length - c := by omega rw [min_eq_left hle] at h simpa only [← hedef, ← hcdef] using h by_cases hLE : L ≤ E · -- The reported last key does not exceed `end_.key`: `t = e`, contradiction. have himp : ∀ k : Key, (decide (r.end_.key ≤ (k : WithTop Key)) = true) → (decide (L ≤ k) = true) := by intro k hk rw [decide_eq_true_eq] at hk ⊢ rw [hE] at hk exact le_trans hLE (WithTop.coe_le_coe.mp hk) have h1 := countP_eq_countP_filter_of_imp (l := RangeRead.completeKeys db r) (p := fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) (q := fun k : Key => decide (L ≤ k)) himp rw [hcntE, hfilter] at h1 exact (ne_of_lt hlt) h1.symm · -- The reported last key exceeds `end_.key`: count the keys in `[end_.key, L)`. have hkey : L ≤ keyAfterN n E := hcase.resolve_left hLE have hEL : E < L := lt_of_not_ge hLE have htR : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq, hE] exact WithTop.coe_le_coe.mpr (le_trans (le_of_lt hEL) (hLle x hx)) set D : Nat := ((RangeRead.completeKeys db r).filter (fun k : Key => decide ((k : WithTop Key) < L))).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hDdef have hDeq : e = D + res.keys.length := by have h := List.countP_eq_countP_filter_add (RangeRead.completeKeys db r) (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) (fun k : Key => decide ((k : WithTop Key) < L)) rw [hcntE] at h have hsecond : (RangeRead.completeKeys db r).filter (fun a : Key => !decide ((a : WithTop Key) < L)) = res.keys := by rw [← hfilter] apply List.filter_congr intro a _ by_cases h : ((a : WithTop Key) < L) · have hnl : ¬ L ≤ a := fun hk => absurd (WithTop.coe_le_coe.mpr hk) (not_le.mpr h) simp [h, hnl] · have hnl : L ≤ a := by exact WithTop.coe_le_coe.mp (not_lt.mp h) simp [h, hnl] have hlen : ((RangeRead.completeKeys db r).filter (fun a : Key => !decide ((a : WithTop Key) < L))).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by rw [hsecond, List.countP_eq_length] intro x hx rw [decide_eq_true_eq, hE] exact WithTop.coe_le_coe.mpr (le_trans (le_of_lt hEL) (hLle x hx)) rw [hlen] at h simpa only [hDdef] using h have hDle : D ≤ n := by have hp_eq : (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)) && decide ((k : WithTop Key) < L)) = fun k : Key => decide (E ≤ k ∧ k < L) := by funext k by_cases h1 : (r.end_.key ≤ (k : WithTop Key)) · by_cases h2 : ((k : WithTop Key) < L) · have h1' : E ≤ k := by rw [hE] at h1; exact WithTop.coe_le_coe.mp h1 have h2' : k < L := WithTop.coe_lt_coe.mp h2 simp [h1, h2, h1', h2'] · have h2' : ¬ k < L := fun hk => h2 (WithTop.coe_lt_coe.mpr hk) simp [h1, h2, h2'] · have h1' : ¬ E ≤ k := fun hk => h1 (by rw [hE]; exact WithTop.coe_le_coe.mpr hk) simp [h1, h1'] have hDlen : D = ((RangeRead.completeKeys db r).filter (fun k : Key => decide (E ≤ k ∧ k < L))).length := by rw [hDdef, List.countP_eq_length_filter, List.filter_filter, hp_eq] rw [hDlen] exact le_trans (completeKeys_filter_length_le (db := db) (r := r) hrev _) (length_filter_between_le_of_le_keyAfterN db.nodup hkey) have hn' : n = e - res.keys.length - 1 := by rw [hn, htR] omega /-- **Agreement on `[last, ⊤)` preserves the unbounded end in the corrected top branch.** A compatible database with an unbounded end has its keys at or above the reported last exactly the reported keys reversed. Any other database agreeing there has the same keys at or above the last; the strict top-branch inequality then bounds its keys at or above `end_.key` by `e - 1`, so its end is also unbounded. -/ private theorem resolve_end_eq_top_of_agree_begin_last {db db' : DB} {r : RangeRead} {res : Result} {E L : Key} {n : Nat} (hmore : res.more = true) (hrev : r.reverse = true) (_hbegin : r.begin.offset = 1) (_hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) (hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne) (hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1) (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) (hcase : L ≤ E ∨ L ≤ keyAfterN n E) (hcomp : RangeRead.Compatible db r res) (hEt : resolve db r.end_ = (⊤ : WithTop Key)) (hagmem : ∀ k : Key, (L : WithTop Key) ≤ (k : WithTop Key) → (k ∈ db.keys ↔ k ∈ db'.keys)) : resolve db' r.end_ = (⊤ : WithTop Key) := by have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev have hLle : ∀ x ∈ res.keys, L ≤ x := by intro x hx rw [hL] exact (hsort.pairwise.imp le_of_lt).rel_getLast hx have hpre := RangeRead.compatible_keys_prefix hcomp have hLmem : L ∈ RangeRead.completeKeys db r := by rw [hL]; exact hpre.subset (List.getLast_mem hne) have hLlo : resolve db r.begin ≤ (L : WithTop Key) := (RangeRead.mem_completeKeys.mp hLmem).2.1 have hfilter : (RangeRead.completeKeys db r).filter (fun k : Key => decide (L ≤ k)) = res.keys := by simpa only [hL] using ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp).2 have hdbEq : db.keys.filter (fun k : Key => decide (L ≤ k)) = res.keys.reverse := by have h := completeKeys_filter_ge_rev (db := db) (r := r) (last := L) hrev hEt hLlo rw [hfilter] at h have hrevh := congrArg List.reverse h simpa only [List.reverse_reverse] using hrevh.symm have hdbEq' : db'.keys.filter (fun k : Key => decide (L ≤ k)) = res.keys.reverse := by rw [← hdbEq] apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db'.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) · intro k rw [List.mem_filter, List.mem_filter] constructor · rintro ⟨hk', hpred⟩ have hk : k ∈ db.keys := (hagmem k (WithTop.coe_le_coe.mpr (of_decide_eq_true hpred))).mpr hk' exact ⟨hk, hpred⟩ · rintro ⟨hk, hpred⟩ have hk' : k ∈ db'.keys := (hagmem k (WithTop.coe_le_coe.mpr (of_decide_eq_true hpred))).mp hk exact ⟨hk', hpred⟩ -- The number of keys of `db'` at or above `end_.key` is at most `e`. have hcountE : db'.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := by by_cases hLE : L ≤ E · -- All such keys are reported keys, since `E ≥ L`. have himp : ∀ k : Key, (decide (r.end_.key ≤ (k : WithTop Key)) = true) → (decide (L ≤ k) = true) := by intro k hk rw [decide_eq_true_eq] at hk ⊢ rw [hE] at hk exact le_trans hLE (WithTop.coe_le_coe.mp hk) have h1 := countP_eq_countP_filter_of_imp (l := db'.keys) (p := fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) (q := fun k : Key => decide (L ≤ k)) himp rw [hdbEq'] at h1 rw [h1, List.countP_reverse] exact le_of_lt hlt · -- Split the keys at `L`: the reported keys above, at most `n` keys below. have hEL : E < L := lt_of_not_ge hLE have hkey : L ≤ keyAfterN n E := hcase.resolve_left hLE have ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq, hE] exact WithTop.coe_le_coe.mpr (le_trans (le_of_lt hEL) (hLle x hx)) have hsplit := List.countP_eq_countP_filter_add db'.keys (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) (fun k : Key => decide ((k : WithTop Key) < L)) -- The part below `L` is counted by the interval `[E, L)`. have h1 : (db'.keys.filter (fun k : Key => decide ((k : WithTop Key) < L))).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (db'.keys.filter (fun k : Key => decide (E ≤ k ∧ k < L))).length := by rw [List.countP_eq_length_filter, List.filter_filter] congr 1 apply List.filter_congr intro k _ by_cases hp : (r.end_.key ≤ (k : WithTop Key)) · by_cases hq : ((k : WithTop Key) < L) · have hp' : E ≤ k := by rw [hE] at hp; exact WithTop.coe_le_coe.mp hp have hq' : k < L := WithTop.coe_lt_coe.mp hq simp [hp, hq, hp', hq'] · have hq' : ¬ k < L := fun hk => hq (WithTop.coe_lt_coe.mpr hk) simp [hp, hq, hq'] · have hp' : ¬ E ≤ k := fun hk => hp (by rw [hE]; exact WithTop.coe_le_coe.mpr hk) simp [hp, hp'] have hbelow : (db'.keys.filter (fun k : Key => decide (E ≤ k ∧ k < L))).length ≤ n := length_filter_between_le_of_le_keyAfterN db'.nodup hkey -- The part above `L` is exactly the reported keys. have hfilt2 : db'.keys.filter (fun k : Key => !decide ((k : WithTop Key) < L)) = db'.keys.filter (fun k : Key => decide (L ≤ k)) := by apply List.filter_congr intro k _ by_cases h : ((k : WithTop Key) < L) · have hnl : ¬ L ≤ k := fun hk => absurd (WithTop.coe_le_coe.mpr hk) (not_le.mpr h) simp [h, hnl] · have hnl : L ≤ k := WithTop.coe_le_coe.mp (not_lt.mp h) simp [h, hnl] have hlen2 : (db'.keys.filter (fun k : Key => !decide ((k : WithTop Key) < L))).length = res.keys.length := by rw [hfilt2, hdbEq', List.length_reverse] have h2 : (db'.keys.filter (fun k : Key => !decide ((k : WithTop Key) < L))).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by have h2c : (db'.keys.filter (fun k : Key => !decide ((k : WithTop Key) < L))).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (db'.keys.filter (fun k : Key => !decide ((k : WithTop Key) < L))).length := by rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq, hE] have hnot : ¬ ((x : WithTop Key) < L) := by have hx' := (List.mem_filter.mp hx).2 by_contra hcon rw [decide_eq_true hcon] at hx' simp at hx' have hLx : L ≤ x := WithTop.coe_le_coe.mp (not_lt.mp hnot) exact WithTop.coe_le_coe.mpr (le_trans (le_of_lt hEL) hLx) rw [h2c, hlen2] rw [h1, h2] at hsplit have hn' : n = (r.end_.offset - 1).toNat - res.keys.length - 1 := by rw [hn, ht] have hlen_le : res.keys.length ≤ (r.end_.offset - 1).toNat := by rw [← ht]; exact le_of_lt hlt omega -- Now `resolve db' r.end_` cannot land inside the database. set e : Nat := (r.end_.offset - 1).toNat with hedef set c : Nat := db'.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcdef have hlen_eq : db'.keys.length = c + db'.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by rw [hcdef] exact (countP_lt_add_countP_ge db'.keys r.end_.key).symm have hlen_le : db'.keys.length ≤ c + e := by rw [hlen_eq] exact Nat.add_le_add_left hcountE c have hanc0 : 0 ≤ r.end_.anchor db' := anchor_nonneg_of_one_le (db := db') (s := r.end_) (by omega) have hanc : (r.end_.anchor db').toNat = c + e := by rw [anchor_toNat_eq (db := db') (s := r.end_) (by omega), hcdef, hedef] rw [resolve_eq_top hanc0] rw [hanc] exact hlen_le /-- **Soundness of the corrected top branch beginning at the reported last key.** Once the end resolves to the sentinel, agreement on `[last, ⊤)` fixes the stored keys at or above `last`; the corrected top-branch hypotheses keep the end unbounded for the agreed database as well (`resolve_end_eq_top_of_agree_begin_last`), so compatibility is preserved. -/ private theorem sound_topRev_begin_last {r : RangeRead} {res : Result} (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) {E L : Key} {n : Nat} (hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne) (hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1) (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) (hcase : L ≤ E ∨ L ≤ keyAfterN n E) : Sound r res ⟨(L : WithTop Key), ⊤⟩ := by intro db₁ db₂ hagree have step : ∀ db db', AgreeOn ⟨(L : WithTop Key), ⊤⟩ db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp have hlim : RangeRead.withinLimit r res.keys := hcomp.1 have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp have hLmem : L ∈ RangeRead.completeKeys db r := by rw [hL]; exact hpre.subset (List.getLast_mem hne) have hbegL : r.begin.key ≤ (L : WithTop Key) := le_trans (key_le_resolve_of_offset_one hbegin) (RangeRead.mem_completeKeys.mp hLmem).2.1 have hEt : resolve db r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_top_branch_rev hcomp hmore hrev hbegin hcross hend hne hE hL hn hlt hcase have hagmem : ∀ k : Key, (L : WithTop Key) ≤ (k : WithTop Key) → (k ∈ db.keys ↔ k ∈ db'.keys) := by intro k hk exact (agreeOn_iff ⟨(L : WithTop Key), ⊤⟩ db db').mp hag' k (ConflictRange.mem_iff.mpr ⟨hk, WithTop.coe_lt_top k⟩) have hEt' := resolve_end_eq_top_of_agree_begin_last hmore hrev hbegin hcross hend hne hE hL hn hlt hcase hcomp hEt hagmem have hfilter : (RangeRead.completeKeys db r).filter (fun k : Key => decide (L ≤ k)) = res.keys := by simpa only [hL] using ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp).2 have hdbEq : db.keys.filter (fun k : Key => decide (L ≤ k)) = res.keys.reverse := by have h := completeKeys_filter_ge_rev (db := db) (r := r) (last := L) hrev hEt (RangeRead.mem_completeKeys.mp hLmem).2.1 rw [hfilter] at h have hrevh := congrArg List.reverse h simpa only [List.reverse_reverse] using hrevh.symm have hdbEq' : db'.keys.filter (fun k : Key => decide (L ≤ k)) = res.keys.reverse := by rw [← hdbEq] apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db'.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) · intro k rw [List.mem_filter, List.mem_filter] constructor · rintro ⟨hk', hpred⟩ exact ⟨(hagmem k (WithTop.coe_le_coe.mpr (of_decide_eq_true hpred))).mpr hk', hpred⟩ · rintro ⟨hk, hpred⟩ exact ⟨(hagmem k (WithTop.coe_le_coe.mpr (of_decide_eq_true hpred))).mp hk, hpred⟩ have hLmem' : L ∈ db'.keys := by have h1 : L ∈ res.keys.reverse := List.mem_reverse.mpr (by rw [hL]; exact List.getLast_mem hne) rw [← hdbEq'] at h1 exact List.mem_of_mem_filter h1 have hL' : resolve db' r.begin ≤ (L : WithTop Key) := (key_le_resolve_iff_of_offset_one hbegin hLmem').mp hbegL have hfilter' : (RangeRead.completeKeys db' r).filter (fun k : Key => decide (L ≤ k)) = res.keys := by rw [completeKeys_filter_ge_rev (db := db') hrev hEt' hL', hdbEq', List.reverse_reverse] exact (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hlim, by simpa only [hL] using hfilter'⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ /-- **Minimality of the corrected top branch beginning at the reported last key.** Soundness is `sound_topRev_begin_last`. Keys between the reported last and head are reported-or-between; keys above the head are necessary by `necessary_above_head_top_rev`. -/ private theorem minimal_topRev_begin_last {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) {E L : Key} {n : Nat} (hE : r.end_.key = (E : WithTop Key)) (hne : res.keys ≠ []) (hL : L = res.keys.getLast hne) (hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1) (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) (hcase : L ≤ E ∨ L ≤ keyAfterN n E) : Minimal r res ⟨(L : WithTop Key), ⊤⟩ := by refine (minimal_iff_sound_and_necessary).mpr ⟨sound_topRev_begin_last hmore hrev hbegin hcross hend hne hE hL hn hlt hcase, ?_⟩ intro k hk have hLk : L ≤ k := WithTop.coe_le_coe.mp hk.1 by_cases hkH : k ≤ res.keys.head hne · exact necessary_of_between_result hread (by rw [hL]; exact List.getLast_mem hne) (List.head_mem hne) hLk hkH · exact necessary_above_head_top_rev hread hmore hrev hbegin hne hlt (lt_of_not_ge hkH) /-- **Minimality of the corrected top branch beginning at `end_.key`.** This is the case where the successor chain from `end_.key` still reaches below the reported last key. Soundness is `sound_topRev_begin_end`; keys in `[end_.key, last)` are supplied by `necessary_pad_top_rev`, and the remaining keys by the between/above-head lemmas. -/ private theorem minimal_topRev_begin_end {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ []) {E L : Key} {n : Nat} (hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne) (hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1) (hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat) (hroom : keyAfterN n E < L) : Minimal r res ⟨(E : WithTop Key), ⊤⟩ := by have hEL : (E : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key) := by rw [← hL] exact WithTop.coe_lt_coe.mpr (lt_of_le_of_lt (keyAfterN_le_self E n) hroom) have hroom' : keyAfterN n E < res.keys.getLast hne := by rw [← hL]; exact hroom refine (minimal_iff_sound_and_necessary).mpr ⟨sound_topRev_begin_end hmore hrev hbegin (by omega) hcross hne hE hEL, ?_⟩ intro k hk have hEk : E ≤ k := WithTop.coe_le_coe.mp hk.1 by_cases hkL : k < L · exact necessary_pad_top_rev hread hmore hrev hbegin hcross hend hne hE hEL hlt hn hroom' hEk (by rw [← hL]; exact hkL) · have hLk : L ≤ k := le_of_not_gt hkL by_cases hkH : k ≤ res.keys.head hne · exact necessary_of_between_result hread (by rw [hL]; exact List.getLast_mem hne) (List.head_mem hne) hLk hkH · exact necessary_above_head_top_rev hread hmore hrev hbegin hne hlt (lt_of_not_ge hkH) /-- **Minimality of the corrected full reversed truncated rule.** The under-end and finite branches coincide with the earlier rule; the top branch splits on whether the successor chain from `end_.key` reaches below the reported last, using `minimal_topRev_begin_end` or `minimal_topRev_begin_last`. When `end_.key` is the sentinel every key is below it, so the top-of-last theorem applies. -/ theorem minimal_closedForm_of_offset_one_truncated_rev_fullC {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOneTruncatedRevFullC r res) := by obtain ⟨db₀, hcomp₀⟩ := hread have hread' : Readable r res := ⟨db₀, hcomp₀⟩ have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl by_cases hle : r.end_.offset ≤ 1 · have h := minimal_closedForm_of_offset_one_truncated_rev_full hread' hmore hrev hbegin (Or.inl hle) unfold closedFormOffsetOneTruncatedRevFull at h rw [ite_eq_left hle] at h unfold closedFormOffsetOneTruncatedRevFullC rw [ite_eq_left hle] exact h · have hcount_le : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤ (r.end_.offset - 1).toNat := reported_count_ge_le_offset_sub_one_rev hread' hmore hrev hbegin hcross (by omega : 2 ≤ r.end_.offset) by_cases ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat · have h := minimal_closedForm_of_offset_one_truncated_rev_full_finite hread' hmore hrev hbegin hcross (by omega : 2 ≤ r.end_.offset) ht unfold closedFormOffsetOneTruncatedRevFull at h rw [ite_eq_right hle, ite_eq_left ht] at h unfold closedFormOffsetOneTruncatedRevFullC rw [ite_eq_right hle] dsimp only rw [ite_eq_left ht] simpa only [hlast, hhead] using h · have hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) < (r.end_.offset - 1).toNat := lt_of_le_of_ne hcount_le ht set n : Nat := (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1 with hn_def have hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1 := hn_def unfold closedFormOffsetOneTruncatedRevFullC rw [ite_eq_right hle] dsimp only rw [ite_eq_right ht] by_cases htop : r.end_.key = (⊤ : WithTop Key) · rw [htop] have h := minimal_topOfLast_of_end_offset_ge_two_rev hread' hmore hrev hbegin (by omega : 2 ≤ r.end_.offset) (fun k _ => by rw [htop]; exact WithTop.coe_lt_top k) unfold topOfLast at h exact h · obtain ⟨E, hE⟩ := WithTop.ne_top_iff_exists.mp htop rw [← hE] dsimp only set n : Nat := (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide ((↑E : WithTop Key) ≤ (k : WithTop Key))) - 1 with hn_def have hn : n = (r.end_.offset - 1).toNat - res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1 := by rw [hn_def, hE] by_cases hroom : keyAfterN n E < res.keys.getLastD ([] : Key) · have hroom' : keyAfterN n E < res.keys.getLast hne := by rw [← hlast]; exact hroom have h := minimal_topRev_begin_end hread' hmore hrev hbegin hcross (by omega : 2 ≤ r.end_.offset) hne hE.symm rfl hn hlt hroom' rw [ite_eq_left hroom] exact h · have hge : res.keys.getLast hne ≤ keyAfterN n E := by rw [← hlast] exact le_of_not_gt hroom have h := minimal_topRev_begin_last hread' hmore hrev hbegin hcross (by omega : 2 ≤ r.end_.offset) hE.symm hne rfl hn hlt (Or.inr hge) rw [ite_eq_right hroom] simpa only [← hlast] using h /-- **One compact rule for every result at begin offset one.** Dispatch on `res.more` and on the traversal order: complete results use the three-branch rule (forward or reversed), truncated forward results use `closedFormOffsetOneTruncated`, and truncated reversed results use the corrected full rule `closedFormOffsetOneTruncatedRevFullC`. -/ def closedFormOffsetOneUniversal (r : RangeRead) (res : Result) : ConflictRange := if res.more = true then if r.reverse = true then closedFormOffsetOneTruncatedRevFullC r res else closedFormOffsetOneTruncated r res else closedFormOffsetOneAny r res /-- The universal rule is minimal on the offset-one cross-free region, with no residual case: the corrected reversed truncated top branch closes the last cell. -/ theorem minimal_closedForm_of_offset_one_universal {r : RangeRead} {res : Result} (hread : Readable r res) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) : Minimal r res (closedFormOffsetOneUniversal r res) := by unfold closedFormOffsetOneUniversal by_cases hmore : res.more = true · rw [ite_eq_left hmore] by_cases hrev : r.reverse = true · rw [ite_eq_left hrev] exact minimal_closedForm_of_offset_one_truncated_rev_fullC hread hmore hrev hbegin hcross · rw [ite_eq_right hrev] have hfalse : r.reverse = false := by cases hr : r.reverse <;> simp_all exact minimal_closedForm_of_offset_one_truncated hread hmore hfalse hbegin hcross · rw [ite_eq_right hmore] have hfalse : res.more = false := by cases hm : res.more <;> simp_all exact minimal_closedForm_of_offset_one_any hread hfalse hne hbegin hcross /-- The universal rule is unconditional on the automatic region; the extra `hauto` hypothesis is retained for compatibility with earlier statements. -/ theorem minimal_closedForm_of_offset_one_universal_of_auto {r : RangeRead} {res : Result} (hread : Readable r res) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (_hauto : r.reverse = false ∨ res.more = false ∨ r.end_.offset ≤ 1 ∨ r.end_.key = (⊤ : WithTop Key)) : Minimal r res (closedFormOffsetOneUniversal r res) := minimal_closedForm_of_offset_one_universal hread hne hbegin hcross /-- The region version of the universal rule; the extra `hcell` hypothesis is retained for compatibility with earlier statements. -/ theorem minimal_closedForm_of_offset_one_universal_of_not_cell {r : RangeRead} {res : Result} (hread : Readable r res) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.begin.key ≤ r.end_.key) (_hcell : ¬ (r.reverse = true ∧ res.more = true ∧ 2 ≤ r.end_.offset ∧ r.end_.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key))) : Minimal r res (closedFormOffsetOneUniversal r res) := minimal_closedForm_of_offset_one_universal hread hne hbegin hcross /-! ## The crossed region at begin offset one The remaining cell of the offset-one closed form is the *crossed* selector pair `end_.key < begin_.key`. There the complete window starts at the first stored key at or above `begin_.key`, while the end resolution counts stored keys from `end_.key`; the minimal range therefore starts at `end_.key`, not at `begin_.key`. The lemmas below supply the crossed counterparts of the finite/top branch analysis. -/ /-- **The length of the complete window at begin offset one.** This is the general (not necessarily cross-free) form of `completeKeys_count_ge_eq_min`: the window length is the end anchor index minus the count of stored keys below `begin_.key`. -/ theorem completeKeys_length_of_offset_one {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).length = min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) := by rw [completeKeys_eq_filter_take_of_offset_one hrev hbegin hend, List.length_take] have hflen : (db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length = db.keys.length - db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) := by have hEq : db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = db.keys.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) := by apply List.filter_congr intro k _ rw [decide_eq_decide] exact not_lt.symm rw [hEq, filter_not_lt_eq_drop_countP db.sorted r.begin.key, List.length_drop] rw [hflen] exact Nat.min_eq_left (Nat.sub_le_sub_right (Nat.min_le_right _ _) _) /-- **The complete window length at any positive offsets.** For a non-reversed read, the number of complete keys is the end anchor's stored-key index minus the begin anchor's index. This is the length counterpart of `completeKeys_count_ge_eq_general` and is valid for crossed selectors as well. -/ theorem completeKeys_length_general {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).length = min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db.keys.length - (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + (r.begin.offset - 1).toNat) := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hls : l.SortedLT := by rw [hl]; exact db.sorted have hanB : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbegin, hp, hb, hl] have hA : l.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) = l.drop (p + b) := by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hanB] set d := l.countP (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) with hd have hd_eq : d = min (cE + e) l.length := by rw [hd, countP_lt_resolve] rw [anchor_toNat_eq (s := r.end_) hend, hcE, he, hl] have hck : RangeRead.completeKeys db r = (l.drop (p + b)).take (d - (p + b)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop (p + b)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p + b) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) (p + b), ← hd, nat_sub_min_right] rw [hck, List.length_take, List.length_drop, hd_eq] exact Nat.min_eq_left (Nat.sub_le_sub_right (Nat.min_le_right _ _) _) /-- **In the crossed case every complete key lies at or above `end_.key`.** The begin resolution is at or above `begin_.key > end_.key`, so the count at or above `end_.key` is the whole window length. -/ theorem completeKeys_count_ge_eq_length_of_crossed {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (RangeRead.completeKeys db r).length := by rw [completeKeys_eq_filter_take_of_offset_one hrev hbegin hend, List.countP_eq_length_filter, List.filter_eq_self.mpr] intro k hk rw [decide_eq_true_eq] have hk' : k ∈ db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) := List.mem_of_mem_take hk exact le_trans (le_of_lt hcross) (of_decide_eq_true (List.mem_filter.mp hk').2) /-- **The crossed finite branch has an empty `[end_.key, begin_.key)` gap.** If the number of reported keys at or above `end_.key` equals `end_.offset - 1`, then in a crossed read at begin offset one no stored key lies in `[end_.key, begin_.key)` and the end anchor still fits inside the database. -/ theorem crossed_counts_of_t_eq_e {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (hres : res.keys = RangeRead.completeKeys db r) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ∧ 0 < (r.end_.offset - 1).toNat := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set e' := (r.end_.offset - 1).toNat with he' have hls : l.SortedLT := by rw [hl]; exact db.sorted have hcEp : cE ≤ p := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_of_lt_of_le hk (le_of_lt hcross) have htlen : res.keys.length = e' := by have hcount := completeKeys_count_ge_eq_length_of_crossed (db := db) (r := r) hrev hbegin hcross (by omega) rw [← hres] at hcount omega have hlen : min (cE + e') l.length - p = e' := by have h := completeKeys_length_of_offset_one (db := db) (r := r) hrev hbegin (by omega) rw [← hres] at h rw [← hl, ← hp, ← hcE, ← he'] at h omega have hp_le_cE : p ≤ cE := by have h1 : min (cE + e') l.length - p ≤ cE + e' - p := Nat.sub_le_sub_right (Nat.min_le_left _ _) _ omega refine ⟨le_antisymm hcEp hp_le_cE, ?_⟩ omega /-- **The complete window as a drop-and-take at any positive offsets.** For a non-reversed read, the complete keys are the stored keys after the begin anchor, truncated after the end anchor. -/ theorem completeKeys_eq_drop_take_general {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) : RangeRead.completeKeys db r = (db.keys.drop (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + (r.begin.offset - 1).toNat)).take (min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat) db.keys.length - (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + (r.begin.offset - 1).toNat)) := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hls : l.SortedLT := by rw [hl]; exact db.sorted have hanB : (r.begin.anchor db).toNat = p + b := by rw [anchor_toNat_eq (s := r.begin) hbegin, hp, hb, hl] have hA : l.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) = l.drop (p + b) := by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hanB] set d := l.countP (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) with hd have hd_eq : d = min (cE + e) l.length := by rw [hd, countP_lt_resolve] rw [anchor_toNat_eq (s := r.end_) hend, hcE, he, hl] rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop (p + b)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p + b) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter, hA, filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) (p + b), ← hd, nat_sub_min_right, hd_eq] /-- **In the crossed case every complete key lies at or above `end_.key` at any positive begin offset.** -/ theorem completeKeys_count_ge_eq_length_of_crossed_general {db : DB} {r : RangeRead} (_hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (_hend : 1 ≤ r.end_.offset) : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (RangeRead.completeKeys db r).length := by rw [List.countP_eq_length_filter, List.filter_eq_self.mpr] intro k hk rw [decide_eq_true_eq] have hk' := RangeRead.mem_completeKeys.mp hk exact le_trans (le_of_lt hcross) (le_trans (key_le_resolve_of_one_le (db := db) (s := r.begin) hbegin) hk'.2.1) /-- **The crossed finite branch at any positive begin offset.** If the number of reported keys at or above `end_.key`, plus `begin.offset - 1`, is `end_.offset - 1`, then no stored key lies in the selector gap and the end anchor fits inside the database. This generalizes `crossed_counts_of_t_eq_e` beyond begin offset one. -/ theorem crossed_counts_of_t_add_b_eq_e {db : DB} {r : RangeRead} {res : Result} (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) (hne : res.keys ≠ []) (hres : res.keys = RangeRead.completeKeys db r) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ∧ db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + (r.end_.offset - 1).toNat ≤ db.keys.length := by set l := db.keys with hl set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hcEp : cE ≤ p := by rw [hp, hcE] apply countP_le_countP_of_imp intro k _ hk rw [decide_eq_true_eq] at hk ⊢ exact lt_trans hk hcross have htlen : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by rw [hres] exact completeKeys_count_ge_eq_length_of_crossed_general (db := db) hrev hbegin hcross hend have hlen : min (cE + e) l.length - (p + b) = res.keys.length := by have h := completeKeys_length_general (db := db) (r := r) hrev hbegin hend rw [← hl, ← hp, ← hcE, ← hb, ← he, ← hres] at h exact h.symm have htb : res.keys.length + b = e := by omega have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne have hlt : p + b < min (cE + e) l.length := by have hpos : 0 < min (cE + e) l.length - (p + b) := by omega exact Nat.lt_of_sub_pos hpos have hM : min (cE + e) l.length = p + e := by have hle : p + b ≤ min (cE + e) l.length := le_of_lt hlt have heq : min (cE + e) l.length = res.keys.length + (p + b) := (Nat.sub_eq_iff_eq_add hle).mp hlen omega have hp_e_le_cEe : p + e ≤ cE + e := by calc p + e = min (cE + e) l.length := hM.symm _ ≤ cE + e := Nat.min_le_left _ _ have hp_e_le_len : p + e ≤ l.length := by calc p + e = min (cE + e) l.length := hM.symm _ ≤ l.length := Nat.min_le_right _ _ refine ⟨le_antisymm hcEp (by omega), ?_⟩ omega /-- The counts below `E`, between `E` and `B`, and at or above `B` partition the list. -/ theorem countP_lt_add_between {l : List Key} {E B : WithTop Key} (hEB : E ≤ B) : l.countP (fun k : Key => decide ((k : WithTop Key) < E)) + l.countP (fun k : Key => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B)) = l.countP (fun k : Key => decide ((k : WithTop Key) < B)) := by induction l with | nil => simp | cons a t ih => by_cases haE : ((a : Key) : WithTop Key) < E · have haB : ((a : Key) : WithTop Key) < B := lt_of_lt_of_le haE hEB have hbetween : ¬ (E ≤ ((a : Key) : WithTop Key) ∧ ((a : Key) : WithTop Key) < B) := fun h => not_le.mpr haE h.1 rw [List.countP_cons_of_pos (by simpa using haE), List.countP_cons_of_neg (by simpa using hbetween), List.countP_cons_of_pos (by simpa using haB)] omega · by_cases haB : ((a : Key) : WithTop Key) < B · have hbetween : E ≤ ((a : Key) : WithTop Key) ∧ ((a : Key) : WithTop Key) < B := ⟨le_of_not_gt haE, haB⟩ rw [List.countP_cons_of_neg (by simpa using haE), List.countP_cons_of_pos (by simpa using hbetween), List.countP_cons_of_pos (by simpa using haB)] omega · have hbetween : ¬ (E ≤ ((a : Key) : WithTop Key) ∧ ((a : Key) : WithTop Key) < B) := fun h => haB h.2 rw [List.countP_cons_of_neg (by simpa using haE), List.countP_cons_of_neg (by simpa using hbetween), List.countP_cons_of_neg (by simpa using haB)] omega /-- If the counts below `E` and below `B` agree (with `E ≤ B`), no stored key lies in `[E, B)`. -/ private theorem not_mem_between_of_countP_lt_eq {l : List Key} {E B : WithTop Key} (hEB : E ≤ B) (h : l.countP (fun k : Key => decide ((k : WithTop Key) < E)) = l.countP (fun k : Key => decide ((k : WithTop Key) < B))) : ∀ k ∈ l, ¬ (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B) := by have hsum := countP_lt_add_between (l := l) hEB rw [h] at hsum have hzero : l.countP (fun k : Key => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B)) = 0 := by omega intro k hk hkb have hpos : 0 < l.countP (fun k : Key => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B)) := List.countP_pos_iff.mpr ⟨k, hk, by rw [decide_eq_true_eq]; exact hkb⟩ omega /-- **The top range starting at or below both selector keys is sound at positive offsets.** Agreement on `[lo, ⊤)` fixes both resolutions, hence the complete window. -/ theorem sound_topRange_of_lo_le {r : RangeRead} {res : Result} {lo : WithTop Key} (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) (hBl : lo ≤ r.begin.key) (hEl : lo ≤ r.end_.key) : Sound r res ⟨lo, ⊤⟩ := by intro db₁ db₂ hag have hagree : ∀ (k : Key), lo ≤ (k : WithTop Key) → (k ∈ db₁.keys ↔ k ∈ db₂.keys) := by intro k hk have h1 := congrArg (fun l : List Key => k ∈ l) hag have hcr : k ∈ (⟨lo, ⊤⟩ : ConflictRange) := ⟨hk, WithTop.coe_lt_top k⟩ rw [ConflictRange.mem_keys_iff, ConflictRange.mem_keys_iff] at h1 exact ⟨fun hk1 => (h1.mp ⟨hk1, hcr⟩).1, fun hk2 => (h1.mpr ⟨hk2, hcr⟩).1⟩ have hrb : resolve db₁ r.begin = resolve db₂ r.begin := resolve_eq_of_agree_ge hbegin fun k hk => hagree k (le_trans hBl hk) have hre : resolve db₁ r.end_ = resolve db₂ r.end_ := resolve_eq_of_agree_ge hend fun k hk => hagree k (le_trans hEl hk) have hwin : (db₁.keys.filter (fun (k : Key) => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_))) = (db₂.keys.filter (fun (k : Key) => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db₁ r.end_))) := by apply List.SortedLT.eq_of_mem_iff · exact List.sortedLT_iff_pairwise.mpr (db₁.sorted.pairwise.filter _) · exact List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _) · intro k rw [List.mem_filter, List.mem_filter] refine ⟨fun hk1 => ⟨?_, hk1.2⟩, fun hk2 => ⟨?_, hk2.2⟩⟩ · have hklo : lo ≤ (k : WithTop Key) := le_trans hBl (le_trans (key_le_resolve_of_one_le (db := db₁) (s := r.begin) hbegin) (of_decide_eq_true hk1.2).1) exact (hagree k hklo).mp hk1.1 · have hklo : lo ≤ (k : WithTop Key) := le_trans hBl (le_trans (key_le_resolve_of_one_le (db := db₁) (s := r.begin) hbegin) (of_decide_eq_true hk2.2).1) exact (hagree k hklo).mpr hk2.1 have hin : RangeRead.inRange db₁.keys (resolve db₁ r.begin) (resolve db₁ r.end_) = RangeRead.inRange db₂.keys (resolve db₂ r.begin) (resolve db₂ r.end_) := by unfold RangeRead.inRange rw [hwin, hrb, hre] have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by unfold RangeRead.completeKeys rw [hin] exact RangeRead.compatible_congr hck def crossFreeAnchor (r : RangeRead) : RangeRead := { r with begin := { key := r.end_.key, offset := 1 } } theorem compatible_crossed_iff_crossFree {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.Compatible db (crossFreeAnchor r) res := by obtain ⟨db₀, hcomp₀⟩ := hread have hres₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hc₀ := crossed_counts_of_t_eq_e (db := db₀) hrev hbegin hcross hend hres₀ ht have hres₀len : res.keys.length = (r.end_.offset - 1).toNat := by have hcount := completeKeys_count_ge_eq_length_of_crossed (db := db₀) (r := r) hrev hbegin hcross (by omega) rw [← hres₀] at hcount omega have hres₀ne : res.keys ≠ [] := hne intro db constructor · intro hcomp have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hc := crossed_counts_of_t_eq_e (db := db) hrev hbegin hcross hend hres ht have hanchor : r.begin.anchor db = (crossFreeAnchor r).begin.anchor db := by unfold Selector.anchor crossFreeAnchor simp only omega have hresolve : resolve db r.begin = resolve db ({ key := r.end_.key, offset := 1 } : Selector) := by unfold resolve rw [hanchor] rfl refine ⟨?_, ?_⟩ · change r.withinLimit res.keys exact hcomp.1 · right refine ⟨by simp [hmore], ?_⟩ have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db (crossFreeAnchor r) := by unfold RangeRead.completeKeys RangeRead.inRange crossFreeAnchor simp only rw [hresolve] rw [← hck] exact hres · intro hcomp have hres : res.keys = RangeRead.completeKeys db (crossFreeAnchor r) := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq -- All reported keys, hence all complete keys of the anchor read, are at least E. have hall_ge : ∀ k ∈ res.keys, r.end_.key ≤ (k : WithTop Key) := by intro k hk have hkanchor : k ∈ RangeRead.completeKeys db (crossFreeAnchor r) := by rw [← hres]; exact hk have h1 : (crossFreeAnchor r).begin.key ≤ resolve db (crossFreeAnchor r).begin := key_le_resolve_of_one_le (db := db) (s := (crossFreeAnchor r).begin) (by simp [crossFreeAnchor]) have h2 : (crossFreeAnchor r).begin.key = r.end_.key := rfl exact le_trans (h2 ▸ h1) (RangeRead.mem_completeKeys.mp hkanchor).2.1 -- and strictly at least `B` (since `res` comes from a crossed read and `t = e`) have hall_ge_B : ∀ k ∈ res.keys, (k : WithTop Key) ≥ r.begin.key := by intro k hk have hk₀ : k ∈ RangeRead.completeKeys db₀ r := by rw [← hres₀]; exact hk exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) (by omega)) (RangeRead.mem_completeKeys.mp hk₀).2.1 -- show no stored key lies in [E, B) have hno : ∀ k ∈ db.keys, ¬ (r.end_.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key) := by intro k hk hkb have hkwin : k ∈ RangeRead.completeKeys db (crossFreeAnchor r) := by refine RangeRead.mem_completeKeys.mpr ⟨hk, ?_, ?_⟩ · exact (key_le_resolve_iff_of_offset_one (db := db) (s := (crossFreeAnchor r).begin) (by simp [crossFreeAnchor]) hk).mp (by simpa [crossFreeAnchor] using hkb.1) · have hresne : res.keys ≠ [] := hne have hfirst : (res.keys.head hresne : Key) ∈ res.keys := List.head_mem hresne have hfirst_anchor : res.keys.head hresne ∈ RangeRead.completeKeys db (crossFreeAnchor r) := by rw [← hres]; exact hfirst have hltres := (RangeRead.mem_completeKeys.mp hfirst_anchor).2.2 have hfirstB : r.begin.key ≤ ((res.keys.head hresne : Key) : WithTop Key) := hall_ge_B _ hfirst exact lt_of_lt_of_le hkb.2 (le_trans hfirstB (le_of_lt hltres)) rw [← hres] at hkwin exact absurd (hall_ge_B k hkwin) (not_le.mpr hkb.2) -- hence the counts below E and below B agree have hcount : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) := by have hsum := countP_lt_add_between (l := db.keys) (E := r.end_.key) (B := r.begin.key) (le_of_lt hcross) have hzero : db.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key)) = 0 := by by_contra hpos obtain ⟨k, hk, hkdec⟩ := List.countP_pos_iff.mp (Nat.pos_of_ne_zero hpos) exact hno k hk (of_decide_eq_true hkdec) omega have hanchor : r.begin.anchor db = (crossFreeAnchor r).begin.anchor db := by unfold Selector.anchor crossFreeAnchor simp only omega have hresolve : resolve db r.begin = resolve db ({ key := r.end_.key, offset := 1 } : Selector) := by unfold resolve rw [hanchor] rfl refine ⟨?_, ?_⟩ · exact hcomp.1 · right refine ⟨by simp [hmore], ?_⟩ have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db (crossFreeAnchor r) := by unfold RangeRead.completeKeys RangeRead.inRange crossFreeAnchor simp only rw [hresolve] rw [hck] exact hres /-- Soundness is invariant under pointwise equivalence of compatibility. -/ theorem sound_of_compatible_iff {r r' : RangeRead} {res : Result} {cr : ConflictRange} (h : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res) : Sound r res cr ↔ Sound r' res cr := by constructor · intro hs db₁ db₂ hagree rw [← h db₁, ← h db₂] exact hs db₁ db₂ hagree · intro hs db₁ db₂ hagree rw [h db₁, h db₂] exact hs db₁ db₂ hagree /-- Minimality is invariant under pointwise equivalence of compatibility. -/ theorem minimal_of_compatible_iff {r r' : RangeRead} {res : Result} {cr : ConflictRange} (h : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res) : Minimal r' res cr → Minimal r res cr := by intro hmin refine ⟨(sound_of_compatible_iff h).mpr hmin.1, ?_⟩ intro cr' hsub hs exact hmin.2 cr' hsub ((sound_of_compatible_iff h).mp hs) /-- **Crossed finite-branch minimality.** At begin offset one, with crossed selectors and `t = e`, the finite branch's range starts at `end_.key` rather than `begin_.key`. The cross-free rule applied to the read whose begin key is moved down to `end_.key` gives exactly this range, and the two reads have the same compatible databases in this branch. -/ theorem minimal_truncatedRange_of_finite_crossed {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (r.end_.offset - 1).toNat) : Minimal r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by let r' := crossFreeAnchor r have hiff := compatible_crossed_iff_crossFree hread hrev hmore hne hbegin hcross hend ht obtain ⟨db₀, hcomp₀⟩ := hread have hread' : Readable r' res := ⟨db₀, (hiff db₀).mp hcomp₀⟩ have hmin : Minimal r' res ⟨r'.begin.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := minimal_truncatedRange_of_finite (r := r') hread' hmore hne (by simpa [r', crossFreeAnchor] using hrev) (by simp [r', crossFreeAnchor]) (by simp [r', crossFreeAnchor]) hend (by simpa [r', crossFreeAnchor] using ht) have hmin' : Minimal r' res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by simpa [r', crossFreeAnchor] using hmin exact minimal_of_compatible_iff hiff hmin' /-- The truncated range's stored keys are the stored keys at or above the begin key, filtered at or below the last reported key. This holds for every forward read; no offset or resolve condition is needed. -/ theorem truncatedRange_keys_eq_filter_le {db : DB} {r : RangeRead} {last : Key} : (truncatedRange r last).keys db = (db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter (fun k : Key => decide (k ≤ last)) := by unfold truncatedRange ConflictRange.keys rw [show db.keys.filter (fun (k : Key) => decide (r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) = db.keys.filter (fun (k : Key) => decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) && decide (r.begin.key ≤ (k : WithTop Key))) from List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter] apply List.filter_congr intro k _ rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff] /-- If filtering an ascending list at or below a threshold is a take, then filtering any prefix of it at or below the threshold is the corresponding shorter take. -/ theorem filter_take_eq_take_min {α : Type*} {p : α → Bool} {l : List α} {q : Nat} (h : l.filter p = l.take q) (m : Nat) : (l.take m).filter p = l.take (min m q) := by induction l generalizing q m with | nil => simp | cons a rest ih => cases q with | zero => simp only [List.take_zero, List.filter_cons] at h ⊢ cases hpa : p a with | true => simp only [hpa] at h exact absurd h (by simp) | false => simp only [hpa] at h have hrest : rest.filter p = rest.take 0 := by simpa using h cases m with | zero => simp | succ m => simp only [List.take_succ_cons, List.filter_cons, hpa, Bool.false_eq_true, ite_false] rw [ih hrest m] simp | succ q => cases m with | zero => simp | succ m => simp only [List.take_succ_cons, List.filter_cons] at h ⊢ cases hpa : p a with | true => simp only [hpa] at h ⊢ have hrest : rest.filter p = rest.take q := (List.cons.inj h).2 rw [ih hrest m] simp [Nat.succ_min_succ] | false => simp only [hpa, Bool.false_eq_true, ite_false] at h ⊢ have ha : a ∈ rest.filter p := by rw [h] exact List.mem_cons_self .. exact absurd (List.mem_filter.mp ha).2 (by simp [hpa]) /-- **The equal-selector window.** When `begin.key = end_.key` and at least `(end_.offset - 1).toNat` stored keys lie at or above it, the complete keys are the stored keys at or above `begin.key`, dropped by `(begin.offset - 1).toNat` and cut to length `(end_.offset - 1).toNat - (begin.offset - 1).toNat`. Both selectors anchor at the same count `c` of stored keys below the shared key, so the window is the rank interval `[c + (begin.offset - 1).toNat, c + (end_.offset - 1).toNat)`. -/ private theorem completeKeys_eq_drop_take_of_key_eq {db : DB} {r : RangeRead} (hrev : r.reverse = false) (hbeginB : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 1 ≤ r.end_.offset) (hlen : (r.end_.offset - 1).toNat ≤ (db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length) : RangeRead.completeKeys db r = ((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).drop (r.begin.offset - 1).toNat).take ((r.end_.offset - 1).toNat - (r.begin.offset - 1).toNat) := by set l := db.keys with hl set c := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hc set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hls : l.SortedLT := by rw [hl]; exact db.sorted have hcE : l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = c := by rw [hc] exact List.countP_congr (fun k _ => by rw [hkey]) have hA : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.drop c := by have hcongr : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.filter (fun k : Key => decide (¬ ((k : Key) : WithTop Key) < r.begin.key)) := List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt] rw [hcongr, filter_not_lt_eq_drop_countP hls r.begin.key, hc] have hanB : (r.begin.anchor db).toNat = c + b := by rw [anchor_toNat_eq (s := r.begin) hbeginB, hb] have hanE : (r.end_.anchor db).toNat = c + e := by rw [anchor_toNat_eq (s := r.end_) hend, he] rw [show db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = c from by rw [← hcE, hl]] set d := l.countP (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) with hd have hd_eq : d = c + e := by have hmin : d = min (r.end_.anchor db).toNat l.length := by rw [hd, hl] exact countP_lt_resolve rw [hmin, hanE] have hAlen : (l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length = l.length - c := by rw [hA, List.length_drop] have hle : c + e ≤ l.length := by have hlen' : e ≤ (l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length := by simpa [hl] using hlen rw [hAlen] at hlen' have hc_le : c ≤ l.length := by rw [hc] exact List.countP_le_length omega exact Nat.min_eq_left hle have hck : RangeRead.completeKeys db r = (l.drop (c + b)).take (d - (c + b)) := by rw [RangeRead.completeKeys, ite_eq_right (by simp [hrev])] have hdrop : (l.drop (c + b)).SortedLT := List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := c + b) hls.pairwise) rw [show RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) = db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) from rfl] rw [show db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_)) = l.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_) && decide (resolve db r.begin ≤ (k : WithTop Key))) from by rw [← hl] exact List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]] rw [← List.filter_filter] rw [show l.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key))) = l.drop (c + b) from by rw [hl, filter_resolve_le_eq_drop (db := db) (s := r.begin), hanB]] rw [filter_lt_eq_take_countP hdrop (resolve db r.end_), countP_drop_eq hls (resolve db r.end_) (c + b), ← hd, nat_sub_min_right] rw [hck, hd_eq] have hdrop_eq : l.drop (c + b) = ((l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).drop b) := by rw [hA, List.drop_drop] rw [hdrop_eq] congr 1 omega /-- **Finite branch of the equal-selector complete cell.** When `begin.key = end_.key` and the reported keys at or above that shared key fill exactly `(end_.offset - 1) - (begin.offset - 1)` slots, agreement on the truncated range `[begin.key, keyAfter last)` fixes the complete keys. Both selectors anchor at the same count of stored keys below the shared key, so the complete window is the rank interval between the two offsets, while the truncated range sees the shared prefix up to `last`. -/ private theorem sound_truncatedRange_of_key_eq_finite_general {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 2 ≤ r.end_.offset) (htpos : 0 < res.keys.length) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) : Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp₀⟩ := hread have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hlast] have hcompof : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.withinLimit r res.keys ∧ RangeRead.completeKeys db r = res.keys := by intro db constructor · rintro ⟨hlim, hdisj | ⟨_, heq⟩⟩ · rw [hmore] at hdisj exact absurd hdisj.1 (by simp) · exact ⟨hlim, heq.symm⟩ · rintro ⟨hlim, heq⟩ exact ⟨hlim, Or.inr ⟨hmore, heq.symm⟩⟩ set last := res.keys.getLast hne with hlastdef set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have step : ∀ db₁ db₂, AgreeOn (truncatedRange r last) db₁ db₂ → RangeRead.Compatible db₁ r res → RangeRead.Compatible db₂ r res := by intro db₁ db₂ hagree hcomp₁ rw [hcompof db₁] at hcomp₁ obtain ⟨hlim, hck₁⟩ := hcomp₁ rw [hcompof db₂] -- Every reported key lies at or above the shared selector key. have hE_all : ∀ k ∈ res.keys, r.end_.key ≤ (k : WithTop Key) := by intro k hk have hkck : k ∈ RangeRead.completeKeys db₁ r := by rw [hck₁]; exact hk have hmem := (RangeRead.mem_completeKeys.mp hkck).2.1 have hbl : r.begin.key ≤ resolve db₁ r.begin := key_le_resolve_of_one_le (db := db₁) (s := r.begin) hbegin have hle : r.begin.key ≤ (k : WithTop Key) := le_trans hbl hmem rwa [hkey] at hle have hcount_len : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := List.countP_eq_length.mpr (fun k hk => by rw [decide_eq_true_eq]; exact hE_all k hk) have hn : res.keys.length + b = e := by rw [← hcount_len] exact ht have hb_le_e : b ≤ e := by omega -- The reported last is below the resolved end of `db₁`. have hlast_mem : last ∈ res.keys := by rw [hlastdef]; exact List.getLast_mem hne have hlr₁ : (last : WithTop Key) < resolve db₁ r.end_ := by have hkck : last ∈ RangeRead.completeKeys db₁ r := by rw [hck₁]; exact hlast_mem exact (RangeRead.mem_completeKeys.mp hkck).2.2 have hfil₁ : (RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last)) = res.keys := by rw [hck₁] exact filter_le_getLast_eq_of_prefix hsort.pairwise (List.prefix_refl _) hne have hF₁ := completeKeys_filter_le_drop (db := db₁) (r := r) (last := last) hrev hbegin hlr₁ rw [hfil₁] at hF₁ have hTdrop₁ : ((truncatedRange r last).keys db₁).drop b = res.keys := hF₁.symm -- The truncated range of `db₁` has exactly `e` stored keys. have hTlen_lower : ((truncatedRange r last).keys db₁).length = b + res.keys.length := by have hld := congrArg List.length hTdrop₁ rw [List.length_drop] at hld have hb_le : b ≤ ((truncatedRange r last).keys db₁).length := by by_contra hb' have hzero : ((truncatedRange r last).keys db₁).length - b = 0 := Nat.sub_eq_zero_of_le (le_of_not_ge hb') omega omega have hTlen_upper : ((truncatedRange r last).keys db₁).length ≤ e := by have h := filter_length_le_offset_of_resolve_end_gt (db := db₁) (r := r) (last := last) (by omega) hlr₁ rw [← hkey] at h rw [← truncatedRange_keys_eq_filter_le (db := db₁) (r := r) (last := last)] at h simpa [he] using h have hTlen₁ : ((truncatedRange r last).keys db₁).length = e := by omega have hT₂ : (truncatedRange r last).keys db₂ = (truncatedRange r last).keys db₁ := hagree.symm have hTlen₂ : ((truncatedRange r last).keys db₂).length = e := by rw [hT₂, hTlen₁] -- Enough stored keys at or above the shared key for the end selector. have hlenA₂ : e ≤ (db₂.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).length := by have hle := List.length_filter_le (fun k : Key => decide (k ≤ last)) (db₂.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))) rw [← truncatedRange_keys_eq_filter_le (db := db₂) (r := r) (last := last)] at hle omega have hAsort₂ : (db₂.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).SortedLT := List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _) -- The truncated range is exactly the first `e` keys at or above the shared key. have htake₂ : (db₂.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).take e = (truncatedRange r last).keys db₂ := by have hq : (db₂.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).countP (fun k : Key => decide (k ≤ last)) = e := by rw [List.countP_eq_length_filter] rw [← truncatedRange_keys_eq_filter_le (db := db₂) (r := r) (last := last), hTlen₂] have hfil := filter_le_eq_take_countP hAsort₂ last rw [hq] at hfil exact hfil.symm.trans (truncatedRange_keys_eq_filter_le (db := db₂) (r := r) (last := last)).symm -- Assemble the complete window of `db₂`. have hck₂ : RangeRead.completeKeys db₂ r = res.keys := by rw [completeKeys_eq_drop_take_of_key_eq (db := db₂) hrev hbegin hkey (by omega) hlenA₂] rw [List.take_drop, show b + (e - b) = e from Nat.add_sub_cancel' hb_le_e] rw [htake₂, hT₂, hTdrop₁] exact ⟨hlim, hck₂⟩ intro db₁ db₂ hagree exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ /-- **Finite branch of the equal-selector complete cell, minimality.** Under the count identity `t + (begin.offset - 1) = end.offset - 1`, the truncated range is the minimal sound range; necessity is the begin key and the last reported key, exactly as in the general finite branch. -/ theorem minimal_truncatedRange_of_key_eq_finite_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hne : res.keys ≠ []) (hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat) : Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by obtain ⟨db₀, hcomp⟩ := hread have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl rw [hgetLast] have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r := RangeRead.compatible_keys_prefix hcomp refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · rw [← hgetLast] exact sound_truncatedRange_of_key_eq_finite_general ⟨db₀, hcomp⟩ hrev hmore hne hbegin hkey hend (List.length_pos_of_ne_nil hne) ht · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (hpre₀.ne_nil hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) have hkle : k ≤ res.keys.getLast hne := (lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs /-- **Sentinel end in the equal-selector top branch.** When `begin.key = end_.key` and the reported keys at or above the shared key fill fewer than `(end_.offset - 1) - (begin.offset - 1)` slots, the resolved end of every compatible database is the sentinel. Otherwise the complete window would be the rank interval `[c + b, c + e)` of the stored keys at or above the shared key, so its reported keys would number exactly `e - b`. -/ private theorem resolve_end_eq_top_of_key_eq_top_general {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (_hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat < (r.end_.offset - 1).toNat) : resolve db r.end_ = (⊤ : WithTop Key) := by by_contra hnotop have hck : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq set A := db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hA set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hb_lt_e : b < e := by omega -- The end selector's filtered list is `A`, since the two keys agree. have hres_end := resolve_eq_filter_getElem? (db := db) (s := r.end_) (by omega : 1 ≤ r.end_.offset) have hf : (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))) = A := by rw [hA, hkey] rw [hf] at hres_end -- A finite end means the `e`-th key of `A` exists. have hlen : e ≤ A.length := by cases hget : A[e]? with | none => rw [hget] at hres_end exact absurd hres_end hnotop | some k => have hlt := (List.getElem?_eq_some_iff.mp hget).1 omega have hW := completeKeys_eq_drop_take_of_key_eq (db := db) hrev hbegin hkey (by omega) hlen have hWlen : (RangeRead.completeKeys db r).length = e - b := by rw [hW, List.length_take, List.length_drop] have hle : e - b ≤ A.length - b := by omega rw [Nat.min_eq_left hle] have hcountW : (RangeRead.completeKeys db r).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (RangeRead.completeKeys db r).length := by rw [hW, List.countP_eq_length] intro k hk rw [decide_eq_true_eq] have hkA : k ∈ A := List.mem_of_mem_drop (List.mem_of_mem_take hk) have hkb : r.begin.key ≤ (k : WithTop Key) := of_decide_eq_true (List.mem_filter.mp hkA).2 rwa [← hkey] have ht' : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = e - b := by rw [hck, hcountW, hWlen] omega /-- **Strict top margin in the equal-selector top branch.** If the reported keys at or above the shared key fall short of the offset gap, the compatible database has strictly fewer stored keys than the count below `end_.key` plus the end offset. This is the margin needed to keep the end selector at the sentinel after inserting a fresh key. -/ private theorem key_eq_top_strict_margin {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat < (r.end_.offset - 1).toNat) : db.keys.length < db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := by have hend : 2 ≤ r.end_.offset := by omega have hE := resolve_end_eq_top_of_key_eq_top_general hcomp hmore hrev hne hbegin hkey hend ht have hck : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq set l := db.keys with hl set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he set c := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hc set A := (topRange r).keys db with hA have hAs : A.SortedLT := by rw [hA] unfold topRange ConflictRange.keys exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _) have hckDrop : RangeRead.completeKeys db r = A.drop b := by rw [completeKeys_eq_topRange_keys_drop (db := db) hrev hbegin hE, hA] have hb_le : b ≤ A.length := by have hdne : A.drop b ≠ [] := by intro hnil apply hne rw [hck, hckDrop, hnil] by_contra h exact hdne (List.drop_eq_nil_iff.mpr (by omega)) have hcount : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = A.length - b := by rw [hck, hckDrop] have hcl : (A.drop b).countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (A.drop b).length := by rw [List.countP_eq_length] intro k hk rw [decide_eq_true_eq] have hkA : k ∈ A := List.mem_of_mem_drop hk have hkb : r.begin.key ≤ (k : WithTop Key) := by rw [hA] at hkA have h := of_decide_eq_true (List.mem_filter.mp hkA).2 simpa [topRange] using h.1 rwa [← hkey] rw [hcl, List.length_drop] have hAlen : A.length = l.length - c := by rw [hA] unfold topRange ConflictRange.keys rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < (⊤ : WithTop Key))) = l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) from List.filter_congr fun k _ => by rw [decide_eq_decide]; exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩] rw [show l.filter (fun (k : Key) => decide (r.begin.key ≤ (↑k : WithTop Key))) = l.filter (fun (k : Key) => decide (¬ ((↑k : WithTop Key) < r.begin.key))) from List.filter_congr fun k _ => by rw [decide_eq_decide, not_lt]] rw [filter_not_lt_eq_drop_countP (by rw [hl]; exact db.sorted) r.begin.key, hc, List.length_drop] have hcE : l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = c := by rw [hc] exact List.countP_congr (fun k _ => by rw [hkey]) have hA_lt : A.length < e := by have := ht rw [hcount] at this omega have hlen_eq : l.length = c + A.length := by rw [hAlen] have hc_le : c ≤ l.length := by rw [hc]; exact List.countP_le_length omega calc l.length = c + A.length := hlen_eq _ < c + e := by omega _ = l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + e := by rw [hcE] /-- **Top-branch necessity above the reported last, equal selectors.** When `begin.key = end_.key` and the reported keys at or above the shared key fall short of the offset gap, every key at or above the last reported key is necessary. The sentinel end is forced by `resolve_end_eq_top_of_key_eq_top_general`, the strict margin by `key_eq_top_strict_margin`, and inserting a fresh key above the last then preserves the sentinel while extending the complete window. -/ private theorem necessary_of_key_eq_top_general {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat < (r.end_.offset - 1).toNat) {x : Key} (hlo : res.keys.getLast hne ≤ x) : Necessary r res x := by obtain ⟨db₀, hcomp⟩ := hread intro cr hs by_cases hx : x ∈ res.keys · exact necessary_of_mem_result ⟨db₀, hcomp⟩ hx cr hs · by_contra hcr have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev have hmaxres : ∀ k ∈ res.keys, k ≤ res.keys.getLast hne := fun k hk => (hsort.pairwise.imp le_of_lt).rel_getLast hk have hE₀ : resolve db₀ r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_key_eq_top_general hcomp hmore hrev hne hbegin hkey hend ht have hL_lt : db₀.keys.length < db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) + (r.end_.offset - 1).toNat := key_eq_top_strict_margin hcomp hmore hrev hne hbegin hkey ht set b := (r.begin.offset - 1).toNat with hb set A := (topRange r).keys db₀ with hA have hAs : A.SortedLT := by rw [hA] unfold topRange ConflictRange.keys exact List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _) have hckDrop : RangeRead.completeKeys db₀ r = A.drop b := by rw [completeKeys_eq_topRange_keys_drop (db := db₀) hrev hbegin hE₀, hA] have hdne : A.drop b ≠ [] := by intro hnil apply hne rw [hres, hckDrop, hnil] have hb_lt : b < A.length := by by_contra h exact hdne (List.drop_eq_nil_iff.mpr (by omega)) have hhead_drop : (A.drop b).head hdne = A[b] := List.head_drop hdne have hhead_mem : A[b] ∈ res.keys := by rw [← hhead_drop, hres, hckDrop] exact List.head_mem hdne have hbegin_le_last : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := le_trans (begin_key_le_head_of_one_le_offset ⟨db₀, hcomp⟩ hne hbegin) (WithTop.coe_le_coe.mpr (hmaxres _ (List.head_mem hne))) have hall : ∀ k ∈ db₀.keys, k ≤ x := by intro k hk by_cases hbk : r.begin.key ≤ ((k : Key) : WithTop Key) · have hkA : k ∈ A := by rw [hA, ConflictRange.mem_keys_iff] exact ⟨hk, hbk, WithTop.coe_lt_top k⟩ have hkappend : k ∈ A.take b ++ A.drop b := by rw [List.take_append_drop] exact hkA rcases List.mem_append.mp hkappend with hktake | hkdrop · obtain ⟨i, hi, hik⟩ := List.mem_take_iff_getElem.mp hktake have hi_lt_b : i < b := lt_of_lt_of_le hi (Nat.min_le_left _ _) have hi_lt_A : i < A.length := lt_of_lt_of_le hi (Nat.min_le_right _ _) have hile : A[i] ≤ A[b] := (hAs.getElem_le_getElem_iff).mpr (by omega) have hk_le_head : k ≤ A[b] := by rw [← hik]; exact hile exact le_trans hk_le_head (le_trans (hmaxres _ hhead_mem) hlo) · have hkres : k ∈ res.keys := by rw [hres, hckDrop]; exact hkdrop exact le_trans (hmaxres k hkres) hlo · have hklt : ((k : Key) : WithTop Key) < r.begin.key := lt_of_not_ge hbk have hkx : ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := le_trans (le_of_lt hklt) (le_trans hbegin_le_last (WithTop.coe_le_coe.mpr hlo)) exact WithTop.coe_le_coe.mp hkx have hx0 : x ∉ db₀.keys := by intro hxm by_cases hbx : r.begin.key ≤ ((x : Key) : WithTop Key) · have hxA : x ∈ A := by rw [hA, ConflictRange.mem_keys_iff] exact ⟨hxm, hbx, WithTop.coe_lt_top x⟩ have hxappend : x ∈ A.take b ++ A.drop b := by rw [List.take_append_drop] exact hxA rcases List.mem_append.mp hxappend with hxtake | hxdrop · obtain ⟨i, hi, hix⟩ := List.mem_take_iff_getElem.mp hxtake have hi_lt_b : i < b := lt_of_lt_of_le hi (Nat.min_le_left _ _) have hi_lt_A : i < A.length := lt_of_lt_of_le hi (Nat.min_le_right _ _) have hile : A[i] ≤ A[b] := (hAs.getElem_le_getElem_iff).mpr (by omega) have hx_le_head : x ≤ A[b] := by rw [← hix]; exact hile have hx_eq_head : x = A[b] := le_antisymm hx_le_head (le_trans (hmaxres _ hhead_mem) hlo) exact hx (hx_eq_head ▸ hhead_mem) · exact hx (by rw [hres, hckDrop]; exact hxdrop) · have hxlt : ((x : Key) : WithTop Key) < r.begin.key := lt_of_not_ge hbx have hxltlast : x < res.keys.getLast hne := WithTop.coe_lt_coe.mp (lt_of_lt_of_le hxlt hbegin_le_last) exact absurd hlo (not_le.mpr hxltlast) have hEins : resolve (db₀.insert x hx0) r.end_ = (⊤ : WithTop Key) := resolve_end_eq_top_of_insert_top hx0 hL_lt hend exact absurd (mem_result_of_insert hcomp hs hcr hmore hne hx0 (fun k hk => WithTop.coe_le_coe.mpr (hall k hk)) hEins) hx /-- **Equal-selector top branch, minimality.** When `begin.key = end_.key` and the reported keys at or above the shared key satisfy `t + (begin.offset - 1) < end_.offset - 1`, the unbounded top range `[begin.key, ⊤)` is the minimal sound conflict range. -/ theorem minimal_topRange_of_key_eq_top_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 2 ≤ r.end_.offset) (ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat < (r.end_.offset - 1).toNat) : Minimal r res (topRange r) := by obtain ⟨db₀, hcomp⟩ := hread have hres : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := begin_key_ne_top_of_completeKeys_ne_nil hrev (by rw [← hres]; exact hne) hbegin obtain ⟨v, hv⟩ := exists_begin_key_of_ne_top hbk_ne_top refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩ · exact sound_topRange_of_one_le_le hbegin (by omega) (le_of_eq hkey) · intro k hk cr hs have hlast_nec : Necessary r res (res.keys.getLast hne) := necessary_of_mem_result ⟨db₀, hcomp⟩ (List.getLast_mem hne) by_cases hkle : k ≤ res.keys.getLast hne · have hbegin_nec : Necessary r res v := necessary_begin_key ⟨db₀, hcomp⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hk.1) exact hbegin_nec.of_between hlast_nec hvk hkle cr hs · exact necessary_of_key_eq_top_general ⟨db₀, hcomp⟩ hrev hmore hne hbegin hkey hend ht (le_of_lt (lt_of_not_ge hkle)) cr hs /-- **Equal-selector count bound.** For a nonempty complete result with `begin.key = end_.key`, the number `t` of reported keys at or above the shared key plus `(begin.offset - 1)` is at most `(end_.offset - 1)`. The end selector either lands at a finite key, where the complete window is a `take` of `A.drop b`, or overshoots, where the window is all of `A.drop b` and the overshoot gives `|A| ≤ e`. -/ private theorem key_eq_count_add_le {db : DB} {r : RangeRead} {res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 1 ≤ r.end_.offset) : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat ≤ (r.end_.offset - 1).toNat := by have hck : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq set A := db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hA set b := (r.begin.offset - 1).toNat with hb set e := (r.end_.offset - 1).toNat with he have hres_end := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend have hf : (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))) = A := by rw [hA, hkey] rw [hf] at hres_end have hcountA : ∀ x ∈ A, r.begin.key ≤ (x : WithTop Key) := by intro x hx rw [hA] at hx exact of_decide_eq_true (List.mem_filter.mp hx).2 cases hget : A[e]? with | some k => have hlen : e ≤ A.length := by have := (List.getElem?_eq_some_iff.mp hget).1 omega have hW := completeKeys_eq_drop_take_of_key_eq (db := db) hrev hbegin hkey (by omega) hlen have ht_eq : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = ((A.drop b).take (e - b)).length := by rw [hck, hW] rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] have hxA : x ∈ A := List.mem_of_mem_drop (List.mem_of_mem_take hx) have hxb : r.begin.key ≤ (x : WithTop Key) := hcountA x hxA rwa [← hkey] have hb_lt_e : b < e := by by_contra h have htake : (A.drop b).take (e - b) = [] := by rw [show e - b = 0 by omega] rfl apply hne rw [hck, hW] simpa [← he, ← hb] using htake rw [ht_eq, List.length_take] have hle : min (e - b) (A.length - b) ≤ e - b := Nat.min_le_left _ _ omega | none => have hlen_none : A.length ≤ e := List.getElem?_eq_none_iff.mp hget have hE : resolve db r.end_ = (⊤ : WithTop Key) := by rw [hres_end, hget] have hAtop : (topRange r).keys db = A := by rw [hA] unfold topRange ConflictRange.keys exact List.filter_congr fun k _ => by rw [decide_eq_decide] exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩ have hckDrop : RangeRead.completeKeys db r = A.drop b := by rw [completeKeys_eq_topRange_keys_drop (db := db) hrev hbegin hE, hAtop, ← hb] have hb_le : b ≤ A.length := by by_contra h have hnil : A.drop b = [] := List.drop_eq_nil_iff.mpr (by omega) apply hne rw [hck, hckDrop, hnil] have ht_eq : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = (A.drop b).length := by rw [hck, hckDrop] rw [List.countP_eq_length] intro x hx rw [decide_eq_true_eq] have hxA : x ∈ A := List.mem_of_mem_drop hx have hxb : r.begin.key ≤ (x : WithTop Key) := hcountA x hxA rwa [← hkey] rw [ht_eq, List.length_drop] omega /-- **The equal-selector complete closed form.** When `begin.key = end_.key`, the minimal complete-result conflict range is `[begin.key, keyAfter (last reported))` when `t + (begin.offset - 1) = end_.offset - 1`, and `[begin.key, ⊤)` otherwise. -/ def closedFormKeyEqComplete (r : RangeRead) (res : Result) : ConflictRange := if res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat then truncatedRange r (res.keys.getLastD ([] : Key)) else topRange r /-- **The equal-selector complete closed form is minimal.** The finite branch is `minimal_truncatedRange_of_key_eq_finite_general`; the complementary branch has `t + (begin.offset - 1) < end_.offset - 1` by `key_eq_count_add_le`, so it is the top branch `minimal_topRange_of_key_eq_top_general`. -/ theorem minimal_closedForm_of_key_eq_complete_general {r : RangeRead} {res : Result} (hread : Readable r res) (hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset) (hkey : r.begin.key = r.end_.key) (hend : 2 ≤ r.end_.offset) : Minimal r res (closedFormKeyEqComplete r res) := by have hread' := hread obtain ⟨db₀, hcomp⟩ := hread unfold closedFormKeyEqComplete by_cases ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) + (r.begin.offset - 1).toNat = (r.end_.offset - 1).toNat · rw [ite_eq_left ht] exact minimal_truncatedRange_of_key_eq_finite_general hread' hmore hne hrev hbegin hkey hend ht · rw [ite_eq_right ht] have hle := key_eq_count_add_le (db := db₀) hcomp hmore hrev hne hbegin hkey (by omega) exact minimal_topRange_of_key_eq_top_general hread' hmore hrev hne hbegin hkey hend (by omega) /-! ## The crossed complete cell at begin offset zero with a nonpositive end offset At `begin.offset = 0` a crossed complete result resolves its begin selector onto the reported head. When the end offset is nonpositive, `resolve end_` is a finite key at or below `end_.key`, and the complete window is the stored keys in `[head, resolve end_)`. Agreement on `[head, end_.key)` fixes the top `(-end_.offset)` stored keys below `end_.key`, hence fixes `resolve end_`; the extra keys between `resolve end_` and `end_.key` do not enter the window. The range `[head, end_.key)` is therefore sound, and every key in it is necessary by convexity and by the end-selector necessity `necessary_last_to_end_key`. -/ /-- **Resolution at a nonpositive offset, read from the top.** At `offset ≤ 0`, the resolution is the `(-offset)`-th stored key strictly below the selector key, counted from the top, or the empty key when there are too few. -/ theorem resolve_eq_filter_lt_reverse {db : DB} {s : Selector} (hoff : s.offset ≤ 0) : resolve db s = (match (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[ (-s.offset).toNat]? with | some k => ((k : Key) : WithTop Key) | none => (([] : Key) : WithTop Key)) := by set m := (-s.offset).toNat with hm have hoff' : s.offset = -(m : ℤ) := by rw [hm, Int.toNat_of_nonneg (by omega : (0 : ℤ) ≤ -s.offset)]; ring set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) with hc have hanchor : s.anchor db = (c : ℤ) - (m : ℤ) - 1 := by unfold Selector.anchor; rw [← hc, hoff']; ring have hflen : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).length = c := by rw [← List.countP_eq_length_filter, ← hc] have hclen : c ≤ db.keys.length := by rw [hc]; exact List.countP_le_length by_cases hmc : m < c · have h0 : 0 ≤ s.anchor db := by rw [hanchor]; omega have hancEq : s.anchor db = ((c - 1 - m : ℕ) : ℤ) := by rw [hanchor] have : (m : ℤ) + 1 ≤ (c : ℤ) := by exact_mod_cast hmc omega have hidx : (s.anchor db).toNat = c - 1 - m := by rw [hancEq, Int.toNat_natCast] have hlen : (s.anchor db).toNat < db.keys.length := by rw [hidx]; omega have hres : resolve db s = ((db.keys[c - 1 - m]'(by omega) : Key) : WithTop Key) := by rw [resolve_eq_getElem h0 hlen] apply WithTop.coe_inj.mp simp only [hidx] have hsome : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[m]? = some (db.keys[c - 1 - m]'(by omega)) := by rw [List.getElem?_reverse (by rw [hflen]; omega)] rw [hflen] rw [getElem?_filter_of_lt_countP db.sorted (by rw [← hc]; omega)] exact List.getElem?_eq_getElem (by omega) rw [hres, hsome] · have hle : c ≤ m := by omega have hneg : s.anchor db < 0 := by rw [hanchor]; omega rw [resolve_eq_nil hneg] have hnone : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[m]? = none := List.getElem?_eq_none (by rw [List.length_reverse, hflen]; exact hle) rw [hnone] /-- Splitting the keys strictly below `E` at a genuine key `a` into those below `a` and those in `[a, E)`. -/ theorem filter_lt_eq_filter_lt_append_between {l : List Key} (hs : l.SortedLT) {a : Key} {E : WithTop Key} (haE : (a : WithTop Key) ≤ E) : l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < E)) = l.filter (fun (k : Key) => decide ((↑k : WithTop Key) < (a : WithTop Key))) ++ l.filter (fun (k : Key) => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) := by induction l with | nil => rfl | cons x xs ih => have hs' : xs.SortedLT := List.sortedLT_iff_pairwise.mpr (List.pairwise_cons.mp hs.pairwise).2 have hih := ih hs' have hx_le : ∀ k ∈ xs, (x : Key) < k := (List.pairwise_cons.mp hs.pairwise).1 by_cases hxE : ((x : Key) : WithTop Key) < E · have hFE_pos : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < E)) = x :: xs.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) := List.filter_cons_of_pos (p := fun k : Key => decide ((↑k : WithTop Key) < E)) (a := x) (decide_eq_true hxE) by_cases hxa : ((x : Key) : WithTop Key) < ((a : Key) : WithTop Key) · have hFa_pos : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) = x :: xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) := List.filter_cons_of_pos (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) (a := x) (decide_eq_true hxa) have hG_neg : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) = xs.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) := List.filter_cons_of_neg (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) (a := x) (by simp [not_le.mpr hxa]) rw [hFE_pos, hFa_pos, hG_neg, hih] rfl · have hax : ((a : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := le_of_not_gt hxa have hFa_nil : xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) = [] := by rw [List.filter_eq_nil_iff] intro k hk have hxk : ((x : Key) : WithTop Key) < (k : WithTop Key) := WithTop.coe_lt_coe.mpr (hx_le k hk) simp only [decide_eq_true_eq] exact not_lt.mpr (le_trans hax (le_of_lt hxk)) have hFa_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) = xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) := List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) (a := x) (by simp [hxa]) have hG_pos : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) = x :: xs.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) := List.filter_cons_of_pos (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) (a := x) (decide_eq_true ⟨hax, hxE⟩) rw [hFE_pos, hFa_neg, hG_pos, hFa_nil, List.nil_append, hih, hFa_nil, List.nil_append] · have hEx : E ≤ ((x : Key) : WithTop Key) := le_of_not_gt hxE have hnot_a : ¬ ((x : Key) : WithTop Key) < ((a : Key) : WithTop Key) := not_lt.mpr (le_trans haE hEx) have hnot_b : ¬ ((a : WithTop Key) ≤ ((x : Key) : WithTop Key) ∧ ((x : Key) : WithTop Key) < E) := fun h => hxE h.2 have hFE_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < E)) = xs.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) := List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < E)) (a := x) (by simp [hxE]) have hFa_neg : (x :: xs).filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) = xs.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) := List.filter_cons_of_neg (p := fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) (a := x) (by simp [hnot_a]) have hG_neg : (x :: xs).filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) = xs.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) := List.filter_cons_of_neg (p := fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) (a := x) (by simp [hxE]) rw [hFE_neg, hFa_neg, hG_neg, hih] /-- A nonpositive-offset selector whose resolution lands at a key `q ≥ a` resolves the same against databases agreeing on the stored keys in `[a, E)`. -/ theorem resolve_eq_of_agree_between {db₁ db₂ : DB} {s : Selector} (hoff : s.offset ≤ 0) {a : Key} {E : WithTop Key} (hskey : s.key = E) (haE : (a : WithTop Key) ≤ E) (hagree : db₁.keys.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) = db₂.keys.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E))) {q : Key} (hq : (db₁.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < s.key))).reverse[ (-s.offset).toNat]? = some q) (hqa : (a : WithTop Key) ≤ ((q : Key) : WithTop Key)) : resolve db₂ s = ((q : Key) : WithTop Key) := by set m := (-s.offset).toNat with hm set A₁ := db₁.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) with hA₁ set B₁ := db₁.keys.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) with hB₁ set F₁ := db₁.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) with hF₁ have hsplit₁ : F₁ = A₁ ++ B₁ := by rw [hF₁, hA₁, hB₁] exact filter_lt_eq_filter_lt_append_between db₁.sorted haE rw [hskey] at hq rw [← hF₁] at hq have hrev₁ : F₁.reverse = B₁.reverse ++ A₁.reverse := by rw [hsplit₁, List.reverse_append] have hm_lt : m < B₁.length := by by_contra hcon have hmge : B₁.length ≤ m := le_of_not_gt hcon have hright : F₁.reverse[m]? = A₁.reverse[m - B₁.length]? := by rw [hrev₁, List.getElem?_append_right (l₁ := B₁.reverse) (l₂ := A₁.reverse) (i := m) (by rwa [List.length_reverse]), List.length_reverse] rw [hright] at hq cases hxA : A₁.reverse[m - B₁.length]? with | none => rw [hxA] at hq; exact absurd hq (by simp) | some x => rw [hxA] at hq have hxmemA : x ∈ A₁ := List.mem_reverse.mp (List.mem_of_getElem? hxA) have hxa : (x : WithTop Key) < (a : WithTop Key) := of_decide_eq_true (List.mem_filter.mp hxmemA).2 have hxq : x = q := by injection hq rw [hxq] at hxa exact absurd hqa (not_le.mpr hxa) have hBq : B₁.reverse[m]? = some q := by have hleft : F₁.reverse[m]? = B₁.reverse[m]? := by rw [hrev₁] exact List.getElem?_append_left (l₁ := B₁.reverse) (l₂ := A₁.reverse) (i := m) (by rwa [List.length_reverse]) rwa [hleft] at hq set A₂ := db₂.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (a : WithTop Key))) with hA₂ set B₂ := db₂.keys.filter (fun k : Key => decide ((a : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < E)) with hB₂ set F₂ := db₂.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < E)) with hF₂ have hB₂_eq : B₂ = B₁ := by rw [hB₂, hB₁]; exact hagree.symm have hsplit₂ : F₂ = A₂ ++ B₂ := by rw [hF₂, hA₂, hB₂] exact filter_lt_eq_filter_lt_append_between db₂.sorted haE have hFq : F₂.reverse[m]? = some q := by have hrev₂ : F₂.reverse = B₂.reverse ++ A₂.reverse := by rw [hsplit₂, List.reverse_append] rw [hrev₂] rw [List.getElem?_append_left (l₁ := B₂.reverse) (l₂ := A₂.reverse) (i := m) (by rw [List.length_reverse, hB₂_eq]; exact hm_lt)] rw [hB₂_eq] exact hBq rw [resolve_eq_filter_lt_reverse (db := db₂) (s := s) hoff, hskey, ← hF₂, ← hm, hFq] /-- A resolution at a nonpositive offset that is a genuine key is the entry at the corresponding index of the reversed filter of keys below the selector key. -/ theorem resolve_filter_reverse_eq_some_of_ne_nil {db : DB} {s : Selector} (hoff : s.offset ≤ 0) {q : Key} (hqne : q ≠ []) (hq : resolve db s = ((q : Key) : WithTop Key)) : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[ (-s.offset).toNat]? = some q := by rw [resolve_eq_filter_lt_reverse (db := db) (s := s) hoff] at hq cases h : (db.keys.filter (fun (k : Key) => decide ((↑k : WithTop Key) < s.key))).reverse[ (-s.offset).toNat]? with | none => rw [h] at hq exact absurd (WithTop.coe_inj.mp hq).symm hqne | some k => rw [h] at hq have hk : k = q := WithTop.coe_inj.mp hq rw [hk] /-- At a nonpositive offset the resolution is never the sentinel `⊤`. -/ theorem resolve_ne_top_of_offset_nonpos {db : DB} {s : Selector} (hoff : s.offset ≤ 0) : resolve db s ≠ (⊤ : WithTop Key) := by intro htop by_cases hneg : s.anchor db < 0 · rw [resolve_eq_ite, ite_eq_left hneg] at htop exact absurd htop (by simp) · rw [resolve_eq_ite, ite_eq_right hneg] at htop have h0 : 0 ≤ s.anchor db := le_of_not_gt hneg have hanc : s.anchor db ≤ (db.keys.length : ℤ) - 1 := by unfold Selector.anchor have hc : (db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < s.key)) : ℤ) ≤ (db.keys.length : ℤ) := by exact_mod_cast List.countP_le_length omega have hlt : (s.anchor db).toNat < db.keys.length := by have hlt' : ((s.anchor db).toNat : ℤ) < (db.keys.length : ℤ) := by rw [Int.toNat_of_nonneg h0]; omega exact_mod_cast hlt' split at htop · exact absurd htop (by simp) · rename_i hnone rw [List.getElem?_eq_getElem hlt] at hnone exact absurd hnone (by simp) /-- **The crossed nonpositive-begin complete under-end at `begin.offset = 0` with a nonpositive end offset.** A forward complete result at `begin.offset = 0` whose `begin.key` lies strictly above the reported head, with `end.offset ≤ 0`, has the range from the reported head up to `end_.key`, `[head, end_.key)`, as its minimal sound conflict range. -/ theorem minimal_headToEnd_of_zero_begin_crossed_endNonpos {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hend : r.end_.offset ≤ 0) : Minimal r res ⟨((res.keys.head hne : Key) : WithTop Key), r.end_.key⟩ := by obtain ⟨db₀, hcomp₀⟩ := hread have hreadable : Readable r res := ⟨db₀, hcomp₀⟩ have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩ · intro db₁ db₂ hagree have step : ∀ db db', AgreeOn ⟨((res.keys.head hne : Key) : WithTop Key), r.end_.key⟩ db db' → RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by intro db db' hag' hcomp_db have hlim : RangeRead.withinLimit r res.keys := hcomp_db.1 have hres_eq : res.keys = RangeRead.completeKeys db r := by rcases hcomp_db.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩ · simp [hmore] at hm · exact heq have hhead_stored : res.keys.head hne ∈ db.keys := RangeRead.compatible_keys_subset hcomp_db hhead_mem have hhead_ck := RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hhead_mem) have hhead_lt_res : ((res.keys.head hne : Key) : WithTop Key) < resolve db r.end_ := hhead_ck.2.2 have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact hhead_ck.2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross (res.keys.head hne) hhead_stored hcross have hres_le_E : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend have hhead_lt_E : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key := lt_of_lt_of_le hhead_lt_res hres_le_E have hB_le_E : r.begin.key ≤ r.end_.key := by by_contra hcon have hEB : r.end_.key < r.begin.key := lt_of_not_ge hcon rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hn | ht | ⟨k, hkdb, hkres⟩ · rw [hn] at hhead_lt_res exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le _)) · exact absurd ht (resolve_ne_top_of_offset_nonpos hend) · have hk_lt_B : (k : WithTop Key) < r.begin.key := lt_of_le_of_lt (by rw [← hkres]; exact hres_le_E) hEB have hk_le_head : (k : WithTop Key) ≤ ((res.keys.head hne : Key) : WithTop Key) := by have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k hkdb hk_lt_B rwa [hL] at hb have hhead_lt_k : ((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) := by rw [← hkres]; exact hhead_lt_res exact absurd hk_le_head (not_le.mpr hhead_lt_k) have hno : ∀ k ∈ db.keys, ((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) → (k : WithTop Key) < r.begin.key → False := by intro k hk hheadk hkB have hb := resolve_zero_begin_le_of_mem_below (db := db) hbegin hhead_stored hcross k hk hkB rw [hL] at hb exact absurd hb (not_le.mpr hheadk) have hfilt : db.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key)) = db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key)) := by simpa [AgreeOn, ConflictRange.keys] using hag' have hhead_in_filt : res.keys.head hne ∈ db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key)) := by rw [← hfilt] exact List.mem_filter.mpr ⟨hhead_stored, by rw [decide_eq_true_eq]; exact ⟨le_refl _, hhead_lt_E⟩⟩ have hhead_stored' : res.keys.head hne ∈ db'.keys := List.mem_of_mem_filter hhead_in_filt have hno' : ∀ k ∈ db'.keys, ((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) → (k : WithTop Key) < r.begin.key → False := by intro k hk' hheadk hkB have hk_in : k ∈ db'.keys.filter (fun k : Key => decide (((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key)) := List.mem_filter.mpr ⟨hk', by rw [decide_eq_true_eq] exact ⟨le_of_lt hheadk, lt_of_lt_of_le hkB hB_le_E⟩⟩ rw [← hfilt] at hk_in exact hno k (List.mem_of_mem_filter hk_in) hheadk hkB have hL' : resolve db' r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · rcases resolve_eq_nil_or_eq_top_or_mem (db := db') (s := r.begin) with hn | ht | ⟨k, hkdb', hkres⟩ · rw [hn]; exact coe_nil_le _ · exact absurd ht (resolve_ne_top_of_offset_nonpos (by rw [hbegin])) · rw [hkres] by_contra hnot have hheadk : ((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) := lt_of_not_ge hnot have hk_lt_B : (k : WithTop Key) < r.begin.key := by have hb := resolve_zero_begin_lt_key (db := db') hbegin hhead_stored' hcross rwa [hkres] at hb exact absurd (hno' k hkdb' hheadk hk_lt_B) (by simp) · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored' hcross (res.keys.head hne) hhead_stored' hcross rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hn | ht | ⟨q, hqdb, hqeq⟩ · rw [hn] at hhead_lt_res exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le _)) · exact absurd ht (resolve_ne_top_of_offset_nonpos hend) · have hqne : q ≠ [] := by intro hqnil rw [hqnil] at hqeq rw [hqeq] at hhead_lt_res exact absurd hhead_lt_res (not_lt.mpr (coe_nil_le _)) have hqspec : (db.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < r.end_.key))).reverse[ (-r.end_.offset).toNat]? = some q := resolve_filter_reverse_eq_some_of_ne_nil hend hqne hqeq have hqa : ((res.keys.head hne : Key) : WithTop Key) ≤ ((q : Key) : WithTop Key) := by rw [← hqeq]; exact le_of_lt hhead_lt_res have hR' : resolve db' r.end_ = ((q : Key) : WithTop Key) := resolve_eq_of_agree_between (db₁ := db) (db₂ := db') (s := r.end_) hend rfl (le_of_lt hhead_lt_E) hfilt hqspec hqa have hR : resolve db' r.end_ = resolve db r.end_ := by rw [hR', hqeq] have hmemE : ∀ k : Key, (k ∈ db.keys ∧ ((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key) ↔ (k ∈ db'.keys ∧ ((res.keys.head hne : Key) : WithTop Key) ≤ (↑k : WithTop Key) ∧ (↑k : WithTop Key) < r.end_.key) := by intro k have h := congrArg (fun l : List Key => k ∈ l) hfilt simp only [List.mem_filter, decide_eq_true_eq] at h exact Iff.of_eq h have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db' r := by unfold RangeRead.completeKeys rw [ite_eq_right (by simp [hrev]), ite_eq_right (by simp [hrev])] unfold RangeRead.inRange rw [hL, hL', hR] apply eq_of_forall_mem_iff_of_pairwise · exact db.sorted.pairwise.filter _ · exact db'.sorted.pairwise.filter _ · intro k simp only [List.mem_filter, decide_eq_true_eq] constructor · rintro ⟨hk, h1, h2⟩ exact ⟨((hmemE k).mp ⟨hk, h1, lt_of_lt_of_le h2 hres_le_E⟩).1, h1, h2⟩ · rintro ⟨hk, h1, h2⟩ exact ⟨((hmemE k).mpr ⟨hk, h1, lt_of_lt_of_le h2 hres_le_E⟩).1, h1, h2⟩ exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩ exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩ · intro k hlo hhi have hk_le : res.keys.head hne ≤ k := WithTop.coe_le_coe.mp hlo by_cases hklast : k ≤ res.keys.getLast hne · exact necessary_of_between_result hreadable (List.head_mem hne) (List.getLast_mem hne) hk_le hklast · exact fun cr hs => necessary_last_to_end_key hreadable hrev hmore hne (by omega) cr hs (le_of_lt (lt_of_not_ge hklast)) hhi /-! ### Reducing a crossed complete read at begin offset zero to offset one When the begin offset is zero and the begin key lies strictly above the reported head, the begin selector resolves onto the head. If in addition the begin key is at or below `end_.key`, every reported key lies below the begin key, so a database can only store a key strictly between the head and the begin key if the end window reaches it; that key would then be reported. Consequently the crossed read has exactly the same compatible databases as the read whose begin selector is moved to offset one on the reported head. This lets the offset-one closed form answer the cell. -/ /-- At offset one keyed at a stored key, the selector resolves to that key. -/ theorem resolve_offset_one_key_of_mem {db : DB} {k : Key} (hk : k ∈ db.keys) : resolve db ({ key := ((k : Key) : WithTop Key), offset := 1 } : Selector) = ((k : Key) : WithTop Key) := by apply le_antisymm · exact (key_le_resolve_iff_of_offset_one (db := db) (s := ({ key := ((k : Key) : WithTop Key), offset := 1 } : Selector)) rfl hk).mp (le_refl _) · exact key_le_resolve_of_one_le (db := db) (s := ({ key := ((k : Key) : WithTop Key), offset := 1 } : Selector)) (by norm_num : (1 : ℤ) ≤ 1) /-- `headD` agrees with `head` on a nonempty list. -/ theorem headD_eq_head_sound {l : List Key} (h : l ≠ []) : l.headD ([] : Key) = l.head h := by cases l with | nil => exact absurd rfl h | cons a t => rfl /-- The offset-one read anchored at the least reported key. -/ def zeroBeginAnchor (r : RangeRead) (res : Result) : RangeRead := { r with begin := { key := ((res.keys.headD ([] : Key) : Key) : WithTop Key), offset := 1 } } /-- **Reduction of the crossed complete begin-zero read.** For a nonempty complete forward result at `begin.offset = 0` with `head < begin.key ≤ end.key` and a positive end offset, the compatible databases are exactly those of `zeroBeginAnchor`, whose begin selector is at offset one on the reported head. -/ theorem compatible_zero_crossed_iff_anchor {r : RangeRead} {res : Result} (hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ []) (hbegin : r.begin.offset = 0) (hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) (hBE : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset) : ∀ db : DB, RangeRead.Compatible db r res ↔ RangeRead.Compatible db (zeroBeginAnchor r res) res := by obtain ⟨db₀, hcomp₀⟩ := hread have hhead_mem₀ : res.keys.head hne ∈ res.keys := List.head_mem hne have hres₀ : res.keys = RangeRead.completeKeys db₀ r := by rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hhead_stored₀ : res.keys.head hne ∈ db₀.keys := (RangeRead.mem_completeKeys.mp (by rw [← hres₀]; exact hhead_mem₀)).1 have hL₀ : resolve db₀ r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact (RangeRead.mem_completeKeys.mp (by rw [← hres₀]; exact hhead_mem₀)).2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored₀ hcross (res.keys.head hne) hhead_stored₀ hcross have hno₀ : ∀ k ∈ db₀.keys, ¬ (((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key) := by intro k hk hkb have h := resolve_zero_begin_le_of_mem_below hbegin hhead_stored₀ hcross k hk hkb.2 rw [hL₀] at h exact absurd h (not_le.mpr hkb.1) have hres_avoid : ∀ k ∈ res.keys, ¬ (((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key) := by intro k hk hkb have hk₀ : k ∈ RangeRead.completeKeys db₀ r := by rw [← hres₀]; exact hk exact hno₀ k (RangeRead.mem_completeKeys.mp hk₀).1 hkb have hanchor_key : (zeroBeginAnchor r res).begin.key = ((res.keys.head hne : Key) : WithTop Key) := by unfold zeroBeginAnchor simp only rw [headD_eq_head_sound hne] have hanchor_begin : (zeroBeginAnchor r res).begin = ({ key := ((res.keys.head hne : Key) : WithTop Key), offset := 1 } : Selector) := by unfold zeroBeginAnchor simp only rw [headD_eq_head_sound hne] have hE_resolve : r.end_.key ≤ resolve db₀ r.end_ := key_le_resolve_of_one_le (db := db₀) (s := r.end_) hend intro db constructor · intro hcomp have hres : res.keys = RangeRead.completeKeys db r := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne have hhead_stored : res.keys.head hne ∈ db.keys := (RangeRead.mem_completeKeys.mp (by rw [← hres]; exact hhead_mem)).1 have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · exact (RangeRead.mem_completeKeys.mp (by rw [← hres]; exact hhead_mem)).2.1 · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross (res.keys.head hne) hhead_stored hcross have hL' : resolve db (zeroBeginAnchor r res).begin = ((res.keys.head hne : Key) : WithTop Key) := by rw [hanchor_begin] exact resolve_offset_one_key_of_mem hhead_stored refine ⟨?_, ?_⟩ · simpa [RangeRead.withinLimit, zeroBeginAnchor] using hcomp.1 · right refine ⟨hmore, ?_⟩ have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db (zeroBeginAnchor r res) := by unfold RangeRead.completeKeys RangeRead.inRange zeroBeginAnchor rw [hrev] simp only [Bool.false_eq_true, ite_false] rw [hL] congr 1 funext k change decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_) = decide (resolve db (zeroBeginAnchor r res).begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_) rw [hL'] rw [← hck] exact hres · intro hcomp have hres : res.keys = RangeRead.completeKeys db (zeroBeginAnchor r res) := by rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩ · simp [hmore] at hm · exact heq have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne have hhead_stored : res.keys.head hne ∈ db.keys := (RangeRead.mem_completeKeys.mp (by rw [← hres]; exact hhead_mem)).1 have hL' : resolve db (zeroBeginAnchor r res).begin = ((res.keys.head hne : Key) : WithTop Key) := by rw [hanchor_begin] exact resolve_offset_one_key_of_mem hhead_stored have hE_resolve' : r.end_.key ≤ resolve db (zeroBeginAnchor r res).end_ := by simpa [zeroBeginAnchor] using key_le_resolve_of_one_le (db := db) (s := r.end_) hend have hno : ∀ k ∈ db.keys, ¬ (((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) ∧ (k : WithTop Key) < r.begin.key) := by intro k hk hkb have hkck : k ∈ RangeRead.completeKeys db (zeroBeginAnchor r res) := by refine RangeRead.mem_completeKeys.mpr ⟨hk, ?_, ?_⟩ · rw [hL'] exact le_of_lt hkb.1 · exact lt_of_lt_of_le hkb.2 (le_trans hBE hE_resolve') rw [← hres] at hkck exact hres_avoid k hkck hkb have hL : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by apply le_antisymm · rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with hn | ht | ⟨q, hq, hqeq⟩ · rw [hn] exact coe_nil_le _ · exact absurd ht (resolve_ne_top_of_offset_nonpos (by rw [hbegin])) · rw [hqeq] by_contra hcon have hqgt : ((res.keys.head hne : Key) : WithTop Key) < (q : WithTop Key) := lt_of_not_ge hcon have hqB : (q : WithTop Key) < r.begin.key := by have hlt := resolve_zero_begin_lt_key (db := db) hbegin hhead_stored hcross rwa [hqeq] at hlt exact absurd ⟨hqgt, hqB⟩ (hno q hq) · exact resolve_zero_begin_le_of_mem_below hbegin hhead_stored hcross (res.keys.head hne) hhead_stored hcross refine ⟨?_, ?_⟩ · simpa [RangeRead.withinLimit, zeroBeginAnchor] using hcomp.1 · right refine ⟨hmore, ?_⟩ have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db (zeroBeginAnchor r res) := by unfold RangeRead.completeKeys RangeRead.inRange zeroBeginAnchor rw [hrev] simp only [Bool.false_eq_true, ite_false] rw [hL] congr 1 funext k change decide (((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_) = decide (resolve db (zeroBeginAnchor r res).begin ≤ (k : WithTop Key) ∧ (k : WithTop Key) < resolve db r.end_) rw [hL'] rw [hck] exact hres end FormalConflictRange