- Vendor the FormalConflictRange reference library needed by the proof - Add Bridge.lean with simp lemmas connecting the Statement definitions to the reference library - Prove Statement.closedFormMinimal in Proof.lean - Register the new libraries in the Lake config
1438 lines
72 KiB
Lean4
1438 lines
72 KiB
Lean4
/-
|
||
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
|
||
Released under Apache 2.0 license as described in the file LICENSE.
|
||
Authors: FormalConflictRange contributors
|
||
-/
|
||
|
||
import FormalConflictRange.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
|
||
|
||
set_option maxHeartbeats 1200000
|
||
|
||
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]
|
||
simp only [if_false]
|
||
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
|
||
unfold residualE at 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 [if_neg hne]
|
||
by_cases hend1 : r.end_.offset ≤ 1
|
||
· rw [if_pos hend1]
|
||
exact minimal_bottomRange_of_nonpos_underEnd_nonempty hread hrev hmore hne hbegin hend1 hlo
|
||
· rw [if_neg hend1]
|
||
have hend : 2 ≤ r.end_.offset := by omega
|
||
by_cases hte : residualT r res = residualE r
|
||
· rw [if_pos 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 [if_neg 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 [hrev])]
|
||
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 [hrev])]
|
||
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
|
||
|
||
|
||
set_option maxHeartbeats 2400000
|
||
|
||
/-- 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
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [Bool.decide_and]
|
||
rw [show decide (last < k) =
|
||
decide ((↑last : WithTop Key) < (↑k : WithTop Key)) from
|
||
decide_eq_decide.mpr (WithTop.coe_lt_coe.symm)]
|
||
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 [if_neg (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 [if_pos (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
|