- Update deprecated lemmas (ite_eq_left/right, ENat casts, List.Sublist, ...) - Replace push_neg with push Not and resolve unused-variable warnings - Convert flexible simp/simp_all calls to explicit simp only lists - Remove unscoped maxHeartbeats options, open scoped Classical, and unused tactics - Add missing module docstrings and clean up style linter hits - Wrap over-long lines and flatten the deeply nested minimal_conflictRangeClosedForm_total proof `lake build` now completes with zero warnings.
412 lines
21 KiB
Lean4
412 lines
21 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.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
|