Files
conflict-range/FormalConflictRange/ZeroCrossTrunc.lean
T

2367 lines
119 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.
/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
import FormalConflictRange.ZeroCrossLong
import FormalConflictRange.Reduction
import FormalConflictRange.NonposClosedForm
/-!
# Crossed truncated results at begin offset zero
At `begin.offset = 0` the begin anchor is `cnt begin.key - 1`, so a crossed read
(`begin.key` strictly above the reported head) resolves its begin selector exactly onto
the greatest stored key below `begin.key`, which compatibility forces to be the reported
head. No stored key can lie strictly between the head and `begin.key`.
This module closes the family with an unbounded end selector (`end.key = ⊤` and
`end.offset ≥ 1`). Writing `head` for the reported head and `last` for the reported
last, the minimal range is
`[head, max begin.key (keyAfter last))`.
The lower endpoint is the reported head. The upper endpoint is `begin.key` when the
reported keys stop below it (every key in `(last, begin.key)` would lift the begin
resolution off the head), and `keyAfter last` when the reported keys already reach it.
-/
namespace FormalConflictRange
/-- A forward truncated result at begin offset zero, crossed, with `end.offset = 1`
or an unbounded end selector (`end.key = ⊤`, `end.offset ≥ 1`). -/
abbrev zeroCrossTruncReadAllEnd (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
(r.end_.offset = 1 ∨ (r.end_.key = (⊤ : WithTop Key) ∧ 1 ≤ r.end_.offset))
/-- A forward truncated result at begin offset zero, crossed, with positive end offset
and every reported key strictly below `end.key`. -/
abbrev zeroCrossTruncBelowEnd (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
1 ≤ r.end_.offset ∧ ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
/-- A forward truncated result at begin offset zero, crossed, with positive end offset
and the end key at or above the reported head. -/
abbrev zeroCrossTruncEndGeHead (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
1 ≤ r.end_.offset ∧
((leastReported r res : Key) : WithTop Key) ≤ r.end_.key
/-- A forward truncated result at begin offset zero, crossed, with the end key strictly
below the reported head and enough capacity in the gap `[end.key, head)` to absorb the
reported keys up to `end.offset - 1`. -/
abbrev zeroCrossTruncLowEndSmall (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
2 ≤ r.end_.offset ∧
r.end_.key < ((leastReported r res : Key) : WithTop Key) ∧
intervalCard r.end_.key ((leastReported r res : Key) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞)
/-- A forward truncated result at begin offset zero, crossed, with the end key strictly
below the reported head and more keys available in the gap `[end.key, head)` than the
end offset can absorb. In this cell the whole gap up to the head is necessary. -/
abbrev zeroCrossTruncLowEndBig (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
2 ≤ r.end_.offset ∧
r.end_.key < ((leastReported r res : Key) : WithTop Key) ∧
(((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((leastReported r res : Key) : WithTop Key) +
(res.keys.length : ℕ∞)
/-- The crossed truncated begin-zero closed form. -/
noncomputable def closedFormZeroCrossTrunc (r : RangeRead) (res : Result) : ConflictRange :=
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)⟩
/-- The crossed truncated begin-zero closed form when the gap `[end.key, head)` is
saturated: the lower endpoint drops to `end.key`. -/
noncomputable def closedFormZeroCrossTruncLowEnd (r : RangeRead) (res : Result) :
ConflictRange :=
⟨r.end_.key,
max r.begin.key (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)⟩
/-- A forward truncated result at begin offset zero, crossed, with a nonpositive end
offset. -/
abbrev zeroCrossTruncNonposEnd (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
r.end_.offset ≤ 0
/-- A forward truncated result at begin offset zero, crossed, with `end.offset = 0`. -/
abbrev zeroCrossTruncZeroEnd (r : RangeRead) (res : Result) : Prop :=
r.begin.offset = 0 ∧ r.reverse = false ∧ res.more = true ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
r.end_.offset = 0
/-- The crossed truncated begin-zero closed form with a nonpositive end offset: the
reported head up to the larger of `begin.key` and `end_.key`. -/
noncomputable def closedFormZeroCrossTruncNonposEnd (r : RangeRead) (res : Result) :
ConflictRange :=
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key r.end_.key⟩
/-- `getLastD` agrees with `getLast` on a nonempty list. -/
theorem getLastD_eq_getLast_zero_cross_trunc {l : List Key} (h : l ≠ []) :
l.getLastD ([] : Key) = l.getLast h := by
cases l with
| nil => exact absurd rfl h
| cons a t =>
cases t with
| nil => rfl
| cons b t => simp [List.getLastD, List.getLast]
/-- `headD` agrees with `head` on a nonempty list. -/
theorem headD_eq_head_zero_cross_trunc {l : List Key} (h : l ≠ []) :
l.headD ([] : Key) = l.head h := by
rw [List.headD_eq_head?, List.head?_eq_some_head h]; rfl
/-- At begin offset zero, a compatible crossed truncated read resolves its begin
selector onto the reported head. -/
theorem resolve_begin_eq_head_of_zero_crossed_more {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)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) :
resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne
have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hcomp).subset hhead_mem
have hhead_db : res.keys.head hne ∈ db.keys :=
(RangeRead.mem_completeKeys.mp hhead_ck).1
exact le_antisymm
(RangeRead.mem_completeKeys.mp hhead_ck).2.1
(resolve_zero_begin_le_of_mem_below hbegin hhead_db hcross
(res.keys.head hne) hhead_db hcross)
/-- In a compatible crossed truncated begin-zero read, no stored key lies strictly
between the reported head and `begin.key`. -/
theorem no_stored_between_head_begin_of_zero_crossed_more {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)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key) :
∀ k ∈ db.keys, ¬ (((res.keys.head hne : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne
have hhead_db : res.keys.head hne ∈ db.keys :=
RangeRead.compatible_keys_subset hcomp hhead_mem
have hL := resolve_begin_eq_head_of_zero_crossed_more hcomp hrev hmore hne hbegin hcross
intro k hk hkb
have hle := resolve_zero_begin_le_of_mem_below hbegin hhead_db hcross k hk hkb.2
rw [hL] at hle
exact absurd hle (not_le.mpr hkb.1)
/-- With an unbounded end selector, the complete keys are exactly the stored keys at
or above the begin resolution. -/
theorem completeKeys_eq_filter_ge_of_end_top {db : DB} {r : RangeRead} {H : Key}
(hrev : r.reverse = false) (hendkey : r.end_.key = (⊤ : WithTop Key))
(hendoff : 1 ≤ r.end_.offset)
(hbegin : resolve db r.begin = ((H : Key) : WithTop Key)) :
RangeRead.completeKeys db r =
db.keys.filter (fun k : Key => decide (((H : Key) : WithTop Key) ≤ (k : WithTop Key))) := by
have htop : resolve db r.end_ = (⊤ : WithTop Key) :=
resolve_eq_top_of_key_eq_top hendkey hendoff
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hbegin, htop]
apply List.filter_congr
intro k _
rw [decide_eq_decide]
exact ⟨fun h => h.1, fun h => ⟨h, WithTop.coe_lt_top k⟩⟩
/-- The stored keys in `[H, last]` in a crossed truncated begin-zero read. -/
theorem completeKeys_filter_le_of_end_top {db : DB} {r : RangeRead} {H last : Key}
(hrev : r.reverse = false) (hendkey : r.end_.key = (⊤ : WithTop Key))
(hendoff : 1 ≤ r.end_.offset)
(hbegin : resolve db r.begin = ((H : Key) : WithTop Key)) :
(RangeRead.completeKeys db r).filter
(fun k : Key => decide (k ≤ last)) =
(db.keys.filter (fun k : Key => decide (((H : Key) : WithTop Key) ≤ (k : WithTop
Key)))).filter
(fun k : Key => decide (k ≤ last)) := by
rw [completeKeys_eq_filter_ge_of_end_top (db := db) hrev hendkey hendoff hbegin]
/-- For `end_.offset = 1`, a stored key strictly below the resolved end is strictly
below `end_.key`. -/
theorem lt_end_key_of_lt_resolve_end_offset_one {db : DB} {r : RangeRead}
(hend : r.end_.offset = 1) {k : Key} (hk : k ∈ db.keys)
(h : (k : WithTop Key) < resolve db r.end_) :
(k : WithTop Key) < r.end_.key := by
set c := db.keys.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) with hc
have hanc : r.end_.anchor db = (c : ℤ) := by
unfold Selector.anchor; rw [hc]; omega
by_cases hlt : c < db.keys.length
· have hres : resolve db r.end_ = (((db.keys[c]'hlt : Key)) : WithTop Key) := by
rw [resolve_eq_ite, ite_eq_right (by rw [hanc]; exact not_lt.mpr (Int.natCast_nonneg _)),
hanc, Int.toNat_natCast, List.getElem?_eq_getElem hlt]
rw [hres] at h
by_contra hkE
push Not at hkE
obtain ⟨j, hj, hjx⟩ := List.mem_iff_getElem.mp hk
have hcj : c ≤ j := by
by_contra hcon
have hjc : j < c := not_le.mp hcon
have hklt := getElem_lt_of_lt_countP_top (w := r.end_.key) db.sorted hj
(by rw [← hc]; exact hjc)
rw [hjx] at hklt
exact absurd hkE (not_le.mpr hklt)
have hle0 : db.keys[c] ≤ db.keys[j] := (db.sorted.getElem_le_getElem_iff).mpr hcj
rw [hjx] at hle0
exact absurd h (not_lt.mpr (WithTop.coe_le_coe.mpr hle0))
· have hclen : c = db.keys.length :=
le_antisymm (by rw [hc]; exact List.countP_le_length) (not_lt.mp hlt)
have : decide ((k : WithTop Key) < r.end_.key) = true :=
(List.countP_eq_length.mp hclen) k hk
exact of_decide_eq_true this
/-- Filtering the complete keys at or below `last` reads off the stored keys in
`[H, last]`, provided the begin resolution is `H` and `last` lies below the end
resolution. This does not require the end resolution to be unbounded. -/
theorem completeKeys_filter_le_of_resolve_begin {db : DB} {r : RangeRead} {H last : Key}
(hrev : r.reverse = false)
(hbegin : resolve db r.begin = ((H : Key) : WithTop Key))
(hlt : ((last : Key) : WithTop Key) < resolve db r.end_) :
(RangeRead.completeKeys db r).filter
(fun k : Key => decide (k ≤ last)) =
db.keys.filter (fun k : Key => decide
(((H : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hbegin, List.filter_filter]
apply List.filter_congr
intro k _
by_cases hH : ((H : Key) : WithTop Key) ≤ (k : WithTop Key)
· by_cases hL : k ≤ last
· have hR : (k : WithTop Key) < resolve db r.end_ :=
lt_of_le_of_lt (WithTop.coe_le_coe.mpr hL) hlt
simp [hH, hL, hR]
· simp [hH, hL]
· simp [hH]
/-- Splitting the stored keys in `[E, last]` at `head`. -/
theorem filter_end_le_split_between {db : DB} {E : WithTop Key} {head last : Key}
(hEh : E ≤ (head : WithTop Key)) (hhl : head ≤ last) :
(db.keys.filter (fun (k : Key) => decide (E ≤ (k : WithTop Key)))).filter
(fun (k : Key) => decide (k ≤ last)) =
between db E ((head : Key) : WithTop Key) ++
db.keys.filter (fun (k : Key) => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr ((db.sorted.pairwise.filter _).filter _)
· rw [List.sortedLT_iff_pairwise, List.pairwise_append]
refine ⟨?_, ?_, ?_⟩
· rw [← List.sortedLT_iff_pairwise]
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
· rw [← List.sortedLT_iff_pairwise]
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
· intro x hx y hy
simp only [between, List.mem_filter, decide_eq_true_eq] at hx
simp only [List.mem_filter, decide_eq_true_eq] at hy
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mp hx.2.2) (WithTop.coe_le_coe.mp hy.2.1)
· intro k
rw [List.mem_filter, List.mem_filter, List.mem_append, between, List.mem_filter,
List.mem_filter]
simp only [decide_eq_true_eq]
constructor
· rintro ⟨⟨hkdb, hEk⟩, hklast⟩
by_cases hkh : (k : WithTop Key) < (head : WithTop Key)
· exact Or.inl ⟨hkdb, hEk, hkh⟩
· exact Or.inr ⟨hkdb, not_lt.mp hkh, hklast⟩
· rintro (⟨hkdb, hEk, hkh⟩ | ⟨hkdb, hHk, hklast⟩)
· exact ⟨⟨hkdb, hEk⟩, le_trans (le_of_lt (WithTop.coe_lt_coe.mp hkh)) hhl⟩
· exact ⟨⟨hkdb, le_trans hEh hHk⟩, hklast⟩
/-- **Compatibility transfers across agreement on the crossed truncated begin-zero
range.** -/
theorem compatible_of_agree_zeroCrossTrunc {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hend : r.end_.offset = 1 ∨ (r.end_.key = (⊤ : WithTop Key) ∧ 1 ≤ r.end_.offset))
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormZeroCrossTrunc r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormZeroCrossTrunc r res) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
have hno1 := no_stored_between_head_begin_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross'
have hno2 : ∀ k ∈ db2.keys, ¬ (((head : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
intro k hk2 hkb
have hk1 : k ∈ db1.keys :=
(hmk k (le_of_lt hkb.1) (lt_of_lt_of_le hkb.2 (le_max_left _ _))).mpr hk2
exact hno1 k hk1 hkb
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_db2 hcross' hno2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ := by
rcases hend with hend | ⟨hendkey, hendoff⟩
· have hlast_db1 : last ∈ db1.keys :=
(RangeRead.mem_completeKeys.mp hlast_ck1).1
have hlastE : ((last : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_offset_one hend hlast_db1 hlt1
have hcnt : ((db2.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
have hzero : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop
Key)))).filter
(fun k : Key => decide (k ≤ last))).length = 0 := by
rw [List.length_eq_zero_iff, List.filter_eq_nil_iff]
intro k hk
have hkge : r.end_.key ≤ (k : WithTop Key) :=
decide_eq_true_eq.mp (List.mem_filter.mp hk).2
have hlastk : last < k :=
WithTop.coe_lt_coe.mp (lt_of_lt_of_le hlastE hkge)
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_le]
exact hlastk
rw [hzero, hend]
simp
exact resolve_end_gt_of_filter_length_le (by rw [hend]) hcnt
· rw [resolve_eq_top_of_key_eq_top hendkey hendoff]
exact WithTop.coe_lt_top last
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
have hck1 : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hck2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
have heq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1,
hge, hle⟩
· rintro ⟨hk2, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2,
hge, hle⟩
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hck2, ← heq, ← hck1, hres1len]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- **Compatibility transfers across agreement on the crossed truncated begin-zero
range when every reported key is below `end.key` and the end offset is at least one.** -/
theorem compatible_of_agree_zeroCrossTruncBelowEnd {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hge : 1 ≤ r.end_.offset)
(hbelow : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormZeroCrossTrunc r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormZeroCrossTrunc r res) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
have hno1 := no_stored_between_head_begin_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross'
have hno2 : ∀ k ∈ db2.keys, ¬ (((head : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
intro k hk2 hkb
have hk1 : k ∈ db1.keys :=
(hmk k (le_of_lt hkb.1) (lt_of_lt_of_le hkb.2 (le_max_left _ _))).mpr hk2
exact hno1 k hk1 hkb
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_db2 hcross' hno2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hlastE : ((last : Key) : WithTop Key) < r.end_.key := by
rw [hlast]
exact hbelow (res.keys.getLast hne) (List.getLast_mem hne)
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
lt_of_lt_of_le hlastE (key_le_resolve_of_one_le (db := db2) (s := r.end_) hge)
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
have hck1 : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hck2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
have heq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge', hle⟩
exact ⟨(hmk k hge' (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1,
hge', hle⟩
· rintro ⟨hk2, hge', hle⟩
exact ⟨(hmk k hge' (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2,
hge', hle⟩
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hck2, ← heq, ← hck1, hres1len]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- **Compatibility transfers across agreement on the crossed truncated begin-zero
range when the end key is at or above the reported head and the end offset is at
least one.** -/
theorem compatible_of_agree_zeroCrossTruncEndGeHead {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hge : 1 ≤ r.end_.offset)
(hheadE : ((res.keys.head hne : Key) : WithTop Key) ≤ r.end_.key)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormZeroCrossTrunc r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hheadE' : ((head : Key) : WithTop Key) ≤ r.end_.key := by
rw [hhead]; exact hheadE
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormZeroCrossTrunc r res) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
have hno1 := no_stored_between_head_begin_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross'
have hno2 : ∀ k ∈ db2.keys, ¬ (((head : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
intro k hk2 hkb
have hk1 : k ∈ db1.keys :=
(hmk k (le_of_lt hkb.1) (lt_of_lt_of_le hkb.2 (le_max_left _ _))).mpr hk2
exact hno1 k hk1 hkb
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_db2 hcross' hno2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hfiltereq : (db1.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) =
(db2.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr ((db1.sorted.pairwise.filter _).filter _)
· exact List.sortedLT_iff_pairwise.mpr ((db2.sorted.pairwise.filter _).filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨⟨hk1, hEk⟩, hkle⟩
exact ⟨⟨(hmk k (le_trans hheadE' hEk)
(lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkle) hlast_upper)).mp hk1, hEk⟩, hkle⟩
· rintro ⟨⟨hk2, hEk⟩, hkle⟩
exact ⟨⟨(hmk k (le_trans hheadE' hEk)
(lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkle) hlast_upper)).mpr hk2, hEk⟩, hkle⟩
have hcnt1 : ((db1.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 :=
filter_length_le_offset_of_resolve_end_gt (db := db1) hge hlt1
have hcnt2 : ((db2.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 [← hfiltereq]
exact hcnt1
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
resolve_end_gt_of_filter_length_le (db := db2) hge hcnt2
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
have hck1 : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hck2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
have heq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge', hle⟩
exact ⟨(hmk k hge' (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1,
hge', hle⟩
· rintro ⟨hk2, hge', hle⟩
exact ⟨(hmk k hge' (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2,
hge', hle⟩
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hck2, ← heq, ← hck1, hres1len]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- **Compatibility transfers across agreement on the crossed truncated begin-zero
range when the end key is below the reported head but the gap to the head absorbs the
reported keys.** -/
theorem compatible_of_agree_zeroCrossTruncLowEndSmall {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hge : 2 ≤ r.end_.offset)
(hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key))
(hsmall : intervalCard r.end_.key (((res.keys.head hne : Key)) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞))
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormZeroCrossTrunc r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by
rw [hhead]; exact hEhead
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormZeroCrossTrunc r res) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
have hno1 := no_stored_between_head_begin_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross'
have hno2 : ∀ k ∈ db2.keys, ¬ (((head : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
intro k hk2 hkb
have hk1 : k ∈ db1.keys :=
(hmk k (le_of_lt hkb.1) (lt_of_lt_of_le hkb.2 (le_max_left _ _))).mpr hk2
exact hno1 k hk1 hkb
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_db2 hcross' hno2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hpart1 : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
have hck1 := completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
rw [← hck1]; exact hres1len
have hpart2 : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
have heq : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr (db2.sorted.pairwise.filter _)
· exact List.sortedLT_iff_pairwise.mpr (db1.sorted.pairwise.filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk2, hHk, hklast⟩
exact ⟨(hmk k hHk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mpr hk2,
hHk, hklast⟩
· rintro ⟨hk1, hHk, hklast⟩
exact ⟨(hmk k hHk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mp hk1,
hHk, hklast⟩
rw [heq, hpart1]
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hc1 hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
have hsplit := filter_end_le_split_between (db := db2) (E := r.end_.key)
(head := head) (last := last) (le_of_lt hEhead') hhead_le_last
have hbetween : (((between db2 r.end_.key ((head : Key) : WithTop Key)).length : ℕ∞)) ≤
intervalCard r.end_.key ((head : Key) : WithTop Key) :=
between_length_le_intervalCard (db := db2) (le_of_lt hEhead')
have hsum : ((((between db2 r.end_.key ((head : Key) : WithTop Key)).length +
res.keys.length : ℕ)) : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) := by
rw [Nat.cast_add]
exact le_trans (add_le_add hbetween le_rfl) hsmall
have hcnt2 : ((db2.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
have hlen : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length =
(between db2 r.end_.key ((head : Key) : WithTop Key)).length + res.keys.length := by
rw [hsplit, hpart2, List.length_append]
rw [hlen]
exact_mod_cast hsum
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
resolve_end_gt_of_filter_length_le (db := db2) (by omega) hcnt2
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have hck2 := completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
rw [hck2, hpart2]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- **Compatibility transfers across agreement on the saturated crossed truncated
begin-zero range `[end.key, max begin.key (keyAfter last))`.** Here the end gap is
explicitly tracked, so the count of stored keys in `[end.key, last]` is the same in
both databases. -/
theorem compatible_of_agree_zeroCrossTruncLowEndBig {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hge : 2 ≤ r.end_.offset)
(hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key))
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormZeroCrossTruncLowEnd r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by
rw [hhead]; exact hEhead
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross
have hcr : closedFormZeroCrossTruncLowEnd r res =
⟨r.end_.key, max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTruncLowEnd
rw [hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hE_upper : r.end_.key < upper := lt_trans hEhead' (lt_of_lt_of_le hcross' (le_max_left _ _))
have hhead_upper : ((head : Key) : WithTop Key) < upper :=
lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper :=
lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormZeroCrossTruncLowEnd r res) db1 db2).mp hagree
have hmk : ∀ k : Key, r.end_.key ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys :=
(hmk head (le_of_lt hEhead') hhead_upper).mp hhead_db1
have hno1 := no_stored_between_head_begin_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross'
have hno2 : ∀ k ∈ db2.keys, ¬ (((head : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
intro k hk2 hkb
have hk1 : k ∈ db1.keys :=
(hmk k (le_trans (le_of_lt hEhead') (le_of_lt hkb.1))
(lt_of_lt_of_le hkb.2 (le_max_left _ _))).mpr hk2
exact hno1 k hk1 hkb
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_db2 hcross' hno2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hpart1 : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
have hck1 := completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
rw [← hck1]; exact hres1len
have hpart2 : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
have heq : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr (db2.sorted.pairwise.filter _)
· exact List.sortedLT_iff_pairwise.mpr (db1.sorted.pairwise.filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk2, hHk, hklast⟩
exact ⟨(hmk k (le_trans (le_of_lt hEhead') hHk)
(lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mpr hk2,
hHk, hklast⟩
· rintro ⟨hk1, hHk, hklast⟩
exact ⟨(hmk k (le_trans (le_of_lt hEhead') hHk)
(lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mp hk1,
hHk, hklast⟩
rw [heq, hpart1]
have hcnt1 : ((db1.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 :=
filter_length_le_offset_of_resolve_end_gt (db := db1) (by omega) hlt1
have hcnt_eq : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))) =
((db1.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr ((db2.sorted.pairwise.filter _).filter _)
· exact List.sortedLT_iff_pairwise.mpr ((db1.sorted.pairwise.filter _).filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨⟨hk2, hEk⟩, hklast⟩
exact ⟨⟨(hmk k hEk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mpr hk2,
hEk⟩, hklast⟩
· rintro ⟨⟨hk1, hEk⟩, hklast⟩
exact ⟨⟨(hmk k hEk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mp hk1,
hEk⟩, hklast⟩
have hcnt2 : ((db2.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 [hcnt_eq]; exact hcnt1
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
resolve_end_gt_of_filter_length_le (db := db2) (by omega) hcnt2
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have hck2 := completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
rw [hck2, hpart2]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- **The crossed truncated begin-zero closed form is minimal** when the end selector
is unbounded. -/
theorem minimal_closedForm_of_zeroCross_trunc_readAllEnd {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncReadAllEnd r res) :
Minimal r res (closedFormZeroCrossTrunc r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hend⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread'
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTrunc hrev hmore hne hbegin hcross hend hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTrunc hrev hmore hne hbegin hcross hend hc2
(AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· -- `last < k < begin.key`
have hk_gt_last : last < k := lt_of_not_ge hkle
have hhead_lt_k : head < k := lt_of_le_of_lt hhead_le_last hk_gt_last
have hk_lt_B : (k : WithTop Key) < r.begin.key := by
by_contra hnot
have hBle : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hnot
by_cases hc : r.begin.key ≤ (((keyAfter last : Key)) : WithTop Key)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
(((keyAfter last : Key)) : WithTop Key) := max_eq_right hc
rw [hupper] at hkhi
have hkle' : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp hkhi)
exact absurd hkle' (not_le.mpr hk_gt_last)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
r.begin.key := max_eq_left (le_of_not_ge hc)
rw [hupper] at hkhi
exact absurd hBle (not_le.mpr hkhi)
have hno := no_stored_between_head_begin_of_zero_crossed_more hcomp₀ hrev hmore hne
hbegin hcross'
have hk_notmem : k ∉ db₀.keys := by
intro hkdb
exact hno k hkdb ⟨by exact WithTop.coe_lt_coe.mpr hhead_lt_k, hk_lt_B⟩
let db' : DB := toggle db₀ k
have hdb' : db' = db₀.insert k hk_notmem := toggle_eq_insert_of_not_mem hk_notmem
have hk_mem' : k ∈ db'.keys := by
rw [hdb']
exact DB.mem_insert_self db₀ k hk_notmem
have hno' : ∀ z ∈ db'.keys, ¬ (((k : Key) : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hdb', DB.insert_keys, List.mem_orderedInsert] at hz
rcases hz with hzk | hzold
· subst hzk
exact absurd hzb.1 (not_lt.mpr le_rfl)
· have hz0 : z ∈ db₀.keys := hzold
exact hno z hz0 ⟨lt_trans (WithTop.coe_lt_coe.mpr hhead_lt_k) hzb.1, hzb.2⟩
have hresb : resolve db' r.begin = ((k : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hk_mem' hk_lt_B hno'
have hnot : ¬ RangeRead.Compatible db' r res := by
intro hcomp'
have h := ((compatible_iff_truncated_keys (db := db') hrev hmore hne).mp hcomp').2
have hempty : (RangeRead.completeKeys db' r).filter
(fun x : Key => decide (x ≤ last)) = [] := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hresb]
rw [List.filter_eq_nil_iff]
intro x hx
have hx' : ((k : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < resolve db' r.end_ :=
decide_eq_true_eq.mp (List.mem_filter.mp hx).2
have hkx : k ≤ x := WithTop.coe_le_coe.mp hx'.1
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_le]
exact lt_of_lt_of_le hk_gt_last hkx
rw [hempty] at h
exact hne h.symm
exact necessary_of_toggle ⟨db₀, hcomp₀, hnot⟩
/-- **The crossed truncated begin-zero closed form is minimal** when every reported key is
below `end.key` and `end.offset ≥ 1`. -/
theorem minimal_closedForm_of_zeroCross_trunc_belowEnd {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncBelowEnd r res) :
Minimal r res (closedFormZeroCrossTrunc r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hge, hbelow⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread'
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTruncBelowEnd hrev hmore hne hbegin hcross hge
hbelow hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTruncBelowEnd hrev hmore hne hbegin hcross hge
hbelow hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· have hk_gt_last : last < k := lt_of_not_ge hkle
have hhead_lt_k : head < k := lt_of_le_of_lt hhead_le_last hk_gt_last
have hk_lt_B : (k : WithTop Key) < r.begin.key := by
by_contra hnot
have hBle : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hnot
by_cases hc : r.begin.key ≤ (((keyAfter last : Key)) : WithTop Key)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
(((keyAfter last : Key)) : WithTop Key) := max_eq_right hc
rw [hupper] at hkhi
have hkle' : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp hkhi)
exact absurd hkle' (not_le.mpr hk_gt_last)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
r.begin.key := max_eq_left (le_of_not_ge hc)
rw [hupper] at hkhi
exact absurd hBle (not_le.mpr hkhi)
-- insert `k` into the gap `(last, begin.key)`
have hno := no_stored_between_head_begin_of_zero_crossed_more hcomp₀ hrev hmore hne
hbegin hcross'
have hk_notmem : k ∉ db₀.keys := by
intro hkdb
exact hno k hkdb ⟨by exact WithTop.coe_lt_coe.mpr hhead_lt_k, hk_lt_B⟩
let db' : DB := toggle db₀ k
have hdb' : db' = db₀.insert k hk_notmem := toggle_eq_insert_of_not_mem hk_notmem
have hk_mem' : k ∈ db'.keys := by
rw [hdb']
exact DB.mem_insert_self db₀ k hk_notmem
have hno' : ∀ z ∈ db'.keys, ¬ (((k : Key) : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hdb', DB.insert_keys, List.mem_orderedInsert] at hz
rcases hz with hzk | hzold
· subst hzk
exact absurd hzb.1 (not_lt.mpr le_rfl)
· have hz0 : z ∈ db₀.keys := hzold
exact hno z hz0 ⟨lt_trans (WithTop.coe_lt_coe.mpr hhead_lt_k) hzb.1, hzb.2⟩
have hresb : resolve db' r.begin = ((k : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hk_mem' hk_lt_B hno'
have hnot : ¬ RangeRead.Compatible db' r res := by
intro hcomp'
have h := ((compatible_iff_truncated_keys (db := db') hrev hmore hne).mp hcomp').2
have hempty : (RangeRead.completeKeys db' r).filter
(fun x : Key => decide (x ≤ last)) = [] := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hresb]
rw [List.filter_eq_nil_iff]
intro x hx
have hx' : ((k : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < resolve db' r.end_ :=
decide_eq_true_eq.mp (List.mem_filter.mp hx).2
have hkx : k ≤ x := WithTop.coe_le_coe.mp hx'.1
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_le]
exact lt_of_lt_of_le hk_gt_last hkx
rw [hempty] at h
exact hne h.symm
exact necessary_of_toggle ⟨db₀, hcomp₀, hnot⟩
/-- **Compatibility transfers across agreement on the nonpositive-end crossed
truncated begin-zero range.** -/
theorem compatible_of_agree_zeroCrossTruncNonposEnd {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hend : r.end_.offset ≤ 0)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormZeroCrossTruncNonposEnd r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross
have hcr : closedFormZeroCrossTruncNonposEnd r res =
⟨((head : Key) : WithTop Key), max r.begin.key r.end_.key⟩ := by
unfold closedFormZeroCrossTruncNonposEnd
rw [hheadD]
set upper : WithTop Key := max r.begin.key r.end_.key with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hsort := (RangeRead.compatible_sortedLT hc1 hrev).pairwise.imp le_of_lt
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
have hle := resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend
exact lt_of_lt_of_le (lt_of_lt_of_le hlt1 hle) (by rw [hupper]; exact le_max_right _ _)
have hmem := (agreeOn_iff (closedFormZeroCrossTruncNonposEnd r res) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
have hno1 := no_stored_between_head_begin_of_zero_crossed_more hc1 hrev hmore hne hbegin hcross'
have hno2 : ∀ k ∈ db2.keys, ¬ (((head : Key) : WithTop Key) < (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key) := by
intro k hk2 hkb
have hk1 : k ∈ db1.keys :=
(hmk k (le_of_lt hkb.1) (lt_of_lt_of_le hkb.2 (by rw [hupper]; exact le_max_left _ _))).mpr
hk2
exact hno1 k hk1 hkb
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_db2 hcross' hno2
have hne_top : resolve db1 r.end_ ≠ (⊤ : WithTop Key) :=
resolve_ne_top_of_offset_nonpos hend
obtain ⟨q, hq⟩ := WithTop.ne_top_iff_exists.mp hne_top
have hlast_q : last < q := by
have h := hlt1
rw [← hq] at h
exact WithTop.coe_lt_coe.mp h
have hqne : q ≠ ([] : Key) := by
intro hnil
have h : last < ([] : Key) := by rwa [hnil] at hlast_q
exact absurd h (List.not_lt_nil last)
have hq_le_E : ((q : Key) : WithTop Key) ≤ r.end_.key := by
rw [hq]
exact resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend
have hhead_q : ((head : Key) : WithTop Key) ≤ ((q : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hhead_le_last hlast_q))
have hEnd_upper : r.end_.key ≤ upper := by
rw [hupper]; exact le_max_right _ _
have hagreeEnd : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mp hk1, hge, hlt⟩
· rintro ⟨hk2, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mpr hk2, hge, hlt⟩
have hqget := resolve_filter_reverse_eq_some_of_ne_nil (db := db1) (s := r.end_) hend hqne hq.symm
have hresEnd2 : resolve db2 r.end_ = ((q : Key) : WithTop Key) :=
resolve_eq_of_agree_between (db₁ := db1) (db₂ := db2) (s := r.end_) hend
(E := r.end_.key) rfl (le_trans hhead_q hq_le_E) hagreeEnd hqget hhead_q
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ := by
rw [hresEnd2]
exact WithTop.coe_lt_coe.mpr hlast_q
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
have hck1 : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hck2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
have heq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1,
hge, hle⟩
· rintro ⟨hk2, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2,
hge, hle⟩
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hck2, ← heq, ← hck1, hres1len]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- A key strictly between the reported last and `begin.key` is necessary in a crossed
truncated begin-zero read. -/
theorem necessary_zeroCross_trunc_gap {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hkgt : res.keys.getLast hne < k) (hkB : (k : WithTop Key) < r.begin.key) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
have hhead_lt_k : head < k := lt_of_le_of_lt hhead_le_last hkgt
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hno := no_stored_between_head_begin_of_zero_crossed_more hcomp₀ hrev hmore hne
hbegin hcross'
have hk_notmem : k ∉ db₀.keys := by
intro hkdb
exact hno k hkdb ⟨WithTop.coe_lt_coe.mpr hhead_lt_k, hkB⟩
let db' : DB := toggle db₀ k
have hdb' : db' = db₀.insert k hk_notmem := toggle_eq_insert_of_not_mem hk_notmem
have hk_mem' : k ∈ db'.keys := by
rw [hdb']
exact DB.mem_insert_self db₀ k hk_notmem
have hno' : ∀ z ∈ db'.keys, ¬ (((k : Key) : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hdb', DB.insert_keys, List.mem_orderedInsert] at hz
rcases hz with hzk | hzold
· subst hzk
exact absurd hzb.1 (not_lt.mpr le_rfl)
· have hz0 : z ∈ db₀.keys := hzold
exact hno z hz0 ⟨lt_trans (WithTop.coe_lt_coe.mpr hhead_lt_k) hzb.1, hzb.2⟩
have hresb : resolve db' r.begin = ((k : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hk_mem' hkB hno'
have hnot : ¬ RangeRead.Compatible db' r res := by
intro hcomp'
have h := ((compatible_iff_truncated_keys (db := db') hrev hmore hne).mp hcomp').2
have hempty : (RangeRead.completeKeys db' r).filter
(fun x : Key => decide (x ≤ last)) = [] := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hresb]
rw [List.filter_eq_nil_iff]
intro x hx
have hx' : ((k : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < resolve db' r.end_ :=
decide_eq_true_eq.mp (List.mem_filter.mp hx).2
have hkx : k ≤ x := WithTop.coe_le_coe.mp hx'.1
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_le]
exact lt_of_lt_of_le hkgt hkx
rw [hempty] at h
exact hne h.symm
exact necessary_of_toggle ⟨db₀, hcomp₀, hnot⟩
/-- **The crossed truncated begin-zero closed form is minimal** when the end key is at
or above the reported head and `end.offset ≥ 1`. -/
theorem minimal_closedForm_of_zeroCross_trunc_endGeHead {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncEndGeHead r res) :
Minimal r res (closedFormZeroCrossTrunc r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hge, hheadE⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread'
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hheadE' : ((head : Key) : WithTop Key) ≤ r.end_.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, hheadD] at hheadE
exact hheadE
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTruncEndGeHead hrev hmore hne hbegin hcross hge
hheadE' hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTruncEndGeHead hrev hmore hne hbegin hcross hge
hheadE' hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· have hk_gt_last : last < k := lt_of_not_ge hkle
have hhead_lt_k : head < k := lt_of_le_of_lt hhead_le_last hk_gt_last
have hk_lt_B : (k : WithTop Key) < r.begin.key := by
by_contra hnot
have hBle : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hnot
by_cases hc : r.begin.key ≤ (((keyAfter last : Key)) : WithTop Key)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
(((keyAfter last : Key)) : WithTop Key) := max_eq_right hc
rw [hupper] at hkhi
have hkle' : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp hkhi)
exact absurd hkle' (not_le.mpr hk_gt_last)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
r.begin.key := max_eq_left (le_of_not_ge hc)
rw [hupper] at hkhi
exact absurd hBle (not_le.mpr hkhi)
exact necessary_zeroCross_trunc_gap hread hrev hmore hne hbegin hcross hk_gt_last hk_lt_B
/-- A bounded gap with more keys than the end offset can absorb makes every key in
`[end.key, head)` necessary: filling the gap to the offset and then adding the target
overflows the end resolution. -/
theorem necessary_zeroCross_trunc_between_end_head {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hge : 2 ≤ r.end_.offset)
(hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key))
(hbig : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((res.keys.head hne : Key) : WithTop Key) +
(res.keys.length : ℕ∞))
(hkE : r.end_.key ≤ (k : WithTop Key))
(hkH : (k : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
set e1 : ℕ := (r.end_.offset - 1).toNat with he1
set rl : ℕ := res.keys.length with hrl
set n : ℕ := e1 - rl with hn
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by rw [hhead]; exact hcross
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by rw [hhead]; exact hEhead
have hkH' : (k : WithTop Key) < ((head : Key) : WithTop Key) := by rw [hhead]; exact hkH
have hres_sorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
have hres_pair : res.keys.Pairwise (· ≤ ·) := hres_sorted.pairwise.imp le_of_lt
have hhead_le : ∀ x ∈ res.keys, head ≤ x := by
intro x hx
have := hres_pair.rel_head hx
simpa [hhead] using this
have hle_last : ∀ x ∈ res.keys, x ≤ last := by
intro x hx
have := hres_pair.rel_getLast hx
simpa [hlast] using this
have hlast_mem : last ∈ res.keys := by rw [hlast]; exact List.getLast_mem hne
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
have hhead_le_last : head ≤ last := hhead_le last hlast_mem
have hno := no_stored_between_head_begin_of_zero_crossed_more hcomp₀ hrev hmore hne hbegin hcross'
-- The reported length is bounded by the end offset.
have hlast_ck0 : last ∈ RangeRead.completeKeys db₀ r :=
(RangeRead.compatible_keys_prefix hcomp₀).subset hlast_mem
have hlt0 : ((last : Key) : WithTop Key) < resolve db₀ r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck0).2.2
have hcnt0 : ((db₀.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last))).length ≤ e1 := by
simpa [he1] using filter_length_le_offset_of_resolve_end_gt (db := db₀) (by omega) hlt0
have hres_sub : res.keys ⊆
((db₀.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last))) := by
intro x hx
have hxdb : x ∈ db₀.keys := RangeRead.compatible_keys_subset hcomp₀ hx
have hxE : r.end_.key ≤ (x : WithTop Key) :=
le_trans (le_of_lt hEhead') (WithTop.coe_le_coe.mpr (hhead_le x hx))
have hxl : x ≤ last := hle_last x hx
rw [List.mem_filter, List.mem_filter]
exact ⟨⟨hxdb, by simpa using hxE⟩, by simpa using hxl⟩
have hrle : rl ≤ e1 := by
have := hres_sorted.nodup.length_le_of_subset hres_sub
exact le_trans (by simpa [hrl] using this) hcnt0
-- Capacity in the gap to build the witness.
have hbig' : (e1 : ℕ∞) < intervalCard r.end_.key ((head : Key) : WithTop Key) +
(rl : ℕ∞) := by
simpa [he1, hrl, hhead] using hbig
have hcard : ((n + 1 : ℕ) : ℕ∞) ≤
intervalCard r.end_.key ((head : Key) : WithTop Key) := by
by_cases htop : intervalCard r.end_.key ((head : Key) : WithTop Key) = (⊤ : ℕ∞)
· rw [htop]; exact le_top
· obtain ⟨G, hG⟩ := ENat.ne_top_iff_exists.mp htop
have hlt : e1 < G + rl := by
have hb := hbig'
rw [← hG] at hb
rw [← ENat.natCast_add] at hb
exact ENat.natCast_lt_natCast.mp hb
have hGle : n + 1 ≤ G := by
rw [hn]; omega
rw [← hG]
exact ENat.natCast_le_natCast.mpr hGle
obtain ⟨dbK, hKrange, hkK, hKlen⟩ :=
exists_db_keysIn_avoid (B := r.end_.key) (E := ((head : Key) : WithTop Key))
(k := k) (m := n) hcard
have hK_ge : ∀ x ∈ dbK.keys, r.end_.key ≤ (x : WithTop Key) :=
fun x hx => (hKrange x hx).1
have hK_lt : ∀ x ∈ dbK.keys, x < head :=
fun x hx => WithTop.coe_lt_coe.mp (hKrange x hx).2
-- The witness database.
have hsort_append : (dbK.keys ++ res.keys).SortedLT := by
refine List.sortedLT_append.mpr ⟨dbK.sorted, hres_sorted, ?_⟩
intro a ha b hb
exact lt_of_lt_of_le (hK_lt a ha) (hhead_le b hb)
let dbw : DB := ⟨dbK.keys ++ res.keys, hsort_append⟩
have hdbw : dbw.keys = dbK.keys ++ res.keys := rfl
have hk_notmem : k ∉ dbw.keys := by
rw [hdbw, List.mem_append]
rintro (hkK' | hkres)
· exact hkK hkK'
· exact absurd (hhead_le k hkres) (not_le.mpr (WithTop.coe_lt_coe.mp hkH'))
have hhead_dbw : head ∈ dbw.keys := by
rw [hdbw]; exact List.mem_append.mpr (Or.inr hhead_mem)
have hno_dbw : ∀ z ∈ dbw.keys, ¬ (((head : Key) : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hdbw, List.mem_append] at hz
rcases hz with hz | hz
· exact absurd hzb.1 (not_lt.mpr (WithTop.coe_le_coe.mpr (le_of_lt (hK_lt z hz))))
· exact hno z (RangeRead.compatible_keys_subset hcomp₀ hz) hzb
have hresb : resolve dbw r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_dbw hcross' hno_dbw
have hmem_all_E : ∀ x ∈ dbw.keys, r.end_.key ≤ (x : WithTop Key) := by
intro x hx
rw [hdbw, List.mem_append] at hx
rcases hx with hx | hx
· exact hK_ge x hx
· exact le_trans (le_of_lt hEhead') (WithTop.coe_le_coe.mpr (hhead_le x hx))
have hcntE : dbw.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hmem_all_E x hx)
have hdbw_len : dbw.keys.length = e1 := by
rw [hdbw, List.length_append, hKlen, ← hrl, hn]
exact Nat.sub_add_cancel hrle
have hanchor : (r.end_.anchor dbw).toNat = e1 := by
rw [anchor_toNat_eq (db := dbw) (s := r.end_) (by omega), hcntE, ← he1]
omega
have hrestop : resolve dbw r.end_ = (⊤ : WithTop Key) := by
apply resolve_eq_top
· exact anchor_nonneg_of_one_le (db := dbw) (s := r.end_) (by omega)
· rw [hanchor, hdbw_len]
have hck : RangeRead.completeKeys dbw r = res.keys := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hresb, hrestop]
have hpred : (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < (⊤ : WithTop Key))) =
(fun x : Key => decide (((head : Key) : WithTop Key) ≤ (x : WithTop Key))) := by
funext x; simp
rw [hpred, hdbw, List.filter_append]
have hleft : dbK.keys.filter
(fun x : Key => decide (((head : Key) : WithTop Key) ≤ (x : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_le.mpr (WithTop.coe_lt_coe.mpr (hK_lt x hx))
have hright : res.keys.filter
(fun x : Key => decide (((head : Key) : WithTop Key) ≤ (x : WithTop Key))) = res.keys := by
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact WithTop.coe_le_coe.mpr (hhead_le x hx)
rw [hleft, hright, List.nil_append]
have hfilter_le : res.keys.filter (fun x : Key => decide (x ≤ last)) = res.keys := by
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact hle_last x hx
have hcompw : RangeRead.Compatible dbw r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hcomp₀.1, by rw [hck, hfilter_le]⟩
-- Toggling the target on overflows the end offset.
have hdb' : toggle dbw k = dbw.insert k hk_notmem := toggle_eq_insert_of_not_mem hk_notmem
have hkeys_toggle : (toggle dbw k).keys = dbw.keys.orderedInsert (· ≤ ·) k := by
rw [hdb', DB.insert_keys]
have hlen_toggle : (toggle dbw k).keys.length = e1 + 1 := by
rw [hkeys_toggle, List.orderedInsert_length, hdbw_len]
have hmem_all : ∀ x ∈ (toggle dbw k).keys,
r.end_.key ≤ (x : WithTop Key) ∧ x ≤ last := by
intro x hx
rw [hkeys_toggle, List.mem_orderedInsert] at hx
rcases hx with rfl | hx
· exact ⟨hkE, le_trans (le_of_lt (WithTop.coe_lt_coe.mp hkH')) hhead_le_last⟩
· rw [hdbw, List.mem_append] at hx
rcases hx with hx | hx
· exact ⟨hK_ge x hx, le_trans (le_of_lt (hK_lt x hx)) hhead_le_last⟩
· exact ⟨le_trans (le_of_lt hEhead') (WithTop.coe_le_coe.mpr (hhead_le x hx)),
hle_last x hx⟩
have hcount_toggle :
((toggle dbw k).keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last)) = (toggle dbw k).keys := by
have h1 : (toggle dbw k).keys.filter
(fun x : Key => decide (r.end_.key ≤ (x : WithTop Key))) = (toggle dbw k).keys := by
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact (hmem_all x hx).1
rw [h1]
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact (hmem_all x hx).2
have hnot : ¬ RangeRead.Compatible (toggle dbw k) r res := by
intro hc
have hlast_ck : last ∈ RangeRead.completeKeys (toggle dbw k) r :=
(RangeRead.compatible_keys_prefix hc).subset hlast_mem
have hlt : ((last : Key) : WithTop Key) < resolve (toggle dbw k) r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck).2.2
have hcnt := filter_length_le_offset_of_resolve_end_gt (db := toggle dbw k) (by omega) hlt
rw [hcount_toggle, hlen_toggle, ← he1] at hcnt
omega
exact necessary_of_toggle ⟨dbw, hcompw, hnot⟩
/-- **The crossed truncated begin-zero closed form is minimal** when the end gap is
saturated: the whole gap `[end.key, head)` is necessary, so the lower endpoint drops to
`end.key`. -/
theorem minimal_closedForm_of_zeroCross_trunc_lowEndBig {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncLowEndBig r res) :
Minimal r res (closedFormZeroCrossTruncLowEnd r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hge, hEheadD, hbigD⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread'
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
have hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key) := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hEheadD
exact hEheadD
have hbig : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((res.keys.head hne : Key) : WithTop Key) +
(res.keys.length : ℕ∞) := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hbigD
exact hbigD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by
rw [hhead]; exact hEhead
have hbig' : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((head : Key) : WithTop Key) + (res.keys.length : ℕ∞) := by
simpa [hhead] using hbig
have hcr : closedFormZeroCrossTruncLowEnd r res =
⟨r.end_.key,
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTruncLowEnd
rw [hlastD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTruncLowEndBig hrev hmore hne hbegin hcross hge
hEhead' hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTruncLowEndBig hrev hmore hne hbegin hcross hge
hEhead' hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· by_cases hkhead : k < head
· exact necessary_zeroCross_trunc_between_end_head hread hrev hmore hne hbegin hcross hge
hEhead' hbig' hklo (WithTop.coe_lt_coe.mpr hkhead)
· exact Necessary.of_between hhead_nec hlast_nec (le_of_not_gt hkhead) hkle
· have hk_gt_last : last < k := lt_of_not_ge hkle
have hhead_lt_k : head < k := lt_of_le_of_lt hhead_le_last hk_gt_last
have hk_lt_B : (k : WithTop Key) < r.begin.key := by
by_contra hnot
have hBle : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hnot
by_cases hc : r.begin.key ≤ (((keyAfter last : Key)) : WithTop Key)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
(((keyAfter last : Key)) : WithTop Key) := max_eq_right hc
rw [hupper] at hkhi
have hkle' : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp hkhi)
exact absurd hkle' (not_le.mpr hk_gt_last)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
r.begin.key := max_eq_left (le_of_not_ge hc)
rw [hupper] at hkhi
exact absurd hBle (not_le.mpr hkhi)
exact necessary_zeroCross_trunc_gap hread hrev hmore hne hbegin hcross hk_gt_last hk_lt_B
/-- **The crossed truncated begin-zero closed form is minimal** when the end key is
below the reported head but the gap to the head absorbs the reported keys. -/
theorem minimal_closedForm_of_zeroCross_trunc_lowEndSmall {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncLowEndSmall r res) :
Minimal r res (closedFormZeroCrossTrunc r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hge, hEheadD, hsmallD⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread'
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
have hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key) := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hEheadD
exact hEheadD
have hsmall : intervalCard r.end_.key (((res.keys.head hne : Key)) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hsmallD
exact hsmallD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, getLastD_eq_getLast_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by
rw [hhead]; exact hEhead
have hcr : closedFormZeroCrossTrunc r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormZeroCrossTrunc
rw [hheadD, hlastD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTruncLowEndSmall hrev hmore hne hbegin hcross hge
hEhead' hsmall hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTruncLowEndSmall hrev hmore hne hbegin hcross hge
hEhead' hsmall hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· have hk_gt_last : last < k := lt_of_not_ge hkle
have hhead_lt_k : head < k := lt_of_le_of_lt hhead_le_last hk_gt_last
have hk_lt_B : (k : WithTop Key) < r.begin.key := by
by_contra hnot
have hBle : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hnot
by_cases hc : r.begin.key ≤ (((keyAfter last : Key)) : WithTop Key)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
(((keyAfter last : Key)) : WithTop Key) := max_eq_right hc
rw [hupper] at hkhi
have hkle' : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp hkhi)
exact absurd hkle' (not_le.mpr hk_gt_last)
· have hupper : max r.begin.key (((keyAfter last : Key)) : WithTop Key) =
r.begin.key := max_eq_left (le_of_not_ge hc)
rw [hupper] at hkhi
exact absurd hBle (not_le.mpr hkhi)
exact necessary_zeroCross_trunc_gap hread hrev hmore hne hbegin hcross hk_gt_last hk_lt_B
/-- A key at or above `begin.key` and below `end.key` is necessary in the crossed
truncated begin-zero read with `end.offset = 0`. -/
theorem necessary_zeroCross_trunc_above_begin {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hend : r.end_.offset = 0)
(hkgt : res.keys.getLast hne < k)
(hkE : (k : WithTop Key) < r.end_.key)
(hkge : r.begin.key ≤ (k : WithTop Key)) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx => (hsort.pairwise.imp
le_of_lt).rel_getLast hx
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hk_notmem : k ∉ res.keys := by
intro hk
exact absurd (hle_last k hk) (not_le.mpr hkgt)
have hsortD : (res.keys ++ [k]).SortedLT := by
refine List.sortedLT_append.mpr ⟨hsort, ?_, ?_⟩
· rw [List.sortedLT_iff_pairwise]
exact List.pairwise_singleton _ k
intro a ha b hb
simp only [List.mem_singleton] at hb
subst hb
exact lt_of_le_of_lt (hle_last a ha) hkgt
let dbw : DB := ⟨res.keys ++ [k], hsortD⟩
have hdbw : dbw.keys = res.keys ++ [k] := rfl
have hk_mem : k ∈ dbw.keys := by rw [hdbw]; simp
have hhead_mem : head ∈ dbw.keys := by
rw [hdbw, hhead]
exact List.mem_append.mpr (Or.inl (List.head_mem hne))
have hno : ∀ z ∈ dbw.keys, ¬ ((↑head : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hdbw] at hz
rcases List.mem_append.mp hz with hz | hz
· have hz0 : z ∈ db₀.keys := RangeRead.compatible_keys_subset hcomp₀ hz
exact no_stored_between_head_begin_of_zero_crossed_more hcomp₀ hrev hmore hne hbegin hcross'
z hz0 hzb
· simp only [List.mem_singleton] at hz
subst hz
exact absurd hkge (not_le.mpr hzb.2)
have hresb : resolve dbw r.begin = (↑head : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_mem hcross' hno
have hDlt : ∀ x ∈ dbw.keys, (x : WithTop Key) < r.end_.key := by
intro x hx
rw [hdbw] 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))
(lt_trans (WithTop.coe_lt_coe.mpr hkgt) hkE)
· simp only [List.mem_singleton] at hx
subst hx
exact hkE
have hcount_end : dbw.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) =
dbw.keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hDlt x hx
have hlen : dbw.keys.length = res.keys.length + 1 := by
rw [hdbw, List.length_append]
simp
have hanchor : r.end_.anchor dbw = (res.keys.length : Int) := by
cases hE : r.end_.key with
| top =>
rw [anchor_of_top (s := r.end_) hE, hlen]
push_cast
rw [hend]
ring
| coe e =>
have hce : dbw.keys.countP (fun x : Key => decide (x < e)) = dbw.keys.length := by
rw [← countP_lt_coe (l := dbw.keys) e, ← hE]
exact hcount_end
rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlen]
push_cast
rw [hend]
ring
have hget : dbw.keys[res.keys.length]? = some k := by
rw [hdbw, List.getElem?_append]
rw [ite_eq_right (not_lt.mpr (le_refl _)), Nat.sub_self]
simp
have hre : resolve dbw r.end_ = ((k : Key) : WithTop Key) := by
rw [resolve, ite_eq_right (by rw [hanchor]; omega)]
rw [hanchor, Int.toNat_natCast, hget]
have hltk : ((last : Key) : WithTop Key) < resolve dbw r.end_ := by
rw [hre]
exact WithTop.coe_lt_coe.mpr hkgt
have hckw : (RangeRead.completeKeys dbw r).filter
(fun x : Key => decide (x ≤ last)) = res.keys := by
rw [completeKeys_filter_le_of_resolve_begin (db := dbw) hrev hresb hltk]
rw [hdbw, List.filter_append]
have hres_fil : res.keys.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ (x : Key) ≤ last)) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact ⟨WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx), hle_last x hx⟩
have hk_fil : [k].filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ (x : Key) ≤ last)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
simp only [List.mem_singleton] at hx
subst hx
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
exact fun _ => not_le.mpr hkgt
rw [hres_fil, hk_fil, List.append_nil]
have hcompw : RangeRead.Compatible dbw r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨hcomp₀.1, hckw⟩
have hD' : (dbw.erase k).keys = res.keys := by
rw [DB.erase_keys, hdbw, List.erase_append_right [k] hk_notmem]
simp
have hsort' : (dbw.erase k).keys.SortedLT := (dbw.erase k).sorted
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]
rw [hD'] at hx
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hle_last x hx))
(lt_trans (WithTop.coe_lt_coe.mpr hkgt) hkE)
have hlen' : (dbw.erase k).keys.length = res.keys.length := by rw [hD']
have hanchor' : 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, hlen']
rw [hend]
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, hlen']
rw [hend]
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', hEqInt, Int.toNat_natCast]
have hD'get? : (dbw.erase k).keys[res.keys.length - 1]? = some last := by
rw [hD', List.getElem?_eq_getElem (by omega)]
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']; omega)]
rw [hanchor', hEqInt, Int.toNat_natCast, hD'get?]
have hresb' : resolve (dbw.erase k) r.begin = (↑head : WithTop Key) := by
have hhead_mem' : head ∈ (dbw.erase k).keys := by
rw [hD', hhead]
exact List.head_mem hne
have hno' : ∀ z ∈ (dbw.erase k).keys, ¬ ((↑head : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hD'] at hz
exact hno z (by rw [hdbw]; exact List.mem_append.mpr (Or.inl hz)) hzb
exact resolve_begin_eq_of_no_between_zero hbegin hhead_mem' hcross' hno'
have hckE : RangeRead.completeKeys (dbw.erase k) r = res.keys.dropLast := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hresb', hre']
have hpred : ∀ x ∈ (dbw.erase k).keys,
decide (((↑head : WithTop Key)) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < ((↑last : Key) : WithTop Key)) =
decide (((↑head : WithTop Key)) ≤ (x : WithTop Key) ∧ x < last) := by
intro x _
rw [decide_eq_decide]
exact and_congr_right fun _ => WithTop.coe_lt_coe
rw [List.filter_congr hpred, hD']
have hhead_le_all : ∀ x ∈ res.keys, ((head : Key) : WithTop Key) ≤ (x : WithTop Key) := by
intro x hx
exact WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx)
rw [show res.keys.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ x < last)) =
res.keys.filter (fun x : Key => decide (x < last)) from by
apply List.filter_congr
intro x hx
rw [decide_eq_decide]
exact ⟨fun h => h.2, fun h => ⟨hhead_le_all x hx, h⟩⟩]
conv_lhs => rw [← List.dropLast_append_getLast hne, hlast]
rw [List.filter_append]
have hfil : res.keys.dropLast.filter (fun x : Key => decide (x < last)) = res.keys.dropLast :=
by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
have h := hsort.pairwise.rel_dropLast_getLast hx
simpa [hlast] using h
rw [hfil]
simp
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 necessary_of_toggle ⟨dbw, hcompw, by
rw [toggle_eq_erase_of_mem hk_mem]
exact hnot⟩
/-- For a crossed truncated begin-zero read with a nonpositive end offset, a key in
`[begin.key, end_.key)` above the reported last has a toggle witness. The witness adds
the `(1 - end.offset)` filler keys needed to land the end resolution just above the
reported last. -/
theorem exists_witness_zeroCross_trunc_nonposEnd {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hend : r.end_.offset ≤ 0)
(hkgt : res.keys.getLast hne < k) (hkE : (k : WithTop Key) < r.end_.key)
(hkge : r.begin.key ≤ (k : WithTop Key)) :
∃ dbw : DB, RangeRead.Compatible dbw r res ∧ k ∈ dbw.keys ∧
¬ RangeRead.Compatible (dbw.erase k) r res := by
obtain ⟨db, hcomp⟩ := hread
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx =>
(hsort.pairwise.imp le_of_lt).rel_getLast hx
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hlast_ck : last ∈ 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 : ((last : 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 (le_of_eq hbegin) hend
set m := (1 - r.end_.offset).toNat with hm
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
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 hkE
· exact (hGmem x hx').2
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
-- the begin selector resolves to the reported head
have hhead_mem : head ∈ dbw.keys := by
rw [hdbw_keys, hD, hhead]
exact List.mem_append.mpr (Or.inl (List.head_mem hne))
have hno : ∀ z ∈ dbw.keys, ¬ ((↑head : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
rw [hdbw_keys, hD] at hz
rcases List.mem_append.mp hz with hz | hz
· have hz0 : z ∈ db.keys := RangeRead.compatible_keys_subset hcomp hz
exact no_stored_between_head_begin_of_zero_crossed_more hcomp hrev hmore hne hbegin hcross'
z hz0 hzb
· have hzraw : z ∈ raw := hFperm.mem_iff.mpr hz
have hzsub : z ∈ G := by
rw [hraw] at hzraw
rcases List.mem_cons.mp (List.mem_of_mem_take hzraw) with hzk | hzG
· subst hzk
exact absurd hzb.2 (not_lt.mpr hkge)
· exact List.mem_of_mem_erase hzG
have hz0 : z ∈ db.keys := by
rw [hG] at hzsub
exact (List.mem_filter.mp hzsub).1
exact no_stored_between_head_begin_of_zero_crossed_more hcomp hrev hmore hne hbegin hcross'
z hz0 ⟨lt_of_le_of_lt (WithTop.coe_le_coe.mpr hhead_le_last)
(WithTop.coe_lt_coe.mpr (hGmem z hzsub).1), hzb.2⟩
have hrb : resolve dbw r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_mem hcross' hno
-- every stored key is below the 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?]
have hltF : ((last : Key) : WithTop Key) < resolve dbw r.end_ := by
rw [hre]
exact WithTop.coe_lt_coe.mpr (hFmem (F.head hFne) (List.head_mem hFne)).1
-- complete keys of the witness are the reported keys
have hckw : (RangeRead.completeKeys dbw r).filter
(fun x : Key => decide (x ≤ last)) = res.keys := by
rw [completeKeys_filter_le_of_resolve_begin (db := dbw) hrev hrb hltF]
rw [hdbw_keys, hD, List.filter_append]
have hres_fil : res.keys.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ (x : Key) ≤ last)) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact ⟨WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx), hle_last x hx⟩
have hF_fil : F.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ (x : Key) ≤ last)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
exact fun _ => not_le.mpr (hFmem x hx).1
rw [hres_fil, hF_fil, List.append_nil]
have hcompw : RangeRead.Compatible dbw r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨hcomp.1, hckw⟩
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 hhead_mem' : head ∈ (dbw.erase k).keys := by
rw [hD', hhead]
exact List.mem_append.mpr (Or.inl (List.head_mem hne))
have hno' : ∀ z ∈ (dbw.erase k).keys, ¬ ((↑head : WithTop Key) < (z : WithTop Key) ∧
(z : WithTop Key) < r.begin.key) := by
intro z hz hzb
exact hno z (by
rw [DB.erase_keys, hdbw_keys] at hz
exact List.mem_of_mem_erase hz) hzb
have hrb' : resolve (dbw.erase k) r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_of_no_between_zero hbegin hhead_mem' hcross' hno'
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
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hrb', hre']
have hpred : ∀ x ∈ (dbw.erase k).keys,
decide (((↑head : WithTop Key)) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < ((↑last : Key) : WithTop Key)) =
decide (((↑head : WithTop Key)) ≤ (x : WithTop Key) ∧ x < last) := by
intro x _
rw [decide_eq_decide]
exact and_congr_right fun _ => WithTop.coe_lt_coe
rw [List.filter_congr hpred, hD', List.filter_append]
have hhead_le_all : ∀ x ∈ res.keys, ((head : Key) : WithTop Key) ≤ (x : WithTop Key) := by
intro x hx
exact WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx)
rw [show res.keys.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ x < last)) =
res.keys.filter (fun x : Key => decide (x < last)) from by
apply List.filter_congr
intro x hx
rw [decide_eq_decide]
exact ⟨fun h => h.2, fun h => ⟨hhead_le_all x hx, h⟩⟩]
conv_lhs => rw [← List.dropLast_append_getLast hne, hlast]
rw [List.filter_append]
have hfil : res.keys.dropLast.filter (fun x : Key => decide (x < last)) = res.keys.dropLast :=
by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
have h := hsort.pairwise.rel_dropLast_getLast hx
simpa [hlast] using h
rw [hfil]
have hFnil : (F.erase k).filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ x < last)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
intro _
exact not_lt.mpr (le_of_lt (hFmem x (List.mem_of_mem_erase hx)).1)
rw [hFnil, List.append_nil]
simp
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⟩
/-- A key at or above `begin.key` and below `end.key` is necessary in a crossed
truncated begin-zero read with a nonpositive end offset. -/
theorem necessary_zeroCross_trunc_above_begin_nonposEnd {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset = 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hend : r.end_.offset ≤ 0)
(hkgt : res.keys.getLast hne < k)
(hkE : (k : WithTop Key) < r.end_.key)
(hkge : r.begin.key ≤ (k : WithTop Key)) :
Necessary r res k := by
obtain ⟨db, hcomp⟩ := hread
obtain ⟨dbw, hcompw, hkdbw, hnot⟩ :=
exists_witness_zeroCross_trunc_nonposEnd ⟨db, hcomp⟩ hrev hmore hne hbegin hcross hend
hkgt hkE hkge
exact necessary_of_toggle ⟨dbw, hcompw, by
rw [toggle_eq_erase_of_mem hkdbw]
exact hnot⟩
/-- **The crossed truncated begin-zero closed form is minimal** when `end.offset = 0`. -/
theorem minimal_closedForm_of_zeroCross_trunc_zeroEnd {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncZeroEnd r res) :
Minimal r res (closedFormZeroCrossTruncNonposEnd r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hend⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hcr : closedFormZeroCrossTruncNonposEnd r res =
⟨((head : Key) : WithTop Key), max r.begin.key r.end_.key⟩ := by
unfold closedFormZeroCrossTruncNonposEnd
rw [hheadD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTruncNonposEnd hrev hmore hne hbegin hcross
(le_of_eq hend) hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTruncNonposEnd hrev hmore hne hbegin hcross
(le_of_eq hend) hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread' (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread' (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· have hkgt : last < k := lt_of_not_ge hkle
by_cases hkB : (k : WithTop Key) < r.begin.key
· exact necessary_zeroCross_trunc_gap hread' hrev hmore hne hbegin hcross hkgt hkB
· have hkge : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hkB
by_cases hleE : r.begin.key ≤ r.end_.key
· have hmax : max r.begin.key r.end_.key = r.end_.key := max_eq_right hleE
have hkE : (k : WithTop Key) < r.end_.key := by rw [← hmax]; exact hkhi
exact necessary_zeroCross_trunc_above_begin hread' hrev hmore hne hbegin hcross hend
(by rw [← hlast]; exact hkgt) hkE hkge
· exfalso
have hltE : r.end_.key < r.begin.key := lt_of_not_ge hleE
have hmax : max r.begin.key r.end_.key = r.begin.key := max_eq_left (le_of_lt hltE)
rw [hmax] at hkhi
exact absurd hkhi (not_lt.mpr hkge)
/-- **The crossed truncated begin-zero closed form is minimal** for every nonpositive
end offset. -/
theorem minimal_closedForm_of_zeroCross_trunc_nonposEnd {r : RangeRead} {res : Result}
(hread : Readable r res) (h : zeroCrossTruncNonposEnd r res) :
Minimal r res (closedFormZeroCrossTruncNonposEnd r res) := by
obtain ⟨hbegin, hrev, hmore, hcrossD, hend⟩ := h
have hread' : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, headD_eq_head_zero_cross_trunc hne] at hcrossD
exact hcrossD
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, headD_eq_head_zero_cross_trunc hne]
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hcr : closedFormZeroCrossTruncNonposEnd r res =
⟨((head : Key) : WithTop Key), max r.begin.key r.end_.key⟩ := by
unfold closedFormZeroCrossTruncNonposEnd
rw [hheadD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_zeroCrossTruncNonposEnd hrev hmore hne hbegin hcross
hend hc1 hagree
· intro hc2
exact compatible_of_agree_zeroCrossTruncNonposEnd hrev hmore hne hbegin hcross
hend hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread' (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread' (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· have hkgt : last < k := lt_of_not_ge hkle
by_cases hkB : (k : WithTop Key) < r.begin.key
· exact necessary_zeroCross_trunc_gap hread' hrev hmore hne hbegin hcross hkgt hkB
· have hkge : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hkB
by_cases hleE : r.begin.key ≤ r.end_.key
· have hmax : max r.begin.key r.end_.key = r.end_.key := max_eq_right hleE
have hkE : (k : WithTop Key) < r.end_.key := by rw [← hmax]; exact hkhi
exact necessary_zeroCross_trunc_above_begin_nonposEnd hread' hrev hmore hne hbegin
hcross hend (by rw [← hlast]; exact hkgt) hkE hkge
· exfalso
have hltE : r.end_.key < r.begin.key := lt_of_not_ge hleE
have hmax : max r.begin.key r.end_.key = r.begin.key := max_eq_left (le_of_lt hltE)
rw [hmax] at hkhi
exact absurd hkhi (not_lt.mpr hkge)
end FormalConflictRange