Files
conflict-range/FormalConflictRange/NegCrossTruncRevCrossedNonpos.lean
T

968 lines
51 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.NegCrossTruncRevCrossedLarge
/-!
# Reversed crossed negative-begin truncated cells at a nonpositive end offset
This module closes the last reversed truncated crossed cell: the end selector has
nonpositive offset, so the window ends at a stored key strictly below `end_.key`.
The setting is
* `reverse = true`, `more = true`, `res.keys ≠ []`, `begin.offset < 0`;
* the crossed selectors `end_.key < begin.key`;
* `end_.offset ≤ 0`.
Writing `L` for the reported last, `t = |res.keys|`, `p = (1 - end_.offset).toNat` and
`cap = intervalCard end_.key begin.key`, the minimal range is `[L, end_.key)` when
`cap + t + p ≤ beginSlack + 1` and `[L, begin.key)` otherwise. The pad count `p` is the
number of stored keys in `[resolve end_, end_.key)`, which the count identity
`between_last_end_key_length_eq_of_end_nonpos` adds to the reported keys.
-/
namespace FormalConflictRange
/-- **The reported keys are the stored keys in `[last, resolve end_)` read backwards.**
Unlike the end-offset-one version, this does not simplify the resolved end to `end_.key`;
it is the count of that window that the nonpositive-end count identity needs. -/
theorem res_keys_eq_reverse_between_resolve_end {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ []) :
res.keys = (between db ((res.keys.getLast hne : Key) : WithTop Key)
(resolve db r.end_)).reverse := by
set L : Key := res.keys.getLast hne with hLdef
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
have hfil : (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) = res.keys :=
(compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp |>.2
have hLfil : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
rw [hfil]; exact hLmem
have hLck : L ∈ RangeRead.completeKeys db r := (List.mem_filter.mp hLfil).1
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
(RangeRead.mem_completeKeys.mp hLck).2.1
have hid := completeKeys_filter_ge_eq_resolve_end (db := db) (r := r) (last := L) hrev hrb
rw [hfil] at hid
rw [hid]
congr 1
unfold between
rw [List.filter_filter]
apply List.filter_congr
intro k _
conv_lhs => rw [← Bool.decide_and]
rw [decide_eq_decide]
constructor
· rintro ⟨hk, hL⟩
exact ⟨WithTop.coe_le_coe.mpr hL, hk⟩
· rintro ⟨hL, hk⟩
exact ⟨hk, WithTop.coe_le_coe.mp hL⟩
/-- **The stored keys in `[last, resolve end_)` number the reported keys.** Immediate
from the reversed-window identity. -/
theorem between_last_resolve_end_length {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ []) :
(between db ((res.keys.getLast hne : Key) : WithTop Key) (resolve db r.end_)).length =
res.keys.length := by
have h := res_keys_eq_reverse_between_resolve_end (db := db) hcomp hmore hrev hne
have h2 := congrArg List.length h
rw [List.length_reverse] at h2
exact h2.symm
/-- **The pad count is at most the end count.** A nonempty truncated result at a
nonpositive end offset has its end anchor at a nonnegative index, so the
`(1 - end_.offset)` padding keys fit below `end_.key`. -/
theorem pad_le_cnt_end_of_end_nonpos {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ []) (hend : r.end_.offset ≤ 0) :
(1 - r.end_.offset).toNat ≤ cnt db r.end_.key := by
set p : ℕ := (1 - r.end_.offset).toNat with hpdef
have hpcast : (p : Int) = 1 - r.end_.offset := by
rw [hpdef, Int.toNat_of_nonneg (by omega)]
set c : ℕ := cnt db r.end_.key with hcdef
have hc_eq : (db.keys.countP
(fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))) = c := by
rw [hcdef]; rfl
have hanc : r.end_.anchor db = (c : Int) - (p : Int) := by
unfold Selector.anchor
rw [hc_eq, hpcast]
ring
have hnonnil : between db ((res.keys.getLast hne : Key) : WithTop Key)
(resolve db r.end_) ≠ [] := by
intro hnil
have h := res_keys_eq_reverse_between_resolve_end (db := db) hcomp hmore hrev hne
rw [hnil] at h
exact hne (by simpa using h.symm)
have hanchor_nonneg : 0 ≤ r.end_.anchor db := by
by_contra hneg
have := resolve_eq_nil (db := db) (s := r.end_) (lt_of_not_ge hneg)
rw [this] at hnonnil
apply hnonnil
unfold between
rw [List.filter_eq_nil_iff]
intro k _
rw [decide_eq_true_eq, not_and]
intro _
exact not_lt.mpr (WithTop.coe_le_coe.mpr (nil_le_key k))
have : (0 : Int) ≤ (c : Int) - (p : Int) := by rwa [← hanc]
omega
/-- **The count below the end resolution at a nonpositive end offset.** With
`c = cnt db end_.key` stored keys below `end_.key`, the end anchor is `c - p` where
`p = (1 - end_.offset).toNat`, and the resolved index is at least `0` because a
nonempty truncated result forces the resolution above the empty key. Hence
`cnt db (resolve end_) = c - p`. -/
theorem cnt_resolve_end_eq_of_end_nonpos {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ []) (hend : r.end_.offset ≤ 0) :
cnt db (resolve db r.end_) = cnt db r.end_.key - (1 - r.end_.offset).toNat := by
set p : ℕ := (1 - r.end_.offset).toNat with hpdef
have hpcast : (p : Int) = 1 - r.end_.offset := by
rw [hpdef, Int.toNat_of_nonneg (by omega)]
set c : ℕ := cnt db r.end_.key with hcdef
have hc_eq : (db.keys.countP
(fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))) = c := by
rw [hcdef]; rfl
have hanc : r.end_.anchor db = (c : Int) - (p : Int) := by
unfold Selector.anchor
rw [hc_eq, hpcast]
ring
-- The resolution is not the empty key: a nonempty reported window lies strictly
-- above it.
have hnonnil : between db ((res.keys.getLast hne : Key) : WithTop Key)
(resolve db r.end_) ≠ [] := by
intro hnil
have h := res_keys_eq_reverse_between_resolve_end (db := db) hcomp hmore hrev hne
rw [hnil] at h
exact hne (by simpa using h.symm)
have hanchor_nonneg : 0 ≤ r.end_.anchor db := by
by_contra hneg
have := resolve_eq_nil (db := db) (s := r.end_) (lt_of_not_ge hneg)
rw [this] at hnonnil
apply hnonnil
unfold between
rw [List.filter_eq_nil_iff]
intro k _
rw [decide_eq_true_eq, not_and]
intro _
exact not_lt.mpr (WithTop.coe_le_coe.mpr (nil_le_key k))
have hcge : p ≤ c := by
have : (0 : Int) ≤ (c : Int) - (p : Int) := by rwa [← hanc]
omega
have hmin : cnt db (resolve db r.end_) = min (r.end_.anchor db).toNat db.keys.length :=
countP_lt_resolve
have hclen : c ≤ db.keys.length := by rw [hcdef]; exact cnt_le_length db r.end_.key
have htoNat : (r.end_.anchor db).toNat = c - p := by
rw [hanc]; omega
rw [hmin, htoNat, Nat.min_eq_left (by omega)]
/-- **The nonpositive-end count identity.** For a compatible reversed truncated result
with `end_.offset ≤ 0`, the stored keys in `[last, end_.key)` are exactly the reported
keys together with the `(1 - end_.offset)` stored keys in `[resolve end_, end_.key)`. -/
theorem between_last_end_key_length_eq_of_end_nonpos {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ []) (hend : r.end_.offset ≤ 0) :
(between db ((res.keys.getLast hne : Key) : WithTop Key) r.end_.key).length =
res.keys.length + (1 - r.end_.offset).toNat := by
set L : Key := res.keys.getLast hne with hLdef
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
have hLck : L ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hcomp).subset hLmem
have hLres : ((L : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp hLck).2.2
have hLleRes : ((L : Key) : WithTop Key) ≤ resolve db r.end_ := le_of_lt hLres
have hresEnd_le : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hLleEnd : ((L : Key) : WithTop Key) ≤ r.end_.key := le_trans hLleRes hresEnd_le
have hresLen := between_last_resolve_end_length (db := db) hcomp hmore hrev hne
have hcntRes := cnt_resolve_end_eq_of_end_nonpos (db := db) hcomp hmore hrev hne hend
have hsplit := cnt_sub_eq_between_length (db := db) (E := ((L : Key) : WithTop Key))
(B := r.end_.key) hLleEnd
have hsplitRes := cnt_sub_eq_between_length (db := db) (E := ((L : Key) : WithTop Key))
(B := resolve db r.end_) hLleRes
rw [hresLen] at hsplitRes
have hmono : cnt db ((L : Key) : WithTop Key) ≤ cnt db (resolve db r.end_) :=
cnt_le_cnt_of_le db hLleRes
have hp_le := pad_le_cnt_end_of_end_nonpos (db := db) hcomp hmore hrev hne hend
omega
/-- **The stored keys in `[last, resolve end_)` are the first `t` keys of
`[last, end_.key)`.** When the end resolution lies at or below `end_.key`, filtering
`[last, end_.key)` at the resolution is a prefix of the sorted interval, and its length
is the number of reported keys. -/
theorem between_resolve_eq_take_of_end_le {db : DB} {r : RangeRead} {L : Key} {t : ℕ}
(hresEnd_le : resolve db r.end_ ≤ r.end_.key)
(hlen : (between db ((L : Key) : WithTop Key) (resolve db r.end_)).length = t) :
between db ((L : Key) : WithTop Key) (resolve db r.end_) =
(between db ((L : Key) : WithTop Key) r.end_.key).take t := by
set V : List Key := between db ((L : Key) : WithTop Key) r.end_.key with hV
have hVsorted : V.SortedLT := by
rw [hV]; unfold between
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
have hfilter : V.filter (fun k : Key => decide ((k : WithTop Key) < resolve db r.end_)) =
between db ((L : Key) : WithTop Key) (resolve db r.end_) := by
rw [hV]; unfold between
rw [List.filter_filter]
apply List.filter_congr
intro k _
by_cases hres : ((k : WithTop Key) < resolve db r.end_)
· have hE : ((k : WithTop Key) < r.end_.key) := lt_of_lt_of_le hres hresEnd_le
simp [hres, hE]
· simp [hres, Bool.decide_and]
rw [← hfilter, filter_lt_eq_take_countP hVsorted]
congr 1
rw [List.countP_eq_length_filter, hfilter, hlen]
/-- **Necessity of the reversed truncated range at a nonpositive end offset.** Every key
in `[last reported, end_.key)` is necessary: reported keys by
`necessary_of_mem_result`, keys up to the head by convexity, and keys from the head to
`end_.key` by `necessary_head_to_end_key`. -/
theorem necessary_of_mem_truncatedRangeRev_of_end_nonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ [])
(hend : r.end_.offset ≤ 0) {k : Key}
(hkL : ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key))
(hkE : (k : WithTop Key) < r.end_.key) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
by_cases hkhead : k ≤ res.keys.head hne
· exact necessary_of_between_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)
(List.head_mem hne) (WithTop.coe_le_coe.mp hkL) hkhead
· have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead)
exact fun cr hs =>
necessary_head_to_end_key ⟨db₀, hcomp₀⟩ hrev hne (by omega) cr hs hheadk hkE
/-- **Reduction to the read whose begin selector is the reported last at offset one.** A
compatible database for the crossed negative-begin truncated read is compatible with the
reduced read: both see exactly the reported keys at or above the reported last. -/
theorem compatible_reduce_begin_last {r : RangeRead} {res : Result} {L : Key}
(hrev : r.reverse = true) (hmore : res.more = true) (hne : res.keys ≠ [])
(hLmem : L ∈ res.keys) (hLgetLast : L = res.keys.getLast hne) :
∀ db, RangeRead.Compatible db r res →
RangeRead.Compatible db
{ r with begin := ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) } res := by
intro db hcomp
have hfil : (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) = res.keys := by
have h := (compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp |>.2
rw [← hLgetLast] at h
exact h
have hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
rw [hfil]; exact hLmem
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
(RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt).1).2.1
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
have hres' : resolve db ({ r with begin :=
({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) } : RangeRead).begin =
((L : Key) : WithTop Key) :=
resolve_offset_one_key_of_mem hLdb
have hLck_filter : (RangeRead.completeKeys db
({ r with begin := ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) } :
RangeRead)).filter (fun k => decide (L ≤ k)) =
RangeRead.completeKeys db
({ r with begin := ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) } :
RangeRead) := by
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq]
have hk' := (RangeRead.mem_completeKeys.mp hk).2.1
exact WithTop.coe_le_coe.mp (by rwa [hres'] at hk')
have hck' : RangeRead.completeKeys db
({ r with begin := ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) } :
RangeRead) = res.keys := by
rw [← hLck_filter]
exact (completeKeys_filter_ge_eq_of_both_le (db := db) (r₁ := r)
(r₂ := { r with begin := ({ key := ((L : Key) : WithTop Key), offset := 1 } :
Selector) }) hrev (by simpa using hrev) (by simp) hrb (le_of_eq hres')).symm.trans hfil
refine ⟨by simpa [RangeRead.withinLimit] using hcomp.1, Or.inl ⟨hmore, ?_, hne⟩⟩
rw [hck']
/-- **Small-capacity soundness.** Under `cap + t + p ≤ beginSlack + 1`, agreement on
`[last, end_.key)` keeps the begin resolution at or below the reported last, so
compatibility transfers. -/
theorem sound_truncatedRangeRev_of_negCross_crossedNonpos_small {r : RangeRead}
{res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset ≤ 0)
(hcap : intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1) :
Sound r res (truncatedRangeRev r (res.keys.getLast hne)) := by
set L : Key := res.keys.getLast hne with hLdef
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
have hLcross : ((L : Key) : WithTop Key) < r.begin.key := by rw [hLdef]; exact hcross
have hLgetLast : L = res.keys.getLast hne := hLdef.symm
obtain ⟨db₀, hcomp₀⟩ := hread
let r' : RangeRead :=
{ r with begin := { key := ((L : Key) : WithTop Key), offset := 1 } }
have hr'_rev : r'.reverse = true := by simp [r', hrev]
have hr'_end : r'.end_ = r.end_ := rfl
have hr'_beg : r'.begin = ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) := rfl
have hr'_off : r'.begin.offset = 1 := rfl
have hreduce : ∀ db : DB, RangeRead.Compatible db r res → RangeRead.Compatible db r' res :=
compatible_reduce_begin_last hrev hmore hne hLmem hLgetLast
have hread' : Readable r' res := ⟨db₀, hreduce db₀ hcomp₀⟩
have hgetLastD : res.keys.getLastD ([] : Key) = L := by
rw [hLdef, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hmin' : Minimal r' res (truncatedRangeRev r L) := by
have hm := minimal_truncatedRangeRev_of_end_offset_nonpos (r := r') hread' hmore
hr'_rev hr'_off hend
rwa [hgetLastD] at hm
have hS' : Sound r' res (truncatedRangeRev r L) := hmin'.sound
-- `truncatedRangeRev r' L` is definitionally `truncatedRangeRev r L`.
have step : ∀ db db', AgreeOn (truncatedRangeRev r L) db db' →
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
intro db db' hag' hcomp
have hcomp' : RangeRead.Compatible db r' res := hreduce db hcomp
have hcomp'' : RangeRead.Compatible db' r' res := (hS' db db' hag').mp hcomp'
have hbetweenEq' : between db ((L : Key) : WithTop Key) r.end_.key =
between db' ((L : Key) : WithTop Key) r.end_.key := by
have h := hag'
unfold AgreeOn ConflictRange.keys at h
unfold between
exact h
have hbetweenLen : (between db ((L : Key) : WithTop Key) r.end_.key).length =
res.keys.length + (1 - r.end_.offset).toNat :=
between_last_end_key_length_eq_of_end_nonpos (db := db) hcomp hmore hrev hne hend
have hLres : ((L : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp
((RangeRead.compatible_keys_prefix hcomp).subset hLmem)).2.2
have hresEnd_le : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hLE : ((L : Key) : WithTop Key) < r.end_.key := lt_of_lt_of_le hLres hresEnd_le
have hcapNat : (between db' r.end_.key r.begin.key).length + res.keys.length +
(1 - r.end_.offset).toNat ≤ beginSlack r + 1 := by
have hb : ((between db' r.end_.key r.begin.key).length : ℕ∞) ≤
intervalCard r.end_.key r.begin.key :=
between_length_le_intervalCard (le_of_lt hcrossE)
have hsum : (((between db' r.end_.key r.begin.key).length + res.keys.length +
(1 - r.end_.offset).toNat : ℕ) : ℕ∞) ≤ ((beginSlack r + 1 : ℕ) : ℕ∞) := by
rw [Nat.cast_add, Nat.cast_add]
calc ((between db' r.end_.key r.begin.key).length : ℕ∞) +
(res.keys.length : ℕ∞) + ((1 - r.end_.offset).toNat : ℕ∞)
≤ intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞) := by gcongr
_ ≤ (beginSlack r : ℕ∞) + 1 := hcap
_ = ((beginSlack r + 1 : ℕ) : ℕ∞) := by rw [Nat.cast_add, Nat.cast_one]
exact_mod_cast hsum
have hsplit := between_length_add (db := db') (L := ((L : Key) : WithTop Key))
(E := r.end_.key) (B := r.begin.key) (le_of_lt hLE) (le_of_lt hcrossE)
have hboundLen : (between db' ((L : Key) : WithTop Key) r.begin.key).length ≤
beginSlack r + 1 := by
rw [hsplit, ← hbetweenEq', hbetweenLen]; omega
have hboundInt :
((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 := by
have hs : (beginSlack r : Int) = -r.begin.offset := beginSlack_cast r (le_of_lt hbeg)
have hble : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) ≤
(beginSlack r : Int) + 1 := by exact_mod_cast hboundLen
linarith
have hLdb' : L ∈ db'.keys := RangeRead.compatible_keys_subset hcomp'' hLmem
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
resolve_begin_le_of_between_bound hLdb' hLcross hboundInt
have hres'_db' : resolve db' r'.begin = ((L : Key) : WithTop Key) := by
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb'
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
refine ⟨by simpa [r', RangeRead.withinLimit] using hcomp''.1, ?_⟩
have h1 := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r) hrev hrb'
have h2' := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r') hr'_rev
(le_of_eq hres'_db')
have h2 := (compatible_iff_truncated_keys_rev (db := db') hr'_rev hmore hne).mp
hcomp'' |>.2
rw [h1, ← h2']
exact h2
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- **Rewriting `between` as a double filter at a genuine key.** -/
theorem between_eq_filter_filter (db : DB) (L : Key) (B : WithTop Key) :
between db ((L : Key) : WithTop Key) B =
(db.keys.filter (fun k : Key => decide (L ≤ k))).filter
(fun k => decide (((k : Key) : WithTop Key) < B)) := by
unfold between
rw [List.filter_filter]
apply List.filter_congr
intro k _
by_cases hL : L ≤ k
· have hL' : ((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr hL
by_cases hB : ((k : Key) : WithTop Key) < B
· simp [hL, hL', hB]
· simp [hB, hL']
· have hL' : ¬ ((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
fun h => hL (WithTop.coe_le_coe.mp h)
simp [hL, hL']
/-- **Large-capacity soundness.** Agreement on `[last, begin.key)` preserves
compatibility; the count identity locates the end resolution at a fixed relative position
inside that interval, so both databases resolve to the same reported window. -/
theorem sound_beginKeyRange_of_negCross_crossedNonpos {r : RangeRead} {res : Result}
(hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset ≤ 0) :
Sound r res ⟨((res.keys.getLast hne : Key) : WithTop Key), r.begin.key⟩ := by
set L : Key := res.keys.getLast hne with hLdef
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
have hLcross : ((L : Key) : WithTop Key) < r.begin.key := by rw [hLdef]; exact hcross
have step : ∀ db db', AgreeOn ⟨((L : Key) : WithTop Key), r.begin.key⟩ db db' →
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
intro db db' hag' hcomp
have hbetweenEq : between db ((L : Key) : WithTop Key) r.begin.key =
between db' ((L : Key) : WithTop Key) r.begin.key := by
have h := hag'
unfold AgreeOn ConflictRange.keys at h
unfold between
exact h
have hLres : ((L : Key) : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp
((RangeRead.compatible_keys_prefix hcomp).subset hLmem)).2.2
have hresEnd_le : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hLE : ((L : Key) : WithTop Key) < r.end_.key := lt_of_lt_of_le hLres hresEnd_le
have hVeq : between db ((L : Key) : WithTop Key) r.end_.key =
between db' ((L : Key) : WithTop Key) r.end_.key :=
between_eq_of_agree (db := db) (db' := db') (last := ((L : Key) : WithTop Key))
(beginKey := r.end_.key) (endKey := r.begin.key) hag' (le_of_lt hLE) (le_of_lt hcrossE)
have hbound := between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
have hbound' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 := by
rw [← hbetweenEq]; exact hbound
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
have hLdb' : L ∈ db'.keys := by
have hmem : L ∈ between db ((L : Key) : WithTop Key) r.begin.key := by
unfold between
exact List.mem_filter.mpr ⟨hLdb, by simp [hLcross]⟩
rw [hbetweenEq] at hmem
exact (List.mem_filter.mp hmem).1
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
resolve_begin_le_of_between_bound hLdb' hLcross hbound'
set p : ℕ := (1 - r.end_.offset).toNat with hpdef
have hpcast : (p : Int) = 1 - r.end_.offset := by
rw [hpdef, Int.toNat_of_nonneg (by omega)]
have hVlen : (between db ((L : Key) : WithTop Key) r.end_.key).length =
res.keys.length + p :=
between_last_end_key_length_eq_of_end_nonpos (db := db) hcomp hmore hrev hne hend
have hVlen' : (between db' ((L : Key) : WithTop Key) r.end_.key).length =
res.keys.length + p := by rw [← hVeq]; exact hVlen
have hcntEqB : cnt db' r.end_.key = cnt db' ((L : Key) : WithTop Key) +
(between db' ((L : Key) : WithTop Key) r.end_.key).length :=
cnt_eq_add_between db' (le_of_lt hLE)
have hanc : r.end_.anchor db' =
(cnt db' ((L : Key) : WithTop Key) : Int) + res.keys.length := by
change (cnt db' r.end_.key : Int) + r.end_.offset - 1 = _
rw [hcntEqB, hVlen']
push_cast
rw [hpcast]; ring
have hp_pos : 0 < p := by
rw [hpdef]
have : (0 : Int) < 1 - r.end_.offset := by omega
omega
have hlen_ge : cnt db' ((L : Key) : WithTop Key) + res.keys.length < db'.keys.length := by
have h := cnt_eq_add_between db' (le_of_lt hLE)
rw [hVlen'] at h
have := cnt_le_length db' r.end_.key
omega
have hanc_nonneg : 0 ≤ r.end_.anchor db' := by rw [hanc]; positivity
have hanc_toNat : (r.end_.anchor db').toNat =
cnt db' ((L : Key) : WithTop Key) + res.keys.length := by
rw [hanc]; omega
have hanc_len : (r.end_.anchor db').toNat < db'.keys.length := by
rw [hanc_toNat]; exact hlen_ge
have hcntRes : cnt db' (resolve db' r.end_) = (r.end_.anchor db').toNat := by
change db'.keys.countP
(fun k => decide (((k : Key) : WithTop Key) < resolve db' r.end_)) = _
rw [countP_lt_resolve, Nat.min_eq_left (le_of_lt hanc_len)]
have hLleRes : ((L : Key) : WithTop Key) ≤ resolve db' r.end_ := by
have hres := resolve_eq_getElem (db := db') (s := r.end_) hanc_nonneg hanc_len
rw [hres]
refine WithTop.coe_le_coe.mpr (le_getElem_of_countP_le db'.sorted ?_ hanc_len)
rw [← cnt_coe db' L, hanc_toNat]; omega
have hresLen' : (between db' ((L : Key) : WithTop Key) (resolve db' r.end_)).length =
res.keys.length := by
rw [← cnt_sub_eq_between_length (db := db') hLleRes, hcntRes, hanc_toNat,
Nat.add_sub_cancel_left]
have htakeDb : between db ((L : Key) : WithTop Key) (resolve db r.end_) =
(between db ((L : Key) : WithTop Key) r.end_.key).take res.keys.length :=
between_resolve_eq_take_of_end_le (db := db) (r := r) (L := L) (t := res.keys.length)
hresEnd_le (between_last_resolve_end_length (db := db) hcomp hmore hrev hne)
have htakeDb' : between db' ((L : Key) : WithTop Key) (resolve db' r.end_) =
(between db' ((L : Key) : WithTop Key) r.end_.key).take res.keys.length :=
between_resolve_eq_take_of_end_le (db := db') (r := r) (L := L) (t := res.keys.length)
(resolve_le_key_of_offset_nonpos hend) hresLen'
have hbetween_res_eq : between db ((L : Key) : WithTop Key) (resolve db r.end_) =
between db' ((L : Key) : WithTop Key) (resolve db' r.end_) := by
rw [htakeDb, htakeDb', hVeq]
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
refine ⟨by simpa [RangeRead.withinLimit] using hcomp.1, ?_⟩
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
resolve_begin_le_of_between_bound hLdb hLcross hbound
have hfilDb : (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) = res.keys :=
(compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp |>.2
have hidDb := completeKeys_filter_ge_eq_resolve_end (db := db) (r := r) (last := L) hrev hrb
have hidDb' := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r) (last := L) hrev hrb'
have hbridgeDb : ((db.keys.filter (fun k : Key => decide (L ≤ k))).filter
(fun k => decide (((k : Key) : WithTop Key) < resolve db r.end_))) =
between db ((L : Key) : WithTop Key) (resolve db r.end_) :=
(between_eq_filter_filter db L (resolve db r.end_)).symm
have hbridgeDb' : ((db'.keys.filter (fun k : Key => decide (L ≤ k))).filter
(fun k => decide (((k : Key) : WithTop Key) < resolve db' r.end_))) =
between db' ((L : Key) : WithTop Key) (resolve db' r.end_) :=
(between_eq_filter_filter db' L (resolve db' r.end_)).symm
rw [hidDb', hbridgeDb', ← hbetween_res_eq, ← hbridgeDb, ← hidDb, hfilDb]
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- **Gap-key necessity in the large-capacity nonpositive-end crossed cell.** The
witness database stores the reported keys, the `p` pad keys that any compatible database
stores in `[resolve end, end_.key)`, and `beginSlack + 1 - t - p` gap keys in
`[end_.key, begin_.key)`. Its begin anchor is zero and it resolves onto the reported
last. Inserting the target raises the anchor to one, so the reported last leaves the
window and the reported keys can no longer be a prefix of the complete keys. -/
theorem necessary_of_mem_gap_of_negCross_crossedNonpos_large {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset ≤ 0)
(hlarge : (beginSlack r : ℕ∞) + 2 ≤
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞))
{k : Key} (hkE : r.end_.key ≤ (k : WithTop Key))
(hkB : (k : WithTop Key) < r.begin.key) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
set L : Key := res.keys.getLast hne with hLdef
set t : ℕ := res.keys.length with htdef
set s : ℕ := beginSlack r with hsdef
set p : ℕ := (1 - r.end_.offset).toNat with hpdef
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
have hLle : ∀ x ∈ res.keys, L ≤ x := by
intro x hx; rw [hLdef]; exact (hsort.pairwise.imp le_of_lt).rel_getLast hx
have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r :=
RangeRead.compatible_keys_prefix hcomp₀
have hreported_lt_R : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < resolve db₀ r.end_ := by
intro x hx
exact (RangeRead.mem_completeKeys.mp (hpre₀.subset hx)).2.2
have hreported_lt_E : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.end_.key := by
intro x hx
exact lt_of_lt_of_le (hreported_lt_R x hx)
(resolve_le_key_of_offset_nonpos (db := db₀) (s := r.end_) hend)
have hLltE : ((L : Key) : WithTop Key) < r.end_.key := hreported_lt_E L hLmem
have hEcross : r.end_.key ≤ r.begin.key := le_of_lt hcrossE
have hbound : ((between db₀ ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 :=
between_add_offset_le_one (db := db₀) hcomp₀ hmore hrev hne hcross
have hbLen_le : (between db₀ ((L : Key) : WithTop Key) r.begin.key).length ≤ s + 1 := by
have hs : (beginSlack r : Int) = -r.begin.offset := beginSlack_cast r (le_of_lt hbeg)
have hb2 : ((between db₀ ((L : Key) : WithTop Key) r.begin.key).length : Int) ≤
(beginSlack r : Int) + 1 := by linarith
have : ((between db₀ ((L : Key) : WithTop Key) r.begin.key).length : Int) ≤
(s : Int) + 1 := by rw [hsdef]; exact hb2
exact_mod_cast this
have hVlen : (between db₀ ((L : Key) : WithTop Key) r.end_.key).length = t + p := by
rw [htdef, hpdef]
exact between_last_end_key_length_eq_of_end_nonpos (db := db₀) hcomp₀ hmore hrev hne hend
have hsplit := between_length_add (db := db₀) (L := ((L : Key) : WithTop Key))
(E := r.end_.key) (B := r.begin.key) (le_of_lt hLltE) hEcross
have ht_le : t + p ≤ s + 1 := by omega
-- enough room in the crossed gap for the witness keys and the target
have hcard : (((s + 1 - t - p) + 1 : ℕ) : ℕ∞) ≤ intervalCard r.end_.key r.begin.key := by
cases hcap : intervalCard r.end_.key r.begin.key with
| top => exact le_top
| coe n =>
have hnat : s + 2 ≤ n + t + p := by
have h' : ((s + 2 : ℕ) : ℕ∞) ≤ ((n + t + p : ℕ) : ℕ∞) := by
rw [hcap] at hlarge
simpa [ENat.natCast_add] using hlarge
exact_mod_cast h'
have hn : (s + 1 - t - p) + 1 ≤ n := by omega
exact_mod_cast hn
-- the pad keys taken from `db₀`
have hLres : ((L : Key) : WithTop Key) < resolve db₀ r.end_ := hreported_lt_R L hLmem
have hresEnd_le : resolve db₀ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
set Pad : List Key := between db₀ (resolve db₀ r.end_) r.end_.key with hPaddef
have hPadLen : Pad.length = p := by
rw [hPaddef]
have hsplitP := between_length_add (db := db₀) (L := ((L : Key) : WithTop Key))
(E := resolve db₀ r.end_) (B := r.end_.key) (le_of_lt hLres) hresEnd_le
have hresLen : (between db₀ ((L : Key) : WithTop Key) (resolve db₀ r.end_)).length = t := by
rw [htdef]
exact between_last_resolve_end_length (db := db₀) hcomp₀ hmore hrev hne
rw [hVlen, hresLen] at hsplitP
omega
have hPadPos : 0 < Pad.length := by rw [hPadLen, hpdef]; omega
have hPadSorted : Pad.SortedLT := by
rw [hPaddef]; unfold between
exact List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _)
have hPadMem : ∀ x ∈ Pad, resolve db₀ r.end_ ≤ (x : WithTop Key) ∧
(x : WithTop Key) < r.end_.key := by
intro x hx
rw [hPaddef] at hx
unfold between at hx
rw [List.mem_filter] at hx
exact of_decide_eq_true hx.2
set P0 : Key := Pad[(0 : ℕ)]'hPadPos with hP0def
have hP0mem : P0 ∈ Pad := List.getElem_mem hPadPos
have hP0min : ∀ x ∈ Pad, P0 ≤ x := by
intro x hx
obtain ⟨j, hj, hjx⟩ := List.mem_iff_getElem.mp hx
have hle : Pad[(0 : ℕ)]'hPadPos ≤ Pad[j]'hj :=
hPadSorted.getElem_le_getElem_iff.mpr (Nat.zero_le j)
rw [hP0def]
rwa [hjx] at hle
obtain ⟨dbG, hGrange, hkG, hGlen⟩ :=
exists_db_keysIn_avoid (B := r.end_.key) (E := r.begin.key) (k := k)
(m := s + 1 - t - p) hcard
set G : List Key := dbG.keys with hGdef
have hGmem : ∀ x ∈ G, r.end_.key ≤ (x : WithTop Key) ∧
(x : WithTop Key) < r.begin.key := by
intro x hx
simpa only [G, keysIn, Set.mem_ofPred_eq] using hGrange x (by simpa [hGdef] using hx)
have hGlen' : G.length = s + 1 - t - p := by rw [hGdef]; exact hGlen
-- assemble the ascending witness database
have hresSort : res.keys.reverse.SortedLT := hsort.reverse
have hGsorted : G.SortedLT := by rw [hGdef]; exact dbG.sorted
have hcrossRP : ∀ x ∈ res.keys.reverse, ∀ y ∈ Pad, x < y := by
intro x hx y hy
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hreported_lt_R x (List.mem_reverse.mp hx))
(hPadMem y hy).1)
have hcrossPG : ∀ x ∈ Pad, ∀ y ∈ G, x < y := by
intro x hx y hy
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hPadMem x hx).2 (hGmem y hy).1)
have hcrossRG : ∀ x ∈ res.keys.reverse, ∀ y ∈ G, x < y := by
intro x hx y hy
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hreported_lt_E x (List.mem_reverse.mp hx))
(hGmem y hy).1)
have hRPsorted : (res.keys.reverse ++ Pad).SortedLT :=
List.sortedLT_append.mpr ⟨hresSort, hPadSorted, hcrossRP⟩
have hcrossAllG : ∀ x ∈ (res.keys.reverse ++ Pad), ∀ y ∈ G, x < y := by
intro x hx y hy
rcases List.mem_append.mp hx with hx' | hx'
· exact hcrossRG x hx' y hy
· exact hcrossPG x hx' y hy
have hkeysSorted : (res.keys.reverse ++ Pad ++ G).SortedLT :=
List.sortedLT_append.mpr ⟨hRPsorted, hGsorted, hcrossAllG⟩
let db_a : DB := ⟨res.keys.reverse ++ Pad ++ G, hkeysSorted⟩
have hdb_a : db_a.keys = res.keys.reverse ++ Pad ++ G := rfl
have hlen_a : db_a.keys.length = s + 1 := by
rw [hdb_a, List.length_append, List.length_append, List.length_reverse, hGlen']
omega
have hcntB : db_a.keys.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.begin.key)) = t + p + G.length := by
rw [hdb_a, List.countP_append, List.countP_append, List.countP_reverse]
have h1 : res.keys.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.begin.key)) = t := by
rw [htdef, List.countP_eq_length]
intro x hx; rw [decide_eq_true_eq]
exact lt_trans (hreported_lt_E x hx) hcrossE
have h2 : Pad.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.begin.key)) = p := by
rw [← hPadLen, List.countP_eq_length]
intro x hx; rw [decide_eq_true_eq]
exact lt_trans (hPadMem x hx).2 hcrossE
have h3 : G.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.begin.key)) = G.length := by
rw [List.countP_eq_length]
intro x hx; rw [decide_eq_true_eq]; exact (hGmem x hx).2
rw [h1, h2, h3]
have hanchor : r.begin.anchor db_a = 0 := by
rw [anchor_eq_count_sub_slack db_a r (le_of_lt hbeg), hcntB, hGlen', ← hsdef]
have hts : t + p + (s + 1 - t - p) = s + 1 := by omega
rw [hts]; push_cast; ring
have h0lt : (0 : ℕ) < db_a.keys.length := by rw [hlen_a]; omega
have hmin_a : ∀ x ∈ db_a.keys, L ≤ x := by
intro x hx
rw [hdb_a] at hx
rcases List.mem_append.mp hx with hx' | hxG
· rcases List.mem_append.mp hx' with hxr | hxP
· exact hLle x (List.mem_reverse.mp hxr)
· exact le_of_lt (WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (hreported_lt_R L hLmem) (hPadMem x hxP).1))
· exact le_of_lt (WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (hreported_lt_E L hLmem) (hGmem x hxG).1))
have hLmem_a : L ∈ db_a.keys := by
rw [hdb_a]
exact List.mem_append_left _ (List.mem_append_left _ (List.mem_reverse.mpr hLmem))
have hget0 : db_a.keys[(0 : ℕ)] = L :=
getElem_zero_eq_of_forall_le hkeysSorted hmin_a hLmem_a h0lt
have hresBegin : resolve db_a r.begin = ((L : Key) : WithTop Key) := by
have h0 : 0 ≤ r.begin.anchor db_a := by rw [hanchor]
have hlt : (r.begin.anchor db_a).toNat < db_a.keys.length := by
rw [hanchor]; simpa using h0lt
rw [resolve_eq_getElem h0 hlt]
have hidx : (r.begin.anchor db_a).toNat = 0 := by rw [hanchor]; rfl
simp [hidx, hget0]
have hcntEnd : cnt db_a r.end_.key = t + p := by
unfold cnt
rw [hdb_a, List.countP_append, List.countP_append, List.countP_reverse]
have h1 : res.keys.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.end_.key)) = t := by
rw [htdef, List.countP_eq_length]
intro x hx; rw [decide_eq_true_eq]; exact hreported_lt_E x hx
have h2 : Pad.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.end_.key)) = p := by
rw [← hPadLen, List.countP_eq_length]
intro x hx; rw [decide_eq_true_eq]; exact (hPadMem x hx).2
have h3 : G.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.end_.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [decide_eq_true_eq, not_lt]
exact (hGmem x hx).1
rw [h1, h2, h3]
omega
have hancEnd : r.end_.anchor db_a = (t : Int) := by
change (cnt db_a r.end_.key : Int) + r.end_.offset - 1 = _
rw [hcntEnd]
have hpcast : (p : Int) = 1 - r.end_.offset := by
rw [hpdef, Int.toNat_of_nonneg (by omega)]
push_cast; rw [hpcast]; ring
have hresEnd : resolve db_a r.end_ = ((P0 : Key) : WithTop Key) := by
have h0 : 0 ≤ r.end_.anchor db_a := by rw [hancEnd]; positivity
have hlt : (r.end_.anchor db_a).toNat < db_a.keys.length := by
rw [hancEnd, hlen_a]; omega
have hlen1 : res.keys.reverse.length = t := by rw [List.length_reverse, htdef]
have hidx : (r.end_.anchor db_a).toNat = t := by rw [hancEnd]; simp
have hget : db_a.keys[(r.end_.anchor db_a).toNat]'hlt = P0 := by
simp only [hdb_a] at hlt ⊢
simp only [hidx, ← hlen1]
simp only [List.append_assoc]
rw [List.getElem_append_right (as := res.keys.reverse) (bs := Pad ++ G)
(i := res.keys.reverse.length) (by simp)]
simp only [Nat.sub_self]
rw [List.getElem_append_left (i := 0) (as := Pad) (bs := G) hPadPos]
rw [resolve_eq_getElem h0 hlt, hget]
have hfilter : db_a.keys.filter (fun x : Key => decide
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < resolve db_a r.end_)) = res.keys.reverse := by
rw [hdb_a, List.filter_append, List.filter_append, hresEnd]
have h1 : (res.keys.reverse).filter (fun x : Key => decide
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < ((P0 : Key) : WithTop Key))) = res.keys.reverse := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact ⟨WithTop.coe_le_coe.mpr (hLle x (List.mem_reverse.mp hx)),
lt_of_lt_of_le (hreported_lt_R x (List.mem_reverse.mp hx)) (hPadMem P0 hP0mem).1⟩
have h2 : Pad.filter (fun x : Key => decide
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < ((P0 : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
intro hP
exact absurd hP.2 (not_lt.mpr (WithTop.coe_le_coe.mpr (hP0min x hx)))
have h3 : G.filter (fun x : Key => decide
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < ((P0 : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
intro hP
have hle : ((P0 : Key) : WithTop Key) ≤ (x : WithTop Key) :=
le_trans (hPadMem P0 hP0mem).2.le (hGmem x hx).1
exact absurd hP.2 (not_lt.mpr hle)
rw [h1, h2, h3]
simp
have hcomplete : RangeRead.completeKeys db_a r = res.keys := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [hrev]
simp only [ite_true]
rw [hresBegin, hfilter, List.reverse_reverse]
have hcompat_a : RangeRead.Compatible db_a r res :=
⟨hcomp₀.1, Or.inl ⟨hmore, by rw [hcomplete], hne⟩⟩
have hk_a : k ∉ db_a.keys := by
rw [hdb_a]
intro hmem
rcases List.mem_append.mp hmem with hx | hx
· rcases List.mem_append.mp hx with hxr | hxP
· exact absurd (hreported_lt_E k (List.mem_reverse.mp hxr)) (not_lt.mpr hkE)
· exact absurd (hPadMem k hxP).2 (not_lt.mpr hkE)
· exact hkG (by simpa [hGdef] using hx)
-- insert the target: the first two sorted keys are the reported last and something above
let db_b : DB := db_a.insert k hk_a
have hins : (res.keys.reverse ++ Pad ++ G).orderedInsert (· ≤ ·) k =
res.keys.reverse ++ Pad ++ G.orderedInsert (· ≤ ·) k := by
refine orderedInsert_append_of_forall_lt_left ?_
intro x hx
rcases List.mem_append.mp hx with hx' | hxP
· exact WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (hreported_lt_E x (List.mem_reverse.mp hx')) hkE)
· exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hPadMem x hxP).2 hkE)
have hb_keys : db_b.keys = res.keys.reverse ++ Pad ++ G.orderedInsert (· ≤ ·) k := by
rw [show db_b.keys = db_a.keys.orderedInsert (· ≤ ·) k from rfl, hdb_a, hins]
have hb_len : db_b.keys.length = s + 2 := by
rw [hb_keys, List.length_append, List.length_append, List.length_reverse,
List.orderedInsert_length, hGlen', htdef, hsdef]
omega
have hb_all : ∀ x ∈ db_b.keys,
decide (((x : Key) : WithTop Key) < r.begin.key) = true := by
intro x hx
rw [decide_eq_true_eq]
rw [hb_keys] at hx
rcases List.mem_append.mp hx with hx' | hx'
· rcases List.mem_append.mp hx' with hxr | hxP
· exact lt_trans (hreported_lt_E x (List.mem_reverse.mp hxr)) hcrossE
· exact lt_trans (hPadMem x hxP).2 hcrossE
· rw [List.mem_orderedInsert] at hx'
rcases hx' with rfl | hxG
· exact hkB
· exact (hGmem x hxG).2
have hb_cntB : db_b.keys.countP (fun x : Key =>
decide (((x : Key) : WithTop Key) < r.begin.key)) = s + 2 := by
rw [← hb_len, List.countP_eq_length]
exact hb_all
have hanchor_b : r.begin.anchor db_b = 1 := by
rw [anchor_eq_count_sub_slack db_b r (le_of_lt hbeg), hb_cntB, ← hsdef]
push_cast; ring
have hget0_b : db_b.keys[(0 : ℕ)] = L := by
have hmin_b : ∀ x ∈ db_b.keys, L ≤ x := by
intro x hx
rw [hb_keys] at hx
rcases List.mem_append.mp hx with hx' | hx'
· rcases List.mem_append.mp hx' with hxr | hxP
· exact hLle x (List.mem_reverse.mp hxr)
· exact le_of_lt (WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (hreported_lt_R L hLmem) (hPadMem x hxP).1))
· rw [List.mem_orderedInsert] at hx'
rcases hx' with rfl | hxG
· exact le_of_lt (WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hreported_lt_E L hLmem) hkE))
· exact le_of_lt (WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (hreported_lt_E L hLmem) (hGmem x hxG).1))
have hLmem_b : L ∈ db_b.keys := by
rw [hb_keys]
exact List.mem_append_left _ (List.mem_append_left _ (List.mem_reverse.mpr hLmem))
have h0lt_b : 0 < db_b.keys.length := by rw [hb_len]; omega
exact getElem_zero_eq_of_forall_le db_b.sorted hmin_b hLmem_b h0lt_b
have h1lt : (1 : ℕ) < db_b.keys.length := by rw [hb_len]; omega
have hresBegin_b : resolve db_b r.begin = ((db_b.keys[(1 : ℕ)] : Key) : WithTop Key) := by
have h0 : 0 ≤ r.begin.anchor db_b := by rw [hanchor_b]; norm_num
have hlt : (r.begin.anchor db_b).toNat < db_b.keys.length := by
rw [hanchor_b]; simpa using h1lt
rw [resolve_eq_getElem h0 hlt]
have hidx : (r.begin.anchor db_b).toNat = 1 := by rw [hanchor_b]; rfl
simp [hidx]
have hLlt : L < db_b.keys[(1 : ℕ)] := by
have h01 : (0 : ℕ) < db_b.keys.length := by omega
have h := (List.SortedLT.getElem_lt_getElem_iff db_b.sorted (hi := h01)
(hj := h1lt)).mpr (show (0 : ℕ) < 1 by omega)
rwa [hget0_b] at h
have hLnot_ck : L ∉ RangeRead.completeKeys db_b r := by
intro hmem
have hle := (RangeRead.mem_completeKeys.mp hmem).2.1
rw [hresBegin_b] at hle
exact absurd hle (not_le.mpr (WithTop.coe_lt_coe.mpr hLlt))
have hnotCompat_b : ¬ RangeRead.Compatible db_b r res := by
intro hc
rcases hc.2 with ⟨_, hpre, _⟩ | ⟨hm, _⟩
· exact hLnot_ck (hpre.subset hLmem)
· rw [hmore] at hm; exact absurd hm (by simp)
refine necessary_of_toggle ⟨db_a, hcompat_a, ?_⟩
rw [toggle_eq_insert_of_not_mem hk_a]
exact hnotCompat_b
/-- **Minimality of the reversed truncated range in the small-capacity nonpositive-end
crossed cell.** Soundness is `sound_truncatedRangeRev_of_negCross_crossedNonpos_small`;
necessity of `[last, end_.key)` is `necessary_of_mem_truncatedRangeRev_of_end_nonpos`. -/
theorem minimal_truncatedRangeRev_of_negCross_crossedNonpos_small {r : RangeRead}
{res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset ≤ 0)
(hcap : intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1) :
Minimal r res (truncatedRangeRev r (res.keys.getLast hne)) := by
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
· exact sound_truncatedRangeRev_of_negCross_crossedNonpos_small hread hmore hrev hbeg hne
hcross hcrossE hend hcap
· intro k hk
rw [ConflictRange.mem_iff] at hk
obtain ⟨hkL, hkE⟩ := hk
exact necessary_of_mem_truncatedRangeRev_of_end_nonpos hread hrev hne hend hkL hkE
/-- **Minimality of `[last, begin_.key)` in the large-capacity nonpositive-end crossed
cell.** Soundness is `sound_beginKeyRange_of_negCross_crossedNonpos`; necessity below
`end_.key` is the truncated-range necessity, and at or above it the gap witness applies. -/
theorem minimal_beginKeyRange_of_negCross_crossedNonpos_large {r : RangeRead}
{res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset ≤ 0)
(hlarge : (beginSlack r : ℕ∞) + 2 ≤
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞)) :
Minimal r res ⟨((res.keys.getLast hne : Key) : WithTop Key), r.begin.key⟩ := by
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
· exact sound_beginKeyRange_of_negCross_crossedNonpos hmore hrev hne hcross hcrossE hend
· intro k hk
rw [ConflictRange.mem_iff] at hk
obtain ⟨hkL, hkB⟩ := hk
by_cases hkE : ((k : Key) : WithTop Key) < r.end_.key
· exact necessary_of_mem_truncatedRangeRev_of_end_nonpos hread hrev hne hend hkL hkE
· exact necessary_of_mem_gap_of_negCross_crossedNonpos_large hread hmore hrev hne hbeg
hcross hcrossE hend hlarge (not_lt.mp hkE) hkB
/-- The reversed crossed negative-begin truncated small-capacity cell at a nonpositive
end offset. -/
abbrev negCrossTruncRevCrossedNonposSmall (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
r.end_.key < r.begin.key ∧ r.end_.offset ≤ 0 ∧
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1
/-- The closed form of the small-capacity nonpositive-end crossed cell:
`[last reported, end_.key)`. -/
noncomputable def closedFormNegCrossTruncRevCrossedNonposSmall (_r : RangeRead)
(res : Result) : ConflictRange :=
truncatedRangeRev _r (res.keys.getLastD ([] : Key))
/-- **The small-capacity nonpositive-end crossed closed form is minimal.** -/
theorem minimal_closedForm_of_negCross_trunc_rev_crossedNonpos_small {r : RangeRead}
{res : Result} (hread : Readable r res)
(h : negCrossTruncRevCrossedNonposSmall r res) :
Minimal r res (closedFormNegCrossTruncRevCrossedNonposSmall r res) := by
obtain ⟨hmore, hrev, hbeg, hne, hcrossD, hcrossE, hend, hcap⟩ := h
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key := by
rw [← hlast]; exact hcrossD
unfold closedFormNegCrossTruncRevCrossedNonposSmall
rw [hlast]
exact minimal_truncatedRangeRev_of_negCross_crossedNonpos_small hread hmore hrev hbeg hne
hcross hcrossE hend hcap
/-- The reversed crossed negative-begin truncated large-capacity cell at a nonpositive
end offset. -/
abbrev negCrossTruncRevCrossedNonposLarge (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
r.end_.key < r.begin.key ∧ r.end_.offset ≤ 0 ∧
(beginSlack r : ℕ∞) + 2 ≤
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞) +
((1 - r.end_.offset).toNat : ℕ∞)
/-- The closed form of the large-capacity nonpositive-end crossed cell:
`[last reported, begin_.key)`. -/
noncomputable def closedFormNegCrossTruncRevCrossedNonposLarge (_r : RangeRead)
(res : Result) : ConflictRange :=
⟨((res.keys.getLastD ([] : Key) : Key) : WithTop Key), _r.begin.key⟩
/-- **The large-capacity nonpositive-end crossed closed form is minimal.** -/
theorem minimal_closedForm_of_negCross_trunc_rev_crossedNonpos_large {r : RangeRead}
{res : Result} (hread : Readable r res)
(h : negCrossTruncRevCrossedNonposLarge r res) :
Minimal r res (closedFormNegCrossTruncRevCrossedNonposLarge r res) := by
obtain ⟨hmore, hrev, hbeg, hne, hcrossD, hcrossE, hend, hlarge⟩ := h
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key := by
rw [← hlast]; exact hcrossD
unfold closedFormNegCrossTruncRevCrossedNonposLarge
rw [hlast]
exact minimal_beginKeyRange_of_negCross_crossedNonpos_large hread hmore hrev hbeg hne
hcross hcrossE hend hlarge
end FormalConflictRange