Files
conflict-range/FormalConflictRange/NegCrossTruncNonclamp.lean
T
andrew af318a7d32 Fix all Lean build warnings
- 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.
2026-11-17 10:04:35 -05:00

1751 lines
95 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.
/-
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.NegCrossComplete
import FormalConflictRange.ZeroCrossTrunc
import FormalConflictRange.NonposRevClosedForm
/-!
# Crossed negative-begin truncated nonclamping unbounded-end cell
This module closes the forward, crossed, truncated, nonclamping cell at a negative
begin offset with an unbounded end selector (`end_.key = ⊤`, `1 ≤ end_.offset`). In
this cell the begin anchor is exactly one past the reported keys below `begin.key`, so
every compatible database resolves the begin selector onto the reported head, and the
minimal sound conflict range is `[head, max begin.key (keyAfter last))`.
The key arithmetic is `count_lt_begin_eq_of_negCross_trunc_nonclamp`: the stored keys
below `begin.key` split at the head with exactly `reportedBelowBegin` keys in
`[head, begin.key)`. Soundness then follows because agreement on that range fixes both
the gap count and the truncated complete keys, and the gap keys `(last, begin.key)` are
necessary by a toggle witness on the reported keys.
-/
open FormalConflictRange
namespace FormalConflictRange
/-- In the nonclamping truncated crossed negative-begin cell, a compatible database
resolves its begin selector onto the reported head. -/
theorem resolve_begin_eq_head_of_negCross_trunc_nonclamp {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (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)
(hnonclamp : beginSlack r < reportedBelowBegin r res) :
resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
set head : Key := res.keys.head hne with hhead
set cB := db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))
with hcB
have hsub : List.Sublist res.keys db.keys := result_sublist_db_of_compatible hcomp hrev
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
have hhead_ck : head ∈ RangeRead.completeKeys db r := hpre.subset hhead_mem
have hle_head : resolve db r.begin ≤ ((head : Key) : WithTop Key) :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.1
have hhead_db : head ∈ db.keys :=
(RangeRead.mem_completeKeys.mp hhead_ck).1
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := hcross
-- Count identity: stored keys below `begin.key` split at the head.
have hsplit := countP_lt_eq_add_filter_withTop db.keys db.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross')
have hres_count : res.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = reportedBelowBegin r res := by
unfold reportedBelowBegin
rw [List.countP_eq_length_filter, List.countP_eq_length_filter]
congr 1
apply List.filter_congr
intro k hk
have hhead_le : ((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr
((RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hk)
rw [decide_eq_decide]
exact and_iff_right hhead_le
have hmin_le : reportedBelowBegin r res ≤
(db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length := by
have h := List.Sublist.countP_le hsub
(p := fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))
rw [hres_count, List.countP_eq_length_filter] at h
exact h
have hcB_ge : beginSlack r + 1 ≤ cB := by
have hN : beginSlack r + 1 ≤
(db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length :=
Nat.succ_le_of_lt (lt_of_lt_of_le hnonclamp hmin_le)
rw [hcB, hsplit]
omega
have hanchor_ge : 0 ≤ r.begin.anchor db := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), ← hcB]
have : (beginSlack r : ℤ) + 1 ≤ (cB : ℤ) := by exact_mod_cast hcB_ge
omega
have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
intro htop
rw [htop] at hle_head
exact absurd hle_head (not_le.mpr (WithTop.coe_lt_top head))
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
by_contra h
exact hnot_top (resolve_eq_top hanchor_ge (le_of_not_gt h))
have hresolve_get : resolve db r.begin =
((db.keys[(r.begin.anchor db).toNat] : Key) : WithTop Key) :=
resolve_eq_getElem hanchor_ge hltlen
-- The head's rank is below the anchor index, so the resolved key is at least the head.
have hcH_le : db.keys.countP (fun k : Key => decide (k < head)) ≤ (r.begin.anchor db).toNat := by
have hanchor_cast : r.begin.anchor db = (cB : ℤ) - (beginSlack r : ℤ) - 1 := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), ← hcB]
have htoNat : (r.begin.anchor db).toNat = cB - (beginSlack r + 1) := by
have hz : r.begin.anchor db = ((cB : ℤ) - ((beginSlack r + 1 : ℕ) : ℤ)) := by
rw [hanchor_cast]; push_cast; ring
have hz2 : ((cB : ℤ) - ((beginSlack r + 1 : ℕ) : ℤ)) =
((cB - (beginSlack r + 1) : ℕ) : ℤ) := by
rw [← Nat.cast_sub hcB_ge]
rw [hz, hz2, Int.toNat_natCast]
rw [htoNat]
have hsplit' : cB = 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 [hcB]; exact hsplit
omega
have hhead_le_resolve : ((head : Key) : WithTop Key) ≤ resolve db r.begin := by
rw [hresolve_get]
exact WithTop.coe_le_coe.mpr (le_getElem_of_countP_le db.sorted hcH_le hltlen)
exact le_antisymm hle_head hhead_le_resolve
/-- The forward, crossed, truncated, nonclamping, unbounded-end negative-begin cell. -/
abbrev negCrossTruncNonclampTop (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧
r.end_.key = (⊤ : WithTop Key) ∧ 1 ≤ r.end_.offset ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res = beginSlack r + 1
/-- The closed form for the cell: from the reported head up to the larger of
`begin.key` and the successor of the reported last. -/
noncomputable def closedFormNegCrossTruncNonclampTop (r : RangeRead) (res : Result) :
ConflictRange :=
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)⟩
/-- The reported keys themselves are compatible with the cell's read. -/
theorem compatible_self_of_negCross_trunc_nonclamp_top {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampTop r res) :
RangeRead.Compatible ⟨res.keys, RangeRead.compatible_sortedLT
(Classical.choose_spec hread) hcell.2.1⟩ r res := by
classical
obtain ⟨hmore, hrev, hbegin, hendkey, hendoff, hcrossD, hnonclamp⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
set head : Key := res.keys.head hne with hhead
let db : DB := ⟨res.keys, hsort⟩
have hdb : db.keys = res.keys := rfl
have hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcrossD' : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key := by
simpa [leastReported, hrev] using hcrossD
have hcross : ((head : Key) : WithTop Key) < r.begin.key := by
rw [← hheadD]; exact hcrossD'
have hcB : res.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
reportedBelowBegin r res := rfl
have hanchor : r.begin.anchor db = 0 := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), hdb, hcB, hnonclamp]
push_cast; ring
have hanchor_nat : (r.begin.anchor db).toNat = 0 := by rw [hanchor]; rfl
have hL : resolve db r.begin = ((head : Key) : WithTop Key) := by
have hlt : (r.begin.anchor db).toNat < db.keys.length := by
rw [hanchor_nat, hdb]; exact List.length_pos_of_ne_nil hne
have hget := resolve_eq_getElem (db := db) (s := r.begin)
(by rw [hanchor]) hlt
rw [hget]
have hidx : db.keys[(r.begin.anchor db).toNat] = head := by
rw [getElem_congr_idx (h' := hanchor_nat)]
simpa [hhead] using
(List.getElem_zero_eq_head (l := res.keys)
(h := List.length_pos_of_ne_nil hne))
rw [hidx]
have hck : RangeRead.completeKeys db r = res.keys := by
rw [completeKeys_eq_filter_ge_of_end_top (db := db) hrev hendkey hendoff hL, hdb]
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq]
exact WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hk)
exact ⟨RangeRead.compatible_withinLimit hcomp₀, Or.inl ⟨hmore, by rw [hck], hne⟩⟩
/-- In the nonclamping truncated crossed negative-begin cell, the number of stored
keys below `begin.key` splits at the reported head with exactly `reportedBelowBegin`
keys in `[head, begin.key)`. -/
theorem count_lt_begin_eq_of_negCross_trunc_nonclamp {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (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)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1) :
db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
db.keys.countP (fun k : Key => decide (k < res.keys.head hne)) +
reportedBelowBegin r res := by
set head : Key := res.keys.head hne with hhead
set cB := db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))
with hcB
have hnonclamp : beginSlack r < reportedBelowBegin r res := by rw [hnonclamp_eq]; omega
have hsub : List.Sublist res.keys db.keys := result_sublist_db_of_compatible hcomp hrev
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hcomp
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
have hhead_ck : head ∈ RangeRead.completeKeys db r := hpre.subset hhead_mem
have hle_head : resolve db r.begin ≤ ((head : Key) : WithTop Key) :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.1
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := hcross
have hsplit := countP_lt_eq_add_filter_withTop db.keys db.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross')
have hres_count : res.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = reportedBelowBegin r res := by
unfold reportedBelowBegin
rw [List.countP_eq_length_filter, List.countP_eq_length_filter]
congr 1
apply List.filter_congr
intro k hk
have hhead_le : ((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr
((RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hk)
rw [decide_eq_decide]
exact and_iff_right hhead_le
have hmin_le : reportedBelowBegin r res ≤
(db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length := by
have h := List.Sublist.countP_le hsub
(p := fun k : Key => decide (((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))
rw [hres_count, List.countP_eq_length_filter] at h
exact h
have hcB_ge : beginSlack r + 1 ≤ cB := by
have hN : beginSlack r + 1 ≤
(db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length :=
Nat.succ_le_of_lt (lt_of_lt_of_le hnonclamp hmin_le)
rw [hcB, hsplit]
omega
have hanchor_ge : 0 ≤ r.begin.anchor db := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), ← hcB]
have : (beginSlack r : ℤ) + 1 ≤ (cB : ℤ) := by exact_mod_cast hcB_ge
omega
have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
intro htop
rw [htop] at hle_head
exact absurd hle_head (not_le.mpr (WithTop.coe_lt_top head))
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
by_contra h
exact hnot_top (resolve_eq_top hanchor_ge (le_of_not_gt h))
have hL := resolve_begin_eq_head_of_negCross_trunc_nonclamp hcomp hrev hmore hne hbegin
hcross hnonclamp
have hget := resolve_eq_getElem (db := db) (s := r.begin) hanchor_ge hltlen
have hval : db.keys[(r.begin.anchor db).toNat] = head :=
WithTop.coe_inj.mp (hget.symm.trans hL)
have hcountP : db.keys.countP (fun k : Key => decide (k < head)) =
(r.begin.anchor db).toNat := countP_lt_eq_of_getElem db.sorted hltlen hval
have htoNat : (r.begin.anchor db).toNat = cB - (beginSlack r + 1) := by
have hanchor_cast : r.begin.anchor db = (cB : ℤ) - (beginSlack r : ℤ) - 1 := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), ← hcB]
have hz : r.begin.anchor db = ((cB : ℤ) - ((beginSlack r + 1 : ℕ) : ℤ)) := by
rw [hanchor_cast]; push_cast; ring
have hz2 : ((cB : ℤ) - ((beginSlack r + 1 : ℕ) : ℤ)) =
((cB - (beginSlack r + 1) : ℕ) : ℤ) := by
rw [← Nat.cast_sub hcB_ge]
rw [hz, hz2, Int.toNat_natCast]
rw [hcB]
omega
/-- **Compatibility transfers across agreement on the nonclamping truncated crossed
negative-begin range `[head, max begin.key (keyAfter last))`.** Agreement on the range
fixes the reported head and the stored keys in `[head, begin.key)`, hence the begin
resolution after the nonclamp count identity, and fixes the truncated complete keys. -/
theorem compatible_of_agree_negCross_trunc_nonclamp_top {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormNegCrossTruncNonclampTop r res) 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 hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hcr : closedFormNegCrossTruncNonclampTop r res = ⟨((head : Key) : WithTop Key), upper⟩ := by
unfold closedFormNegCrossTruncNonclampTop
rw [hheadD, hlastD, hupper]
have hB_upper : r.begin.key ≤ upper := le_max_left _ _
have hlast_upper : ((last : Key) : WithTop Key) < upper :=
lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormNegCrossTruncNonclampTop r res) 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 ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hnonclamp : beginSlack r < reportedBelowBegin r res := by rw [hnonclamp_eq]; omega
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross hnonclamp
have hE1 : resolve db1 r.end_ = (⊤ : WithTop Key) :=
resolve_eq_top_of_key_eq_top hendkey hendoff
have hE2 : resolve db2 r.end_ = (⊤ : WithTop Key) :=
resolve_eq_top_of_key_eq_top hendkey hendoff
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_upper : ((head : Key) : WithTop Key) < upper :=
lt_of_lt_of_le hcross hB_upper
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
-- Count identity for `db1`, and the equal gap counts.
have hcount1 := count_lt_begin_eq_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross
hnonclamp_eq
have hcount1' : db1.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db1.keys.countP (fun k : Key => decide (k < head)) + reportedBelowBegin r res := by
simpa [hhead] using hcount1
have hsplit1 := countP_lt_eq_add_filter_withTop db1.keys db1.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hgaplen1 : (db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = reportedBelowBegin r res := by
rw [hcount1'] at hsplit1
omega
have hgap_eq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : 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 hgaplen2 : (db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = reportedBelowBegin r res := by
rw [← hgap_eq, hgaplen1]
have hsplit2 := countP_lt_eq_add_filter_withTop db2.keys db2.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hcount2 : db2.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db2.keys.countP (fun k : Key => decide (k < head)) + reportedBelowBegin r res := by
rw [hsplit2, hgaplen2]
have cB2_ge : beginSlack r + 1 ≤ db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hcount2, ← hnonclamp_eq]; omega
have hanchor2 : 0 ≤ r.begin.anchor db2 := by
rw [anchor_eq_count_sub_slack db2 r (le_of_lt hbegin)]
have : (beginSlack r : ℤ) + 1 ≤ ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))) : ℤ) := by
exact_mod_cast cB2_ge
omega
have htoNat2 : (r.begin.anchor db2).toNat = db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) -
(beginSlack r + 1) := by
have hz : r.begin.anchor db2 = ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℤ) -
((beginSlack r + 1 : ℕ) : ℤ)) := by
rw [anchor_eq_count_sub_slack db2 r (le_of_lt hbegin)]; push_cast; ring
have hz2 : ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) -
((beginSlack r + 1 : ℕ) : ℤ) =
((db2.keys.countP (fun k : Key =>
decide (((k : Key) : WithTop Key) < r.begin.key)) -
(beginSlack r + 1) : ℕ) : ℤ) := by
rw [← Nat.cast_sub cB2_ge]
rw [hz, hz2, Int.toNat_natCast]
have hidx_eq2 : (r.begin.anchor db2).toNat = db2.keys.countP (fun k => decide (k < head)) := by
rw [htoNat2, hcount2, hnonclamp_eq]
omega
have hltlen2 : (r.begin.anchor db2).toNat < db2.keys.length := by
rw [hidx_eq2]
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_db2
rw [countP_lt_eq_of_getElem db2.sorted hi hix]
exact hi
have hval2 : db2.keys[(r.begin.anchor db2).toNat]'hltlen2 = head := by
simpa [hidx_eq2] using getElem_countP_lt db2.sorted hhead_db2
have hL2 : resolve db2 r.begin = ((head : Key) : WithTop Key) := by
rw [resolve_eq_getElem (db := db2) (s := r.begin) hanchor2 hltlen2]
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hval2
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ := by
rw [hE1]; exact WithTop.coe_lt_top last
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ := by
rw [hE2]; exact WithTop.coe_lt_top last
have hfilter1 : (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 hfilter2 : (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 hL2 hlt2
have hres1fil : (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 hfeq : 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 hres2fil : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hfilter2, ← hfeq, ← hfilter1, hres1fil]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, by simpa [hlast] using hres2fil⟩
/-- Inserting a key strictly above every element of a list appends it. -/
theorem orderedInsert_append_of_forall_lt' {l : List Key} {k : Key}
(h : ∀ x ∈ l, x < k) : l.orderedInsert (· ≤ ·) k = l ++ [k] := by
induction l with
| nil => simp
| cons a t ih =>
have ha : ¬ k ≤ a := fun hka => absurd hka (not_le.mpr (h a (List.mem_cons_self ..)))
rw [List.orderedInsert_cons, ite_eq_right ha,
ih (fun x hx => h x (List.mem_cons_of_mem a hx))]
simp
/-- **Gap keys are necessary.** A key strictly between the reported last and
`begin.key` is necessary: inserting it into the database of reported keys moves the
begin anchor from `0` to `1`, so the reported head is no longer the resolved begin. -/
theorem necessary_negCross_trunc_gap {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
(hkgt : res.keys.getLast hne < k) (hkB : (k : WithTop Key) < r.begin.key) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
let db : DB := ⟨res.keys, hsort⟩
have hdb : db.keys = res.keys := rfl
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcell : negCrossTruncNonclampTop r res :=
⟨hmore, hrev, hbegin, hendkey, hendoff, by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD]; exact hcross, hnonclamp_eq⟩
have hcomp : RangeRead.Compatible db r res :=
compatible_self_of_negCross_trunc_nonclamp_top ⟨db₀, hcomp₀⟩ hcell
have hle_last : ∀ x ∈ res.keys, x ≤ res.keys.getLast hne :=
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
have hk_notmem : k ∉ db.keys := by
rw [hdb]
exact fun hk => absurd (hle_last k hk) (not_le.mpr hkgt)
refine necessary_of_toggle ⟨db, hcomp, ?_⟩
intro hcompk
have htoggle : toggle db k = db.insert k hk_notmem := by
unfold toggle
rw [dite_eq_right hk_notmem]
rw [htoggle] at hcompk
set db' : DB := db.insert k hk_notmem with hdb'
have hkeys' : db'.keys = res.keys ++ [k] := by
rw [hdb', DB.insert_keys]
exact orderedInsert_append_of_forall_lt'
(fun x hx => lt_of_le_of_lt (hle_last x hx) hkgt)
have hcount' : db'.keys.countP (fun x : Key => decide
(((x : Key) : WithTop Key) < r.begin.key)) = reportedBelowBegin r res + 1 := by
rw [hkeys', List.countP_append]
have hkdec : decide (((k : Key) : WithTop Key) < r.begin.key) = true := by
rw [decide_eq_true_eq]; exact hkB
rw [List.countP_singleton, hkdec, ite_eq_left rfl]
have hres_count : res.keys.countP (fun x : Key => decide
(((x : Key) : WithTop Key) < r.begin.key)) = reportedBelowBegin r res := rfl
rw [hres_count]
have hanchor' : r.begin.anchor db' = 1 := by
rw [anchor_eq_count_sub_slack db' r (le_of_lt hbegin), hcount', hnonclamp_eq]
push_cast; ring
have hL' : resolve db' r.begin = ((res.keys.head hne : Key) : WithTop Key) :=
resolve_begin_eq_head_of_negCross_trunc_nonclamp hcompk hrev hmore hne hbegin hcross
(by rw [hnonclamp_eq]; omega)
-- But the count identity for the compatible `db'` would force one stored key
-- below the reported head, while `db'.keys = res.keys ++ [k]` has none.
have hcount_lem := count_lt_begin_eq_of_negCross_trunc_nonclamp hcompk hrev hmore hne hbegin
hcross hnonclamp_eq
have hzero_count : db'.keys.countP (fun x : Key => decide (x < res.keys.head hne)) = 0 := by
apply countP_lt_eq_zero_of_forall_ge
intro x hx
rw [hkeys'] at hx
rcases List.mem_append.mp hx with hx | hx
· exact (hsort.pairwise.imp le_of_lt).rel_head hx
· simp only [List.mem_singleton] at hx
subst hx
exact le_trans ((hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne))
(le_of_lt hkgt)
rw [hcount', hzero_count] at hcount_lem
omega
/-- **Gap keys are necessary for any end selector.** A key strictly between the
reported last and `begin.key` is necessary: toggling it changes the number of stored keys
below `begin.key` by one while leaving the number below the reported head unchanged, so
the nonclamp count identity cannot hold on the toggled database. -/
theorem necessary_negCross_trunc_gap_general {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (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)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
(hkgt : res.keys.getLast hne < k) (hkB : (k : WithTop Key) < r.begin.key) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
have hsort := RangeRead.compatible_sortedLT hcomp₀ hrev
have hhead_le_last : res.keys.head hne ≤ res.keys.getLast hne :=
(hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)
have hhead_lt_k : res.keys.head hne < k := lt_of_le_of_lt hhead_le_last hkgt
have hhead_not_lt : ¬ ((k : Key) : WithTop Key) <
((res.keys.head hne : Key) : WithTop Key) := by
rw [not_lt]
exact WithTop.coe_le_coe.mpr (le_of_lt hhead_lt_k)
refine necessary_of_toggle ⟨db₀, hcomp₀, ?_⟩
intro hcompk
have hiden₀ := count_lt_begin_eq_of_negCross_trunc_nonclamp hcomp₀ hrev hmore hne hbegin
hcross hnonclamp_eq
rw [← countP_lt_coe] at hiden₀
change cnt db₀ r.begin.key = cnt db₀ (res.keys.head hne) + reportedBelowBegin r res at hiden₀
have hiden₁ := count_lt_begin_eq_of_negCross_trunc_nonclamp hcompk hrev hmore hne hbegin
hcross hnonclamp_eq
rw [← countP_lt_coe] at hiden₁
change cnt (toggle db₀ k) r.begin.key =
cnt (toggle db₀ k) (res.keys.head hne) + reportedBelowBegin r res at hiden₁
by_cases hkmem : k ∈ db₀.keys
· have htoggle : toggle db₀ k = db₀.erase k := toggle_eq_erase_of_mem hkmem
rw [htoggle] at hiden₁
rw [cnt_erase_lt db₀ hkmem hkB,
cnt_erase_not_lt db₀ hkmem hhead_not_lt] at hiden₁
have hpos : 1 ≤ cnt db₀ r.begin.key := by
rw [hiden₀]
have hq : 0 < beginSlack r := by
unfold beginSlack
rw [← Int.pos_iff_toNat_pos]
omega
omega
omega
· have htoggle : toggle db₀ k = db₀.insert k hkmem := toggle_eq_insert_of_not_mem hkmem
rw [htoggle] at hiden₁
rw [cnt_insert_lt db₀ k hkmem hkB,
cnt_insert_not_lt db₀ k hkmem hhead_not_lt] at hiden₁
omega
/-- **Closed form for the forward crossed negative-begin truncated nonclamping
unbounded-end cell.** The minimal sound range is
`[head, max begin.key (keyAfter last))`. -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_top {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampTop r res) :
Minimal r res (closedFormNegCrossTruncNonclampTop r res) := by
obtain ⟨hmore, hrev, hbegin, hendkey, hendoff, hcrossD, hnonclamp_eq⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross : ((head : Key) : WithTop Key) < r.begin.key := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hcrossD
exact hcrossD
let upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key)
have hcr : closedFormNegCrossTruncNonclampTop r res =
⟨((head : Key) : WithTop Key), upper⟩ := by
unfold closedFormNegCrossTruncNonclampTop
rw [hheadD, hlastD]
have hsound : Sound r res (closedFormNegCrossTruncNonclampTop r res) := by
intro db1 db2 hagree
exact ⟨fun h => compatible_of_agree_negCross_trunc_nonclamp_top hrev hmore hne hbegin
hendkey hendoff hcross hnonclamp_eq h hagree,
fun h => compatible_of_agree_negCross_trunc_nonclamp_top hrev hmore hne hbegin
hendkey hendoff hcross hnonclamp_eq h hagree.symm⟩
rw [hcr] at hsound ⊢
refine (minimal_iff_sound_and_necessaryRange).mpr ⟨hsound, ?_⟩
intro k hkbeg hkend
by_cases hkle : k ≤ last
· exact necessary_of_between_result hread' (by rw [hhead]; exact List.head_mem hne)
(by rw [hlast]; exact List.getLast_mem hne) (WithTop.coe_le_coe.mp hkbeg) hkle
· have hkgt : res.keys.getLast hne < k := by
simpa [hlast] using lt_of_not_ge hkle
have hkltB : (k : WithTop Key) < r.begin.key := by
have hkmax : (k : WithTop Key) <
max r.begin.key (((keyAfter last : Key)) : WithTop Key) := hkend
rcases lt_max_iff.mp hkmax with h | h
· exact h
· have hklast : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp h)
exact absurd hklast hkle
exact necessary_negCross_trunc_gap hread' hrev hmore hne hbegin hendkey hendoff
hcross hnonclamp_eq hkgt hkltB
/-- **A key below `end_.key` lies below the end resolution at any positive end
offset.** With offset at least one the end anchor is at or past the count of stored keys
below `end_.key`, so the resolution is at or past every key below `end_.key`. -/
theorem lt_resolve_end_of_lt_end_key {db : DB} {r : RangeRead}
(hend : 1 ≤ r.end_.offset) {k : Key} (hk : (k : WithTop Key) < r.end_.key) :
(k : WithTop Key) < resolve db r.end_ := by
set c := db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) with hc
have hanc : r.end_.anchor db = (c : ℤ) + r.end_.offset - 1 := by
unfold Selector.anchor; rw [hc]
have hanchor_nonneg : 0 ≤ r.end_.anchor db := by
rw [hanc]; have : (0 : ℤ) ≤ c := Int.natCast_nonneg _; omega
have hcnt_le : db.keys.countP (fun x : Key => decide (x < keyAfter k)) ≤ c := by
rw [hc]
apply List.countP_mono_left
intro x _ hxd
rw [decide_eq_true_eq] at hxd ⊢
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr ((lt_keyAfter_iff x k).mp hxd)) hk
have hanchor_ge : (db.keys.countP (fun x : Key => decide (x < keyAfter k)) : ℤ) ≤
r.end_.anchor db := by
rw [hanc]
have hcle : (db.keys.countP (fun x : Key => decide (x < keyAfter k)) : ℤ) ≤ (c : ℤ) := by
exact_mod_cast hcnt_le
have hoff : (1 : ℤ) ≤ r.end_.offset := by exact_mod_cast hend
omega
rcases lt_or_ge (r.end_.anchor db).toNat db.keys.length with hlt | hge
· have hres := resolve_eq_getElem (db := db) (s := r.end_) hanchor_nonneg hlt
rw [hres]
have hcount_le_anchor : db.keys.countP (fun x : Key => decide (x < keyAfter k)) ≤
(r.end_.anchor db).toNat := by
omega
have hle : keyAfter k ≤ db.keys[(r.end_.anchor db).toNat] :=
le_getElem_of_countP_le db.sorted hcount_le_anchor hlt
exact WithTop.coe_lt_coe.mpr (lt_of_lt_of_le (keyAfter_self_lt k) hle)
· have htop := resolve_eq_top (db := db) (s := r.end_) hanchor_nonneg hge
rw [htop]; exact WithTop.coe_lt_top k
/-- **Dropping the end bound at `end_.offset = 1` when every reported key lies below
`end_.key`.** At offset one the end selector resolves to the first stored key at or
above `end_.key`, so every stored key at or below the reported last lies below the
resolution; replacing `end_.key` by `⊤` therefore leaves compatibility unchanged. -/
theorem compatible_iff_end_top_of_offset_one {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hend : r.end_.offset = 1)
(hbelow : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) :
RangeRead.Compatible db r res ↔
RangeRead.Compatible db { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res := by
set r' : RangeRead := { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } with hr'
have hlast_lt : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key :=
hbelow _ (List.getLast_mem hne)
have hlt : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ :=
lt_resolve_end_of_end_one hend hlast_lt
have hend' : r'.end_.offset = 1 := by rw [hr']; exact hend
have htop : resolve db r'.end_ = (⊤ : WithTop Key) :=
resolve_eq_top_of_key_eq_top (db := db) (s := r'.end_)
(by rw [hr']) (by rw [hend'])
have hlt' : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r'.end_ := by
rw [htop]; exact WithTop.coe_lt_top _
have hrev' : r'.reverse = false := by rw [hr']; exact hrev
have hfil : (RangeRead.completeKeys db r).filter
(fun k : Key => decide (k ≤ res.keys.getLast hne)) =
(RangeRead.completeKeys db r').filter
(fun k : Key => decide (k ≤ res.keys.getLast hne)) := by
rw [completeKeys_filter_le_eq (db := db) (r := r) hrev hlt,
completeKeys_filter_le_eq (db := db) (r := r') hrev' hlt']
rw [compatible_iff_truncated_keys (r := r) hrev hmore hne,
compatible_iff_truncated_keys (r := r') hrev' hmore hne, hfil]
constructor <;> rintro ⟨h, w⟩ <;> exact ⟨h, w⟩
/-- The forward, crossed, truncated, nonclamping negative-begin cell with end offset
one and every reported key below `end_.key`. -/
abbrev negCrossTruncNonclampEndOne (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ r.end_.offset = 1 ∧
(∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res = beginSlack r + 1
/-- The closed form for the end-one cell, obtained by replacing the end key with `⊤`. -/
noncomputable def closedFormNegCrossTruncNonclampEndOne (r : RangeRead) (res : Result) :
ConflictRange :=
closedFormNegCrossTruncNonclampTop
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res
/-- **Closed form for the forward crossed negative-begin truncated nonclamping
end-offset-one cell.** Every reported key lies below `end_.key`, so the end selector
can be dropped to `⊤` and the unbounded-end rule applies. -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_endOne {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampEndOne r res) :
Minimal r res (closedFormNegCrossTruncNonclampEndOne r res) := by
obtain ⟨hmore, hrev, hbegin, hend, hbelow, hcrossD, hnonclamp_eq⟩ := hcell
obtain ⟨db, hcomp⟩ := hread
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore
have hcompiff : ∀ db, RangeRead.Compatible db r res ↔
RangeRead.Compatible db
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res :=
fun db => compatible_iff_end_top_of_offset_one hrev hmore hne hend hbelow
have hcellTop : negCrossTruncNonclampTop
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res :=
⟨hmore, hrev, hbegin, rfl, by simpa using (le_of_eq hend.symm), hcrossD, hnonclamp_eq⟩
have hread' : Readable { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res :=
⟨db, (hcompiff db).mp hcomp⟩
have hmin := minimal_closedForm_of_negCross_trunc_nonclamp_top hread' hcellTop
unfold closedFormNegCrossTruncNonclampEndOne
exact (minimal_congr_of_compatible_iff (r := r)
(r' := { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } })
(res := res) (cr := closedFormNegCrossTruncNonclampTop
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res) hcompiff).mpr hmin
/-- **Dropping the end bound when every reported key lies below `end_.key`.** -/
theorem completeKeys_filter_le_eq_of_below_end {db : DB} {r : RangeRead} {last : Key}
(hrev : r.reverse = false) (hend : 1 ≤ r.end_.offset)
(hbelow : (last : WithTop Key) < r.end_.key) :
(RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) =
(RangeRead.completeKeys db
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } }).filter
(fun k : Key => decide (k ≤ last)) := by
have hlt : (last : WithTop Key) < resolve db r.end_ :=
lt_resolve_end_of_lt_end_key hend hbelow
have htop : resolve db { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } }.end_ =
(⊤ : WithTop Key) :=
resolve_eq_top_of_key_eq_top (db := db) (s := _) rfl (by simpa using hend)
have hlt' : (last : WithTop Key) <
resolve db { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } }.end_ := by
rw [htop]; exact WithTop.coe_lt_top last
rw [completeKeys_filter_le_eq (db := db) (r := r) hrev hlt,
completeKeys_filter_le_eq (db := db)
(r := { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } }) hrev hlt']
/-- **Dropping the end bound whenever every reported key is below `end_.key`.** -/
theorem compatible_iff_end_top_of_below {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hend : 1 ≤ r.end_.offset)
(hbelow : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) :
RangeRead.Compatible db r res ↔
RangeRead.Compatible db { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res := by
have hlast_lt : ((res.keys.getLast hne : Key) : WithTop Key) < r.end_.key :=
hbelow _ (List.getLast_mem hne)
have hfil := completeKeys_filter_le_eq_of_below_end (db := db) (r := r)
(last := res.keys.getLast hne) hrev hend hlast_lt
rw [compatible_iff_truncated_keys (r := r) hrev hmore hne,
compatible_iff_truncated_keys
(r := { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } }) hrev hmore hne, hfil]
constructor <;> rintro ⟨h, w⟩ <;> exact ⟨h, w⟩
/-- The forward, crossed, truncated, nonclamping negative-begin cell with positive end
offset and every reported key below `end_.key`. -/
abbrev negCrossTruncNonclampBelowEnd (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ 1 ≤ r.end_.offset ∧
(∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res = beginSlack r + 1
/-- The closed form for the below-end cell, obtained by replacing the end key with `⊤`. -/
noncomputable def closedFormNegCrossTruncNonclampBelowEnd (r : RangeRead) (res : Result) :
ConflictRange :=
closedFormNegCrossTruncNonclampTop
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res
/-- **Closed form for the forward crossed negative-begin truncated nonclamping
below-end cell.** Every reported key lies below `end_.key`, so the end selector can be
dropped to `⊤` and the unbounded-end rule applies. -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_below {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampBelowEnd r res) :
Minimal r res (closedFormNegCrossTruncNonclampBelowEnd r res) := by
obtain ⟨hmore, hrev, hbegin, hend, hbelow, hcrossD, hnonclamp_eq⟩ := hcell
obtain ⟨db, hcomp⟩ := hread
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore
have hcompiff : ∀ db, RangeRead.Compatible db r res ↔
RangeRead.Compatible db
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res :=
fun db => compatible_iff_end_top_of_below hrev hmore hne hend hbelow
have hcellTop : negCrossTruncNonclampTop
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res :=
⟨hmore, hrev, hbegin, rfl, by simpa using hend, hcrossD, hnonclamp_eq⟩
have hread' : Readable { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res :=
⟨db, (hcompiff db).mp hcomp⟩
have hmin := minimal_closedForm_of_negCross_trunc_nonclamp_top hread' hcellTop
unfold closedFormNegCrossTruncNonclampBelowEnd
exact (minimal_congr_of_compatible_iff (r := r)
(r' := { r with end_ := { r.end_ with key := (⊤ : WithTop Key) } })
(res := res) (cr := closedFormNegCrossTruncNonclampTop
{ r with end_ := { r.end_ with key := (⊤ : WithTop Key) } } res) hcompiff).mpr hmin
/-- **Compatibility transfers across agreement on the nonclamping truncated crossed
negative-begin range when the end key is at or above the reported head.** Agreement on
`[head, max begin.key (keyAfter last))` fixes the begin resolution through the nonclamp
count identity, and the end filter count fixes the end resolution above `last`. -/
theorem compatible_of_agree_negCross_trunc_nonclamp_endGeHead {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hge : 1 ≤ r.end_.offset)
(hheadE : ((res.keys.head hne : Key) : WithTop Key) ≤ r.end_.key)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormNegCrossTruncNonclampTop r res) 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 hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hcr : closedFormNegCrossTruncNonclampTop r res = ⟨((head : Key) : WithTop Key), upper⟩ := by
unfold closedFormNegCrossTruncNonclampTop
rw [hheadD, hlastD, hupper]
have hB_upper : r.begin.key ≤ upper := le_max_left _ _
have hlast_upper : ((last : Key) : WithTop Key) < upper :=
lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormNegCrossTruncNonclampTop r res) 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 ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hnonclamp : beginSlack r < reportedBelowBegin r res := by rw [hnonclamp_eq]; omega
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross hnonclamp
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_upper : ((head : Key) : WithTop Key) < upper :=
lt_of_lt_of_le hcross hB_upper
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
-- Count identity for `db1`, and the equal gap counts.
have hcount1 := count_lt_begin_eq_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross
hnonclamp_eq
have hcount1' : db1.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db1.keys.countP (fun k : Key => decide (k < head)) + reportedBelowBegin r res := by
simpa [hhead] using hcount1
have hsplit1 := countP_lt_eq_add_filter_withTop db1.keys db1.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hgaplen1 : (db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = reportedBelowBegin r res := by
rw [hcount1'] at hsplit1
omega
have hgap_eq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : 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 hgaplen2 : (db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = reportedBelowBegin r res := by
rw [← hgap_eq, hgaplen1]
have hsplit2 := countP_lt_eq_add_filter_withTop db2.keys db2.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hcount2 : db2.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db2.keys.countP (fun k : Key => decide (k < head)) + reportedBelowBegin r res := by
rw [hsplit2, hgaplen2]
have cB2_ge : beginSlack r + 1 ≤ db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hcount2, ← hnonclamp_eq]; omega
have hanchor2 : 0 ≤ r.begin.anchor db2 := by
rw [anchor_eq_count_sub_slack db2 r (le_of_lt hbegin)]
have : (beginSlack r : ℤ) + 1 ≤ ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))) : ℤ) := by
exact_mod_cast cB2_ge
omega
have htoNat2 : (r.begin.anchor db2).toNat = db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) -
(beginSlack r + 1) := by
have hz : r.begin.anchor db2 = ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℤ) -
((beginSlack r + 1 : ℕ) : ℤ)) := by
rw [anchor_eq_count_sub_slack db2 r (le_of_lt hbegin)]; push_cast; ring
have hz2 : ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) -
((beginSlack r + 1 : ℕ) : ℤ) =
((db2.keys.countP (fun k : Key =>
decide (((k : Key) : WithTop Key) < r.begin.key)) -
(beginSlack r + 1) : ℕ) : ℤ) := by
rw [← Nat.cast_sub cB2_ge]
rw [hz, hz2, Int.toNat_natCast]
have hidx_eq2 : (r.begin.anchor db2).toNat = db2.keys.countP (fun k => decide (k < head)) := by
rw [htoNat2, hcount2, hnonclamp_eq]
omega
have hltlen2 : (r.begin.anchor db2).toNat < db2.keys.length := by
rw [hidx_eq2]
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_db2
rw [countP_lt_eq_of_getElem db2.sorted hi hix]
exact hi
have hval2 : db2.keys[(r.begin.anchor db2).toNat]'hltlen2 = head := by
simpa [hidx_eq2] using getElem_countP_lt db2.sorted hhead_db2
have hL2 : resolve db2 r.begin = ((head : Key) : WithTop Key) := by
rw [resolve_eq_getElem (db := db2) (s := r.begin) hanchor2 hltlen2]
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hval2
-- The end resolution is above `last` for both databases, by the end filter count.
have hheadE' : ((head : Key) : WithTop Key) ≤ r.end_.key := by rw [hhead]; exact hheadE
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hfiltereq : (db1.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) =
(db2.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr ((db1.sorted.pairwise.filter _).filter _)
· exact List.sortedLT_iff_pairwise.mpr ((db2.sorted.pairwise.filter _).filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨⟨hk1, hEk⟩, hkle⟩
exact ⟨⟨(hmk k (le_trans hheadE' hEk)
(lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkle) hlast_upper)).mp hk1, hEk⟩, hkle⟩
· rintro ⟨⟨hk2, hEk⟩, hkle⟩
exact ⟨⟨(hmk k (le_trans hheadE' hEk)
(lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkle) hlast_upper)).mpr hk2, hEk⟩, hkle⟩
have hcnt1 : ((db1.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat :=
filter_length_le_offset_of_resolve_end_gt (db := db1) hge hlt1
have hcnt2 : ((db2.keys.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by
rw [← hfiltereq]
exact hcnt1
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
resolve_end_gt_of_filter_length_le (db := db2) hge hcnt2
have hfilter1 : (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 hfilter2 : (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 hL2 hlt2
have hres1fil : (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 hfeq : 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 hres2fil : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hfilter2, ← hfeq, ← hfilter1, hres1fil]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, by simpa [hlast] using hres2fil⟩
/-- The forward, crossed, truncated, nonclamping negative-begin cell with positive end
offset and the end key at or above the reported head. -/
abbrev negCrossTruncNonclampEndGeHead (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ 1 ≤ r.end_.offset ∧
((leastReported r res : Key) : WithTop Key) ≤ r.end_.key ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res = beginSlack r + 1
/-- **Closed form for the forward crossed negative-begin truncated nonclamping
end-at-or-above-head cell.** The minimal sound range is again
`[head, max begin.key (keyAfter last))`. -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_endGeHead {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampEndGeHead r res) :
Minimal r res (closedFormNegCrossTruncNonclampTop r res) := by
obtain ⟨hmore, hrev, hbegin, hge, hheadED, hcrossD, hnonclamp_eq⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross : ((head : Key) : WithTop Key) < r.begin.key := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hcrossD
exact hcrossD
have hheadE : ((head : Key) : WithTop Key) ≤ r.end_.key := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hheadED
exact hheadED
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key)
have hcr : closedFormNegCrossTruncNonclampTop r res =
⟨((head : Key) : WithTop Key), upper⟩ := by
unfold closedFormNegCrossTruncNonclampTop
rw [hheadD, hlastD]
have hsound : Sound r res (closedFormNegCrossTruncNonclampTop r res) := by
intro db1 db2 hagree
exact ⟨fun h => compatible_of_agree_negCross_trunc_nonclamp_endGeHead hrev hmore hne hbegin
hge hheadE hcross hnonclamp_eq h hagree,
fun h => compatible_of_agree_negCross_trunc_nonclamp_endGeHead hrev hmore hne hbegin
hge hheadE hcross hnonclamp_eq h hagree.symm⟩
rw [hcr] at hsound ⊢
refine (minimal_iff_sound_and_necessaryRange).mpr ⟨hsound, ?_⟩
intro k hkbeg hkend
by_cases hkle : k ≤ last
· exact necessary_of_between_result hread' (by rw [hhead]; exact List.head_mem hne)
(by rw [hlast]; exact List.getLast_mem hne) (WithTop.coe_le_coe.mp hkbeg) hkle
· have hkgt : res.keys.getLast hne < k := by
simpa [hlast] using lt_of_not_ge hkle
have hkltB : (k : WithTop Key) < r.begin.key := by
have hkmax : (k : WithTop Key) <
max r.begin.key (((keyAfter last : Key)) : WithTop Key) := hkend
rcases lt_max_iff.mp hkmax with h | h
· exact h
· have hklast : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp h)
exact absurd hklast hkle
exact necessary_negCross_trunc_gap_general hread' hrev hmore hne hbegin hcross
hnonclamp_eq hkgt hkltB
/-- **Begin resolution and reported window from agreement in the nonclamping crossed
negative-begin truncated cell.** Agreement on `[head, max begin.key (keyAfter last))`
forces the nonclamp count identity on the second database, hence the same begin
resolution `head`, and fixes the stored keys in `[head, last]`. -/
theorem begin_eq_head_and_window_of_agree_negCross_trunc_nonclamp {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)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hmk : ∀ k : Key,
((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) <
max r.begin.key (((keyAfter (res.keys.getLast hne) : Key)) : WithTop Key) →
(k ∈ db1.keys ↔ k ∈ db2.keys)) :
resolve db2 r.begin = ((res.keys.head hne : Key) : WithTop Key) ∧
db2.keys.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
(k : Key) ≤ res.keys.getLast hne)) = res.keys := 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 [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hB_upper : r.begin.key ≤ upper := le_max_left _ _
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
exact hmk k (by simpa [hhead] using hk1) (by simpa [hhead, hlast, hupper] using hk2)
have hnonclamp : beginSlack r < reportedBelowBegin r res := by rw [hnonclamp_eq]; omega
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross hnonclamp
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_upper : ((head : Key) : WithTop Key) < upper :=
lt_of_lt_of_le hcross hB_upper
have hhead_db2 : head ∈ db2.keys := (hmk' head le_rfl hhead_upper).mp hhead_db1
have hcount1 := count_lt_begin_eq_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross
hnonclamp_eq
have hcount1' : db1.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db1.keys.countP (fun k : Key => decide (k < head)) + reportedBelowBegin r res := by
simpa [hhead] using hcount1
have hsplit1 := countP_lt_eq_add_filter_withTop db1.keys db1.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hgaplen1 : (db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = reportedBelowBegin r res := by
rw [hcount1'] at hsplit1
omega
have hgap_eq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : 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 hgaplen2 : (db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length = reportedBelowBegin r res := by
rw [← hgap_eq, hgaplen1]
have hsplit2 := countP_lt_eq_add_filter_withTop db2.keys db2.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross)
have hcount2 : db2.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db2.keys.countP (fun k : Key => decide (k < head)) + reportedBelowBegin r res := by
rw [hsplit2, hgaplen2]
have cB2_ge : beginSlack r + 1 ≤ db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hcount2, ← hnonclamp_eq]; omega
have hanchor2 : 0 ≤ r.begin.anchor db2 := by
rw [anchor_eq_count_sub_slack db2 r (le_of_lt hbegin)]
have : (beginSlack r : ℤ) + 1 ≤ ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))) : ℤ) := by
exact_mod_cast cB2_ge
omega
have htoNat2 : (r.begin.anchor db2).toNat = db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) -
(beginSlack r + 1) := by
have hz : r.begin.anchor db2 = ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℤ) -
((beginSlack r + 1 : ℕ) : ℤ)) := by
rw [anchor_eq_count_sub_slack db2 r (le_of_lt hbegin)]; push_cast; ring
have hz2 : ((db2.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) : ℕ) : ℤ) -
((beginSlack r + 1 : ℕ) : ℤ) =
((db2.keys.countP (fun k : Key =>
decide (((k : Key) : WithTop Key) < r.begin.key)) -
(beginSlack r + 1) : ℕ) : ℤ) := by
rw [← Nat.cast_sub cB2_ge]
rw [hz, hz2, Int.toNat_natCast]
have hidx_eq2 : (r.begin.anchor db2).toNat = db2.keys.countP (fun k => decide (k < head)) := by
rw [htoNat2, hcount2, hnonclamp_eq]
omega
have hltlen2 : (r.begin.anchor db2).toNat < db2.keys.length := by
rw [hidx_eq2]
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_db2
rw [countP_lt_eq_of_getElem db2.sorted hi hix]
exact hi
have hval2 : db2.keys[(r.begin.anchor db2).toNat]'hltlen2 = head := by
simpa [hidx_eq2] using getElem_countP_lt db2.sorted hhead_db2
have hL2 : resolve db2 r.begin = ((head : Key) : WithTop Key) := by
rw [resolve_eq_getElem (db := db2) (s := r.begin) hanchor2 hltlen2]
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hval2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hres1fil : (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 hfilter1 := completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hpart1 : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
rw [← hfilter1]; exact hres1fil
have hpart2 : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
have heq : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr (db2.sorted.pairwise.filter _)
· exact List.sortedLT_iff_pairwise.mpr (db1.sorted.pairwise.filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk2, hHk, hklast⟩
exact ⟨(hmk' k hHk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast)
(lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last))
(le_max_right _ _)))).mpr hk2, hHk, hklast⟩
· rintro ⟨hk1, hHk, hklast⟩
exact ⟨(hmk' k hHk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast)
(lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last))
(le_max_right _ _)))).mp hk1, hHk, hklast⟩
rw [heq, hpart1]
exact ⟨hL2, hpart2⟩
/-- The closed form for the low-end (saturated gap) crossed negative-begin truncated
nonclamping cell: from `end.key` instead of the reported head. -/
noncomputable def closedFormNegCrossTruncNonclampLowEnd (r : RangeRead) (res : Result) :
ConflictRange :=
⟨r.end_.key,
max r.begin.key (((keyAfter (res.keys.getLastD ([] : Key)) : Key)) : WithTop Key)⟩
/-- **Compatibility transfers across agreement on the low-end crossed negative-begin
truncated nonclamping range when the gap absorbs the reported keys.** -/
theorem compatible_of_agree_negCross_trunc_nonclamp_lowEndSmall {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hge : 2 ≤ r.end_.offset)
(hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key))
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
(hsmall : intervalCard r.end_.key (((res.keys.head hne : Key)) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞))
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormNegCrossTruncNonclampTop r res) 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 hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcr : closedFormNegCrossTruncNonclampTop r res =
⟨((head : Key) : WithTop Key),
max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormNegCrossTruncNonclampTop
rw [hheadD, hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper :=
lt_of_lt_of_le hcross (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper :=
lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hmem := (agreeOn_iff (closedFormNegCrossTruncNonclampTop r res) 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 ?_
rw [hcr]
exact ⟨hk1, hk2⟩
obtain ⟨hL2, hpart2⟩ := begin_eq_head_and_window_of_agree_negCross_trunc_nonclamp
hrev hmore hne hbegin hcross hnonclamp_eq hc1 (fun k hk1 hk2 => hmk k hk1 (by simpa [hupper]
using hk2))
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by rw [hhead]; exact hEhead
have hsmall' : intervalCard r.end_.key ((head : Key) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) := by
simpa [hhead] using hsmall
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hc1 hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
have hsplit := filter_end_le_split_between (db := db2) (E := r.end_.key)
(head := head) (last := last) (le_of_lt hEhead') hhead_le_last
have hbetween : (((between db2 r.end_.key ((head : Key) : WithTop Key)).length : ℕ∞)) ≤
intervalCard r.end_.key ((head : Key) : WithTop Key) :=
between_length_le_intervalCard (db := db2) (le_of_lt hEhead')
have hsum : ((((between db2 r.end_.key ((head : Key) : WithTop Key)).length +
res.keys.length : ℕ)) : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) := by
rw [Nat.cast_add]
exact le_trans (add_le_add hbetween le_rfl) hsmall'
have hpart2' : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
simpa [hhead, hlast] using hpart2
have hcnt2 : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by
have hlen : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length =
(between db2 r.end_.key ((head : Key) : WithTop Key)).length + res.keys.length := by
rw [hsplit, hpart2', List.length_append]
rw [hlen]
exact_mod_cast hsum
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
resolve_end_gt_of_filter_length_le (db := db2) (by omega) hcnt2
have hck2 := completeKeys_filter_le_of_resolve_begin (db := db2) hrev hL2 hlt2
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, by rw [hck2, hpart2']⟩
/-- **Compatibility transfers across agreement on the saturated low-end crossed
negative-begin truncated nonclamping range.** -/
theorem compatible_of_agree_negCross_trunc_nonclamp_lowEndBig {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hge : 2 ≤ r.end_.offset)
(hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key))
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormNegCrossTruncNonclampLowEnd r res) 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 hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcr : closedFormNegCrossTruncNonclampLowEnd r res =
⟨r.end_.key, max r.begin.key (((keyAfter last : Key)) : WithTop Key)⟩ := by
unfold closedFormNegCrossTruncNonclampLowEnd
rw [hlastD]
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key) with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper :=
lt_of_lt_of_le hcross (le_max_left _ _)
have hlast_upper : ((last : Key) : WithTop Key) < upper :=
lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (keyAfter_self_lt last)) (le_max_right _ _)
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by rw [hhead]; exact hEhead
have hE_upper : r.end_.key < upper := lt_trans hEhead' hhead_upper
have hmem := (agreeOn_iff (closedFormNegCrossTruncNonclampLowEnd r res) db1 db2).mp hagree
have hmkE : ∀ k : Key, r.end_.key ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
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
exact hmkE k (le_trans (le_of_lt hEhead') hk1) hk2
obtain ⟨hL2, hpart2⟩ := begin_eq_head_and_window_of_agree_negCross_trunc_nonclamp
hrev hmore hne hbegin hcross hnonclamp_eq hc1 (fun k hk1 hk2 => hmk k hk1 (by simpa [hupper]
using hk2))
have hpart2' : db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) = res.keys := by
simpa [hhead, hlast] using hpart2
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hcnt1 : ((db1.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat :=
filter_length_le_offset_of_resolve_end_gt (db := db1) (by omega) hlt1
have hcnt_eq : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))) =
((db1.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr ((db2.sorted.pairwise.filter _).filter _)
· exact List.sortedLT_iff_pairwise.mpr ((db1.sorted.pairwise.filter _).filter _)
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨⟨hk2, hEk⟩, hklast⟩
exact ⟨⟨(hmkE k hEk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mpr hk2,
hEk⟩, hklast⟩
· rintro ⟨⟨hk1, hEk⟩, hklast⟩
exact ⟨⟨(hmkE k hEk (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hklast) hlast_upper)).mp hk1,
hEk⟩, hklast⟩
have hcnt2 : ((db2.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last))).length ≤ (r.end_.offset - 1).toNat := by
rw [hcnt_eq]; exact hcnt1
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ :=
resolve_end_gt_of_filter_length_le (db := db2) (by omega) hcnt2
have hck2 := completeKeys_filter_le_of_resolve_begin (db := db2) hrev hL2 hlt2
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, by rw [hck2, hpart2']⟩
/-- **Gap keys below the reported head are necessary in the saturated low-end cell.**
A key `k` with `end.key ≤ k < head` is necessary: building a witness with `n` gap keys in
`[end.key, head)` excluding `k` puts the begin anchor exactly at the reported head and
saturates the end offset. Toggling `k` on then overflows the end offset. -/
theorem necessary_negCross_trunc_between_end_head {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (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)
(hnonclamp_eq : reportedBelowBegin r res = beginSlack r + 1)
(hge : 2 ≤ r.end_.offset)
(hEhead : r.end_.key < ((res.keys.head hne : Key) : WithTop Key))
(hbig : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((res.keys.head hne : Key) : WithTop Key) +
(res.keys.length : ℕ∞))
(hkE : r.end_.key ≤ (k : WithTop Key))
(hkH : (k : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
set e1 : ℕ := (r.end_.offset - 1).toNat with he1
set rl : ℕ := res.keys.length with hrl
set n : ℕ := e1 - rl with hn
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by rw [hhead]; exact hcross
have hEhead' : r.end_.key < ((head : Key) : WithTop Key) := by rw [hhead]; exact hEhead
have hkH' : (k : WithTop Key) < ((head : Key) : WithTop Key) := by rw [hhead]; exact hkH
have hres_sorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
have hres_pair : res.keys.Pairwise (· ≤ ·) := hres_sorted.pairwise.imp le_of_lt
have hhead_le : ∀ x ∈ res.keys, head ≤ x := by
intro x hx
have := hres_pair.rel_head hx
simpa [hhead] using this
have hle_last : ∀ x ∈ res.keys, x ≤ last := by
intro x hx
have := hres_pair.rel_getLast hx
simpa [hlast] using this
have hlast_mem : last ∈ res.keys := by rw [hlast]; exact List.getLast_mem hne
have hhead_mem : head ∈ res.keys := by rw [hhead]; exact List.head_mem hne
have hhead_le_last : head ≤ last := hhead_le last hlast_mem
-- The reported length is bounded by the end offset.
have hlast_ck0 : last ∈ RangeRead.completeKeys db₀ r :=
(RangeRead.compatible_keys_prefix hcomp₀).subset hlast_mem
have hlt0 : ((last : Key) : WithTop Key) < resolve db₀ r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck0).2.2
have hcnt0 : ((db₀.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last))).length ≤ e1 := by
simpa [he1] using filter_length_le_offset_of_resolve_end_gt (db := db₀) (by omega) hlt0
have hres_sub : res.keys ⊆
((db₀.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last))) := by
intro x hx
have hxdb : x ∈ db₀.keys := RangeRead.compatible_keys_subset hcomp₀ hx
have hxE : r.end_.key ≤ (x : WithTop Key) :=
le_trans (le_of_lt hEhead') (WithTop.coe_le_coe.mpr (hhead_le x hx))
have hxl : x ≤ last := hle_last x hx
rw [List.mem_filter, List.mem_filter]
exact ⟨⟨hxdb, by simpa using hxE⟩, by simpa using hxl⟩
have hrle : rl ≤ e1 := by
have := hres_sorted.nodup.length_le_of_subset hres_sub
exact le_trans (by simpa [hrl] using this) hcnt0
have hbig' : (e1 : ℕ∞) < intervalCard r.end_.key ((head : Key) : WithTop Key) +
(rl : ℕ∞) := by
simpa [he1, hrl, hhead] using hbig
have hcard : ((n + 1 : ℕ) : ℕ∞) ≤
intervalCard r.end_.key ((head : Key) : WithTop Key) := by
by_cases htop : intervalCard r.end_.key ((head : Key) : WithTop Key) = (⊤ : ℕ∞)
· rw [htop]; exact le_top
· obtain ⟨G, hG⟩ := ENat.ne_top_iff_exists.mp htop
have hlt : e1 < G + rl := by
have hb := hbig'
rw [← hG] at hb
rw [← ENat.natCast_add] at hb
exact ENat.natCast_lt_natCast.mp hb
have hGle : n + 1 ≤ G := by
rw [hn]; omega
rw [← hG]
exact ENat.natCast_le_natCast.mpr hGle
obtain ⟨dbK, hKrange, hkK, hKlen⟩ :=
exists_db_keysIn_avoid (B := r.end_.key) (E := ((head : Key) : WithTop Key))
(k := k) (m := n) hcard
have hK_ge : ∀ x ∈ dbK.keys, r.end_.key ≤ (x : WithTop Key) :=
fun x hx => (hKrange x hx).1
have hK_lt : ∀ x ∈ dbK.keys, x < head :=
fun x hx => WithTop.coe_lt_coe.mp (hKrange x hx).2
-- The witness database.
have hsort_append : (dbK.keys ++ res.keys).SortedLT := by
refine List.sortedLT_append.mpr ⟨dbK.sorted, hres_sorted, ?_⟩
intro a ha b hb
exact lt_of_lt_of_le (hK_lt a ha) (hhead_le b hb)
let dbw : DB := ⟨dbK.keys ++ res.keys, hsort_append⟩
have hdbw : dbw.keys = dbK.keys ++ res.keys := rfl
have hk_notmem : k ∉ dbw.keys := by
rw [hdbw, List.mem_append]
rintro (hkK' | hkres)
· exact hkK hkK'
· exact absurd (hhead_le k hkres) (not_le.mpr (WithTop.coe_lt_coe.mp hkH'))
have hhead_dbw : head ∈ dbw.keys := by
rw [hdbw]; exact List.mem_append.mpr (Or.inr hhead_mem)
-- The begin selector resolves onto the reported head because the anchor is `n`.
have hcntB_dbw : cnt dbw r.begin.key = n + reportedBelowBegin r res := by
unfold cnt
rw [hdbw, List.countP_append]
have hKcount : dbK.keys.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
dbK.keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact lt_trans (WithTop.coe_lt_coe.mpr (hK_lt x hx)) hcross'
rw [hKcount, hKlen]
rfl
have hdbw_len : dbw.keys.length = n + rl := by
rw [hdbw, List.length_append, hKlen, hrl]
have hanchorB : r.begin.anchor dbw = (n : ℤ) := by
have hcountP : dbw.keys.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
n + reportedBelowBegin r res := by
simpa only [cnt] using hcntB_dbw
rw [anchor_eq_count_sub_slack dbw r (le_of_lt hbegin), hcountP, hnonclamp_eq]
push_cast; ring
have hanchorB_nonneg : 0 ≤ r.begin.anchor dbw := by
rw [hanchorB]; exact Int.natCast_nonneg n
have hltlenB : (r.begin.anchor dbw).toNat < dbw.keys.length := by
rw [hanchorB, Int.toNat_natCast, hdbw_len]
have hpos : 0 < rl := by rw [hrl]; exact List.length_pos_of_ne_nil hne
omega
have hltlenB_n : n < dbw.keys.length := by
rw [hanchorB, Int.toNat_natCast] at hltlenB
exact hltlenB
have hres_eq_head : res.keys = head :: res.keys.tail := by
rw [hhead]; exact (List.cons_head_tail hne).symm
have hsplitw : dbw.keys = dbK.keys ++ head :: res.keys.tail := by
rw [hdbw, hres_eq_head]
rfl
have hval_n : dbw.keys[n]'hltlenB_n = head := by
have := List.getElem_of_append (l := dbw.keys) (l₁ := dbK.keys) (a := head)
(l₂ := res.keys.tail) hsplitw hKlen
simpa using this
have hidx : (r.begin.anchor dbw).toNat = n := by
rw [hanchorB, Int.toNat_natCast]
have hresb : resolve dbw r.begin = ((head : Key) : WithTop Key) := by
rw [resolve_eq_getElem (db := dbw) (s := r.begin) hanchorB_nonneg hltlenB]
simp only [hidx]
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hval_n
have hmem_all_E : ∀ x ∈ dbw.keys, r.end_.key ≤ (x : WithTop Key) := by
intro x hx
rw [hdbw, List.mem_append] at hx
rcases hx with hx | hx
· exact hK_ge x hx
· exact le_trans (le_of_lt hEhead') (WithTop.coe_le_coe.mpr (hhead_le x hx))
have hcntE : dbw.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hmem_all_E x hx)
have hdbw_len_e1 : dbw.keys.length = e1 := by
rw [hdbw_len, hn]
exact Nat.sub_add_cancel hrle
have hanchorE : (r.end_.anchor dbw).toNat = e1 := by
rw [anchor_toNat_eq (db := dbw) (s := r.end_) (by omega), hcntE, ← he1]
omega
have hrestop : resolve dbw r.end_ = (⊤ : WithTop Key) := by
apply resolve_eq_top
· exact anchor_nonneg_of_one_le (db := dbw) (s := r.end_) (by omega)
· rw [hanchorE, hdbw_len_e1]
have hck : RangeRead.completeKeys dbw r = res.keys := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hresb, hrestop]
have hpred : (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < (⊤ : WithTop Key))) =
(fun x : Key => decide (((head : Key) : WithTop Key) ≤ (x : WithTop Key))) := by
funext x; simp
rw [hpred, hdbw, List.filter_append]
have hleft : dbK.keys.filter
(fun x : Key => decide (((head : Key) : WithTop Key) ≤ (x : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_le.mpr (WithTop.coe_lt_coe.mpr (hK_lt x hx))
have hright : res.keys.filter
(fun x : Key => decide (((head : Key) : WithTop Key) ≤ (x : WithTop Key))) = res.keys := by
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact WithTop.coe_le_coe.mpr (hhead_le x hx)
rw [hleft, hright, List.nil_append]
have hfilter_le : res.keys.filter (fun x : Key => decide (x ≤ last)) = res.keys := by
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact hle_last x hx
have hcompw : RangeRead.Compatible dbw r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hcomp₀.1, by rw [hck, hfilter_le]⟩
-- Toggling the target on overflows the end offset.
have hdb' : toggle dbw k = dbw.insert k hk_notmem := toggle_eq_insert_of_not_mem hk_notmem
have hkeys_toggle : (toggle dbw k).keys = dbw.keys.orderedInsert (· ≤ ·) k := by
rw [hdb', DB.insert_keys]
have hlen_toggle : (toggle dbw k).keys.length = e1 + 1 := by
rw [hkeys_toggle, List.orderedInsert_length, hdbw_len_e1]
have hmem_all : ∀ x ∈ (toggle dbw k).keys,
r.end_.key ≤ (x : WithTop Key) ∧ x ≤ last := by
intro x hx
rw [hkeys_toggle, List.mem_orderedInsert] at hx
rcases hx with rfl | hx
· exact ⟨hkE, le_trans (le_of_lt (WithTop.coe_lt_coe.mp hkH')) hhead_le_last⟩
· rw [hdbw, List.mem_append] at hx
rcases hx with hx | hx
· exact ⟨hK_ge x hx, le_trans (le_of_lt (hK_lt x hx)) hhead_le_last⟩
· exact ⟨le_trans (le_of_lt hEhead') (WithTop.coe_le_coe.mpr (hhead_le x hx)),
hle_last x hx⟩
have hcount_toggle :
((toggle dbw k).keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key)))).filter
(fun x : Key => decide (x ≤ last)) = (toggle dbw k).keys := by
have h1 : (toggle dbw k).keys.filter
(fun x : Key => decide (r.end_.key ≤ (x : WithTop Key))) = (toggle dbw k).keys := by
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact (hmem_all x hx).1
rw [h1]
apply List.filter_eq_self.mpr
intro x hx
rw [decide_eq_true_eq]
exact (hmem_all x hx).2
have hnot : ¬ RangeRead.Compatible (toggle dbw k) r res := by
intro hc
have hlast_ck : last ∈ RangeRead.completeKeys (toggle dbw k) r :=
(RangeRead.compatible_keys_prefix hc).subset hlast_mem
have hlt : ((last : Key) : WithTop Key) < resolve (toggle dbw k) r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck).2.2
have hcnt := filter_length_le_offset_of_resolve_end_gt (db := toggle dbw k) (by omega) hlt
rw [hcount_toggle, hlen_toggle, ← he1] at hcnt
omega
exact necessary_of_toggle ⟨dbw, hcompw, hnot⟩
/-- The forward, crossed, truncated, nonclamping negative-begin low-end cell with
positive end offset and the end key strictly below the reported head, in the branch
where the gap to the head absorbs the reported keys. -/
abbrev negCrossTruncNonclampLowEndSmall (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ 2 ≤ r.end_.offset ∧
r.end_.key < ((leastReported r res : Key) : WithTop Key) ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res = beginSlack r + 1 ∧
intervalCard r.end_.key ((leastReported r res : Key) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞)
/-- The forward, crossed, truncated, nonclamping negative-begin low-end cell with
positive end offset and the end key strictly below the reported head, in the saturated
branch. -/
abbrev negCrossTruncNonclampLowEndBig (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ 2 ≤ r.end_.offset ∧
r.end_.key < ((leastReported r res : Key) : WithTop Key) ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res = beginSlack r + 1 ∧
(((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((leastReported r res : Key) : WithTop Key) +
(res.keys.length : ℕ∞)
/-- **Closed form for the low-end absorbing branch.** The minimal range is
`[head, max begin.key (keyAfter last))`. -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_lowEndSmall {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampLowEndSmall r res) :
Minimal r res (closedFormNegCrossTruncNonclampTop r res) := by
obtain ⟨hmore, hrev, hbegin, hge, hEheadD, hcrossD, hnonclamp_eq, hsmallD⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross : ((head : Key) : WithTop Key) < r.begin.key := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hcrossD
exact hcrossD
have hEhead : r.end_.key < ((head : Key) : WithTop Key) := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hEheadD
exact hEheadD
have hsmall : intervalCard r.end_.key ((head : Key) : WithTop Key) +
(res.keys.length : ℕ∞) ≤ (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hsmallD
exact hsmallD
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key)
have hcr : closedFormNegCrossTruncNonclampTop r res =
⟨((head : Key) : WithTop Key), upper⟩ := by
unfold closedFormNegCrossTruncNonclampTop
rw [hheadD, hlastD]
have hsound : Sound r res (closedFormNegCrossTruncNonclampTop r res) := by
intro db1 db2 hagree
exact ⟨fun h => compatible_of_agree_negCross_trunc_nonclamp_lowEndSmall hrev hmore hne hbegin
hge hEhead hcross hnonclamp_eq hsmall h hagree,
fun h => compatible_of_agree_negCross_trunc_nonclamp_lowEndSmall hrev hmore hne hbegin
hge hEhead hcross hnonclamp_eq hsmall h hagree.symm⟩
rw [hcr] at hsound ⊢
refine (minimal_iff_sound_and_necessaryRange).mpr ⟨hsound, ?_⟩
intro k hkbeg hkend
by_cases hkle : k ≤ last
· exact necessary_of_between_result hread' (by rw [hhead]; exact List.head_mem hne)
(by rw [hlast]; exact List.getLast_mem hne) (WithTop.coe_le_coe.mp hkbeg) hkle
· have hkgt : res.keys.getLast hne < k := by
simpa [hlast] using lt_of_not_ge hkle
have hkltB : (k : WithTop Key) < r.begin.key := by
have hkmax : (k : WithTop Key) <
max r.begin.key (((keyAfter last : Key)) : WithTop Key) := hkend
rcases lt_max_iff.mp hkmax with h | h
· exact h
· have hklast : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp h)
exact absurd hklast hkle
exact necessary_negCross_trunc_gap_general hread' hrev hmore hne hbegin hcross
hnonclamp_eq hkgt hkltB
/-- **Closed form for the saturated low-end branch.** The minimal range is
`[end.key, max begin.key (keyAfter last))`. -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_lowEndBig {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncNonclampLowEndBig r res) :
Minimal r res (closedFormNegCrossTruncNonclampLowEnd r res) := by
obtain ⟨hmore, hrev, hbegin, hge, hEheadD, hcrossD, hnonclamp_eq, hbigD⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross : ((head : Key) : WithTop Key) < r.begin.key := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hcrossD
exact hcrossD
have hEhead : r.end_.key < ((head : Key) : WithTop Key) := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hEheadD
exact hEheadD
have hbig : (((r.end_.offset - 1).toNat : ℕ) : ℕ∞) <
intervalCard r.end_.key ((head : Key) : WithTop Key) + (res.keys.length : ℕ∞) := by
have hle : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hle, hheadD] at hbigD
exact hbigD
set upper : WithTop Key := max r.begin.key (((keyAfter last : Key)) : WithTop Key)
have hcr : closedFormNegCrossTruncNonclampLowEnd r res =
⟨r.end_.key, upper⟩ := by
unfold closedFormNegCrossTruncNonclampLowEnd
rw [hlastD]
have hsound : Sound r res (closedFormNegCrossTruncNonclampLowEnd r res) := by
intro db1 db2 hagree
exact ⟨fun h => compatible_of_agree_negCross_trunc_nonclamp_lowEndBig hrev hmore hne hbegin
hge hEhead hcross hnonclamp_eq h hagree,
fun h => compatible_of_agree_negCross_trunc_nonclamp_lowEndBig hrev hmore hne hbegin
hge hEhead hcross hnonclamp_eq h hagree.symm⟩
rw [hcr] at hsound ⊢
refine (minimal_iff_sound_and_necessaryRange).mpr ⟨hsound, ?_⟩
intro k hkbeg hkend
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread' (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread' (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· by_cases hkhead : k < head
· exact necessary_negCross_trunc_between_end_head hread' hrev hmore hne hbegin hcross
hnonclamp_eq hge hEhead hbig hkbeg (WithTop.coe_lt_coe.mpr hkhead)
· exact Necessary.of_between hhead_nec hlast_nec (le_of_not_gt hkhead) hkle
· have hkgt : res.keys.getLast hne < k := by
simpa [hlast] using lt_of_not_ge hkle
have hkltB : (k : WithTop Key) < r.begin.key := by
have hkmax : (k : WithTop Key) <
max r.begin.key (((keyAfter last : Key)) : WithTop Key) := hkend
rcases lt_max_iff.mp hkmax with h | h
· exact h
· have hklast : k ≤ last := (lt_keyAfter_iff k last).mp (WithTop.coe_lt_coe.mp h)
exact absurd hklast hkle
exact necessary_negCross_trunc_gap_general hread' hrev hmore hne hbegin hcross
hnonclamp_eq hkgt hkltB
end FormalConflictRange