Prove conflict-range closed-form minimality

- 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
This commit is contained in:
andrew committed 2026-11-16 21:53:59 -05:00
1 parent 7a0826e873
commit a54a5f82f8
78 files changed
+91636 -2

No files matched your search

@@ -0,0 +1,406 @@
/-
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.NegCrossTruncBottomGap
import FormalConflictRange.NegCrossTruncClampLong
import FormalConflictRange.NegCrossTruncNonclampNonpos
import FormalConflictRange.NegCrossTruncAnchor
/-!
# The crossed negative-begin truncated nonpositive-end gap cell
This module closes the last forward truncated residual cell: a crossed forward read with
a negative begin offset, a nonpositive end offset, and reported keys strictly below both
selectors. The cell splits on whether the gap above `begin.key` has enough capacity for
the end overshoot, but the closed form is uniform in the two capacity regimes.
Writing `U = max begin.key end_.key`, the minimal sound range is `[⊥, U)` when
`clampNonposBottom` holds, and `[head, U)` otherwise (where `head` is the reported head).
The soundness half is complete.
* Soundness of `[⊥, U)` is `sound_bottomLong_of_nonpos`: agreement below `U` fixes both
selector resolutions, and the complete window lies strictly below `end_.key ≤ U`.
* In the non-bottom branch every compatible database resolves its begin selector onto the
reported head. The gap count in `[head, begin.key)` is forced to `beginSlack + 1` by
`gap_count_eq_beginSlack_of_resolve_head`, and `resolve_begin_eq_head_of_agree_gap`
transports the resolution across agreement on that gap; this yields soundness of
`[head, U)` (`sound_headLong_of_nonbottom`).
The necessity half is still open; see `notes/main.tex`. It splits into toggle witnesses
for keys in `(last, end_.key)` (erase) and in `[end_.key, U)` (insert), with the filler
budget determined by `clampNonposBottom`. The closed form `closedFormNegCrossTruncNonposGap`
is recorded here so the dispatch can be wired once the necessity lemmas land.
-/
namespace FormalConflictRange
/-- The crossed negative-begin truncated nonpositive-end gap cell. -/
def negCrossTruncNonposGap (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
r.end_.offset ≤ 0 ∧ reportedBelowBegin r res ≤ beginSlack r ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.end_.key ∧
r.end_.key < (⊤ : WithTop Key) ∧
(r.end_.key < r.begin.key ∨
intervalCard r.begin.key r.end_.key < (((clampNonposD r + 1 : ℕ)) : ℕ∞))
/-- The closed form of the crossed negative-begin truncated nonpositive-end gap cell. -/
noncomputable def closedFormNegCrossTruncNonposGap (r : RangeRead) (res : Result) :
ConflictRange := by
classical
exact if clampNonposBottom r res then
⟨(([] : Key) : WithTop Key), max r.begin.key r.end_.key⟩
else
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key r.end_.key⟩
/-- **Soundness of `[⊥, max begin.key end.key)` at nonpositive selector offsets.** The
complete window lies strictly below `end_.key`, so agreement on every key below the
maximum fixes both selector resolutions and the whole window. -/
theorem sound_bottomLong_of_nonpos {r : RangeRead} {res : Result}
(hbegin : r.begin.offset ≤ 0) (hend : r.end_.offset ≤ 0) :
Sound r res (⟨(([] : Key) : WithTop Key), max r.begin.key r.end_.key⟩ : ConflictRange) := by
intro db₁ db₂ hagree
set U : WithTop Key := max r.begin.key r.end_.key with hU
have hf : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < U)) =
db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < U)) := by
have h := hagree
rw [AgreeOn, keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h
exact h
have hB : resolve db₁ r.begin = resolve db₂ r.begin :=
resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := U) (s := r.begin)
hbegin (le_max_left _ _) hf
have hE : resolve db₁ r.end_ = resolve db₂ r.end_ :=
resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := U) (s := r.end_)
hend (le_max_right _ _) hf
have hresEnd : resolve db₁ r.end_ ≤ r.end_.key :=
resolve_le_key_of_offset_nonpos hend
have hpred : ∀ db : DB,
db.keys.filter (fun k : Key =>
decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_)) =
(db.keys.filter (fun k : Key => decide ((k : WithTop Key) < U))).filter
(fun k : Key =>
decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_)) := by
intro db
rw [List.filter_filter]
apply List.filter_congr
intro k _
by_cases hlt : (k : WithTop Key) < U
· simp [hlt]
· have hp : ¬ (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_) := by
rintro ⟨-, hkk⟩
exact hlt (lt_of_lt_of_le hkk (le_trans hresEnd (le_max_right _ _)))
simp [hlt, hp]
have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [← hB, ← hE]
rw [hpred db₁, hpred db₂, hf]
unfold RangeRead.Compatible
rw [hck]
/-- When the begin selector resolves onto a stored key `head` at a negative begin
offset, the gap count in `[head, begin.key)` is exactly `beginSlack + 1`. -/
theorem gap_count_eq_beginSlack_of_resolve_head {db : DB} {r : RangeRead} {head : Key}
(hbegin : r.begin.offset < 0)
(hcross : ((head : Key) : WithTop Key) < r.begin.key)
(hanc : 0 ≤ r.begin.anchor db)
(hres : resolve db r.begin = ((head : Key) : WithTop Key)) :
db.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := by
classical
have hne_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
rw [hres]; exact (WithTop.coe_lt_top head).ne
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
by_contra h
rw [resolve_eq_top hanc (by omega)] at hne_top
exact hne_top rfl
have hget : db.keys[(r.begin.anchor db).toNat] = head := by
rw [resolve_eq_getElem hanc hltlen] at hres
exact WithTop.coe_inj.mp hres
have hrank : db.keys.countP (fun k : Key => decide (k < head)) = (r.begin.anchor db).toNat :=
countP_lt_eq_of_getElem db.sorted hltlen hget
have hanchor : r.begin.anchor db = (db.keys.countP (fun k : Key => decide (k < head)) : ℤ) := by
have hconv : ((r.begin.anchor db).toNat : ℤ) = r.begin.anchor db := Int.toNat_of_nonneg hanc
rw [← hrank] at hconv
exact hconv.symm
have hsplit := countP_lt_eq_add_filter_withTop db.keys db.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hsplit' : db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
db.keys.countP (fun k : Key => decide (k < head)) +
(db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length := by
rw [hsplit, ← List.countP_eq_length_filter]
have hkey := anchor_eq_count_sub_slack db r (le_of_lt hbegin)
rw [hanchor] at hkey
have hcast : ((db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) =
(db.keys.countP (fun k : Key => decide (k < head)) : ℤ) +
((db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length : ℤ) := by
rw [hsplit']; push_cast; ring
have hG : (db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = beginSlack r + 1 := by
have h1 : ((db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) =
(db.keys.countP (fun k : Key => decide (k < head)) : ℤ) + (beginSlack r : ℤ) + 1 := by
linarith [hkey]
have : ((db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length : ℤ) = (beginSlack r : ℤ) + 1 := by
linarith [hcast, h1]
omega
rw [List.countP_eq_length_filter]
exact hG
/-- Given agreement on the gap `[head, begin.key)` and a first database whose begin
selector resolves onto the reported head, the second database (which stores the head)
resolves onto the head too. The gap count is forced to `beginSlack + 1` by the anchor
identity, so the anchor is always the rank of the head. -/
theorem resolve_begin_eq_head_of_agree_gap
{db₁ db₂ : DB} {r : RangeRead} {res : Result} {head : Key}
(_hrev : r.reverse = false) (_hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((head : Key) : WithTop Key) < r.begin.key)
(hanc₁ : 0 ≤ r.begin.anchor db₁)
(hres₁ : resolve db₁ r.begin = ((head : Key) : WithTop Key))
(hagree : db₁.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) =
db₂.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)))
(hhead_mem₂ : head ∈ db₂.keys) :
resolve db₂ r.begin = ((head : Key) : WithTop Key) := by
classical
have hsplit₁ := countP_lt_eq_add_filter_withTop db₁.keys db₁.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hsplit₂ := countP_lt_eq_add_filter_withTop db₂.keys db₂.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hsplit₁' : db₁.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
db₁.keys.countP (fun k : Key => decide (k < head)) +
db₁.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hsplit₁, ← List.countP_eq_length_filter]
have hsplit₂' : db₂.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
db₂.keys.countP (fun k : Key => decide (k < head)) +
db₂.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hsplit₂, ← List.countP_eq_length_filter]
have hgap₁ : db₁.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 :=
gap_count_eq_beginSlack_of_resolve_head hbegin hcross hanc₁ hres₁
have hgap₂ : db₂.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := by
rw [List.countP_eq_length_filter, ← hagree, ← List.countP_eq_length_filter]
exact hgap₁
have hanchor₂ : r.begin.anchor db₂ =
(db₂.keys.countP (fun k : Key => decide (k < head)) : ℤ) := by
rw [anchor_eq_count_sub_slack db₂ r (le_of_lt hbegin), hsplit₂', hgap₂]
push_cast
ring
have hlt : db₂.keys.countP (fun k : Key => decide (k < head)) < db₂.keys.length := by
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_mem₂
rw [countP_lt_eq_of_getElem db₂.sorted hi hix]
exact hi
have hnat : (r.begin.anchor db₂).toNat =
db₂.keys.countP (fun k : Key => decide (k < head)) := by
rw [hanchor₂, Int.toNat_natCast]
have h0 : 0 ≤ r.begin.anchor db₂ := by
rw [hanchor₂]; exact Int.natCast_nonneg _
have hlt' : (r.begin.anchor db₂).toNat < db₂.keys.length := by
rw [hnat]; exact hlt
have hget : db₂.keys[(r.begin.anchor db₂).toNat] = head := by
rw [getElem_congr_idx (h' := hnat)]
exact getElem_countP_lt db₂.sorted hhead_mem₂
rw [resolve_eq_getElem h0 hlt']
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hget
/-- **Compatibility transfers across agreement on the crossed negative-begin truncated
nonpositive-end gap range in the non-bottom branch.** Here the range is
`[head, max begin.key end.key)`. -/
theorem compatible_of_agree_negCross_trunc_nonposGap_nonbottom
{r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hnbot : ¬ clampNonposBottom r res)
(hend : r.end_.offset ≤ 0)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (⟨((res.keys.head hne : Key) : WithTop Key),
max r.begin.key r.end_.key⟩ : ConflictRange) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
-- The begin anchor is nonnegative, hence the begin selector resolves onto the head.
have hanc1 : 0 ≤ r.begin.anchor db1 := by
by_contra h
exact hnbot (clampNonposBottom_of_anchor_neg_trunc hc1 hrev hmore hne hbegin hend hclamp
(by omega))
have hpre := RangeRead.compatible_keys_prefix hc1
have hckne : RangeRead.completeKeys db1 r ≠ [] := hpre.ne_nil hne
obtain ⟨a, _ha_mem, ha_res, ha_head⟩ :=
RangeRead.completeKeys_head_resolve hrev hckne hanc1
have hhead_eq_a : res.keys.head hne = a := by
rw [← ha_head]
exact hpre.head hne
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead, hhead_eq_a]; exact ha_res
set upper : WithTop Key := max r.begin.key r.end_.key with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
hpre.subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hsort := (RangeRead.compatible_sortedLT hc1 hrev).pairwise.imp le_of_lt
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
have hle := resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend
exact lt_of_lt_of_le (lt_of_lt_of_le hlt1 hle) (by rw [hupper]; exact le_max_right _ _)
have hmem := (agreeOn_iff (⟨((head : Key) : WithTop Key), upper⟩ : ConflictRange) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
have hB_upper : r.begin.key ≤ upper := by rw [hupper]; exact le_max_left _ _
have hgap : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hB_upper)).mp hk1, hge, hlt⟩
· rintro ⟨hk2, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hB_upper)).mpr hk2, hge, hlt⟩
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_agree_gap hrev hne hbegin hcross' hanc1 hres1 hgap hhead_db2
have hne_top : resolve db1 r.end_ ≠ (⊤ : WithTop Key) :=
resolve_ne_top_of_offset_nonpos hend
obtain ⟨q, hq⟩ := WithTop.ne_top_iff_exists.mp hne_top
have hlast_q : last < q := by
have h := hlt1
rw [← hq] at h
exact WithTop.coe_lt_coe.mp h
have hqne : q ≠ ([] : Key) := by
intro hnil
have h : last < ([] : Key) := by rwa [hnil] at hlast_q
exact absurd h (List.not_lt_nil last)
have hq_le_E : ((q : Key) : WithTop Key) ≤ r.end_.key := by
rw [hq]
exact resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend
have hhead_q : ((head : Key) : WithTop Key) ≤ ((q : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hhead_le_last hlast_q))
have hEnd_upper : r.end_.key ≤ upper := by
rw [hupper]; exact le_max_right _ _
have hagreeEnd : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mp hk1, hge, hlt⟩
· rintro ⟨hk2, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mpr hk2, hge, hlt⟩
have hqget := resolve_filter_reverse_eq_some_of_ne_nil (db := db1) (s := r.end_) hend hqne hq.symm
have hresEnd2 : resolve db2 r.end_ = ((q : Key) : WithTop Key) :=
resolve_eq_of_agree_between (db₁ := db1) (db₂ := db2) (s := r.end_) hend
(E := r.end_.key) rfl (le_trans hhead_q hq_le_E) hagreeEnd hqget hhead_q
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ := by
rw [hresEnd2]
exact WithTop.coe_lt_coe.mpr hlast_q
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
have hck1 : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hck2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
have heq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1,
hge, hle⟩
· rintro ⟨hk2, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2,
hge, hle⟩
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hck2, ← heq, ← hck1, hres1len]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- **Soundness of `[head, max begin.key end.key)` in the non-bottom branch.** -/
theorem sound_headLong_of_nonbottom {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hclamp : reportedBelowBegin r res ≤ beginSlack r)
(hnbot : ¬ clampNonposBottom r res)
(hend : r.end_.offset ≤ 0) :
Sound r res (⟨((res.keys.head hne : Key) : WithTop Key),
max r.begin.key r.end_.key⟩ : ConflictRange) := by
intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_negCross_trunc_nonposGap_nonbottom hrev hmore hne hbegin hcross
hclamp hnbot hend hc1 hagree
· intro hc2
exact compatible_of_agree_negCross_trunc_nonposGap_nonbottom hrev hmore hne hbegin hcross
hclamp hnbot hend hc2 (AgreeOn.symm hagree)
end FormalConflictRange