Files
conflict-range/FormalConflictRange/NegCrossTruncNonposGap.lean
T

412 lines
21 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.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 proved in the companion modules
`NegCrossTruncNonposGapA2a`, `NegCrossTruncNonposGapA2aBottom`, and
`NegCrossTruncNonposGapCrossFree`. 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 defined here; the companion modules prove it minimal on the three subcells.
-/
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