- Vendor the FormalConflictRange reference library needed by the proof - Add Bridge.lean with simp lemmas connecting the Statement definitions to the reference library - Prove Statement.closedFormMinimal in Proof.lean - Register the new libraries in the Lake config
1135 lines
55 KiB
Lean4
1135 lines
55 KiB
Lean4
/-
|
||
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
|
||
Released under Apache 2.0 license as described in the file LICENSE.
|
||
Authors: FormalConflictRange contributors
|
||
-/
|
||
|
||
import FormalConflictRange.NegCrossTruncRevResidualLargeTop
|
||
|
||
/-!
|
||
# The sentinel-begin large-gap top cell of the reversed truncated residual
|
||
|
||
This module closes the sentinel-begin companion of
|
||
`NegCrossTruncRevResidualLargeTop.lean`: the reversed crossed negative-begin
|
||
truncated residual at end offset at least two, with the end key strictly below
|
||
the reported last and the large-gap condition, but with `begin.key = ⊤`.
|
||
|
||
Writing `E := r.end_.key`, `L` for the reported last, `t := #reported`,
|
||
`e := (r.end_.offset - 1).toNat` and `card := intervalCard E L`, the minimal
|
||
range is
|
||
|
||
* `[L, ⊤)` when `e = card + t` **and** `t + r.begin.offset = 1`;
|
||
* `[E, ⊤)` otherwise.
|
||
|
||
In the first (tight) case compatibility forces `resolve end = ⊤` and
|
||
`resolve begin = L`, so the cell has the same compatible databases as the
|
||
sentinel-end read; in the second case the gap keys below `L` are necessary and
|
||
the range must start at `E`.
|
||
-/
|
||
|
||
namespace FormalConflictRange
|
||
|
||
set_option maxHeartbeats 3200000
|
||
|
||
/-- The first optional entry of a nonempty list is its head. -/
|
||
theorem getElem?_zero_eq_head {l : List Key} (hne : l ≠ []) :
|
||
l[0]? = some (l.head hne) := by
|
||
cases l with
|
||
| nil => exact absurd rfl hne
|
||
| cons a t => simp
|
||
|
||
/-! ### The cell and its closed form -/
|
||
|
||
/-- The sentinel-begin large-gap top subcell of the reversed truncated residual. -/
|
||
abbrev negCrossTruncRevResidualTopLargeSentinel (r : RangeRead) (res : Result) : Prop :=
|
||
negCrossTruncRevResidualTopLarge r res ∧ r.begin.key = (⊤ : WithTop Key)
|
||
|
||
/-- The tightness condition of the sentinel-begin large-gap top cell. -/
|
||
noncomputable def sentinelLargeTight (r : RangeRead) (res : Result) : Prop :=
|
||
let L : WithTop Key := ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
|
||
((r.end_.offset - 1).toNat : ℕ∞) = intervalCard r.end_.key L + (res.keys.length : ℕ∞) ∧
|
||
(res.keys.length : Int) + r.begin.offset = 1
|
||
|
||
/-- The closed form of the sentinel-begin large-gap top cell. -/
|
||
noncomputable def closedFormNegCrossTruncRevResidualTopLargeSentinel
|
||
(r : RangeRead) (res : Result) : ConflictRange := by
|
||
classical
|
||
let L : WithTop Key := ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
|
||
exact if sentinelLargeTight r res then ⟨L, ⊤⟩ else ⟨r.end_.key, ⊤⟩
|
||
|
||
/-! ### Converting the tight condition to natural numbers -/
|
||
|
||
/-- The tight `ℕ∞` identity, read in `ℕ`. -/
|
||
theorem tight_nat {r : RangeRead} {res : Result} {L : Key}
|
||
(htight : ((r.end_.offset - 1).toNat : ℕ∞) =
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) + (res.keys.length : ℕ∞)) :
|
||
(r.end_.offset - 1).toNat =
|
||
(intervalCard r.end_.key ((L : Key) : WithTop Key)).toNat + res.keys.length := by
|
||
have hcardtop : intervalCard r.end_.key ((L : Key) : WithTop Key) ≠ ⊤ := by
|
||
intro h
|
||
rw [h] at htight
|
||
have htop : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) = ⊤ := by
|
||
rw [htight]; simp
|
||
exact ENat.natCast_ne_top _ htop
|
||
have h := congrArg ENat.toNat htight
|
||
rw [ENat.toNat_natCast, ENat.toNat_add hcardtop (ENat.natCast_ne_top _),
|
||
ENat.toNat_natCast] at h
|
||
exact h
|
||
|
||
/-! ### The tight counting core -/
|
||
|
||
/-- **The end resolution is the sentinel in the tight compatible cell.**
|
||
|
||
Every compatible database in the tight cell resolves its end selector to `⊤`.
|
||
If the end resolution were a genuine key, the stored keys in `[L, resolve end)`
|
||
would be exactly the reported keys, so the stored keys in `[E, L)` would be the
|
||
whole interval `card = e - t`; the remaining stored keys above `resolve end`
|
||
would then shift the begin anchor, because `begin.key = ⊤`, past the reported
|
||
last, contradicting that the reported last lies in the complete keys. -/
|
||
theorem resolve_end_eq_top_of_tight_forward {db : DB} {r : RangeRead} {res : Result}
|
||
{L : Key}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||
(hL : res.keys.getLast hne = L) (hbtop : r.begin.key = (⊤ : WithTop Key))
|
||
(hend : 2 ≤ r.end_.offset)
|
||
(hEL : r.end_.key < ((L : Key) : WithTop Key))
|
||
(hoff : (res.keys.length : Int) + r.begin.offset = 1) :
|
||
resolve db r.end_ = (⊤ : WithTop Key) := by
|
||
classical
|
||
have htpos : 0 < res.keys.length := List.length_pos_iff.mpr hne
|
||
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
|
||
simpa [hL] using h
|
||
have hLmem : L ∈ res.keys := hL ▸ List.getLast_mem hne
|
||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||
have hLck : L ∈ RangeRead.completeKeys db r := by
|
||
have h := hLmem
|
||
rw [← hfil] at h
|
||
exact (List.mem_filter.mp h).1
|
||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||
(RangeRead.mem_completeKeys.mp hLck).2.1
|
||
obtain ⟨j, hjlt, hjeq⟩ := List.mem_iff_getElem.mp hLdb
|
||
have hcntL : cnt db ((L : Key) : WithTop Key) = j := by
|
||
rw [cnt_coe]
|
||
exact countP_lt_eq_of_getElem db.sorted hjlt hjeq
|
||
by_contra hne_top
|
||
have hbetween_eq : between db ((L : Key) : WithTop Key) (resolve db r.end_) =
|
||
res.keys.reverse := by
|
||
have h := res_keys_eq_reverse_between_resolve_end (db := db) (r := r) hcomp hmore hrev hne
|
||
rw [hL] at h
|
||
simpa [List.reverse_reverse] using (congrArg List.reverse h).symm
|
||
have hlenL : (between db ((L : Key) : WithTop Key) (resolve db r.end_)).length =
|
||
res.keys.length := by
|
||
rw [hbetween_eq, List.length_reverse]
|
||
have hlenE : (between db r.end_.key (resolve db r.end_)).length =
|
||
(r.end_.offset - 1).toNat :=
|
||
length_between_end_resolve_eq_of_ne_top (db := db) (r := r) hend hne_top
|
||
have hLre : ((L : Key) : WithTop Key) < resolve db r.end_ := by
|
||
have hpos : 0 < (between db ((L : Key) : WithTop Key) (resolve db r.end_)).length := by
|
||
rw [hlenL]; exact htpos
|
||
obtain ⟨k, hk⟩ := List.exists_mem_of_ne_nil _ (List.length_pos_iff.mp hpos)
|
||
have hk' := List.mem_filter.mp hk
|
||
rcases (of_decide_eq_true hk'.2) with ⟨hLk, hkre⟩
|
||
exact lt_of_le_of_lt hLk hkre
|
||
have hEre : r.end_.key ≤ resolve db r.end_ :=
|
||
le_of_lt (lt_trans hEL hLre)
|
||
have hcnt1 : cnt db (resolve db r.end_) =
|
||
cnt db ((L : Key) : WithTop Key) +
|
||
(between db ((L : Key) : WithTop Key) (resolve db r.end_)).length :=
|
||
cnt_eq_add_between db (le_of_lt hLre)
|
||
have hcnt2 : cnt db ((L : Key) : WithTop Key) =
|
||
cnt db r.end_.key + (between db r.end_.key ((L : Key) : WithTop Key)).length :=
|
||
cnt_eq_add_between db (le_of_lt hEL)
|
||
have hcnt3 : cnt db (resolve db r.end_) =
|
||
cnt db r.end_.key + (between db r.end_.key (resolve db r.end_)).length :=
|
||
cnt_eq_add_between db hEre
|
||
have hcntTop1 : cnt db (⊤ : WithTop Key) =
|
||
cnt db (resolve db r.end_) +
|
||
(between db (resolve db r.end_) (⊤ : WithTop Key)).length :=
|
||
cnt_eq_add_between db le_top
|
||
have hanchor : r.begin.anchor db = (cnt db (⊤ : WithTop Key) : Int) + r.begin.offset - 1 := by
|
||
change (cnt db r.begin.key : Int) + r.begin.offset - 1 = _
|
||
rw [hbtop]
|
||
have hanchor_eq : r.begin.anchor db =
|
||
(cnt db ((L : Key) : WithTop Key) : Int) +
|
||
((between db (resolve db r.end_) (⊤ : WithTop Key)).length : Int) := by
|
||
rw [hanchor]
|
||
have hN : cnt db (⊤ : WithTop Key) =
|
||
cnt db ((L : Key) : WithTop Key) + res.keys.length +
|
||
(between db (resolve db r.end_) (⊤ : WithTop Key)).length := by
|
||
have := hcntTop1
|
||
rw [hcnt1, hlenL] at this
|
||
exact this
|
||
rw [hN]
|
||
have hoff' : r.begin.offset = 1 - (res.keys.length : Int) := by linarith
|
||
rw [hoff']
|
||
push_cast
|
||
ring
|
||
have hanchor_nonneg : 0 ≤ r.begin.anchor db := by
|
||
rw [hanchor_eq]
|
||
have h1 : (0 : Int) ≤ (cnt db ((L : Key) : WithTop Key) : Int) := by
|
||
exact_mod_cast Nat.zero_le _
|
||
have h2 : (0 : Int) ≤ ((between db (resolve db r.end_) (⊤ : WithTop Key)).length : Int) := by
|
||
exact_mod_cast Nat.zero_le _
|
||
linarith
|
||
have hanchor_le : r.begin.anchor db ≤ (cnt db ((L : Key) : WithTop Key) : Int) := by
|
||
have hj := (resolve_le_getElem_iff (db := db) (s := r.begin) hjlt).mp (by rw [hjeq]; exact hrb)
|
||
have htoNat : (r.begin.anchor db).toNat ≤ j := by
|
||
unfold clampIndex at hj
|
||
by_cases h : (r.begin.anchor db).toNat ≤ db.keys.length
|
||
· rwa [Nat.min_eq_left h] at hj
|
||
· rw [Nat.min_eq_right (by omega)] at hj; omega
|
||
have hanchor_le_j : r.begin.anchor db ≤ (j : Int) := by
|
||
have h1 : r.begin.anchor db ≤ ((r.begin.anchor db).toNat : Int) := by
|
||
rw [Int.toNat_of_nonneg hanchor_nonneg]
|
||
have h2 : ((r.begin.anchor db).toNat : Int) ≤ (j : Int) := by exact_mod_cast htoNat
|
||
linarith
|
||
rwa [hcntL]
|
||
have hzpos : 0 < (between db (resolve db r.end_) (⊤ : WithTop Key)).length := by
|
||
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with hnil | htop | ⟨q, hq, hqeq⟩
|
||
· rw [hnil]
|
||
have hbw : between db (([] : Key) : WithTop Key) (⊤ : WithTop Key) = db.keys := by
|
||
unfold between
|
||
rw [List.filter_eq_self]
|
||
intro k _
|
||
rw [decide_eq_true_eq]
|
||
exact ⟨WithTop.coe_le_coe.mpr (nil_le_key k), WithTop.coe_lt_top k⟩
|
||
rw [hbw]
|
||
obtain ⟨x, hx⟩ := List.exists_mem_of_ne_nil _ hne
|
||
have hxdb : x ∈ db.keys := RangeRead.compatible_keys_subset hcomp (by simpa using hx)
|
||
rw [List.length_pos_iff]
|
||
exact fun hnil' => by rw [hnil'] at hxdb; exact absurd hxdb (by simp)
|
||
· exact absurd htop hne_top
|
||
· rw [hqeq]
|
||
have hmem : q ∈ between db ((q : Key) : WithTop Key) (⊤ : WithTop Key) := by
|
||
unfold between
|
||
rw [List.mem_filter]
|
||
exact ⟨hq, decide_eq_true ⟨le_refl _, WithTop.coe_lt_top q⟩⟩
|
||
rw [List.length_pos_iff]
|
||
exact fun hnil' => by rw [hnil'] at hmem; exact absurd hmem (by simp)
|
||
rw [hanchor_eq] at hanchor_le
|
||
have hz0 : (between db (resolve db r.end_) (⊤ : WithTop Key)).length = 0 := by
|
||
have : ((between db (resolve db r.end_) (⊤ : WithTop Key)).length : Int) ≤ 0 := by linarith
|
||
omega
|
||
omega
|
||
|
||
/-! ### The end resolution from agreement above the reported last -/
|
||
|
||
/-- **The end resolution is the sentinel in the tight cell, from keys at or above the
|
||
reported last.** If every stored key at or above the reported last is one of the
|
||
reported keys then, under tightness, the end selector overshoots: the whole gap
|
||
`[end_.key, last)` holds at most `card` keys, so the keys at or above `end_.key` number
|
||
at most `card + #reported = end_.offset - 1`, exactly the capacity of the end anchor. -/
|
||
theorem resolve_end_eq_top_of_above {db : DB} {r : RangeRead} {res : Result} {L : Key}
|
||
(habove : above db ((L : Key) : WithTop Key) = res.keys.reverse)
|
||
(_hend : 2 ≤ r.end_.offset)
|
||
(hEL : r.end_.key < ((L : Key) : WithTop Key))
|
||
(htight : ((r.end_.offset - 1).toNat : ℕ∞) =
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) + (res.keys.length : ℕ∞)) :
|
||
resolve db r.end_ = (⊤ : WithTop Key) := by
|
||
have hnat := tight_nat htight
|
||
have hcardtop : intervalCard r.end_.key ((L : Key) : WithTop Key) ≠ ⊤ := by
|
||
intro h
|
||
rw [h] at htight
|
||
have htop : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) = ⊤ := by
|
||
rw [htight]; simp
|
||
exact ENat.natCast_ne_top _ htop
|
||
-- `between L ⊤` is `above L`
|
||
have hbetweenTop : between db ((L : Key) : WithTop Key) (⊤ : WithTop Key) =
|
||
above db ((L : Key) : WithTop Key) := by
|
||
unfold between above
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact and_iff_left (WithTop.coe_lt_top k)
|
||
-- the total key count
|
||
have hcnt : cnt db (⊤ : WithTop Key) =
|
||
cnt db r.end_.key + (between db r.end_.key ((L : Key) : WithTop Key)).length +
|
||
res.keys.length := by
|
||
have h1 := cnt_eq_add_between db (le_of_lt hEL :
|
||
r.end_.key ≤ ((L : Key) : WithTop Key))
|
||
have h2 := cnt_eq_add_between (db := db)
|
||
(w₁ := ((L : Key) : WithTop Key)) (w₂ := (⊤ : WithTop Key)) le_top
|
||
rw [hbetweenTop, habove, List.length_reverse] at h2
|
||
rw [h1] at h2
|
||
omega
|
||
-- the gap holds at most `card` keys
|
||
have hgaple : (between db r.end_.key ((L : Key) : WithTop Key)).length ≤
|
||
(intervalCard r.end_.key ((L : Key) : WithTop Key)).toNat := by
|
||
have h := between_length_le_intervalCard (db := db) (E := r.end_.key)
|
||
(B := ((L : Key) : WithTop Key)) (le_of_lt hEL)
|
||
rw [← ENat.natCast_toNat hcardtop] at h
|
||
exact ENat.natCast_le_natCast.mp h
|
||
-- the anchor of the end selector
|
||
have hoff : ((r.end_.offset - 1).toNat : Int) = r.end_.offset - 1 :=
|
||
Int.toNat_of_nonneg (by omega)
|
||
have hanchor : r.end_.anchor db =
|
||
((cnt db r.end_.key + (r.end_.offset - 1).toNat : ℕ) : Int) := by
|
||
unfold Selector.anchor cnt
|
||
rw [Nat.cast_add, hoff]
|
||
ring
|
||
have hanchor_nonneg : 0 ≤ r.end_.anchor db := by
|
||
rw [hanchor]; exact_mod_cast Nat.zero_le _
|
||
have hanchor_toNat : (r.end_.anchor db).toNat =
|
||
cnt db r.end_.key + (r.end_.offset - 1).toNat := by
|
||
rw [hanchor, Int.toNat_natCast]
|
||
refine resolve_eq_top hanchor_nonneg ?_
|
||
rw [hanchor_toNat, ← cnt_top db, hcnt]
|
||
omega
|
||
|
||
/-! ### Recovering agreement above the reported last -/
|
||
|
||
/-- **A compatible database sees exactly the reported keys above the last.** When the
|
||
end selector resolves to the sentinel, the complete keys above the reported last are all
|
||
stored keys above it, and compatibility identifies them with the reported keys. -/
|
||
theorem above_eq_reverse_of_compat_end_top {db : DB} {r : RangeRead} {res : Result} {L : Key}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hne : res.keys ≠ []) (hL : res.keys.getLast hne = L)
|
||
(hre : resolve db r.end_ = (⊤ : WithTop Key)) :
|
||
above db ((L : Key) : WithTop Key) = res.keys.reverse := by
|
||
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
|
||
simpa [hL] using h
|
||
have hLmem : L ∈ res.keys := hL ▸ List.getLast_mem hne
|
||
have hLck : L ∈ RangeRead.completeKeys db r := by
|
||
have h := hLmem
|
||
rw [← hfil] at h
|
||
exact (List.mem_filter.mp h).1
|
||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||
(RangeRead.mem_completeKeys.mp hLck).2.1
|
||
have h := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r) (last := L)
|
||
hrev hre hrb
|
||
rw [hfil] at h
|
||
have hfilUp : db.keys.filter (fun k : Key => decide (L ≤ k)) =
|
||
above db ((L : Key) : WithTop Key) := by
|
||
rw [above_eq_filter]
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact WithTop.coe_le_coe.symm
|
||
rw [hfilUp] at h
|
||
have h2 : res.keys.reverse = above db ((L : Key) : WithTop Key) := by
|
||
rw [h, List.reverse_reverse]
|
||
exact h2.symm
|
||
|
||
/-! ### Reducing the tight cell to the sentinel-end read -/
|
||
|
||
/-- **In the tight cell the end selector is equivalent to the sentinel.** Replacing the
|
||
end selector by `⟨⊤, 1⟩` does not change the compatible databases: forward, `t + off = 1`
|
||
forces the end resolution to the sentinel; backward, agreement with the reported keys
|
||
above the last plus tightness does the same. -/
|
||
theorem compatible_iff_sentinelEnd_of_tight {r : RangeRead} {res : Result} {L : Key}
|
||
(hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||
(hL : res.keys.getLast hne = L) (hbtop : r.begin.key = (⊤ : WithTop Key))
|
||
(hend : 2 ≤ r.end_.offset)
|
||
(hEL : r.end_.key < ((L : Key) : WithTop Key))
|
||
(hoff : (res.keys.length : Int) + r.begin.offset = 1)
|
||
(htight : ((r.end_.offset - 1).toNat : ℕ∞) =
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) + (res.keys.length : ℕ∞)) :
|
||
∀ db, RangeRead.Compatible db r res ↔
|
||
RangeRead.Compatible db { r with end_ := ⟨(⊤ : WithTop Key), 1⟩ } res := by
|
||
intro db
|
||
have htopEnd : resolve db ({ r with end_ := ⟨(⊤ : WithTop Key), 1⟩ } : RangeRead).end_ =
|
||
(⊤ : WithTop Key) := resolve_end_eq_top_of_key_top rfl (by norm_num)
|
||
have hck : resolve db r.end_ = (⊤ : WithTop Key) →
|
||
RangeRead.completeKeys db r =
|
||
RangeRead.completeKeys db { r with end_ := ⟨(⊤ : WithTop Key), 1⟩ } := by
|
||
intro hre
|
||
unfold RangeRead.completeKeys RangeRead.inRange
|
||
rw [hre, htopEnd]
|
||
constructor
|
||
· intro hc
|
||
have hre := resolve_end_eq_top_of_tight_forward hc hmore hrev hne hL hbtop hend hEL hoff
|
||
have hckeq := hck hre
|
||
unfold RangeRead.Compatible at hc ⊢
|
||
rw [hckeq] at hc
|
||
exact hc
|
||
· intro hc
|
||
have habove := above_eq_reverse_of_compat_end_top hc hmore hrev hne hL htopEnd
|
||
have hre := resolve_end_eq_top_of_above (db := db) habove hend hEL htight
|
||
have hckeq := hck hre
|
||
unfold RangeRead.Compatible at hc ⊢
|
||
rw [← hckeq] at hc
|
||
exact hc
|
||
|
||
/-- **The tight sentinel-begin large-gap top cell is minimal with range `[last, ⊤)`.** -/
|
||
theorem minimal_topOfLast_of_sentinel_large_tight {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
|
||
(hbtop : r.begin.key = (⊤ : WithTop Key)) (hend : 2 ≤ r.end_.offset)
|
||
(hEL : r.end_.key < ((res.keys.getLast hne : Key) : WithTop Key))
|
||
(hoff : (res.keys.length : Int) + r.begin.offset = 1)
|
||
(htight : ((r.end_.offset - 1).toNat : ℕ∞) =
|
||
intervalCard r.end_.key ((res.keys.getLast hne : Key) : WithTop Key) +
|
||
(res.keys.length : ℕ∞)) :
|
||
Minimal r res (topOfLast (res.keys.getLast hne)) := by
|
||
set L : Key := res.keys.getLast hne
|
||
set r' : RangeRead := { r with end_ := ⟨(⊤ : WithTop Key), 1⟩ } with hr'
|
||
have hiff := compatible_iff_sentinelEnd_of_tight (r := r) (res := res) (L := L)
|
||
hmore hrev hne rfl hbtop hend hEL hoff htight
|
||
have hread' : Readable r' res := by
|
||
obtain ⟨db, hc⟩ := hread
|
||
exact ⟨db, (hiff db).mp hc⟩
|
||
have hbeg' : r'.begin.offset < 0 := hbeg
|
||
have hmin' : Minimal r' res (topOfLast (res.keys.getLast hne)) :=
|
||
minimal_topOfLast_of_rev_negTrunc_top_nocross hread' hmore hrev hne hbeg' rfl (by norm_num)
|
||
exact (minimal_congr_of_compatible_iff (r := r) (r' := r') hiff).mpr hmin'
|
||
|
||
/-! ### The offset bound in the sentinel-begin cell -/
|
||
|
||
/-- **The reported length and begin offset cannot both be large.** In a compatible
|
||
sentinel-begin truncated result the begin anchor `N + offset - 1` lands at or below the
|
||
reported last, and only `N - index(last)` keys are at or above that last, so
|
||
`#reported + offset ≤ 1`. -/
|
||
theorem sentinel_begin_offset_bound {r : RangeRead} {res : Result} {db : DB}
|
||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||
(hbtop : r.begin.key = (⊤ : WithTop Key)) :
|
||
(res.keys.length : Int) + r.begin.offset ≤ 1 := by
|
||
classical
|
||
set L : Key := res.keys.getLast hne with hL
|
||
set t : Nat := res.keys.length with ht
|
||
set N : Nat := db.keys.length with hN
|
||
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
|
||
simpa [hL] using h
|
||
have hLmem : L ∈ res.keys := by rw [hL]; exact List.getLast_mem hne
|
||
have hLck : L ∈ RangeRead.completeKeys db r := by
|
||
have h := hLmem
|
||
rw [← hfil] at h
|
||
exact (List.mem_filter.mp h).1
|
||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||
(RangeRead.mem_completeKeys.mp hLck).2.1
|
||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||
obtain ⟨j, hjlt, hjeq⟩ := List.mem_iff_getElem.mp hLdb
|
||
have hcntL : cnt db ((L : Key) : WithTop Key) = j := by
|
||
rw [cnt_coe]
|
||
exact countP_lt_eq_of_getElem db.sorted hjlt hjeq
|
||
-- the reported keys fit inside the database
|
||
have htN : t ≤ N := by
|
||
have hpre := RangeRead.compatible_keys_prefix hcomp
|
||
refine le_trans hpre.length_le ?_
|
||
rw [(RangeRead.completeKeys_perm_inRange db r).length_eq]
|
||
exact List.length_filter_le _ _
|
||
-- the number of stored keys at or above the last
|
||
have haboveLen : (above db ((L : Key) : WithTop Key)).length = N - j := by
|
||
have hbT : between db ((L : Key) : WithTop Key) (⊤ : WithTop Key) =
|
||
above db ((L : Key) : WithTop Key) := by
|
||
unfold between above
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact and_iff_left (WithTop.coe_lt_top k)
|
||
have h := cnt_eq_add_between (db := db)
|
||
(w₁ := ((L : Key) : WithTop Key)) (w₂ := (⊤ : WithTop Key)) le_top
|
||
rw [hbT, cnt_top, ← hN, hcntL] at h
|
||
omega
|
||
-- the reported keys are a subset of the keys at or above the last
|
||
have hsubAbove : res.keys ⊆ above db ((L : Key) : WithTop Key) := by
|
||
intro k hk
|
||
rw [mem_above]
|
||
refine ⟨RangeRead.compatible_keys_subset hcomp hk, ?_⟩
|
||
have hsort := RangeRead.compatible_sortedGT hcomp hrev
|
||
have hLk : L ≤ k := (hsort.pairwise.imp le_of_lt).rel_getLast hk
|
||
exact WithTop.coe_le_coe.mpr hLk
|
||
have htNj : t ≤ N - j := by
|
||
have hnd : res.keys.Nodup := by
|
||
rw [← hfil]
|
||
exact (RangeRead.completeKeys_nodup db r).filter _
|
||
have := (List.subperm_of_subset (l₁ := res.keys)
|
||
(l₂ := above db ((L : Key) : WithTop Key)) hnd hsubAbove).length_le
|
||
rw [haboveLen] at this
|
||
exact this
|
||
have hanchor : r.begin.anchor db = (N : Int) + r.begin.offset - 1 := by
|
||
change (cnt db r.begin.key : Int) + r.begin.offset - 1 = _
|
||
rw [hbtop, cnt_top]
|
||
by_cases hneg : r.begin.anchor db < 0
|
||
· -- the anchor is negative: `offset < 1 - N`
|
||
have : (t : Int) + r.begin.offset ≤ 1 := by
|
||
have htN' : (t : Int) ≤ (N : Int) := by exact_mod_cast htN
|
||
have hoff : (r.begin.offset : Int) < 1 - N := by
|
||
rw [hanchor] at hneg; linarith
|
||
linarith
|
||
exact this
|
||
· -- the anchor is nonnegative: it lands at or below `last`
|
||
have hnonneg : 0 ≤ r.begin.anchor db := le_of_not_gt hneg
|
||
have hclamp : clampIndex db r.begin ≤ j :=
|
||
(resolve_le_getElem_iff (db := db) (s := r.begin) hjlt).mp (by rw [hjeq]; exact hrb)
|
||
have htoNat_le : (r.begin.anchor db).toNat ≤ j := by
|
||
unfold clampIndex at hclamp
|
||
by_cases h : (r.begin.anchor db).toNat ≤ N
|
||
· rwa [Nat.min_eq_left h] at hclamp
|
||
· rw [Nat.min_eq_right (by omega)] at hclamp; omega
|
||
have hanchor_le_j : r.begin.anchor db ≤ (j : Int) := by
|
||
have h1 : r.begin.anchor db = ((r.begin.anchor db).toNat : Int) :=
|
||
(Int.toNat_of_nonneg hnonneg).symm
|
||
rw [h1]
|
||
exact_mod_cast htoNat_le
|
||
have hoff : (r.begin.offset : Int) ≤ (j : Int) - N + 1 := by
|
||
rw [hanchor] at hanchor_le_j; linarith
|
||
have htNj' : (t : Int) ≤ (N : Int) - (j : Int) := by
|
||
have h1 : (t : Int) ≤ ((N - j : Nat) : Int) := by exact_mod_cast htNj
|
||
have h2 : ((N - j : Nat) : Int) = (N : Int) - (j : Int) := by
|
||
rw [Nat.cast_sub (le_of_lt hjlt)]
|
||
rwa [h2] at h1
|
||
linarith
|
||
|
||
/-! ### Gap-key necessity in regime A -/
|
||
|
||
/-- **Gap-key necessity in the sentinel-begin large-gap top cell, regime A.**
|
||
|
||
When `#reported + begin.offset = 1` and the gap is not tight, the witness stores `D = e - t`
|
||
gap keys in `[end_.key, last)` avoiding the target, then the reversed reported keys. Its
|
||
begin anchor is exactly `D`, so it resolves onto the reported last, and its end resolves to
|
||
the sentinel. Inserting the target raises the end resolution onto the reported head,
|
||
which leaves the complete keys and breaks the reported prefix. -/
|
||
theorem necessary_gap_of_sentinel_large_A {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
|
||
(hbtop : r.begin.key = (⊤ : WithTop Key))
|
||
(hend : 2 ≤ r.end_.offset)
|
||
(hEL : r.end_.key < ((res.keys.getLast hne : Key) : WithTop Key))
|
||
(ht : res.keys.length < (r.end_.offset - 1).toNat)
|
||
(hstrict : ((r.end_.offset - 1).toNat : ℕ∞) <
|
||
intervalCard r.end_.key ((res.keys.getLast hne : Key) : WithTop Key) +
|
||
(res.keys.length : ℕ∞))
|
||
(hoff : (res.keys.length : Int) + r.begin.offset = 1)
|
||
{k : Key} (hEk : r.end_.key ≤ (k : WithTop Key))
|
||
(hkL : (k : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) :
|
||
Necessary r res k := by
|
||
classical
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set L : Key := res.keys.getLast hne with hL
|
||
set H : Key := res.keys.head hne with hH
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set t : Nat := res.keys.length with ht'
|
||
set D : Nat := e - t with hD
|
||
have htn : 0 < t := List.length_pos_of_ne_nil hne
|
||
have ht_lt : t < e := by simpa [t, e] using ht
|
||
have hDt : D + t = e := by omega
|
||
have hD1 : 1 ≤ D := by omega
|
||
have hLmem : L ∈ res.keys := by rw [hL]; exact List.getLast_mem hne
|
||
have hHmem : H ∈ res.keys := by rw [hH]; exact List.head_mem hne
|
||
have hEL' : E < ((L : Key) : WithTop Key) := by simpa [E, L] using hEL
|
||
have hkL' : ((k : Key) : WithTop Key) < ((L : Key) : WithTop Key) := hkL
|
||
-- room for `D + 1` gap keys avoiding the target
|
||
have hD_lt_card : (D : ℕ∞) < intervalCard E ((L : Key) : WithTop Key) := by
|
||
have hstrict' : (e : ℕ∞) < intervalCard E ((L : Key) : WithTop Key) + (t : ℕ∞) := by
|
||
simpa [E, L, e, t] using hstrict
|
||
have hcast : ((D : ℕ∞) + (t : ℕ∞)) = (e : ℕ∞) := by
|
||
rw [← Nat.cast_add, hDt]
|
||
rw [← hcast] at hstrict'
|
||
exact (ENat.add_lt_add_iff_right (ENat.natCast_ne_top t)).mp hstrict'
|
||
have hroom : (((D + 1 : ℕ) : ℕ∞)) ≤ intervalCard E ((L : Key) : WithTop Key) := by
|
||
have := (ENat.add_one_le_iff (m := (D : ℕ∞))
|
||
(n := intervalCard E ((L : Key) : WithTop Key)) (ENat.natCast_ne_top D)).mpr hD_lt_card
|
||
simpa using this
|
||
obtain ⟨pad, hpadIn, hkpad, hpadlen⟩ :=
|
||
exists_db_keysIn_avoid (B := E) (E := ((L : Key) : WithTop Key)) (k := k) (m := D) hroom
|
||
set G : List Key := pad.keys with hGdef
|
||
have hGmem : ∀ x ∈ G, E ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < ((L : Key) : WithTop Key) := by
|
||
intro x hx
|
||
simpa only [G, keysIn, Set.mem_ofPred_eq] using hpadIn x (by simpa [hGdef] using hx)
|
||
have hGsort : G.SortedLT := by rw [hGdef]; exact pad.sorted
|
||
have hGlen : G.length = D := by rw [hGdef]; exact hpadlen
|
||
have hkG : k ∉ G := by rw [hGdef]; exact hkpad
|
||
-- the reported keys, ascending
|
||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
|
||
set R : List Key := res.keys.reverse with hR
|
||
have hRsort : R.SortedLT := by rw [hR]; exact hsort.reverse
|
||
have hRmem : ∀ y ∈ R, L ≤ y := by
|
||
intro y hy
|
||
rw [hR] at hy
|
||
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.mem_reverse.mp hy)
|
||
have hRleH : ∀ y ∈ R, y ≤ H := by
|
||
intro y hy
|
||
rw [hR] at hy
|
||
exact (hsort.pairwise.imp le_of_lt).rel_head (List.mem_reverse.mp hy)
|
||
have hLleH : L ≤ H := hRmem H (by rw [hR, List.mem_reverse]; exact hHmem)
|
||
have hGR : ∀ x ∈ G, ∀ y ∈ R, x < y := by
|
||
intro x hx y hy
|
||
exact WithTop.coe_lt_coe.mp
|
||
(lt_of_lt_of_le (hGmem x hx).2 (WithTop.coe_le_coe.mpr (hRmem y hy)))
|
||
set T : List Key := G ++ R with hT
|
||
have hTsort : T.SortedLT := by
|
||
rw [hT]
|
||
exact List.sortedLT_append.mpr ⟨hGsort, hRsort, hGR⟩
|
||
let db_a : DB := ⟨T, hTsort⟩
|
||
have hfullKeys : db_a.keys = T := rfl
|
||
have hTlen : T.length = e := by
|
||
rw [hT, List.length_append, hGlen, hR, List.length_reverse, ← ht']
|
||
omega
|
||
have hlen_a : db_a.keys.length = e := by rw [hfullKeys, hTlen]
|
||
have hcnt0 : cnt db_a E = 0 := by
|
||
apply cnt_eq_zero_of_forall_ge
|
||
intro x hx
|
||
rw [hfullKeys, hT] at hx
|
||
rcases List.mem_append.mp hx with hx | hx
|
||
· exact (hGmem x hx).1
|
||
· exact le_trans (le_of_lt hEL') (WithTop.coe_le_coe.mpr (hRmem x hx))
|
||
have hanchorEnd : (r.end_.anchor db_a).toNat = e := by
|
||
have hanc : r.end_.anchor db_a = r.end_.offset - 1 := by
|
||
unfold Selector.anchor
|
||
rw [show List.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) db_a.keys = 0 from by
|
||
rw [← hE]; exact hcnt0]
|
||
ring
|
||
rw [hanc]
|
||
have hre_a : resolve db_a r.end_ = (⊤ : WithTop Key) := by
|
||
refine resolve_eq_top (by
|
||
change 0 ≤ (cnt db_a r.end_.key : Int) + r.end_.offset - 1
|
||
rw [show cnt db_a r.end_.key = 0 from by simpa [hE] using hcnt0]
|
||
push_cast; omega) ?_
|
||
rw [hanchorEnd, hlen_a]
|
||
have hoff' : r.begin.offset = 1 - (t : Int) := by linarith
|
||
have hanchorBegin : r.begin.anchor db_a = (D : Int) := by
|
||
change (cnt db_a r.begin.key : Int) + r.begin.offset - 1 = (D : Int)
|
||
have hecast : (e : Int) = (D : Int) + (t : Int) := by exact_mod_cast hDt.symm
|
||
rw [hbtop, cnt_top, hlen_a, hecast, hoff']
|
||
ring
|
||
have hDltN : D < db_a.keys.length := by rw [hlen_a]; omega
|
||
have hgetD : db_a.keys[D] = L := by
|
||
have h1 : db_a.keys[D]? = some L := by
|
||
rw [hfullKeys, hT]
|
||
rw [List.getElem?_append_right (show G.length ≤ D by rw [hGlen]), hGlen, Nat.sub_self]
|
||
rw [hR, ← List.head?_eq_getElem?, List.head?_reverse, List.getLast?_eq_some_getLast hne, hL]
|
||
rw [List.getElem?_eq_getElem hDltN] at h1
|
||
exact Option.some.inj h1
|
||
have hrb_a : resolve db_a r.begin = ((L : Key) : WithTop Key) := by
|
||
have h0 : 0 ≤ r.begin.anchor db_a := by rw [hanchorBegin]; exact_mod_cast Nat.zero_le _
|
||
have hlt : (r.begin.anchor db_a).toNat < db_a.keys.length := by
|
||
rw [hanchorBegin]; exact_mod_cast hDltN
|
||
rw [resolve_eq_getElem h0 hlt]
|
||
rw [WithTop.coe_eq_coe]
|
||
have hidx : (r.begin.anchor db_a).toNat = D := by rw [hanchorBegin]; rfl
|
||
have h1 : db_a.keys[(r.begin.anchor db_a).toNat]? = some L := by
|
||
have h2 : db_a.keys[(r.begin.anchor db_a).toNat]? = db_a.keys[D]? := by rw [hidx]
|
||
rw [h2, List.getElem?_eq_getElem hDltN]
|
||
exact congrArg some hgetD
|
||
exact Option.some.inj ((List.getElem?_eq_getElem hlt).symm.trans h1)
|
||
have hfilter_a : db_a.keys.filter (fun x : Key => decide (L ≤ x)) = R := by
|
||
rw [hfullKeys, hT, List.filter_append]
|
||
have hGnil : List.filter (fun x : Key => decide (L ≤ x)) G = [] := by
|
||
rw [List.filter_eq_nil_iff]
|
||
intro x hx hlx
|
||
exact absurd (WithTop.coe_le_coe.mpr (of_decide_eq_true hlx))
|
||
(not_le.mpr (hGmem x hx).2)
|
||
have hRself : List.filter (fun x : Key => decide (L ≤ x)) R = R := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
exact decide_eq_true (hRmem x hx)
|
||
rw [hGnil, hRself, List.nil_append]
|
||
have hcomp_a : RangeRead.Compatible db_a r res := by
|
||
refine (compatible_iff_truncated_keys_rev (db := db_a) hrev hmore hne).mpr
|
||
⟨hcomp₀.1, ?_⟩
|
||
rw [completeKeys_filter_ge_eq_resolve_end (db := db_a) (r := r) (last := L) hrev
|
||
(le_of_eq hrb_a), hfilter_a, hR, hre_a]
|
||
simp
|
||
have hk_a : k ∉ db_a.keys := by
|
||
rw [hfullKeys, hT]
|
||
intro hmem
|
||
rcases List.mem_append.mp hmem with hx | hx
|
||
· exact hkG hx
|
||
· exact absurd (WithTop.coe_le_coe.mpr (hRmem k hx)) (not_le.mpr hkL')
|
||
-- insert the target
|
||
let db_b : DB := db_a.insert k hk_a
|
||
have hkR : ∀ x ∈ R, k < x := by
|
||
intro x hx
|
||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le hkL' (WithTop.coe_le_coe.mpr (hRmem x hx)))
|
||
have hins : T.orderedInsert (· ≤ ·) k = G.orderedInsert (· ≤ ·) k ++ R := by
|
||
rw [hT]
|
||
exact orderedInsert_append_of_forall_lt hkR
|
||
have hb_keys : db_b.keys = G.orderedInsert (· ≤ ·) k ++ R := by
|
||
rw [show db_b.keys = db_a.keys.orderedInsert (· ≤ ·) k from rfl, hfullKeys, hins]
|
||
have hb_len : db_b.keys.length = e + 1 := by
|
||
rw [hb_keys, List.length_append, List.orderedInsert_length, hGlen, hR,
|
||
List.length_reverse, ← ht']
|
||
omega
|
||
have hb_cnt0 : cnt db_b E = 0 := by
|
||
apply cnt_eq_zero_of_forall_ge
|
||
intro x hx
|
||
rw [hb_keys] at hx
|
||
rcases List.mem_append.mp hx with hx | hx
|
||
· rw [List.mem_orderedInsert] at hx
|
||
rcases hx with rfl | hx
|
||
· exact hEk
|
||
· exact (hGmem x hx).1
|
||
· exact le_trans (le_of_lt hEL') (WithTop.coe_le_coe.mpr (hRmem x hx))
|
||
have hancEnd_b : (r.end_.anchor db_b).toNat = e := by
|
||
have hanc : r.end_.anchor db_b = r.end_.offset - 1 := by
|
||
unfold Selector.anchor
|
||
rw [show List.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key)) db_b.keys = 0 from by
|
||
rw [← hE]; exact hb_cnt0]
|
||
ring
|
||
rw [hanc]
|
||
have hre_b : resolve db_b r.end_ = ((H : Key) : WithTop Key) := by
|
||
have h0 : 0 ≤ r.end_.anchor db_b := by
|
||
change 0 ≤ (cnt db_b r.end_.key : Int) + r.end_.offset - 1
|
||
rw [show cnt db_b r.end_.key = 0 from by simpa [hE] using hb_cnt0]
|
||
push_cast; omega
|
||
have hlt : (r.end_.anchor db_b).toNat < db_b.keys.length := by
|
||
rw [hancEnd_b, hb_len]; omega
|
||
rw [resolve_eq_getElem h0 hlt, WithTop.coe_eq_coe]
|
||
have hidx : (r.end_.anchor db_b).toNat = e := hancEnd_b
|
||
have hG'len : (G.orderedInsert (· ≤ ·) k).length = D + 1 := by
|
||
rw [List.orderedInsert_length, hGlen]
|
||
have he_ge : (G.orderedInsert (· ≤ ·) k).length ≤ e := by rw [hG'len]; omega
|
||
have h1 : db_b.keys[(r.end_.anchor db_b).toNat]? = some H := by
|
||
have h2 : db_b.keys[(r.end_.anchor db_b).toNat]? = db_b.keys[e]? := by rw [hidx]
|
||
rw [h2, hb_keys, List.getElem?_append_right he_ge]
|
||
have hsub : e - (G.orderedInsert (· ≤ ·) k).length = t - 1 := by
|
||
rw [hG'len, ← hDt]; omega
|
||
rw [hsub, hR]
|
||
rw [List.getElem?_reverse (by rw [← ht']; omega)]
|
||
rw [show res.keys.length - 1 - (t - 1) = 0 by rw [← ht']; omega]
|
||
have hh := getElem?_zero_eq_head (l := res.keys) hne
|
||
rwa [← hH] at hh
|
||
exact Option.some.inj ((List.getElem?_eq_getElem hlt).symm.trans h1)
|
||
have hHmem_b : H ∈ db_b.keys := by
|
||
rw [hb_keys]
|
||
exact List.mem_append_right _ (by rw [hR, List.mem_reverse]; exact hHmem)
|
||
refine necessary_of_toggle ⟨db_a, hcomp_a, ?_⟩
|
||
rw [toggle_eq_insert_of_not_mem hk_a]
|
||
intro hcomp'
|
||
have hfil := (compatible_iff_truncated_keys_rev (db := db_b) hrev hmore hne).mp hcomp' |>.2
|
||
have hHck : H ∈ RangeRead.completeKeys db_b r := by
|
||
have h := hHmem
|
||
rw [← hfil] at h
|
||
exact (List.mem_filter.mp h).1
|
||
exact absurd (RangeRead.mem_completeKeys.mp hHck).2.2 (by rw [hre_b]; exact lt_irrefl _)
|
||
|
||
/-! ### Gap-key necessity in regime B -/
|
||
|
||
/-- **Gap-key necessity in the sentinel-begin large-gap top cell, regime B.**
|
||
|
||
When `#reported + begin.offset ≤ 0`, the witness stores `D = e - t` gap keys in
|
||
`[end_.key, last)` including the target, then the reversed reported keys, then a key
|
||
above the reported head. With the target present the end selector resolves onto the
|
||
last witness key, so the keys above the reported last are exactly the reported ones.
|
||
Erasing the target lowers the database length by one; the end anchor now overshoots and
|
||
the witness key above the head enters the complete window, breaking the reported
|
||
prefix. -/
|
||
theorem necessary_gap_of_sentinel_large_B {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
|
||
(hbtop : r.begin.key = (⊤ : WithTop Key))
|
||
(hend : 2 ≤ r.end_.offset)
|
||
(hEL : r.end_.key < ((res.keys.getLast hne : Key) : WithTop Key))
|
||
(htg : res.keys.length < (r.end_.offset - 1).toNat)
|
||
(hgap : ((r.end_.offset - 1).toNat : ℕ∞) ≤
|
||
intervalCard r.end_.key ((res.keys.getLast hne : Key) : WithTop Key) +
|
||
(res.keys.length : ℕ∞))
|
||
(hoff : (res.keys.length : Int) + r.begin.offset ≤ 0)
|
||
{k : Key} (hEk : r.end_.key ≤ (k : WithTop Key))
|
||
(hkL : (k : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) :
|
||
Necessary r res k := by
|
||
classical
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
set E : WithTop Key := r.end_.key with hE
|
||
set L : Key := res.keys.getLast hne with hL
|
||
set H : Key := res.keys.head hne with hH
|
||
set e : Nat := (r.end_.offset - 1).toNat with he
|
||
set t : Nat := res.keys.length with ht'
|
||
set D : Nat := e - t with hD
|
||
have htn : 0 < t := List.length_pos_of_ne_nil hne
|
||
have ht_lt : t < e := by simpa [t, e] using htg
|
||
have hDt : D + t = e := by omega
|
||
have hD1 : 1 ≤ D := by omega
|
||
have hLmem : L ∈ res.keys := by rw [hL]; exact List.getLast_mem hne
|
||
have hHmem : H ∈ res.keys := by rw [hH]; exact List.head_mem hne
|
||
have hEL' : E < ((L : Key) : WithTop Key) := by simpa [E, L] using hEL
|
||
have hkL' : ((k : Key) : WithTop Key) < ((L : Key) : WithTop Key) := hkL
|
||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
|
||
set R : List Key := res.keys.reverse with hR
|
||
have hRsort : R.SortedLT := by rw [hR]; exact hsort.reverse
|
||
have hRmem : ∀ y ∈ R, L ≤ y := by
|
||
intro y hy
|
||
rw [hR] at hy
|
||
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.mem_reverse.mp hy)
|
||
have hRleH : ∀ y ∈ R, y ≤ H := by
|
||
intro y hy
|
||
rw [hR] at hy
|
||
exact (hsort.pairwise.imp le_of_lt).rel_head (List.mem_reverse.mp hy)
|
||
have hLleH : L ≤ H := hRmem H (by rw [hR, List.mem_reverse]; exact hHmem)
|
||
-- room for `D` gap keys, one of them the target
|
||
have hcapD : (D : ℕ∞) ≤ intervalCard E ((L : Key) : WithTop Key) := by
|
||
have hgap' : (e : ℕ∞) ≤ intervalCard E ((L : Key) : WithTop Key) + (t : ℕ∞) := by
|
||
simpa [E, L, e, t] using hgap
|
||
have hcast : ((D : ℕ∞) + (t : ℕ∞)) = (e : ℕ∞) := by
|
||
rw [← Nat.cast_add, hDt]
|
||
rw [← hcast] at hgap'
|
||
exact (ENat.add_le_add_iff_right (ENat.natCast_ne_top t)).mp hgap'
|
||
have hroom : (((D - 1) + 1 : ℕ) : ℕ∞) ≤ intervalCard E ((L : Key) : WithTop Key) := by
|
||
rw [Nat.sub_add_cancel hD1]; exact hcapD
|
||
obtain ⟨pad, hpadIn, hkpad, hpadlen⟩ :=
|
||
exists_db_keysIn_avoid (B := E) (E := ((L : Key) : WithTop Key)) (k := k)
|
||
(m := D - 1) hroom
|
||
set Gp : List Key := pad.keys with hGpdef
|
||
have hGpmem : ∀ x ∈ Gp, E ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < ((L : Key) : WithTop Key) := by
|
||
intro x hx
|
||
simpa only [Gp, keysIn, Set.mem_ofPred_eq] using hpadIn x (by simpa [hGpdef] using hx)
|
||
have hGpsort : Gp.SortedLT := by rw [hGpdef]; exact pad.sorted
|
||
have hGplen : Gp.length = D - 1 := by rw [hGpdef]; exact hpadlen
|
||
have hkGp : k ∉ Gp := by rw [hGpdef]; exact hkpad
|
||
-- insert the target into the gap keys
|
||
let dbG : DB := pad.insert k hkGp
|
||
set G : List Key := dbG.keys with hGdef
|
||
have hGsort : G.SortedLT := by rw [hGdef]; exact dbG.sorted
|
||
have hGins : G = Gp.orderedInsert (· ≤ ·) k := by
|
||
rw [hGdef]; exact DB.insert_keys pad k hkGp
|
||
have hGlen : G.length = D := by
|
||
rw [hGins, List.orderedInsert_length, hGplen]; omega
|
||
have hGmem : ∀ x ∈ G, E ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < ((L : Key) : WithTop Key) := by
|
||
intro x hx
|
||
rw [hGins, List.mem_orderedInsert] at hx
|
||
rcases hx with rfl | hx
|
||
· exact ⟨hEk, hkL'⟩
|
||
· exact hGpmem x hx
|
||
have hkG : k ∈ G := by
|
||
rw [hGins]; exact (List.mem_orderedInsert (· ≤ ·)).mpr (Or.inl rfl)
|
||
-- a key above the reported head
|
||
set Q : Key := keyAfter H with hQ
|
||
have hHQ : H < Q := by rw [hQ]; exact keyAfter_self_lt H
|
||
have hRQ : ∀ y ∈ R, y < Q := fun y hy => lt_of_le_of_lt (hRleH y hy) hHQ
|
||
have hGQ : ∀ x ∈ G, x < Q := by
|
||
intro x hx
|
||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hGmem x hx).2
|
||
(WithTop.coe_le_coe.mpr (le_trans hLleH (le_of_lt hHQ))))
|
||
have hGR : ∀ x ∈ G, ∀ y ∈ R, x < y := by
|
||
intro x hx y hy
|
||
exact WithTop.coe_lt_coe.mp
|
||
(lt_of_lt_of_le (hGmem x hx).2 (WithTop.coe_le_coe.mpr (hRmem y hy)))
|
||
-- assemble the witness database
|
||
set T : List Key := G ++ R ++ [Q] with hT
|
||
have hGRsort : (G ++ R).SortedLT :=
|
||
List.sortedLT_append.mpr ⟨hGsort, hRsort, hGR⟩
|
||
have hGRQ : ∀ x ∈ G ++ R, ∀ y ∈ [Q], x < y := by
|
||
intro x hx y hy
|
||
rw [List.mem_singleton] at hy
|
||
subst hy
|
||
rcases List.mem_append.mp hx with hx | hx
|
||
· exact hGQ x hx
|
||
· exact hRQ x hx
|
||
have hTsort : T.SortedLT := by
|
||
rw [hT]
|
||
exact List.sortedLT_append.mpr ⟨hGRsort, by simp [List.sortedLT_iff_pairwise], hGRQ⟩
|
||
let db_a : DB := ⟨T, hTsort⟩
|
||
have hfullKeys : db_a.keys = T := rfl
|
||
have hTlen : T.length = D + t + 1 := by
|
||
rw [hT]
|
||
simp [List.length_append, hGlen, hR, ht']
|
||
omega
|
||
have hlen_a : db_a.keys.length = D + t + 1 := by rw [hfullKeys, hTlen]
|
||
have hcnt0 : cnt db_a E = 0 := by
|
||
apply cnt_eq_zero_of_forall_ge
|
||
intro x hx
|
||
rw [hfullKeys, hT] at hx
|
||
rcases List.mem_append.mp hx with hx | hx
|
||
· rcases List.mem_append.mp hx with hx | hx
|
||
· exact (hGmem x hx).1
|
||
· exact le_trans (le_of_lt hEL') (WithTop.coe_le_coe.mpr (hRmem x hx))
|
||
· rw [List.mem_singleton] at hx
|
||
subst hx
|
||
exact le_trans (le_of_lt hEL')
|
||
(WithTop.coe_le_coe.mpr (le_trans hLleH (le_of_lt hHQ)))
|
||
have hanchorEnd : (r.end_.anchor db_a).toNat = e := by
|
||
have hanc : r.end_.anchor db_a = r.end_.offset - 1 := by
|
||
unfold Selector.anchor
|
||
rw [show List.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))
|
||
db_a.keys = 0 from by rw [← hE]; exact hcnt0]
|
||
ring
|
||
rw [hanc]
|
||
have hQidx : db_a.keys[e]? = some Q := by
|
||
rw [hfullKeys, hT]
|
||
rw [List.getElem?_append_right (show (G ++ R).length ≤ e by
|
||
rw [List.length_append, hGlen, hR, List.length_reverse]; omega)]
|
||
rw [List.length_append, hGlen, hR, List.length_reverse]
|
||
rw [show e - (D + res.keys.length) = 0 by omega]
|
||
rfl
|
||
have hre_a : resolve db_a r.end_ = ((Q : Key) : WithTop Key) := by
|
||
have h0 : 0 ≤ r.end_.anchor db_a := by
|
||
change 0 ≤ (cnt db_a r.end_.key : Int) + r.end_.offset - 1
|
||
rw [show cnt db_a r.end_.key = 0 from by simpa [hE] using hcnt0]
|
||
push_cast; omega
|
||
have hlt : (r.end_.anchor db_a).toNat < db_a.keys.length := by
|
||
rw [hanchorEnd, hlen_a]; omega
|
||
rw [resolve_eq_getElem h0 hlt]
|
||
rw [WithTop.coe_eq_coe]
|
||
have hidx : (r.end_.anchor db_a).toNat = e := hanchorEnd
|
||
have h1 : db_a.keys[(r.end_.anchor db_a).toNat]? = some Q := by
|
||
have h2 : db_a.keys[(r.end_.anchor db_a).toNat]? = db_a.keys[e]? := by rw [hidx]
|
||
rw [h2]; exact hQidx
|
||
exact Option.some.inj ((List.getElem?_eq_getElem hlt).symm.trans h1)
|
||
-- the reported last sits at index `D`
|
||
have hLidx : db_a.keys[D]? = some L := by
|
||
rw [hfullKeys, hT, List.append_assoc]
|
||
rw [List.getElem?_append_right (show G.length ≤ D by rw [hGlen])]
|
||
rw [hGlen, Nat.sub_self]
|
||
rw [List.getElem?_append_left (by rw [hR, List.length_reverse, ← ht']; omega)]
|
||
rw [hR, ← List.head?_eq_getElem?, List.head?_reverse, List.getLast?_eq_some_getLast hne, hL]
|
||
have hrb_a : resolve db_a r.begin ≤ ((L : Key) : WithTop Key) := by
|
||
have hDltN : D < db_a.keys.length := by rw [hlen_a]; omega
|
||
have hclamp : clampIndex db_a r.begin ≤ D := by
|
||
unfold clampIndex
|
||
have hanchor_le : r.begin.anchor db_a ≤ (D : Int) := by
|
||
change (cnt db_a r.begin.key : Int) + r.begin.offset - 1 ≤ (D : Int)
|
||
rw [hbtop, cnt_top, hlen_a]
|
||
have hcast : ((D + t + 1 : Nat) : Int) = (D : Int) + (t : Int) + 1 := by push_cast; ring
|
||
rw [hcast]; linarith
|
||
have htoNat : (r.begin.anchor db_a).toNat ≤ D := (Int.toNat_le).mpr hanchor_le
|
||
exact le_trans (Nat.min_le_left _ _) htoNat
|
||
have hget : db_a.keys[D] = L := by
|
||
rw [List.getElem?_eq_getElem hDltN] at hLidx
|
||
exact Option.some.inj hLidx
|
||
rw [← hget]
|
||
exact (resolve_le_getElem_iff (db := db_a) (s := r.begin) hDltN).mpr hclamp
|
||
have hfilter_a : db_a.keys.filter (fun x : Key => decide (L ≤ x)) = R ++ [Q] := by
|
||
rw [hfullKeys, hT, List.filter_append, List.filter_append]
|
||
have hGnil : List.filter (fun x : Key => decide (L ≤ x)) G = [] := by
|
||
rw [List.filter_eq_nil_iff]
|
||
intro x hx hlx
|
||
exact absurd (WithTop.coe_le_coe.mpr (of_decide_eq_true hlx))
|
||
(not_le.mpr (hGmem x hx).2)
|
||
have hRself : List.filter (fun x : Key => decide (L ≤ x)) R = R := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
exact decide_eq_true (hRmem x hx)
|
||
have hQself : List.filter (fun x : Key => decide (L ≤ x)) [Q] = [Q] := by
|
||
simp [decide_eq_true (le_trans hLleH (le_of_lt hHQ))]
|
||
rw [hGnil, hRself, hQself]
|
||
simp
|
||
have hinner_a : (R ++ [Q]).filter
|
||
(fun x : Key => decide ((x : WithTop Key) < resolve db_a r.end_)) = R := by
|
||
rw [hre_a, List.filter_append]
|
||
have hRself : List.filter (fun x : Key =>
|
||
decide ((x : WithTop Key) < ((Q : Key) : WithTop Key))) R = R := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
exact decide_eq_true (WithTop.coe_lt_coe.mpr (hRQ x hx))
|
||
have hQnil : List.filter (fun x : Key =>
|
||
decide ((x : WithTop Key) < ((Q : Key) : WithTop Key))) [Q] = [] := by
|
||
simp
|
||
rw [hRself, hQnil, List.append_nil]
|
||
have hcomp_a : RangeRead.Compatible db_a r res := by
|
||
refine (compatible_iff_truncated_keys_rev (db := db_a) hrev hmore hne).mpr
|
||
⟨hcomp₀.1, ?_⟩
|
||
rw [completeKeys_filter_ge_eq_resolve_end (db := db_a) (r := r) (last := L) hrev hrb_a,
|
||
hfilter_a, hinner_a, hR, List.reverse_reverse]
|
||
-- erase the target
|
||
have hk_a : k ∈ db_a.keys := by
|
||
rw [hfullKeys, hT]
|
||
exact List.mem_append_left _ (List.mem_append_left _ hkG)
|
||
let db_b : DB := db_a.erase k
|
||
have hb_keys : db_b.keys = G.erase k ++ R ++ [Q] := by
|
||
change (db_a.keys.erase k) = _
|
||
rw [hfullKeys, hT, List.append_assoc, List.erase_append_left (R ++ [Q]) hkG,
|
||
List.append_assoc]
|
||
have hb_len : db_b.keys.length = D + t := by
|
||
change (db_a.keys.erase k).length = D + t
|
||
rw [List.length_erase_of_mem hk_a, hlen_a]
|
||
omega
|
||
have hb_cnt0 : cnt db_b E = 0 := by
|
||
apply cnt_eq_zero_of_forall_ge
|
||
intro x hx
|
||
rw [hb_keys] at hx
|
||
rcases List.mem_append.mp hx with hx | hx
|
||
· rcases List.mem_append.mp hx with hx | hx
|
||
· exact (hGmem x (List.mem_of_mem_erase hx)).1
|
||
· exact le_trans (le_of_lt hEL') (WithTop.coe_le_coe.mpr (hRmem x hx))
|
||
· rw [List.mem_singleton] at hx
|
||
subst hx
|
||
exact le_trans (le_of_lt hEL')
|
||
(WithTop.coe_le_coe.mpr (le_trans hLleH (le_of_lt hHQ)))
|
||
have hanchorEnd_b : (r.end_.anchor db_b).toNat = e := by
|
||
have hanc : r.end_.anchor db_b = r.end_.offset - 1 := by
|
||
unfold Selector.anchor
|
||
rw [show List.countP (fun (k : Key) => decide ((↑k : WithTop Key) < r.end_.key))
|
||
db_b.keys = 0 from by rw [← hE]; exact hb_cnt0]
|
||
ring
|
||
rw [hanc]
|
||
have hre_b : resolve db_b r.end_ = (⊤ : WithTop Key) := by
|
||
have h0 : 0 ≤ r.end_.anchor db_b := by
|
||
change 0 ≤ (cnt db_b r.end_.key : Int) + r.end_.offset - 1
|
||
rw [show cnt db_b r.end_.key = 0 from by simpa [hE] using hb_cnt0]
|
||
push_cast; omega
|
||
refine resolve_eq_top h0 ?_
|
||
rw [hanchorEnd_b, hb_len]
|
||
exact le_of_eq hDt
|
||
have hEraseLen : (G.erase k).length = D - 1 := by
|
||
rw [List.length_erase_of_mem hkG, hGlen]
|
||
have hLidx_b : db_b.keys[D - 1]? = some L := by
|
||
rw [hb_keys, List.append_assoc]
|
||
rw [List.getElem?_append_right (show (G.erase k).length ≤ D - 1 by rw [hEraseLen])]
|
||
rw [hEraseLen, Nat.sub_self]
|
||
rw [List.getElem?_append_left (by rw [hR, List.length_reverse, ← ht']; omega)]
|
||
rw [hR, ← List.head?_eq_getElem?, List.head?_reverse, List.getLast?_eq_some_getLast hne, hL]
|
||
have hrb_b : resolve db_b r.begin ≤ ((L : Key) : WithTop Key) := by
|
||
have hjlt : D - 1 < db_b.keys.length := by rw [hb_len]; omega
|
||
have hget : db_b.keys[D - 1] = L := by
|
||
rw [List.getElem?_eq_getElem hjlt] at hLidx_b
|
||
exact Option.some.inj hLidx_b
|
||
rw [← hget]
|
||
apply (resolve_le_getElem_iff (db := db_b) (s := r.begin) hjlt).mpr
|
||
unfold clampIndex
|
||
have hanchor_le : r.begin.anchor db_b ≤ ((D - 1 : Nat) : Int) := by
|
||
change (cnt db_b r.begin.key : Int) + r.begin.offset - 1 ≤ ((D - 1 : Nat) : Int)
|
||
rw [hbtop, cnt_top, hb_len]
|
||
have hcast : ((D + t : Nat) : Int) = (D : Int) + (t : Int) := by push_cast; ring
|
||
rw [hcast]
|
||
have hcast2 : ((D - 1 : Nat) : Int) = (D : Int) - 1 := by
|
||
rw [Nat.cast_sub hD1]; norm_num
|
||
rw [hcast2]
|
||
linarith
|
||
have htoNat : (r.begin.anchor db_b).toNat ≤ D - 1 := (Int.toNat_le).mpr hanchor_le
|
||
exact le_trans (Nat.min_le_left _ _) htoNat
|
||
have hfilter_b : (RangeRead.completeKeys db_b r).filter
|
||
(fun k => decide (L ≤ k)) = Q :: res.keys := by
|
||
rw [completeKeys_filter_ge_eq_resolve_end (db := db_b) (r := r) (last := L) hrev hrb_b,
|
||
hre_b]
|
||
have hbF : db_b.keys.filter (fun x : Key => decide (L ≤ x)) = R ++ [Q] := by
|
||
rw [hb_keys, List.filter_append, List.filter_append]
|
||
have hGnil : List.filter (fun x : Key => decide (L ≤ x)) (G.erase k) = [] := by
|
||
rw [List.filter_eq_nil_iff]
|
||
intro x hx hlx
|
||
exact absurd (WithTop.coe_le_coe.mpr (of_decide_eq_true hlx))
|
||
(not_le.mpr (hGmem x (List.mem_of_mem_erase hx)).2)
|
||
have hRself : List.filter (fun x : Key => decide (L ≤ x)) R = R := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
exact decide_eq_true (hRmem x hx)
|
||
have hQself : List.filter (fun x : Key => decide (L ≤ x)) [Q] = [Q] := by
|
||
simp [decide_eq_true (le_trans hLleH (le_of_lt hHQ))]
|
||
rw [hGnil, hRself, hQself]
|
||
simp
|
||
rw [hbF]
|
||
have hinner : (R ++ [Q]).filter
|
||
(fun x : Key => decide ((x : WithTop Key) < (⊤ : WithTop Key))) = R ++ [Q] := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
exact decide_eq_true (WithTop.coe_lt_top x)
|
||
rw [hinner, List.reverse_append, List.reverse_singleton, hR]
|
||
simp
|
||
refine necessary_of_toggle ⟨db_a, hcomp_a, ?_⟩
|
||
rw [toggle_eq_erase_of_mem hk_a]
|
||
intro hcomp'
|
||
have hfil := (compatible_iff_truncated_keys_rev (db := db_b) hrev hmore hne).mp hcomp' |>.2
|
||
rw [hfilter_b] at hfil
|
||
have hlen_eq := congrArg List.length hfil
|
||
simp at hlen_eq
|
||
|
||
/-! ### Assembling the sentinel-begin cell -/
|
||
|
||
/-- **The sentinel-begin large-gap top cell closed form is minimal.** When the cell is
|
||
tight the range is `[last, ⊤)`, with the compatible databases reduced to the sentinel-end
|
||
read. Otherwise it is `[end_.key, ⊤)`: soundness is
|
||
`sound_topRange_endKey_of_residual_large`; necessity splits `[end_.key, ⊤)` at the
|
||
reported last and head, using the gap-key witnesses of regime A or B (decided by the
|
||
offset bound `sentinel_begin_offset_bound`), convexity for reported keys, and the
|
||
above-head witness. -/
|
||
theorem minimal_closedForm_of_negCross_trunc_rev_residual_top_large_sentinel
|
||
{r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (h : negCrossTruncRevResidualTopLargeSentinel r res) :
|
||
Minimal r res (closedFormNegCrossTruncRevResidualTopLargeSentinel r res) := by
|
||
obtain ⟨hlarge, hbtop⟩ := h
|
||
obtain ⟨hmore, hrev, hbeg, hne, hend, hELD, htopD, hgapD⟩ := hlarge
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
|
||
set L : Key := res.keys.getLast hne with hLdef
|
||
set H : Key := res.keys.head hne with hHdef
|
||
have hlastD : res.keys.getLastD ([] : Key) = L := by
|
||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]
|
||
simp [hLdef]
|
||
have hEL : r.end_.key < ((L : Key) : WithTop Key) := by
|
||
rw [hlastD] at hELD
|
||
exact hELD
|
||
have hgap : ((r.end_.offset - 1).toNat : ℕ∞) ≤
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) + (res.keys.length : ℕ∞) := by
|
||
rw [hlastD] at hgapD
|
||
exact hgapD
|
||
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 hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||
have hHmem : H ∈ res.keys := by rw [hHdef]; exact List.head_mem hne
|
||
have hcountP : res.keys.countP
|
||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by
|
||
rw [List.countP_eq_length]
|
||
intro x hx
|
||
exact decide_eq_true (le_of_lt (lt_of_lt_of_le hEL (WithTop.coe_le_coe.mpr (hLle x hx))))
|
||
have ht : res.keys.length < (r.end_.offset - 1).toNat := by
|
||
rw [hcountP] at htopD
|
||
exact htopD
|
||
by_cases htight : sentinelLargeTight r res
|
||
· -- tight branch: the range is `[last, ⊤)`
|
||
have htight' : ((r.end_.offset - 1).toNat : ℕ∞) =
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) + (res.keys.length : ℕ∞) ∧
|
||
(res.keys.length : Int) + r.begin.offset = 1 := by
|
||
simpa only [sentinelLargeTight, hlastD] using htight
|
||
have hmin := minimal_topOfLast_of_sentinel_large_tight hread' hmore hrev hbeg hne
|
||
hbtop hend (by simpa [hLdef] using hEL) htight'.2 htight'.1
|
||
have hcf : closedFormNegCrossTruncRevResidualTopLargeSentinel r res =
|
||
topOfLast (res.keys.getLast hne) := by
|
||
unfold closedFormNegCrossTruncRevResidualTopLargeSentinel topOfLast
|
||
dsimp only
|
||
rw [if_pos htight]
|
||
simp [List.getLast?_eq_some_getLast hne]
|
||
rw [hcf]
|
||
exact hmin
|
||
· -- non-tight branch: the range is `[end_.key, ⊤)`
|
||
have hmin : Minimal r res ⟨r.end_.key, ⊤⟩ := by
|
||
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
|
||
· exact sound_topRange_endKey_of_residual_large hmore hrev hbeg hne hend hEL
|
||
· intro k hk
|
||
rw [ConflictRange.mem_iff] at hk
|
||
obtain ⟨hEk, _⟩ := hk
|
||
by_cases hkL : (k : WithTop Key) < ((L : Key) : WithTop Key)
|
||
· -- a gap key below the reported last
|
||
have hbound : (res.keys.length : Int) + r.begin.offset ≤ 1 :=
|
||
sentinel_begin_offset_bound hcomp₀ hmore hrev hne hbtop
|
||
rcases lt_or_eq_of_le hbound with hlt1 | heq
|
||
· -- regime B: both lengths cannot be large
|
||
have hB : (res.keys.length : Int) + r.begin.offset ≤ 0 := by omega
|
||
exact necessary_gap_of_sentinel_large_B hread' hmore hrev hbeg hne hbtop hend
|
||
(by simpa [hLdef] using hEL) ht hgap hB hEk hkL
|
||
· -- regime A: the gap is strict
|
||
have hstrict : ((r.end_.offset - 1).toNat : ℕ∞) <
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) +
|
||
(res.keys.length : ℕ∞) := by
|
||
have hnt' : ¬ (((r.end_.offset - 1).toNat : ℕ∞) =
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) +
|
||
(res.keys.length : ℕ∞) ∧
|
||
(res.keys.length : Int) + r.begin.offset = 1) := by
|
||
intro hc
|
||
exact htight (by simpa only [sentinelLargeTight, hlastD] using hc)
|
||
have hle : ((r.end_.offset - 1).toNat : ℕ∞) ≤
|
||
intervalCard r.end_.key ((L : Key) : WithTop Key) +
|
||
(res.keys.length : ℕ∞) := hgap
|
||
exact lt_of_le_of_ne hle (fun he => hnt' ⟨he, heq⟩)
|
||
exact necessary_gap_of_sentinel_large_A hread' hmore hrev hbeg hne hbtop hend
|
||
(by simpa [hLdef] using hEL) ht hstrict heq hEk hkL
|
||
· -- a key at or above the reported last
|
||
have hLk : ((L : Key) : WithTop Key) ≤ (k : WithTop Key) := le_of_not_gt hkL
|
||
have hkKey : L ≤ k := WithTop.coe_le_coe.mp hLk
|
||
by_cases hkH : (k : WithTop Key) ≤ ((H : Key) : WithTop Key)
|
||
· exact necessary_of_between_result hread' hLmem hHmem hkKey
|
||
(WithTop.coe_le_coe.mp hkH)
|
||
· have hHk : H < k := WithTop.coe_lt_coe.mp (lt_of_not_ge hkH)
|
||
exact necessary_above_head_of_residual_top_large hread' hmore hrev hbeg hne
|
||
hend (by simpa [hLdef] using hEL) ht
|
||
(by rw [hbtop]; exact WithTop.coe_lt_top L)
|
||
(by simpa [hHdef] using hHk)
|
||
have hcf : closedFormNegCrossTruncRevResidualTopLargeSentinel r res =
|
||
⟨r.end_.key, ⊤⟩ := by
|
||
unfold closedFormNegCrossTruncRevResidualTopLargeSentinel
|
||
dsimp only
|
||
rw [if_neg htight]
|
||
rw [hcf]
|
||
exact hmin
|
||
|
||
end FormalConflictRange
|