Files
conflict-range/FormalConflictRange/NegCrossTruncRevTop.lean
T

776 lines
41 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.NegCrossTruncClamp
/-!
# Reversed negative-begin truncated, sentinel-end cell
This module closes the reversed traversal analogue of the forward crossed
negative-begin truncated cells, in the first and simplest subcell: the end selector's
key is the sentinel `⊤` and its offset is at least one, so the end resolves to `⊤` in
every database. The minimal sound conflict range is then `[last, ⊤)`, where `last` is
the smallest reported key (the last entry of the descending reversed result).
The proof does not need the clamping/nonclamping split. The key observation is that
agreement on `[last, ⊤)` fixes the whole set of stored keys at or above `last`, and at
a negative begin offset the count of stored keys below `last` cancels in the begin
anchor, so the resolved begin stays at or below `last` on both sides. Hence the
complete keys are `res.keys` followed by keys below `last`, which keeps `res.keys` a
prefix.
Above the reported head, necessity uses the database made of the reported keys in
ascending order: it is compatible, and inserting a fresh key above the head puts it at
the front of the (reversed) complete keys, so the reported keys are no longer a prefix.
-/
open FormalConflictRange
namespace FormalConflictRange
/-- If the end selector's key is the sentinel `⊤` and its offset is at least one, the
end selector resolves to the sentinel in every database. -/
theorem resolve_end_eq_top_of_key_top {db : DB} {r : RangeRead}
(hkey : r.end_.key = (⊤ : WithTop Key)) (hoff : 1 ≤ r.end_.offset) :
resolve db r.end_ = (⊤ : WithTop Key) := by
have hcnt : db.keys.countP
(fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) =
db.keys.length := by
rw [hkey]
exact List.countP_eq_length.mpr fun k _ => by simp
have hann : r.end_.anchor db = (db.keys.length : Int) + r.end_.offset - 1 := by
unfold Selector.anchor
rw [hcnt]
refine resolve_eq_top ?_ ?_
· rw [hann]; omega
· have htoNat : (r.end_.anchor db).toNat =
db.keys.length + (r.end_.offset - 1).toNat := by
rw [hann, show ((db.keys.length : Int) + r.end_.offset - 1) =
((db.keys.length : Int) + (r.end_.offset - 1)) by ring,
Int.toNat_add (Int.natCast_nonneg _) (by omega), Int.toNat_natCast]
rw [htoNat]
omega
/-- When the resolved end is the sentinel and the resolved begin lies at or below
`last`, filtering the reversed complete keys at or above `last` is the reversal of the
stored keys at or above `last`. -/
theorem completeKeys_filter_ge_eq_of_resolve_le {db : DB} {r : RangeRead} {last : Key}
(hrev : r.reverse = true) (hre : resolve db r.end_ = (⊤ : WithTop Key))
(hrb : resolve db r.begin ≤ ((last : Key) : WithTop Key)) :
(RangeRead.completeKeys db r).filter (fun k => decide (last ≤ k)) =
(db.keys.filter (fun k => decide (last ≤ k))).reverse := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [hrev, hre]
simp only [ite_true]
rw [List.filter_reverse, List.reverse_inj, List.filter_filter]
apply List.filter_congr
intro k _hk
by_cases hLk : last ≤ k
· have hres : decide (resolve db r.begin ≤ ((k : Key) : WithTop Key)) = true := by
rw [decide_eq_true_eq]
exact le_trans hrb (WithTop.coe_le_coe.mpr hLk)
simp [hLk, hres]
· simp [hLk]
/-- **The begin anchor bound.** In a compatible crossed reversed truncated result the
number of stored keys in `[last, begin.key)`, plus the begin offset minus one, is at
most zero. This is the cancellation that makes agreement on `[last, ⊤)` sound: adding
or removing keys below `last` shifts the anchor index and the position of `last` in
lockstep. -/
theorem between_add_offset_le_one {r : RangeRead} {res : Result} {db : DB}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key) :
((between db ((res.keys.getLast hne : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 := 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 hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
rw [hfil]; exact hLmem
have hLcomplete : L ∈ RangeRead.completeKeys db r := (List.mem_filter.mp hLfilt).1
have hLmem' := RangeRead.mem_completeKeys.mp hLcomplete
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) := hLmem'.2.1
have hLdb : L ∈ db.keys := hLmem'.1
obtain ⟨j, hjlt, hjeq⟩ := List.mem_iff_getElem.mp hLdb
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 : (r.begin.anchor db).toNat ≤ j := by
have h1 : min (r.begin.anchor db).toNat db.keys.length ≤ j := hclamp
by_cases h : (r.begin.anchor db).toNat ≤ db.keys.length
· rwa [Nat.min_eq_left h] at h1
· rw [Nat.min_eq_right (by omega)] at h1
omega
have hanchor_le : r.begin.anchor db ≤ (j : Int) := by
have h1 : r.begin.anchor db ≤ ((r.begin.anchor db).toNat : Int) := by
by_cases h : 0 ≤ r.begin.anchor db
· rw [Int.toNat_of_nonneg h]
· omega
have h2 : ((r.begin.anchor db).toNat : Int) ≤ (j : Int) := by exact_mod_cast htoNat
linarith
have hcntL : cnt db ((L : Key) : WithTop Key) = j := by
rw [cnt_coe]
exact countP_lt_eq_of_getElem db.sorted hjlt hjeq
have hLleBegin : ((L : Key) : WithTop Key) ≤ r.begin.key := le_of_lt hcross
have hcnt_begin : cnt db r.begin.key = j + (between db ((L : Key) : WithTop Key)
r.begin.key).length := by
rw [cnt_eq_add_between db hLleBegin, hcntL]
have hanchor : r.begin.anchor db = (j : Int) +
((between db ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 := by
change (cnt db r.begin.key : Int) + r.begin.offset - 1 = _
rw [hcnt_begin]; push_cast; ring
have hmain := hanchor_le
rw [hanchor] at hmain
linarith
/-- **The reported-below-begin offset bound.** With a sentinel end, the number of
reported keys below `begin.key` plus the begin offset minus one is at most zero. -/
theorem reportedBelowBegin_add_offset_le_one {r : RangeRead} {res : Result} {db : DB}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
(reportedBelowBegin r res : Int) + r.begin.offset - 1 ≤ 0 := by
set L : Key := res.keys.getLast hne with hLdef
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 hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
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 htop : db.keys.filter (fun k => decide (L ≤ k)) = res.keys.reverse := by
have hre : resolve db r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
have h1 := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r) (last := L) hrev hre hrb
rw [hfil] at h1
have h2 : res.keys.reverse = db.keys.filter (fun k => decide (L ≤ k)) := by
have hrev1 := congrArg List.reverse h1
simpa using hrev1
exact h2.symm
have hbetween : (between db ((L : Key) : WithTop Key) r.begin.key).length
= reportedBelowBegin r res := by
have hbeq : between db ((L : Key) : WithTop Key) r.begin.key =
(db.keys.filter (fun k => decide (L ≤ k))).filter
(fun k => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
unfold between
rw [List.filter_filter]
apply List.filter_congr
intro k _
rw [Bool.decide_and, Bool.and_comm]
by_cases h : L ≤ k
· simp [h, WithTop.coe_le_coe.mpr h]
· have h' : ¬ (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
simpa [WithTop.coe_le_coe] using h
simp [h, h']
rw [hbeq, htop, ← List.countP_eq_length_filter, List.countP_reverse, reportedBelowBegin]
have hmain := between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
rw [hbetween] at hmain
exact hmain
/-- **The begin resolution stays at or below the reported last under agreement on
`[last, ⊤)`.** This is the generic counting step used by both sentinel-end soundness
branches; it does not involve the end selector. -/
theorem resolve_begin_le_of_agree_topOfLast {r : RangeRead} {res : Result} {db db' : DB}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hag : AgreeOn (topOfLast (res.keys.getLast hne)) db db') :
resolve db' r.begin ≤ ((res.keys.getLast hne : Key) : WithTop 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 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 hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
db.keys.filter (fun k => decide (L ≤ k)) := by
have h := hag
unfold AgreeOn at h
rw [topOfLast_keys, topOfLast_keys] at h
exact h.symm
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
have hLdb' : L ∈ db'.keys := by
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
rw [hfilEq]
exact List.mem_filter.mpr ⟨hLdb, by simp⟩
exact (List.mem_filter.mp hmem).1
obtain ⟨j', hj'lt, hj'eq⟩ := 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 hj'lt hj'eq
have hbeq : ∀ d : DB, between d ((L : Key) : WithTop Key) r.begin.key =
(d.keys.filter (fun k : Key => decide (L ≤ k))).filter
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
intro d
unfold between
rw [List.filter_filter]
apply List.filter_congr
intro k _
rw [Bool.decide_and, Bool.and_comm]
by_cases h : L ≤ k
· simp [h, WithTop.coe_le_coe.mpr h]
· have h' : ¬ (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
simpa [WithTop.coe_le_coe] using h
simp [h, h']
have hbetween : between db' ((L : Key) : WithTop Key) r.begin.key =
between db ((L : Key) : WithTop Key) r.begin.key := by
rw [hbeq db', hbeq db, hfilEq]
have hΔ : ((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 hΔ' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 := by
rw [hbetween]; exact hΔ
have hanchor' : r.begin.anchor db' = (j' : Int) +
((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 := by
have hcnt : cnt db' r.begin.key =
j' + (between db' ((L : Key) : WithTop Key) r.begin.key).length := by
rw [cnt_eq_add_between db' (le_of_lt hLcross), hcntL']
change (cnt db' r.begin.key : Int) + r.begin.offset - 1 = _
rw [hcnt]; push_cast; ring
have hanchor_le' : r.begin.anchor db' ≤ (j' : Int) := by
rw [hanchor']; linarith
have htoNat' : (r.begin.anchor db').toNat ≤ j' := by
by_cases h : 0 ≤ r.begin.anchor db'
· exact (Int.toNat_le).mpr hanchor_le'
· have hz : (r.begin.anchor db').toNat = 0 := by omega
rw [hz]; omega
have hclamp' : clampIndex db' r.begin ≤ j' := by
unfold clampIndex
exact le_trans (Nat.min_le_left _ _) htoNat'
have hle := (resolve_le_getElem_iff (db := db') (s := r.begin) hj'lt).mpr hclamp'
rwa [hj'eq] at hle
/-- **Two reversed reads with the same end selector and begin resolutions at or below
`last` see the same stored keys at or above `last`.** -/
theorem completeKeys_filter_ge_eq_of_both_le {db : DB} {r₁ r₂ : RangeRead} {last : Key}
(hrev₁ : r₁.reverse = true) (hrev₂ : r₂.reverse = true)
(hend : r₁.end_ = r₂.end_)
(h₁ : resolve db r₁.begin ≤ ((last : Key) : WithTop Key))
(h₂ : resolve db r₂.begin ≤ ((last : Key) : WithTop Key)) :
(RangeRead.completeKeys db r₁).filter (fun k => decide (last ≤ k)) =
(RangeRead.completeKeys db r₂).filter (fun k => decide (last ≤ k)) := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [hrev₁, hrev₂]
simp only [ite_true]
rw [hend]
rw [List.filter_reverse, List.filter_reverse, List.reverse_inj,
List.filter_filter, List.filter_filter]
apply List.filter_congr
intro k _
by_cases hlk : last ≤ k
· have hlk' : ((last : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr hlk
have hb₁ : resolve db r₁.begin ≤ ((k : Key) : WithTop Key) := le_trans h₁ hlk'
have hb₂ : resolve db r₂.begin ≤ ((k : Key) : WithTop Key) := le_trans h₂ hlk'
simp [hlk, hb₁, hb₂]
· simp [hlk]
/-- **Soundness of the top-of-last range in the reversed negative-begin truncated
sentinel-end cell.** Agreement on `[last, ⊤)` fixes the stored keys at or above `last`,
and the resolved begin stays at or below `last` on both sides because the count of
stored keys in `[last, begin.key)` is shared. -/
theorem sound_topOfLast_of_rev_negTrunc_top {r : RangeRead} {res : Result}
(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)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
Sound r res (topOfLast (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 := hcross
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
intro db db' hag' hcomp
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 hre : resolve db r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
have hre' : resolve db' r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) := by
have hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
rw [hfil]; exact hLmem
exact (RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt).1).2.1
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
db.keys.filter (fun k => decide (L ≤ k)) := by
have h := hag'
unfold AgreeOn at h
rw [topOfLast_keys, topOfLast_keys] at h
exact h.symm
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
have hLdb' : L ∈ db'.keys := by
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
rw [hfilEq]
exact List.mem_filter.mpr ⟨hLdb, by simp⟩
exact (List.mem_filter.mp hmem).1
obtain ⟨j', hj'lt, hj'eq⟩ := 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 hj'lt hj'eq
have hbeq : ∀ d : DB, between d ((L : Key) : WithTop Key) r.begin.key =
(d.keys.filter (fun k : Key => decide (L ≤ k))).filter
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
intro d
unfold between
rw [List.filter_filter]
apply List.filter_congr
intro k _
rw [Bool.decide_and, Bool.and_comm]
by_cases h : L ≤ k
· simp [h, WithTop.coe_le_coe.mpr h]
· have h' : ¬ (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
simpa [WithTop.coe_le_coe] using h
simp [h, h']
have hbetween : between db' ((L : Key) : WithTop Key) r.begin.key =
between db ((L : Key) : WithTop Key) r.begin.key := by
rw [hbeq db', hbeq db, hfilEq]
have hΔ : ((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 hΔ' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 := by
rw [hbetween]; exact hΔ
have hanchor' : r.begin.anchor db' = (j' : Int) +
((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 := by
have hcnt : cnt db' r.begin.key =
j' + (between db' ((L : Key) : WithTop Key) r.begin.key).length := by
rw [cnt_eq_add_between db' (le_of_lt hLcross), hcntL']
change (cnt db' r.begin.key : Int) + r.begin.offset - 1 = _
rw [hcnt]; push_cast; ring
have hanchor_le' : r.begin.anchor db' ≤ (j' : Int) := by
rw [hanchor']; linarith
have htoNat' : (r.begin.anchor db').toNat ≤ j' := by
by_cases h : 0 ≤ r.begin.anchor db'
· exact (Int.toNat_le).mpr hanchor_le'
· have hz : (r.begin.anchor db').toNat = 0 := by omega
rw [hz]; omega
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) := by
have hclamp' : clampIndex db' r.begin ≤ j' := by
unfold clampIndex
exact le_trans (Nat.min_le_left _ _) htoNat'
have hle := (resolve_le_getElem_iff (db := db') (s := r.begin) hj'lt).mpr hclamp'
rwa [hj'eq] at hle
have hdb'filt := completeKeys_filter_ge_eq_of_resolve_le (db := db') (r := r) (last := L)
hrev hre' hrb'
have hdbfilt := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r) (last := L)
hrev hre hrb
refine (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hcomp.1, ?_⟩
rw [hdb'filt, hfilEq, ← hdbfilt, hfil]
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- **Above-head necessity in the reversed negative-begin truncated sentinel-end
cell.** The database made of the reported keys in ascending order is compatible;
inserting a fresh key above the reported head puts it at the front of the reversed
complete keys, so the reported keys are no longer a prefix. -/
theorem necessary_above_head_of_rev_negTrunc_top {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)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset)
{k : Key} (hkH : res.keys.head hne < k) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
set H : Key := res.keys.head hne with hHdef
set L : Key := res.keys.getLast hne with hLdef
have hoff : (reportedBelowBegin r res : Int) + r.begin.offset - 1 ≤ 0 :=
reportedBelowBegin_add_offset_le_one hcomp₀ hmore hrev hne hcross hendkey hendoff
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
have hHge : ∀ x ∈ res.keys, x ≤ H := by
intro x hx; rw [hHdef]; exact (hsort.pairwise.imp le_of_lt).rel_head hx
have hLle : ∀ x ∈ res.keys, L ≤ x := by
intro x hx; rw [hLdef]; exact (hsort.pairwise.imp le_of_lt).rel_getLast hx
have hk_notin : k ∉ res.keys := by
intro hx
have hle := hHge k hx
have hleH : k ≤ res.keys.head hne := by rw [← hHdef]; exact hle
exact absurd hleH (not_le.mpr hkH)
-- the witness database of reported keys in ascending order
have ha_sorted : res.keys.reverse.SortedLT := hsort.reverse
let db_a : DB := ⟨res.keys.reverse, ha_sorted⟩
have ha_keys : db_a.keys = res.keys.reverse := rfl
have haresolve : resolve db_a r.begin ≤ ((L : Key) : WithTop Key) := by
have hanchor : r.begin.anchor db_a = (reportedBelowBegin r res : Int) + r.begin.offset - 1 := by
have hcnt : cnt db_a r.begin.key = reportedBelowBegin r res := by
unfold cnt reportedBelowBegin
rw [ha_keys, List.countP_reverse]
change (cnt db_a r.begin.key : Int) + r.begin.offset - 1 = _
rw [hcnt]
have hle : r.begin.anchor db_a ≤ 0 := by rw [hanchor]; linarith
by_cases hneg : r.begin.anchor db_a < 0
· rw [resolve_eq_nil hneg]
exact WithTop.coe_le_coe.mpr (nil_le_key L)
· have hanc0 : r.begin.anchor db_a = 0 := le_antisymm hle (le_of_not_gt hneg)
have hlen : 0 < db_a.keys.length := by
rw [ha_keys, List.length_reverse]
exact List.length_pos_of_ne_nil hne
have h0lt : (r.begin.anchor db_a).toNat < db_a.keys.length := by
rw [hanc0]; simpa using hlen
have hget0 : db_a.keys[(r.begin.anchor db_a).toNat] = L := by
have hidx : (r.begin.anchor db_a).toNat = 0 := by rw [hanc0]; rfl
have h0 : db_a.keys[(r.begin.anchor db_a).toNat]? = some L := by
rw [hidx, ha_keys, ← List.head?_eq_getElem?]
rw [List.head?_reverse, List.getLast?_eq_some_getLast hne]
have h1 := List.getElem?_eq_getElem h0lt
rw [h0] at h1
exact (Option.some.inj h1).symm
rw [resolve_eq_getElem (le_of_not_gt hneg) h0lt, hget0]
have hre : resolve db_a r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
have hck_a : RangeRead.completeKeys db_a r = res.keys := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [hrev, hre]
simp only [ite_true]
have hpred : db_a.keys.filter (fun x => decide
(resolve db_a r.begin ≤ ((x : Key) : WithTop Key) ∧
((x : Key) : WithTop Key) < (⊤ : WithTop Key))) = db_a.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
have hx' : L ≤ x := by
rw [ha_keys] at hx
exact hLle x (List.mem_reverse.mp hx)
exact ⟨le_trans haresolve (WithTop.coe_le_coe.mpr hx'), WithTop.coe_lt_top x⟩
rw [hpred, ha_keys, List.reverse_reverse]
have hacompat : RangeRead.Compatible db_a r res := by
refine (compatible_iff_truncated_keys_rev (db := db_a) hrev hmore hne).mpr ⟨hcomp₀.1, ?_⟩
rw [hck_a, List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact hLle x hx
have hk_notin_a : k ∉ db_a.keys := by
rw [ha_keys, List.mem_reverse]
exact hk_notin
-- insert the target key above the head
let db_b : DB := db_a.insert k hk_notin_a
have hb_keys : db_b.keys = res.keys.reverse ++ [k] := by
rw [DB.insert_keys]
exact orderedInsert_append_of_forall_lt' (fun x hx => by
have hx' : x ∈ res.keys := by
have hx'' : x ∈ res.keys.reverse := by simpa [db_a] using hx
exact List.mem_reverse.mp hx''
exact lt_of_le_of_lt (hHge x hx') hkH)
have hcnt_b : cnt db_b r.begin.key ≤ reportedBelowBegin r res + 1 := by
unfold cnt reportedBelowBegin
rw [hb_keys, List.countP_append]
have h1 : res.keys.reverse.countP
(fun x => decide (((x : Key) : WithTop Key) < r.begin.key)) =
res.keys.countP (fun x => decide (((x : Key) : WithTop Key) < r.begin.key)) :=
List.countP_reverse
rw [h1]
have h2 : ([k].countP (fun x => decide (((x : Key) : WithTop Key) < r.begin.key))) ≤ 1 := by
rw [List.countP_singleton]
split <;> omega
omega
have hanchor_b : r.begin.anchor db_b ≤ ((res.keys.reverse.length : ℕ) : Int) := by
change (cnt db_b r.begin.key : Int) + r.begin.offset - 1 ≤ _
have h1 : (cnt db_b r.begin.key : Int) ≤ (reportedBelowBegin r res : Int) + 1 := by
exact_mod_cast hcnt_b
have hlen1 : (1 : Int) ≤ ((res.keys.reverse.length : ℕ) : Int) := by
have hp : 0 < res.keys.reverse.length := by
rw [List.length_reverse]
exact List.length_pos_of_ne_nil hne
omega
linarith
have hrb_b : resolve db_b r.begin ≤ ((k : Key) : WithTop Key) := by
have hlenpos : 0 < res.keys.reverse.length := by
rw [List.length_reverse]
exact List.length_pos_of_ne_nil hne
have hkb : res.keys.reverse.length < db_b.keys.length := by
rw [hb_keys, List.length_append]; simp
have hkget : db_b.keys[res.keys.reverse.length] = k := by
have hkget? : db_b.keys[res.keys.reverse.length]? = some k := by
rw [hb_keys]
simp
have h1 := List.getElem?_eq_getElem hkb
rw [hkget?] at h1
exact (Option.some.inj h1).symm
have hclamp : clampIndex db_b r.begin ≤ res.keys.reverse.length := by
unfold clampIndex
have htoNat : (r.begin.anchor db_b).toNat ≤ res.keys.reverse.length := by
by_cases h : 0 ≤ r.begin.anchor db_b
· exact (Int.toNat_le).mpr hanchor_b
· have hz : (r.begin.anchor db_b).toNat = 0 := by omega
rw [hz]; omega
exact le_trans (Nat.min_le_left _ _) htoNat
have hle := (resolve_le_getElem_iff (db := db_b) (s := r.begin) hkb).mpr hclamp
rwa [hkget] at hle
have hkb_mem : k ∈ RangeRead.completeKeys db_b r := by
rw [RangeRead.mem_completeKeys]
have hre_b : resolve db_b r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
exact ⟨DB.mem_insert_self db_a k hk_notin_a, hrb_b, by rw [hre_b]; exact WithTop.coe_lt_top k⟩
have hck_pair : (RangeRead.completeKeys db_b r).Pairwise (· > ·) := by
have h := RangeRead.completeKeys_pairwise (db := db_b) (r := r)
rw [hrev] at h
exact h
have hhead_max : ∀ x ∈ RangeRead.completeKeys db_b r, x ≤ k := by
intro x hx
have hxdb := (RangeRead.mem_completeKeys.mp hx).1
rw [hb_keys, List.mem_append, List.mem_singleton] at hxdb
rcases hxdb with hx' | rfl
· have hx'' : x ∈ res.keys := by
have hxx : x ∈ res.keys.reverse := by simpa [db_a] using hx'
exact List.mem_reverse.mp hxx
exact le_of_lt (lt_of_le_of_lt (hHge x hx'') hkH)
· exact le_rfl
have hhead_eq : (RangeRead.completeKeys db_b r).head (List.ne_nil_of_mem hkb_mem) = k := by
apply le_antisymm (hhead_max _ (List.head_mem _))
exact (hck_pair.imp le_of_lt).rel_head hkb_mem
intro cr hs
by_contra hkcr
have hagree : AgreeOn cr db_a db_b :=
(ConflictRange.keys_insert_of_not_mem cr db_a hk_notin_a hkcr).symm
have hcomp_b : RangeRead.Compatible db_b r res := (hs db_a db_b hagree).mp hacompat
have hpre := RangeRead.compatible_keys_prefix hcomp_b
have hhead := hpre.head hne
have hHk : H = k := by
rw [hHdef]
exact hhead.trans hhead_eq
have hHklt : H < k := by
rw [hHdef]; exact hkH
exact absurd hHk (ne_of_lt hHklt)
/-- Every key at or above the least reported key is necessary in the reversed
negative-begin truncated sentinel-end cell. -/
theorem necessary_of_ge_last_of_rev_negTrunc_top {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)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset)
{k : Key} (hk : ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key)) :
Necessary r res k := by
set L : Key := res.keys.getLast hne with hLdef
set H : Key := res.keys.head hne with hHdef
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 hLk : L ≤ k := WithTop.coe_le_coe.mp hk
by_cases hkres : k ∈ res.keys
· exact necessary_of_mem_result hread hkres
· by_cases hkH : k ≤ H
· exact necessary_of_between_result hread hLmem hHmem hLk hkH
· exact necessary_above_head_of_rev_negTrunc_top hread hmore hrev hne hbeg hcross
hendkey hendoff (by rw [← hHdef]; exact lt_of_not_ge hkH)
/-- **Minimality of `[last, ⊤)` in the reversed negative-begin truncated sentinel-end
cell.** -/
theorem minimal_topOfLast_of_rev_negTrunc_top {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)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
Minimal r res (topOfLast (res.keys.getLast hne)) := by
refine minimal_iff_sound_and_necessary.mpr
⟨sound_topOfLast_of_rev_negTrunc_top hmore hrev hne hbeg hcross hendkey hendoff, ?_⟩
intro k hk
have hk' := ConflictRange.mem_iff.mp hk
exact necessary_of_ge_last_of_rev_negTrunc_top hread hmore hrev hne hbeg hcross
hendkey hendoff hk'.1
/-- **Soundness of `[last, ⊤)` when the sentinel end has a nonpositive offset.** The
reduced read with begin set to offset one on `last` has the same stored keys at or above
`last`, so its already-total nonpositive-end reversed rule transfers soundness. -/
theorem sound_topOfLast_of_rev_negTrunc_top_endNonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ [])
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : r.end_.offset ≤ 0) :
Sound r res (topOfLast (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
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
obtain ⟨db₀, hcomp₀⟩ := hread
have hcomp₀' : RangeRead.Compatible db₀ r' res := by
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 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'.begin = ((L : Key) : WithTop Key) := by
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb₀
have hfeq := completeKeys_filter_ge_eq_of_both_le (db := db₀) (r₁ := r) (r₂ := r')
hrev hr'_rev hr'_end hrb₀ (le_of_eq hres'₀)
rw [compatible_iff_truncated_keys_rev (db := db₀) hr'_rev hmore hne]
exact ⟨by simpa [r', RangeRead.withinLimit] using hcomp₀.1, by rw [← hfeq]; exact hfil₀⟩
have hread' : Readable r' res := ⟨db₀, hcomp₀'⟩
have hgetLast : res.keys.getLastD ([] : Key) = L := by
rw [hLdef, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hS' : Sound r' res (topOfLast L) := by
have hmin' := minimal_truncatedRangeRev_of_end_offset_nonpos (r := r') hread' hmore
hr'_rev (by rfl : r'.begin.offset = 1) hendoff
rw [hgetLast] at hmin'
have hcr : truncatedRangeRev r' L = topOfLast L := by
unfold truncatedRangeRev topOfLast
rw [hr'_end, hendkey]
rw [hcr] at hmin'
exact hmin'.sound
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
intro db db' hag' hcomp
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 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 hLdb' : L ∈ db'.keys := by
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
db.keys.filter (fun k => decide (L ≤ k)) := by
have h := hag'
unfold AgreeOn at h
rw [topOfLast_keys, topOfLast_keys] at h
exact h.symm
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
rw [hfilEq]; exact List.mem_filter.mpr ⟨hLdb, by simp⟩
exact (List.mem_filter.mp hmem).1
have hres'_db : resolve db r'.begin = ((L : Key) : WithTop Key) := by
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb
have hres'_db' : resolve db' r'.begin = ((L : Key) : WithTop Key) := by
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb'
have hfeq_db := completeKeys_filter_ge_eq_of_both_le (db := db) (r₁ := r) (r₂ := r')
hrev hr'_rev hr'_end hrb (le_of_eq hres'_db)
have hcomp'_db : RangeRead.Compatible db r' res := by
rw [compatible_iff_truncated_keys_rev (db := db) hr'_rev hmore hne]
exact ⟨by simpa [r', RangeRead.withinLimit] using hcomp.1, by rw [← hfeq_db]; exact hfil⟩
have hcomp'_db' : RangeRead.Compatible db' r' res := (hS' db db' hag').mp hcomp'_db
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
resolve_begin_le_of_agree_topOfLast hcomp hmore hrev hne hcross hag'
have hfil' : (RangeRead.completeKeys db' r').filter (fun k => decide (L ≤ k)) = res.keys :=
(compatible_iff_truncated_keys_rev (db := db') hr'_rev hmore hne).mp hcomp'_db' |>.2
have hfeq_db' := completeKeys_filter_ge_eq_of_both_le (db := db') (r₁ := r) (r₂ := r')
hrev hr'_rev hr'_end hrb' (le_of_eq hres'_db')
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
exact ⟨by simpa [r', RangeRead.withinLimit] using hcomp'_db'.1, by rw [hfeq_db']; exact hfil'⟩
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- **Above-head necessity at a sentinel end for any end offset.** The general
`necessary_of_end_key_top_rev` already covers both signs of the end offset. -/
theorem necessary_of_ge_last_of_rev_negTrunc_top_any {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ [])
(hendkey : r.end_.key = (⊤ : WithTop Key))
{k : Key} (hk : ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key)) :
Necessary r res k := by
set L : Key := res.keys.getLast hne with hLdef
set H : Key := res.keys.head hne with hHdef
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 hLk : L ≤ k := WithTop.coe_le_coe.mp hk
by_cases hkres : k ∈ res.keys
· exact necessary_of_mem_result hread hkres
· by_cases hkH : k ≤ H
· exact necessary_of_between_result hread hLmem hHmem hLk hkH
· exact necessary_of_end_key_top_rev hread hrev hne hendkey
(le_of_lt (lt_of_not_ge hkH))
/-- **Minimality of `[last, ⊤)` at a sentinel end for any end offset.** -/
theorem minimal_topOfLast_of_rev_negTrunc_top_any {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)
(hendkey : r.end_.key = (⊤ : WithTop Key)) :
Minimal r res (topOfLast (res.keys.getLast hne)) := by
refine minimal_iff_sound_and_necessary.mpr ⟨?_, ?_⟩
· rcases lt_or_ge r.end_.offset 1 with hoff | hoff
· exact sound_topOfLast_of_rev_negTrunc_top_endNonpos hread hmore hrev hne hcross
hendkey (by omega)
· exact sound_topOfLast_of_rev_negTrunc_top hmore hrev hne hbeg hcross hendkey hoff
· intro k hk
exact necessary_of_ge_last_of_rev_negTrunc_top_any hread hrev hne hendkey
(ConflictRange.mem_iff.mp hk).1
/-- **Soundness of `[last, ⊤)` with a sentinel end and no cross hypothesis.** When the
begin key lies at or below the reported last, the begin resolution is at or below the
last because the begin offset is nonpositive; otherwise the counting argument of
`sound_topOfLast_of_rev_negTrunc_top` applies. -/
theorem sound_topOfLast_of_rev_negTrunc_top_nocross {r : RangeRead} {res : Result}
(hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
Sound r res (topOfLast (res.keys.getLast hne)) := by
by_cases hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key
· exact sound_topOfLast_of_rev_negTrunc_top hmore hrev hne hbeg hcross hendkey hendoff
· set L : Key := res.keys.getLast hne with hLdef
have hkeyle : r.begin.key ≤ ((L : Key) : WithTop Key) := le_of_not_gt hcross
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
intro db db' hag' hcomp
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 hre : resolve db r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
have hre' : resolve db' r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_key_top hendkey hendoff
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
le_trans (resolve_le_key_of_offset_nonpos (le_of_lt hbeg)) hkeyle
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
le_trans (resolve_le_key_of_offset_nonpos (le_of_lt hbeg)) hkeyle
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
db.keys.filter (fun k => decide (L ≤ k)) := by
have h := hag'
unfold AgreeOn at h
rw [topOfLast_keys, topOfLast_keys] at h
exact h.symm
have hdb'filt := completeKeys_filter_ge_eq_of_resolve_le (db := db') (r := r)
(last := L) hrev hre' hrb'
have hdbfilt := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r)
(last := L) hrev hre hrb
refine (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr
⟨hcomp.1, ?_⟩
rw [hdb'filt, hfilEq, ← hdbfilt, hfil]
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- **Minimality of `[last, ⊤)` at a sentinel end with no cross hypothesis.** Only the
begin key relative to the reported last changes; necessity is independent of it. -/
theorem minimal_topOfLast_of_rev_negTrunc_top_nocross {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
Minimal r res (topOfLast (res.keys.getLast hne)) := by
refine minimal_iff_sound_and_necessary.mpr
⟨sound_topOfLast_of_rev_negTrunc_top_nocross hmore hrev hne hbeg hendkey hendoff, ?_⟩
intro k hk
exact necessary_of_ge_last_of_rev_negTrunc_top_any hread hrev hne hendkey
(ConflictRange.mem_iff.mp hk).1
/-- The reversed, crossed, negative-begin, truncated cell with sentinel end key. -/
abbrev negCrossTruncRevTop (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 = (⊤ : WithTop Key)
/-- The closed form of the reversed negative-begin truncated sentinel-end cell. -/
noncomputable def closedFormNegCrossTruncRevTop (_r : RangeRead) (res : Result) :
ConflictRange :=
topOfLast (res.keys.getLastD ([] : Key))
/-- **The reversed negative-begin truncated sentinel-end closed form is minimal.** -/
theorem minimal_closedForm_of_negCross_trunc_rev_top {r : RangeRead} {res : Result}
(hread : Readable r res) (h : negCrossTruncRevTop r res) :
Minimal r res (closedFormNegCrossTruncRevTop r res) := by
obtain ⟨hmore, hrev, hbeg, hne, hcrossD, hendkey⟩ := 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 closedFormNegCrossTruncRevTop
rw [hlast]
exact minimal_topOfLast_of_rev_negTrunc_top_any hread hmore hrev hne hbeg hcross hendkey
end FormalConflictRange