Files
conflict-range/FormalConflictRange/NonposClosedForm.lean
T
andrew bd5b3c885c Upgrade to Lean 4.35 and add comparator check
- Move to lean-toolchain v4.35.0 and mathlib v4.35.0
- Opt out of the module-system warning with `allowNonModules`
- Adapt to Lean/Mathlib 4.35 changes: drop now-redundant
  `List.filter_congr` blocks and no-op `ring` calls
- Add `Challenge.lean`, `Solution.lean`, and `comparator.json`

`lake comparator` now accepts the solution against the trusted challenge.
2026-11-17 10:28:15 -05:00

1428 lines
72 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: FormalConflictRange contributors
-/
import FormalConflictRange.Residual
import FormalConflictRange.Nonpos
/-!
# The cross-free nonpositive-begin complete closed form
At a nonpositive begin offset the resolved begin can clamp below `begin.key`, so the
empty key can be forced into every sound range. This module closes the cross-free
complete-result cell there: `begin.offset ≤ 0`, `begin.key ≤` the reported head,
`begin.key ≤ end_.key`, and a nonempty complete result. Writing `t` for the number of
reported keys at or above `end_.key` and `e = end_.offset - 1`, the minimal range is
* `[⊥, end_.key)` when `end_.offset ≤ 1`;
* `[⊥, keyAfter (last reported))` when `t = e` (the finite branch);
* `[⊥, ⊤)` when `t < e` (the top branch).
The finite branch fixes the complete keys below `keyAfter (last reported)`; the top
branch forces the end selector to resolve to `⊤`, and inserting a key above the reported
last then keeps that sentinel and adds the key to the complete window.
-/
open FormalConflictRange
namespace FormalConflictRange
/-- The empty key is at or below every `WithTop Key` bound. -/
theorem coe_nil_le_key_withTop (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)
/-- At a nonpositive offset, a resolution that is not the empty key lies strictly
below the selector's own key. -/
theorem resolve_lt_key_of_offset_nonpos_of_ne_nil {db : DB} {s : Selector}
(hoff : s.offset ≤ 0) (hne : resolve db s ≠ (([] : Key) : WithTop Key)) :
resolve db s < s.key := by
rcases lt_or_ge (s.anchor db) 0 with hneg | hpos
· rw [resolve_eq_nil hneg] at hne
exact absurd rfl hne
· 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 getElem_lt_of_lt_countP_top db.sorted hlt hcnt
/-- In a complete nonempty result at a nonpositive begin offset with `begin.key` at
or below the reported head, the begin selector clamps to the empty key. -/
theorem resolve_eq_nil_of_complete_begin_le_head {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) :
resolve db r.begin = (([] : Key) : WithTop Key) := by
have hres_eq : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
set head : Key := res.keys.head hne with hhead
have hhead_ck : head ∈ RangeRead.completeKeys db r := by
rw [← hres_eq]; exact List.head_mem hne
have hhead_lo : resolve db r.begin ≤ (head : WithTop Key) :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.1
have hhead_hi : (head : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.2
by_contra hne0
have hlt : resolve db r.begin < r.begin.key :=
resolve_lt_key_of_offset_nonpos_of_ne_nil hbegin hne0
have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
intro ht
rw [ht] at hhead_lo
exact absurd hhead_lo (not_le.mpr (WithTop.coe_lt_top head))
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.begin) with h | h | ⟨k, hkdb, hkres⟩
· exact hne0 h
· exact hnot_top h
· have hk_le : (k : WithTop Key) ≤ (head : WithTop Key) := by
rw [← hkres]; exact hhead_lo
have hk_lt_end : (k : WithTop Key) < resolve db r.end_ := lt_of_le_of_lt hk_le hhead_hi
have hk_ck : k ∈ RangeRead.completeKeys db r :=
RangeRead.mem_completeKeys.mpr ⟨hkdb, by rw [hkres], hk_lt_end⟩
have hk_res : k ∈ res.keys := by rw [hres_eq]; exact hk_ck
have hhead_le_k : head ≤ k :=
(RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hk_res
have hhead_le_res : (head : WithTop Key) ≤ resolve db r.begin := by
rw [hkres]; exact WithTop.coe_le_coe.mpr hhead_le_k
have hkeq : resolve db r.begin = (head : WithTop Key) :=
le_antisymm hhead_lo hhead_le_res
rw [hkeq] at hlt
exact absurd hlo (not_le.mpr hlt)
/-- For a compatible *complete* result, the complete keys are exactly the stored keys
in `[resolve begin, last reported]`. -/
theorem completeKeys_eq_filter_le_last {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ []) :
RangeRead.completeKeys db r =
db.keys.filter (fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧
k ≤ res.keys.getLast hne)) := by
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hlast : res.keys.getLast hne ∈ RangeRead.completeKeys db r := by
rw [← hres]; exact List.getLast_mem hne
have hlt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp hlast).2.2
have hf := completeKeys_filter_le_eq (db := db) (r := r)
(last := res.keys.getLast hne) hrev hlt
have hpair : (RangeRead.completeKeys db r).Pairwise (· < ·) := by
have h := RangeRead.completeKeys_pairwise (db := db) (r := r)
rw [hrev] at h
exact h
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp
have hfiltr : (RangeRead.completeKeys db r).filter
(fun k : Key => decide (k ≤ res.keys.getLast hne)) = RangeRead.completeKeys db r := by
have h := filter_le_getLast_eq_of_prefix hpair hpre hne
exact h.trans hres
rw [← hf, hfiltr]
/-- The complete keys at or above `end_.key` are the stored keys at or above
`end_.key` and at or below the reported last, in a complete cross-free nonpositive
read. -/
theorem completeKeys_filter_ge_eq_db_filter {db : DB} {r : RangeRead} {res : Result}
{last : Key} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ [])
(hlast : last = res.keys.getLast hne)
(_hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) :
(RangeRead.completeKeys db r).filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) := by
have hmain := completeKeys_eq_filter_le_last (db := db) (r := r) (res := res)
hcomp hrev hmore hne
rw [hmain, ← hlast]
rw [List.filter_filter, List.filter_filter]
apply List.filter_congr
intro k _
rw [← Bool.decide_and, ← Bool.decide_and, decide_eq_decide]
constructor
· rintro ⟨hE, hs, hl⟩
exact ⟨hl, hE⟩
· rintro ⟨hl, hE⟩
exact ⟨hE, le_trans hstart hE, hl⟩
/-- The number of reported keys at or above `end_.key` is the length of the stored
keys in `[end_.key, last]`, in a complete cross-free nonpositive read. -/
theorem residualT_eq_filter_length {db : DB} {r : RangeRead} {res : Result}
{last : Key} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ [])
(hlast : last = res.keys.getLast hne)
(hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key) :
residualT r res =
((db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length := by
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hc := completeKeys_filter_ge_eq_db_filter (db := db) (r := r) (res := res)
(last := last) hcomp hrev hmore hne hlast hbegin hstart
unfold residualT
rw [List.countP_eq_length_filter, hres, hc]
/-- The reported over-count never exceeds the end offset, in a complete cross-free
nonpositive read with `end_.offset ≥ 2`. -/
theorem residualT_le_residualE_nonpos {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset) :
residualT r res ≤ residualE r := by
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hlast : res.keys.getLast hne ∈ RangeRead.completeKeys db r := by
rw [← hres]; exact List.getLast_mem hne
have hlt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp hlast).2.2
have h := filter_length_le_offset_of_resolve_end_gt (db := db) (r := r)
(last := res.keys.getLast hne) (by omega) hlt
rw [residualT_eq_filter_length hcomp hrev hmore hne rfl hbegin hstart]
simpa [residualE] using h
/-- A stronger Boolean filter is strictly shorter when it misses a member of the
weaker filter. -/
theorem length_filter_lt_of_mem_not {L : List Key} {p q : Key → Bool}
(himp : ∀ a, p a = true → q a = true) {x : Key}
(hxq : x ∈ L.filter q) (hxp : x ∉ L.filter p) :
(L.filter p).length < (L.filter q).length := by
have hsub := filter_sublist_filter_of_imp (l := L) himp
rcases lt_or_eq_of_le hsub.length_le with h | h
· exact h
· exfalso
have heq := hsub.eq_of_length h
rw [← heq] at hxq
exact hxp hxq
end FormalConflictRange
/-- **Finite-branch completeness from agreement (nonpositive cross-free complete).**
If a database agrees on the bottom truncated range with a compatible finite-branch
database, then it is itself complete. -/
theorem completeKeys_eq_res_of_agree_nonpos_complete {db₁ db₂ : DB} {r : RangeRead}
{res : Result} {last : Key}
(hcomp : RangeRead.Compatible db₁ r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
(hstart : resolve db₁ r.begin ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset) (hlast : last = res.keys.getLast hne)
(hte : residualT r res = residualE r)
(hT : (truncatedRangeBottom last).keys db₁ = (truncatedRangeBottom last).keys db₂) :
RangeRead.completeKeys db₂ r = res.keys := by
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 he1 : 0 < residualE r := by unfold residualE; omega
have htpos : 0 < residualT r res := by rw [hte]; exact he1
have hElast : r.end_.key ≤ (last : WithTop Key) := by
rw [hlast]
exact last_ge_end_of_count_pos hsort hne htpos
-- Agreement on `[⊥, keyAfter last)` is equality of the keys at or below `last`.
have hbE : db₁.keys.filter
(fun k : Key => decide ((k : WithTop Key) <
(keyAfter last : WithTop Key))) =
db₂.keys.filter
(fun k : Key => decide ((k : WithTop Key) <
(keyAfter last : WithTop Key))) := by
have h : (truncatedRangeBottom last).keys db₁ =
(truncatedRangeBottom last).keys db₂ := hT
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 ≤ last)) =
db₂.keys.filter (fun k : Key => decide (k ≤ last)) := by
have hc : ∀ db : DB, db.keys.filter
(fun k : Key => decide ((k : WithTop Key) <
(keyAfter last : WithTop Key))) =
db.keys.filter (fun k : Key => decide (k ≤ last)) := 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
have hhead_le_last : res.keys.head hne ≤ last := by
rw [hlast]
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)
have hkey_ka : r.begin.key ≤ (keyAfter last : WithTop Key) :=
le_trans (le_trans hlo (WithTop.coe_le_coe.mpr hhead_le_last))
(WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt last)))
have hbegineq : resolve db₂ r.begin = resolve db₁ r.begin := by
symm
exact resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) hbegin hkey_ka hbE
-- The reference count is `e`.
have hM₁len : ((db₁.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length = residualE r := by
have h := residualT_eq_filter_length (db := db₁) (r := r) (res := res)
(last := last) hcomp hrev hmore hne hlast hbegin hstart
rw [← h]
exact hte
have hM₂ : ((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
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₂, hEk⟩, hkl⟩
have hmem : k ∈ db₁.keys.filter (fun k : Key => decide (k ≤ last)) := by
rw [hb]
exact List.mem_filter.mpr ⟨hk₂, decide_eq_true hkl⟩
exact ⟨⟨(List.mem_filter.mp hmem).1, hEk⟩, hkl⟩
· rintro ⟨⟨hk₁, hEk⟩, hkl⟩
have hmem : k ∈ db₂.keys.filter (fun k : Key => decide (k ≤ last)) := by
rw [← hb]
exact List.mem_filter.mpr ⟨hk₁, decide_eq_true hkl⟩
exact ⟨⟨(List.mem_filter.mp hmem).1, hEk⟩, hkl⟩
have hM₂len : ((db₂.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length = residualE r := by
rw [hM₂, hM₁len]
have hlt₂ : (last : WithTop Key) < resolve db₂ r.end_ :=
resolve_end_gt_of_filter_length_le (db := db₂) (r := r) (last := last)
(by omega) (le_of_eq hM₂len)
-- The complete keys of `db₂` are the stored keys in `[start, last]`.
have hck₂ : RangeRead.completeKeys db₂ r =
db₂.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
k ≤ last)) := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [hrev]
rw [hbegineq]
apply List.filter_congr
intro k hk
rw [decide_eq_decide]
constructor
· rintro ⟨hs, hkt⟩
refine ⟨hs, ?_⟩
by_contra hnk
have hklast : last < k := lt_of_not_ge hnk
have hEk : r.end_.key ≤ (k : WithTop Key) :=
le_trans hElast (WithTop.coe_le_coe.mpr (le_of_lt hklast))
have hkL : k ∈ (db₂.keys.filter
(fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ k)) := by
rw [List.mem_filter, List.mem_filter]
exact ⟨⟨hk, decide_eq_true hEk⟩, decide_eq_true le_rfl⟩
have hknot : k ∉ (db₂.keys.filter
(fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last)) := by
rw [List.mem_filter, List.mem_filter]
rintro ⟨⟨-, -⟩, hle⟩
rw [decide_eq_true_eq] at hle
exact absurd hle (not_le.mpr hklast)
have himp : ∀ a : Key, decide (a ≤ last) = true → decide (a ≤ k) = true := by
intro a ha
rw [decide_eq_true_eq] at ha ⊢
exact le_trans ha (le_of_lt hklast)
have hstrict := length_filter_lt_of_mem_not
(L := db₂.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key))))
(p := fun x : Key => decide (x ≤ last)) (q := fun x : Key => decide (x ≤ k))
himp hkL hknot
have hbound := filter_length_le_offset_of_resolve_end_gt (db := db₂) (r := r)
(last := k) (by omega) hkt
unfold residualE at hM₂len
omega
· rintro ⟨hs, hkl⟩
exact ⟨hs, lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkl) hlt₂⟩
-- Agreement on `[start, last]` is exactly the reported keys.
have hfilter_eq : db₂.keys.filter
(fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧ 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
· exact db₂.sorted.pairwise.sublist List.filter_sublist
· exact db₁.sorted.pairwise.sublist List.filter_sublist
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk₂, hs, hl⟩
have hmem : k ∈ db₁.keys.filter (fun k : Key => decide (k ≤ last)) := by
rw [hb]
exact List.mem_filter.mpr ⟨hk₂, decide_eq_true hl⟩
exact ⟨(List.mem_filter.mp hmem).1, hs, hl⟩
· rintro ⟨hk₁, hs, hl⟩
have hmem : k ∈ db₂.keys.filter (fun k : Key => decide (k ≤ last)) := by
rw [← hb]
exact List.mem_filter.mpr ⟨hk₁, decide_eq_true hl⟩
exact ⟨(List.mem_filter.mp hmem).1, hs, hl⟩
have hck₁ : RangeRead.completeKeys db₁ r =
db₁.keys.filter (fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
k ≤ last)) := by
have h := completeKeys_eq_filter_le_last (db := db₁) (r := r) (res := res)
hcomp hrev hmore hne
rwa [← hlast] at h
rw [hck₂, hfilter_eq, ← hck₁, ← hres]
/-- **A finite end resolution fills the reported count.** In a complete cross-free
nonpositive read with `end.offset ≥ 2`, if the end selector resolves to a genuine key,
then the number of reported keys at or above `end_.key` is exactly `end.offset - 1`. -/
theorem residualT_eq_residualE_of_resolve_end_ne_top {db : DB} {r : RangeRead}
{res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (_hne : res.keys ≠ [])
(_hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(htop : resolve db r.end_ ≠ (⊤ : WithTop Key)) :
residualT r res = residualE r := by
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
set Q := db.keys.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 hend1 : 1 ≤ r.end_.offset := by omega
have hQres := resolve_eq_filter_getElem? (db := db) (s := r.end_) hend1
have heQ : e < Q.length := by
by_contra hge
rw [List.getElem?_eq_none (le_of_not_gt hge)] at hQres
exact htop hQres
have htopq : resolve db r.end_ = ((Q[e] : Key) : WithTop Key) := by
rw [hQres, List.getElem?_eq_getElem heQ]
have hloE : resolve db r.begin ≤ r.end_.key := hstart
-- The reported keys at or above `end_.key` are the first `e` stored keys there.
have hck : (RangeRead.completeKeys db r).filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev])]
rw [hQ]
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, hlo, hhi⟩, hE⟩
exact ⟨⟨hk, hE⟩, hhi⟩
· rintro ⟨⟨hk, hE⟩, hhi⟩
exact ⟨⟨hk, le_trans hloE hE, hhi⟩, hE⟩
have htake : Q.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) =
Q.take e := by
rw [htopq, filter_lt_eq_take_countP hQs ((Q[e] : Key) : WithTop Key)]
congr 1
rw [show Q.countP (fun k : Key => decide ((k : WithTop Key) < ((Q[e] : Key) : 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 heQ rfl
unfold residualT residualE
rw [hres, List.countP_eq_length_filter, hck, htake, List.length_take,
Nat.min_eq_left (le_of_lt heQ)]
/-- **The top branch forces an unbounded end.** In a complete cross-free nonpositive
read with `end.offset ≥ 2`, if the reported count at or above `end_.key` is below
`end.offset - 1`, then the end selector resolves to `⊤`. -/
theorem resolve_end_eq_top_of_residualT_lt_residualE {db : DB} {r : RangeRead}
{res : Result} (hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0) (hstart : resolve db r.begin ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(htlt : residualT r res < residualE r) :
resolve db r.end_ = (⊤ : WithTop Key) := by
by_contra htop
have h := residualT_eq_residualE_of_resolve_end_ne_top hcomp hrev hmore hne hbegin
hstart hend htop
omega
/-- **Finite-branch soundness (nonpositive cross-free complete).** Agreement on the bottom
truncated range fixes the complete keys, so a complete result stays complete. -/
theorem sound_truncatedRangeBottom_of_nonpos_complete {r : RangeRead} {res : Result} {last : Key}
(hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
(hend : 2 ≤ r.end_.offset) (hlast : last = res.keys.getLast hne)
(hte : residualT r res = residualE r) :
Sound r res (truncatedRangeBottom last) := by
intro db₁ db₂ hagree
have hiff : ∀ db : DB, RangeRead.Compatible db r res ↔
RangeRead.withinLimit r res.keys ∧ res.keys = RangeRead.completeKeys db r := by
intro db
constructor
· rintro ⟨hlim, hm | ⟨-, heq⟩⟩
· simp [hmore] at hm
· exact ⟨hlim, heq⟩
· rintro ⟨hlim, hck⟩
exact ⟨hlim, Or.inr ⟨hmore, hck⟩⟩
rw [hiff db₁, hiff db₂]
constructor
· rintro ⟨hlim, hck₁⟩
have hcomp₁ : RangeRead.Compatible db₁ r res := (hiff db₁).mpr ⟨hlim, hck₁⟩
have hstart₁ : resolve db₁ r.begin ≤ r.end_.key := by
rw [resolve_eq_nil_of_complete_begin_le_head hcomp₁ hrev hmore hne hbegin hlo]
exact coe_nil_le_key_withTop r.end_.key
exact ⟨hlim, (completeKeys_eq_res_of_agree_nonpos_complete hcomp₁ hrev hmore hne hbegin
hlo hstart₁ hend hlast hte hagree).symm⟩
· rintro ⟨hlim, hck₂⟩
have hcomp₂ : RangeRead.Compatible db₂ r res := (hiff db₂).mpr ⟨hlim, hck₂⟩
have hstart₂ : resolve db₂ r.begin ≤ r.end_.key := by
rw [resolve_eq_nil_of_complete_begin_le_head hcomp₂ hrev hmore hne hbegin hlo]
exact coe_nil_le_key_withTop r.end_.key
exact ⟨hlim, (completeKeys_eq_res_of_agree_nonpos_complete (db₁ := db₂) (db₂ := db₁) hcomp₂
hrev hmore hne hbegin hlo hstart₂ hend hlast hte hagree.symm).symm⟩
/-- **Finite-branch minimality (nonpositive cross-free complete).** When `t = e`, the
minimal range is `[⊥, keyAfter last)`. -/
theorem minimal_truncatedRangeBottom_of_nonpos_complete_finite {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
(hend : 2 ≤ r.end_.offset)
(hte : residualT r res = residualE r) :
Minimal r res (truncatedRangeBottom (res.keys.getLast hne)) := by
obtain ⟨db₀, hcomp₀⟩ := hread
refine minimal_iff_sound_and_necessaryRange.mpr
⟨sound_truncatedRangeBottom_of_nonpos_complete hrev hmore hne hbegin hlo hend rfl hte, ?_⟩
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
/-- **Top-branch necessity above the reported last (nonpositive cross-free complete).**
Every key above the reported last is necessary: inserting it keeps the unbounded end and
adds it to the complete window. -/
theorem necessary_above_last_of_nonpos_top {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hBhead : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
(hend : 2 ≤ r.end_.offset)
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
{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 hstart₀ : resolve db₀ r.begin ≤ r.end_.key := by
rw [resolve_eq_nil_of_complete_begin_le_head hcomp hrev hmore hne hbegin hBhead]
exact coe_nil_le_key_withTop r.end_.key
have hE₀ : resolve db₀ r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_residualT_lt_residualE hcomp hrev hmore hne hbegin hstart₀ hend htlt
have hElast : r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) :=
last_ge_end_of_count_pos hsort hne htpos
have hhead_le_last : res.keys.head hne ≤ res.keys.getLast hne :=
(hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)
have hbegin_last : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) :=
le_trans hBhead (WithTop.coe_le_coe.mpr hhead_le_last)
have hx0 : x ∉ db₀.keys := by
intro hxk
have hge : resolve db₀ r.begin ≤ ((x : Key) : WithTop Key) :=
le_trans (resolve_le_key_of_offset_nonpos hbegin)
(le_trans hbegin_last (WithTop.coe_le_coe.mpr hlo))
have hmem : x ∈ RangeRead.completeKeys db₀ r := by
rw [RangeRead.mem_completeKeys]
exact ⟨hxk, hge, by rw [hE₀]; exact WithTop.coe_lt_top x⟩
rw [← hres] at hmem
exact hx hmem
have hall : ∀ k ∈ db₀.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := by
intro k hk
by_cases hkb : resolve db₀ r.begin ≤ ((k : Key) : WithTop Key)
· have hmem : k ∈ RangeRead.completeKeys db₀ r := by
rw [RangeRead.mem_completeKeys]
exact ⟨hk, hkb, by rw [hE₀]; exact WithTop.coe_lt_top k⟩
have hkres : k ∈ res.keys := by rw [← hres] at hmem; exact hmem
exact le_trans (WithTop.coe_le_coe.mpr (hmaxres k hkres)) (WithTop.coe_le_coe.mpr hlo)
· have hklt : ((k : Key) : WithTop Key) < resolve db₀ r.begin := lt_of_not_ge hkb
have hk_lt_last : ((k : Key) : WithTop Key) <
((res.keys.getLast hne : Key) : WithTop Key) :=
lt_of_lt_of_le (lt_of_lt_of_le hklt (resolve_le_key_of_offset_nonpos hbegin))
hbegin_last
exact le_trans (WithTop.coe_le_coe.mpr (le_of_lt (WithTop.coe_lt_coe.mp hk_lt_last)))
(WithTop.coe_le_coe.mpr hlo)
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
set Q := db₀.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) with hQ
have hQlelast : ∀ k ∈ Q, k ≤ res.keys.getLast hne := by
intro k hk
rw [hQ] at hk
obtain ⟨hkdb, hkE⟩ := (List.mem_filter.mp hk)
rw [decide_eq_true_eq] at hkE
have hmem : k ∈ RangeRead.completeKeys db₀ r := by
rw [RangeRead.mem_completeKeys]
exact ⟨hkdb, le_trans hstart₀ hkE,
by rw [hE₀]; exact WithTop.coe_lt_top k⟩
have hkres : k ∈ res.keys := by rw [← hres] at hmem; exact hmem
exact hmaxres k hkres
have hfilter : Q.filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = Q := by
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq]
exact hQlelast k hk
have hTQ : residualT r res = Q.length := by
have h := residualT_eq_filter_length (db := db₀) (r := r) (res := res)
(last := res.keys.getLast hne) hcomp hrev hmore hne rfl hbegin hstart₀
rw [h, hfilter]
have hQlen : Q.length = db₀.keys.length -
db₀.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
have hsum := countP_ge_add_countP_lt (l := db₀.keys) r.end_.key
rw [hQ, ← List.countP_eq_length_filter]
omega
have htlt' : Q.length < (r.end_.offset - 1).toNat := by
rw [← hTQ]; exact htlt
rw [hQlen] at htlt'
omega
have hEins := resolve_end_eq_top_of_insert_top hx0 hL_lt hend
exact hx (mem_result_of_insert hcomp hs hcr hmore hne hx0 hall hEins)
/-- **Top-branch minimality (nonpositive cross-free complete).** When `t < e`, the
minimal range is the full range `[⊥, ⊤)`. -/
theorem minimal_fullRange_of_nonpos_complete_top {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
(hend : 2 ≤ r.end_.offset)
(htlt : residualT r res < residualE r) :
Minimal r res ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩ := by
obtain ⟨db₀, hcomp₀⟩ := hread
by_cases htpos : 0 < residualT r res
· refine minimal_iff_sound_and_necessaryRange.mpr ⟨sound_fullRange r res, ?_⟩
intro k _ _
by_cases hkle : k ≤ res.keys.getLast hne
· 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
· exact necessary_above_last_of_nonpos_top ⟨db₀, hcomp₀⟩ hrev hmore hne hbegin hlo hend
htpos htlt (le_of_lt (lt_of_not_ge hkle))
· have hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by
intro k hk
by_contra hge
have hpos : 0 < residualT r res := by
unfold residualT
rw [List.countP_pos_iff]
exact ⟨k, hk, by rw [decide_eq_true_eq]; exact le_of_not_gt hge⟩
omega
exact minimal_fullRange_of_nonpos_overshoot_nonempty ⟨db₀, hcomp₀⟩ hrev hmore hne hbegin
hend hhi hlo
/-- The cross-free nonpositive-begin complete closed form. -/
noncomputable def completeNonposCrossFree (r : RangeRead) (res : Result) : ConflictRange :=
if res.keys = [] then ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩
else if r.end_.offset ≤ 1 then ⟨(([] : Key) : WithTop Key), r.end_.key⟩
else if residualT r res = residualE r then
truncatedRangeBottom (res.keys.getLastD ([] : Key))
else ⟨(([] : Key) : WithTop Key), (⊤ : WithTop Key)⟩
/-- **The cross-free nonpositive-begin complete closed form.** For `begin.offset ≤ 0`,
`begin.key ≤ head`, and a complete nonempty result, the minimal range is `[⊥, end_.key)`
when `end_.offset ≤ 1`, `[⊥, keyAfter last)` in the finite branch `t = e`, and `[⊥, ⊤)`
otherwise. -/
theorem minimal_completeNonposCrossFree {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key)) :
Minimal r res (completeNonposCrossFree r res) := by
unfold completeNonposCrossFree
rw [ite_eq_right hne]
by_cases hend1 : r.end_.offset ≤ 1
· rw [ite_eq_left hend1]
exact minimal_bottomRange_of_nonpos_underEnd_nonempty hread hrev hmore hne hbegin hend1 hlo
· rw [ite_eq_right hend1]
have hend : 2 ≤ r.end_.offset := by omega
by_cases hte : residualT r res = residualE r
· rw [ite_eq_left hte]
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]
exact minimal_truncatedRangeBottom_of_nonpos_complete_finite hread hrev hmore hne hbegin
hlo hend hte
· rw [ite_eq_right hte]
obtain ⟨db₀, hcomp₀⟩ := hread
have hstart₀ : resolve db₀ r.begin ≤ r.end_.key := by
rw [resolve_eq_nil_of_complete_begin_le_head hcomp₀ hrev hmore hne hbegin hlo]
exact coe_nil_le_key_withTop r.end_.key
have htle : residualT r res ≤ residualE r :=
residualT_le_residualE_nonpos hcomp₀ hrev hmore hne hbegin hstart₀ hend
have htlt : residualT r res < residualE r := lt_of_le_of_ne htle hte
exact minimal_fullRange_of_nonpos_complete_top ⟨db₀, hcomp₀⟩ hrev hmore hne hbegin hlo
hend htlt
/-- The reversed-traversal cross-free nonpositive-begin complete closed form. -/
noncomputable def completeNonposCrossFreeRev (r : RangeRead) (res : Result) : ConflictRange :=
completeNonposCrossFree { r with reverse := false }
{ keys := res.keys.reverse, more := false }
/-- The reversed cross-free nonpositive-begin complete rule is minimal. -/
theorem minimal_completeNonposCrossFree_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)
(hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)) :
Minimal r res (completeNonposCrossFreeRev 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 hlo' : r'.begin.key ≤ ((res'.keys.head hne' : Key) : WithTop Key) := by
simpa [r', res'] using hlo
have hmin' : Minimal r' res' (completeNonposCrossFree r' res') :=
minimal_completeNonposCrossFree hread' rfl rfl hne' hbegin hlo'
have hflip := (minimal_flip (r := r) (res := res)
(cr := completeNonposCrossFree r' res') (b := true) hrev hmore)
exact hflip.mp hmin'
/-- A nonempty *complete* result at a nonpositive begin offset, cross-free, with the begin
key at or below the least reported key. This is the cross-free nonpositive-begin complete
cell, in either traversal. -/
abbrev nonposCompleteCrossFree (r : RangeRead) (res : Result) : Prop :=
res.more = false ∧ res.keys ≠ [] ∧ r.begin.offset ≤ 0 ∧
r.begin.key ≤ ((leastReported r res : Key) : WithTop Key)
/-- The cross-free nonpositive-begin complete closed form, in either traversal. -/
noncomputable def closedFormCompleteNonposCrossFree (r : RangeRead) (res : Result) :
ConflictRange :=
if r.reverse = true then completeNonposCrossFreeRev r res
else completeNonposCrossFree r res
/-- **The cross-free nonpositive-begin complete closed form is minimal.** -/
theorem minimal_closedForm_of_complete_nonpos_crossFree {r : RangeRead} {res : Result}
(hread : Readable r res) (h : nonposCompleteCrossFree r res) :
Minimal r res (closedFormCompleteNonposCrossFree r res) := by
obtain ⟨hmore, hne, hbegin, hloD⟩ := h
unfold closedFormCompleteNonposCrossFree
cases hrev : r.reverse with
| false =>
rw [ite_eq_right (by simp [])]
have hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by
have hloD' : r.begin.key ≤
((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
rwa [← hhead]
exact minimal_completeNonposCrossFree hread hrev hmore hne hbegin hlo
| true =>
rw [ite_eq_left (by simp [])]
have hlo : r.begin.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by
have hloD' : r.begin.key ≤
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rwa [← hlast]
exact minimal_completeNonposCrossFree_rev hread hrev hmore hne hbegin hlo
namespace FormalConflictRange
/-- Agreement on keys at or below `last` fixes the `end_.key`-filtered keys at or
below `last`. -/
theorem filter_end_le_swap (db : DB) (r : RangeRead) (last : Key) :
(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 (k ≤ last))).filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by
rw [List.filter_filter, List.filter_filter]
apply List.filter_congr
intro k _
exact Bool.and_comm _ _
/-- Agreement on keys at or below `last` transfers the end-resolution cut at `last`. -/
theorem lt_resolve_end_iff_of_agree_bottom {db₁ db₂ : DB} {r : RangeRead} {last : Key}
(hend : 1 ≤ r.end_.offset)
(hb : db₁.keys.filter (fun k : Key => decide (k ≤ last)) =
db₂.keys.filter (fun k : Key => decide (k ≤ last))) :
((last : Key) : WithTop Key) < resolve db₁ r.end_ ↔
((last : Key) : WithTop Key) < resolve db₂ r.end_ := by
have hQ : (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
rw [filter_end_le_swap, filter_end_le_swap, hb]
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 [← hQ]
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 [hQ]
exact hc2
exact resolve_end_gt_of_filter_length_le (db := db₁) hend hc1
/-- **Soundness of `[⊥, keyAfter last)` for a nonpositive-begin truncated forward
result, with no pinning hypothesis.** Agreement fixes the stored keys at or below the
reported last and the begin resolution. If the end key lies at or below the reported
last, the same agreement fixes the end resolution cut at the reported last; otherwise
the reported last lies below the end key and `end_.key ≤ resolve end_` fixes the cut
for every database. -/
theorem sound_truncatedRangeBottom_of_nonpos_more {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) :
Sound r res (truncatedRangeBottom (res.keys.getLast hne)) := by
intro db₁ db₂ hagree
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
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
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_of_lt :
((res.keys.getLast hne : Key) : WithTop Key) < resolve db₁ r.end_ →
((res.keys.getLast hne : Key) : WithTop Key) < resolve db₂ r.end_ →
(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
intro hlt₁ hlt₂
rw [completeKeys_filter_le_eq (db := db₁) hrev hlt₁,
completeKeys_filter_le_eq (db := db₂) hrev hlt₂,
hA db₁, hA db₂, hres, hb]
rw [compatible_iff_truncated_keys hrev hmore hne,
compatible_iff_truncated_keys (db := db₂) hrev hmore hne]
by_cases hE : r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key)
· -- Non-overshoot: the end key lies at or below the reported last.
constructor
· rintro ⟨hlim, hck₁⟩
have hmem : res.keys.getLast hne ∈ (RangeRead.completeKeys db₁ r).filter
(fun k : Key => decide (k ≤ res.keys.getLast hne)) := by
rw [hck₁]
exact List.getLast_mem hne
have hlt₁ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₁ r.end_ :=
(RangeRead.mem_completeKeys.mp (List.mem_of_mem_filter hmem)).2.2
have hlt₂ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₂ r.end_ :=
(lt_resolve_end_iff_of_agree_bottom (db₁ := db₁) (db₂ := db₂) hge hb).mp hlt₁
exact ⟨hlim, hck_of_lt hlt₁ hlt₂ ▸ hck₁⟩
· rintro ⟨hlim, hck₂⟩
have hmem : res.keys.getLast hne ∈ (RangeRead.completeKeys db₂ r).filter
(fun k : Key => decide (k ≤ res.keys.getLast hne)) := by
rw [hck₂]
exact List.getLast_mem hne
have hlt₂ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₂ r.end_ :=
(RangeRead.mem_completeKeys.mp (List.mem_of_mem_filter hmem)).2.2
have hlt₁ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₁ r.end_ :=
(lt_resolve_end_iff_of_agree_bottom (db₁ := db₂) (db₂ := db₁) hge hb.symm).mp hlt₂
exact ⟨hlim, (hck_of_lt hlt₁ hlt₂).symm ▸ hck₂⟩
· -- The reported last lies below the end key, so every database cuts above it.
have hlast_lt : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key :=
lt_of_not_ge hE
have hlt : ∀ db : DB, ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ :=
fun db => lt_of_lt_of_le hlast_lt (key_le_resolve_of_one_le (db := db) (s := r.end_) hge)
constructor
· rintro ⟨hlim, hck₁⟩
exact ⟨hlim, hck_of_lt (hlt db₁) (hlt db₂) ▸ hck₁⟩
· rintro ⟨hlim, hck₂⟩
exact ⟨hlim, (hck_of_lt (hlt db₁) (hlt db₂)).symm ▸ hck₂⟩
/-- **The nonpositive-begin truncated forward case is minimal with no pinning.** -/
theorem minimal_truncatedRangeBottom_of_nonpos_more {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) :
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_more hrev hbegin hmore hne hlo' hge, ?_⟩
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
/-- A nonempty *truncated forward* result at a nonpositive begin offset, cross-free,
with `1 ≤ end_.offset`. This removes the pinning hypothesis from
`nonposFwdTruncPinned`: the minimal range is still `[⊥, keyAfter last)`. -/
abbrev nonposFwdTrunc (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset ≤ 0 ∧
r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) ∧
1 ≤ r.end_.offset
/-- The cross-free nonpositive-begin forward truncated closed form. -/
noncomputable def closedFormNonposFwdTrunc (_r : RangeRead) (res : Result) : ConflictRange :=
truncatedRangeBottom (res.keys.getLastD ([] : Key))
/-- **The cross-free nonpositive-begin forward truncated closed form is minimal.** -/
theorem minimal_closedForm_of_nonpos_fwdTrunc {r : RangeRead} {res : Result}
(hread : Readable r res) (h : nonposFwdTrunc r res) :
Minimal r res (closedFormNonposFwdTrunc r res) := by
obtain ⟨hmore, hrev, hbegin, hloD, hge⟩ := h
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
unfold closedFormNonposFwdTrunc
rw [hlast]
have hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by
have hloD' : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
rwa [← hhead]
exact minimal_truncatedRangeBottom_of_nonpos_more hread' hrev hmore hne hbegin hlo hge
/-- Splitting a count below `b` at a threshold `a < b`. -/
theorem countP_lt_split {l : List Key} {a b : WithTop Key} (hab : a < b) :
l.countP (fun (k : Key) => decide ((k : WithTop Key) < b)) =
l.countP (fun (k : Key) => decide ((k : WithTop Key) ≤ a)) +
l.countP (fun (k : Key) => decide (a < (k : WithTop Key)) &&
decide ((k : WithTop Key) < b)) := by
induction l with
| nil => rfl
| cons x rest ih =>
simp only [List.countP_cons]
rw [ih]
by_cases hb : ((x : WithTop Key) < b)
· by_cases hle : ((x : WithTop Key) ≤ a)
· have hnb : ¬ (a < (x : WithTop Key)) := not_lt.mpr hle
simp [hb, hle, hnb]
omega
· have hgt : a < (x : WithTop Key) := lt_of_not_ge hle
simp [hb, hle, hgt]
omega
· have hle : ¬ ((x : WithTop Key) ≤ a) := fun h => hb (lt_of_le_of_lt h hab)
simp [hb, hle]
/-- In the compatible nonpositive-begin, nonpositive-end forward truncated case,
there are at least `(1 - end_.offset)` stored keys strictly between the reported last
and `end_.key`. -/
theorem filler_count_nonpos_more_nonpos_end {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (_hrev : r.reverse = false)
(_hmore : res.more = true) (hne : res.keys ≠ [])
(_hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) :
(1 - r.end_.offset).toNat ≤
(db.keys.filter (fun (k : Key) => decide (res.keys.getLast hne < k ∧
((k : WithTop Key) < r.end_.key)))).length := by
set last := res.keys.getLast hne with hlast
set o := r.end_.offset with ho
set c := db.keys.countP (fun (k : Key) => decide ((k : WithTop Key) < r.end_.key))
with hc
set d := db.keys.countP
(fun (k : Key) => decide ((k : WithTop Key) ≤ (↑last : WithTop Key))) with hd
set n := (db.keys.filter (fun (k : Key) => decide (last < k ∧
((k : WithTop Key) < r.end_.key)))).length with hn
have hlastmem : last ∈ db.keys :=
(RangeRead.mem_completeKeys.mp ((RangeRead.compatible_keys_prefix hcomp).subset
(List.getLast_mem hne))).1
have hlast_res : ((last : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp ((RangeRead.compatible_keys_prefix hcomp).subset
(List.getLast_mem hne))).2.2
have hlastE : ((last : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_nonpos hend hlastmem hlast_res
have hsplit : c = d + n := by
rw [hc, hd, hn]
have hs := countP_lt_split (l := db.keys) (a := (↑last : WithTop Key))
(b := r.end_.key) hlastE
have hn' : (db.keys.filter (fun (k : Key) => decide (last < k ∧
((k : WithTop Key) < r.end_.key)))).length =
db.keys.countP (fun (k : Key) => decide ((↑last : WithTop Key) <
(k : WithTop Key)) && decide ((k : WithTop Key) < r.end_.key)) := by
rw [List.countP_eq_length_filter]
congr 1
rw [hn', ← hs]
have hanchor_nonneg : 0 ≤ r.end_.anchor db := by
by_contra hneg
have hnil : resolve db r.end_ = (↑([] : Key) : WithTop Key) :=
resolve_eq_nil (lt_of_not_ge hneg)
rw [hnil] at hlast_res
exact absurd hlast_res (not_lt.mpr (WithTop.coe_le_coe.mpr (nil_le_key last)))
have hanchor_eq : r.end_.anchor db = (c : Int) + o - 1 := by
rw [hc, ho]
cases hE : r.end_.key with
| top => rw [anchor_of_top (s := r.end_) hE, countP_lt_top]
| coe e => rw [anchor_of_coe (s := r.end_) hE, countP_lt_coe]
have hd_le : d ≤ db.keys.countP
(fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_)) := by
rw [hd]
apply countP_le_countP_of_imp
intro k _ hk
rw [decide_eq_true_eq] at hk ⊢
exact lt_of_le_of_lt hk hlast_res
have hres_count : db.keys.countP
(fun (k : Key) => decide ((k : WithTop Key) < resolve db r.end_)) =
min (r.end_.anchor db).toNat db.keys.length := countP_lt_resolve
have hd_le_min : d ≤ min ((c : Int) + o - 1).toNat db.keys.length := by
rw [hres_count, hanchor_eq] at hd_le
exact hd_le
have hanchor_nonneg' : 0 ≤ (c : Int) + o - 1 := by
rw [← hanchor_eq]; exact hanchor_nonneg
have hnat : (((c : Int) + o - 1).toNat : Int) = (c : Int) + o - 1 :=
Int.toNat_of_nonneg hanchor_nonneg'
have hd_lt : (d : Int) < (c : Int) + o := by
have h1 : d ≤ ((c : Int) + o - 1).toNat :=
le_trans hd_le_min (Nat.min_le_left _ _)
have h1' : (d : Int) ≤ (c : Int) + o - 1 := by
rw [← hnat]
exact_mod_cast h1
omega
have hc_eq : (c : Int) = (d : Int) + (n : Int) := by
rw [hsplit]; push_cast; ring
have hn_gt : (n : Int) > -(o : Int) := by omega
have hni : (((1 - o).toNat : ℕ) : Int) ≤ (n : Int) := by
have htoNat : (((1 - o).toNat : ℕ) : Int) = (1 : Int) - o := by
rw [Int.toNat_of_nonneg]; omega
rw [htoNat]
omega
exact_mod_cast hni
/-- At a nonpositive end offset, if the begin selector resolves to `⊥` and the end
selector to a genuine key `w`, the complete keys are exactly the stored keys below
`w`. -/
theorem completeKeys_eq_of_resolve_nil_coe {db : DB} {r : RangeRead} {w : Key}
(hrev : r.reverse = false) (hend : r.end_.offset ≤ 0)
(hb : resolve db r.begin = ((↑([] : Key) : WithTop Key)))
(he : resolve db r.end_ = (↑w : WithTop Key)) :
RangeRead.completeKeys db r =
db.keys.filter (fun k : Key => decide ((↑k : WithTop Key) < (↑w : WithTop Key))) := by
have hwle : (↑w : WithTop Key) ≤ r.end_.key := by
rw [← he]; exact resolve_le_key_of_offset_nonpos hend
rw [completeKeys_eq_filter_of_end_nonpos hrev hend, hb, he, List.filter_filter]
apply List.filter_congr
intro k _
by_cases h : ((↑k : WithTop Key) < (↑w : WithTop Key))
· have hlt : ((↑k : WithTop Key)) < r.end_.key := lt_of_lt_of_le h hwle
have hbot : ((↑([] : Key) : WithTop Key)) ≤ (↑k : WithTop Key) :=
WithTop.coe_le_coe.mpr (nil_le_key k)
simp [h, hlt, hbot]
· simp [h]
/-- **The witness for a key above the reported last, in the nonpositive
forward-truncated nonpositive-end case.** We build a database consisting of the
reported keys followed by exactly `m = (1 - end_.offset)` filler keys in
`(last, end_.key)`, one of which is the target key `k`. The begin selector resolves to
`⊥`, the end selector resolves just above the reported last, so the complete keys are
exactly the reported keys; erasing the target lowers the end resolution to the reported
last and drops the last reported key, breaking compatibility. -/
theorem exists_witness_nonpos_more_nonpos_end {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
{k : Key} (hkgt : res.keys.getLast hne < k) (hklt : (k : WithTop Key) < r.end_.key) :
∃ dbw : DB, RangeRead.Compatible dbw r res ∧ k ∈ dbw.keys ∧
¬ RangeRead.Compatible (dbw.erase k) r res := by
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hlast_ck : res.keys.getLast hne ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne)
obtain ⟨hlast_mem, -, hlast_res⟩ := RangeRead.mem_completeKeys.mp hlast_ck
have hlastE : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_nonpos hend hlast_mem hlast_res
have hfill := filler_count_nonpos_more_nonpos_end hcomp hrev hmore hne hbegin hend
set last := res.keys.getLast hne with hlast
set m := (1 - r.end_.offset).toNat with hm
have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx =>
(hsort.pairwise.imp le_of_lt).rel_getLast hx
have hm1 : 1 ≤ m := by rw [hm]; omega
set G : List Key := db.keys.filter
(fun x : Key => decide (last < x ∧ (x : WithTop Key) < r.end_.key)) with hG
have hGlen : m ≤ G.length := hfill
have hGnodup : G.Nodup := by
rw [hG]; exact db.sorted.pairwise.nodup.filter _
have hGmem : ∀ x ∈ G, last < x ∧ (x : WithTop Key) < r.end_.key := by
intro x hx
rw [hG] at hx
exact of_decide_eq_true (List.mem_filter.mp hx).2
-- the raw filler list starts with `k` and then the reservoir without `k`
set raw : List Key := (k :: G.erase k).take m with hraw
have hrawNodup : raw.Nodup := by
rw [hraw]
refine (List.take_sublist m (k :: G.erase k)).nodup ?_
exact List.nodup_cons.mpr ⟨hGnodup.not_mem_erase, hGnodup.erase k⟩
have hrawLen : raw.length = m := by
rw [hraw, List.length_take]
apply Nat.min_eq_left
by_cases hkG : k ∈ G
· rw [List.length_cons, List.length_erase_of_mem hkG]; omega
· rw [List.length_cons, List.erase_of_not_mem hkG]; omega
have hrawSub : ∀ x ∈ raw, x = k ∨ x ∈ G := by
intro x hx
rw [hraw] at hx
rcases List.mem_cons.mp (List.mem_of_mem_take hx) with rfl | hx'
· exact Or.inl rfl
· exact Or.inr (List.mem_of_mem_erase hx')
have hrawk : k ∈ raw := by
rw [hraw, List.mem_take_iff_getElem]
refine ⟨0, ?_, rfl⟩
rw [List.length_cons]
omega
have hrawGt : ∀ x ∈ raw, last < x := by
intro x hx
rcases hrawSub x hx with rfl | hx'
· exact hkgt
· exact (hGmem x hx').1
have hrawLt : ∀ x ∈ raw, (x : WithTop Key) < r.end_.key := by
intro x hx
rcases hrawSub x hx with rfl | hx'
· exact hklt
· exact (hGmem x hx').2
-- sort the filler
set F : List Key := raw.insertionSort (· ≤ ·) with hF
have hFperm : raw.Perm F := (List.perm_insertionSort (· ≤ ·) raw).symm
have hFsorted : F.SortedLT := by
rw [hF, List.sortedLT_iff_pairwise]
exact DB.pairwise_lt_of_le_of_nodup
(List.pairwise_insertionSort (r := (· ≤ ·)) raw)
(hFperm.nodup_iff.mp hrawNodup)
have hFlen : F.length = m := by rw [hF, List.length_insertionSort, hrawLen]
have hFk : k ∈ F := hFperm.mem_iff.mp hrawk
have hFmem : ∀ x ∈ F, last < x ∧ (x : WithTop Key) < r.end_.key := by
intro x hx
exact ⟨hrawGt x (hFperm.mem_iff.mpr hx), hrawLt x (hFperm.mem_iff.mpr hx)⟩
have hFne : F ≠ [] := by
intro h; rw [h] at hFlen; simp at hFlen; omega
set D : List Key := res.keys ++ F with hD
have hDsort : D.SortedLT := by
rw [hD]
refine List.sortedLT_append.mpr ⟨hsort, hFsorted, ?_⟩
intro a ha b hb
exact lt_of_le_of_lt (hle_last a ha) (hFmem b hb).1
let dbw : DB := ⟨D, hDsort⟩
have hdbw_keys : dbw.keys = D := rfl
have hlastFhead : last < F.head hFne := (hFmem (F.head hFne) (List.head_mem hFne)).1
-- the begin selector resolves to `⊥`
have hbegin_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
intro htop
rw [htop] at hlo
exact WithTop.not_top_le_coe (res.keys.head hne) hlo
obtain ⟨bk, hbk⟩ := WithTop.ne_top_iff_exists.mp hbegin_ne_top
have hbk_le_head : bk ≤ res.keys.head hne := by
have h := hlo
rw [← hbk] at h
exact WithTop.coe_le_coe.mp h
have hDmem : ∀ x ∈ D, bk ≤ x := by
intro x hx
rw [hD] at hx
rcases List.mem_append.mp hx with hx | hx
· exact le_trans hbk_le_head ((hsort.pairwise.imp le_of_lt).rel_head hx)
· exact le_trans (le_trans hbk_le_head
((hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne))) (le_of_lt (hFmem x hx).1)
have hcount_begin : D.countP (fun x : Key => decide (x < bk)) = 0 :=
countP_lt_eq_zero_of_forall_ge hDmem
have hrb : resolve dbw r.begin = ((↑([] : Key) : WithTop Key)) := by
refine resolve_eq_nil ?_
rw [anchor_of_coe (s := r.begin) (v := bk) hbk.symm, hcount_begin]
omega
-- every stored key is below `end_.key`
have hDlt : ∀ x ∈ D, (x : WithTop Key) < r.end_.key := by
intro x hx
rw [hD] at hx
rcases List.mem_append.mp hx with hx | hx
· exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hle_last x hx)) hlastE
· exact (hFmem x hx).2
have hlenD : D.length = res.keys.length + m := by
rw [hD, List.length_append, hFlen]
have hm_int : (m : Int) = 1 - r.end_.offset := by
rw [hm]; exact Int.toNat_of_nonneg (by omega)
have hcount_end : D.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) =
D.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hDlt x hx
have hanchor_end : r.end_.anchor dbw = (res.keys.length : Int) := by
cases hE : r.end_.key with
| top =>
rw [anchor_of_top (s := r.end_) hE, hlenD]
push_cast
rw [hm_int]
ring
| coe e =>
have hce : D.countP (fun x : Key => decide (x < e)) = D.length := by
rw [← countP_lt_coe (l := D) e, ← hE]
exact hcount_end
rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlenD]
push_cast
rw [hm_int]
ring
have ht_lt : res.keys.length < D.length := by rw [hlenD]; omega
have hDget? : dbw.keys[res.keys.length]? = some (F.head hFne) := by
change D[res.keys.length]? = some (F.head hFne)
rw [hD, List.getElem?_append]
rw [ite_eq_right (not_lt.mpr (le_refl _)), Nat.sub_self]
rw [List.getElem?_eq_getElem (by rw [hFlen]; omega), List.head_eq_getElem hFne]
have hre : resolve dbw r.end_ = ((F.head hFne : Key) : WithTop Key) := by
rw [resolve, ite_eq_right (by rw [hanchor_end]; omega)]
rw [hanchor_end, Int.toNat_natCast, hDget?]
-- complete keys of the witness are the reported keys
have hckw : RangeRead.completeKeys dbw r = res.keys := by
rw [completeKeys_eq_of_resolve_nil_coe (db := dbw) hrev hend hrb hre]
have hpred : ∀ x ∈ dbw.keys,
decide ((↑x : WithTop Key) < ((↑(F.head hFne) : Key) : WithTop Key)) =
decide (x < F.head hFne) := by
intro x _; rw [decide_eq_decide, WithTop.coe_lt_coe]
rw [List.filter_congr hpred, hdbw_keys, hD, List.filter_append]
have hres_self : res.keys.filter (fun x : Key => decide (x < F.head hFne)) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact lt_of_le_of_lt (hle_last x hx) hlastFhead
have hF_nil : F.filter (fun x : Key => decide (x < F.head hFne)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr ((hFsorted.pairwise.imp le_of_lt).rel_head hx)
rw [hres_self, hF_nil, List.append_nil]
have hcompw : RangeRead.Compatible dbw r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
refine ⟨hcomp.1, ?_⟩
rw [hckw]
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rw [← hlast]
exact hle_last x hx
have hkdbw : k ∈ dbw.keys := by
rw [hdbw_keys, hD]
exact List.mem_append.mpr (Or.inr hFk)
-- now the erased database
have hk_not_mem_res : k ∉ res.keys := by
intro hk
exact absurd (hle_last k hk) (not_le.mpr hkgt)
have hD' : (dbw.erase k).keys = res.keys ++ F.erase k := by
rw [DB.erase_keys, hdbw_keys, hD]
exact List.erase_append_right F hk_not_mem_res
have hD'mem : ∀ x ∈ (dbw.erase k).keys, bk ≤ x := by
intro x hx
exact hDmem x (by
rw [DB.erase_keys, hdbw_keys] at hx
exact List.mem_of_mem_erase hx)
have hrb' : resolve (dbw.erase k) r.begin = ((↑([] : Key) : WithTop Key)) := by
refine resolve_eq_nil ?_
rw [anchor_of_coe (s := r.begin) (v := bk) hbk.symm,
countP_lt_eq_zero_of_forall_ge hD'mem]
omega
have hD'lt : ∀ x ∈ (dbw.erase k).keys, (x : WithTop Key) < r.end_.key := by
intro x hx
exact hDlt x (by
rw [DB.erase_keys, hdbw_keys] at hx
exact List.mem_of_mem_erase hx)
have hlenD' : (dbw.erase k).keys.length = res.keys.length + m - 1 := by
rw [hD', List.length_append, List.length_erase_of_mem hFk, hFlen]
omega
have hcount_end' : (dbw.erase k).keys.countP
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = (dbw.erase k).keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hD'lt x hx
have hanchor_end' : r.end_.anchor (dbw.erase k) = (res.keys.length : Int) - 1 := by
cases hE : r.end_.key with
| top =>
rw [anchor_of_top (s := r.end_) hE, hlenD']
rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)]
push_cast
rw [hm_int]
ring
| coe e =>
have hce : (dbw.erase k).keys.countP (fun x : Key => decide (x < e)) =
(dbw.erase k).keys.length := by
rw [← countP_lt_coe (l := (dbw.erase k).keys) e, ← hE]
exact hcount_end'
rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlenD']
rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)]
push_cast
rw [hm_int]
ring
have ht1 : 1 ≤ res.keys.length := List.length_pos_of_ne_nil hne
have hEqInt : (res.keys.length : Int) - 1 = ((res.keys.length - 1 : ℕ) : Int) := by
rw [Nat.cast_sub ht1]; norm_num
have htoNat' : (r.end_.anchor (dbw.erase k)).toNat = res.keys.length - 1 := by
rw [hanchor_end', hEqInt, Int.toNat_natCast]
have hD'get? : (dbw.erase k).keys[res.keys.length - 1]? = some last := by
rw [hD', List.getElem?_append]
rw [ite_eq_left (by omega : res.keys.length - 1 < res.keys.length)]
rw [List.getElem?_eq_getElem (by omega : res.keys.length - 1 < res.keys.length)]
congr 1
rw [hlast, List.getLast_eq_getElem hne]
have hre' : resolve (dbw.erase k) r.end_ = ((last : Key) : WithTop Key) := by
rw [resolve, ite_eq_right (by rw [hanchor_end']; omega)]
rw [hanchor_end', hEqInt, Int.toNat_natCast, hD'get?]
have hckE : RangeRead.completeKeys (dbw.erase k) r = res.keys.dropLast := by
rw [completeKeys_eq_of_resolve_nil_coe (db := dbw.erase k) hrev hend hrb' hre']
have hpred : ∀ x ∈ (dbw.erase k).keys,
decide ((↑x : WithTop Key) < ((↑last : Key) : WithTop Key)) =
decide (x < last) := by
intro x _; rw [decide_eq_decide, WithTop.coe_lt_coe]
rw [List.filter_congr hpred, hD', List.filter_append]
have hres_fil : res.keys.filter (fun x : Key => decide (x < last)) = res.keys.dropLast := by
have hcnt : res.keys.countP
(fun x : Key => decide ((↑x : WithTop Key) < ((↑last : Key) : WithTop Key))) =
res.keys.length - 1 := by
rw [countP_lt_coe (l := res.keys) last]
refine countP_lt_eq_of_getElem hsort (by omega) ?_
simp only [hlast, List.getLast_eq_getElem hne]
have hf : res.keys.filter (fun x : Key => decide (x < last)) =
res.keys.filter (fun x : Key =>
decide ((↑x : WithTop Key) < ((↑last : Key) : WithTop Key))) := by
apply List.filter_congr
intro x _
rw [decide_eq_decide, WithTop.coe_lt_coe]
rw [hf, filter_lt_eq_take_countP hsort ((↑last : Key) : WithTop Key), hcnt,
← List.dropLast_eq_take]
have hF_fil : (F.erase k).filter (fun x : Key => decide (x < last)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (le_of_lt (hFmem x (List.mem_of_mem_erase hx)).1)
rw [hres_fil, hF_fil, List.append_nil]
have hnot : ¬ RangeRead.Compatible (dbw.erase k) r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
intro h
have heq := h.2
rw [hckE] at heq
have hfil : res.keys.dropLast.filter
(fun x : Key => decide (x ≤ res.keys.getLast hne)) = res.keys.dropLast := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rw [← hlast]
exact hle_last x (List.mem_of_mem_dropLast hx)
rw [hfil] at heq
have hlen := congrArg List.length heq
rw [List.length_dropLast] at hlen
omega
exact ⟨dbw, hcompw, hkdbw, hnot⟩
/-- Every key strictly above the reported last (and below `end_.key`) is necessary in
the nonpositive forward-truncated nonpositive-end case. -/
theorem necessary_above_last_of_nonpos_more_nonpos_end {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key))
{x : Key} (hxgt : res.keys.getLast hne < x) (hxlt : (x : WithTop Key) < r.end_.key) :
Necessary r res x := by
obtain ⟨db₀, hcomp⟩ := hread
intro cr hs
by_contra hxcr
obtain ⟨dbw, hcompw, -, hnot⟩ :=
exists_witness_nonpos_more_nonpos_end hcomp hrev hmore hne hbegin hend hlo hxgt hxlt
exact hnot ((hs dbw (dbw.erase x)
(ConflictRange.keys_erase_of_not_mem cr dbw hxcr).symm).mp hcompw)
/-- **The nonpositive forward-truncated nonpositive-end cell is `[⊥, end_.key)`.**
Soundness is `sound_bottomRange_of_nonpos_underEnd_nonempty`; keys at or below the
reported last are convex between the (necessary) empty key and the reported keys, and
keys above the reported last are `necessary_above_last_of_nonpos_more_nonpos_end`. -/
theorem minimal_bottomRange_of_nonpos_more_nonpos_end {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
(hne : res.keys ≠ []) (hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0)
(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 hread' : Readable r res := ⟨db₀, hcomp⟩
have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db₀ r :=
(RangeRead.compatible_keys_prefix hcomp).subset (List.head_mem hne)
obtain ⟨hhead_mem, -, hhead_res⟩ := RangeRead.mem_completeKeys.mp hhead_ck
have hheadE : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_nonpos hend hhead_mem hhead_res
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 (by omega) hle, ?_⟩
intro k _ hk
by_cases hk_last : k ≤ res.keys.getLast hne
· 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)) hk_last
· exact necessary_above_last_of_nonpos_more_nonpos_end hread' hmore hrev hne hbegin hend hlo
(not_le.mp hk_last) hk
/-- A nonempty *truncated forward* result at a nonpositive begin offset, cross-free,
with `end_.offset ≤ 0`. In this cell the minimal range is `[⊥, end_.key)`. -/
abbrev nonposFwdTruncNonpos (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset ≤ 0 ∧
r.begin.key ≤ ((leastReported r res : Key) : WithTop Key) ∧
r.end_.offset ≤ 0
/-- The cross-free nonpositive-begin forward truncated nonpositive-end closed form. -/
noncomputable def closedFormNonposFwdTruncNonpos (r : RangeRead) (_res : Result) :
ConflictRange :=
⟨((↑([] : Key) : WithTop Key)), r.end_.key⟩
/-- **The cross-free nonpositive-begin forward truncated nonpositive-end closed form is
minimal.** -/
theorem minimal_closedForm_of_nonpos_fwdTruncNonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (h : nonposFwdTruncNonpos r res) :
Minimal r res (closedFormNonposFwdTruncNonpos r res) := by
obtain ⟨hmore, hrev, hbegin, hloD, hend⟩ := h
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hlo : r.begin.key ≤ ((res.keys.head hne : Key) : WithTop Key) := by
have hloD' : r.begin.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
rwa [← hhead]
exact minimal_bottomRange_of_nonpos_more_nonpos_end hread' hmore hrev hne hbegin hend hlo
end FormalConflictRange