Files
conflict-range/FormalConflictRange/NegCrossClampLongNonpos.lean
T
andrew a54a5f82f8 Prove conflict-range closed-form minimality
- Vendor the FormalConflictRange reference library needed by the proof
- Add Bridge.lean with simp lemmas connecting the Statement definitions
  to the reference library
- Prove Statement.closedFormMinimal in Proof.lean
- Register the new libraries in the Lake config
2026-11-16 21:53:59 -05:00

1475 lines
74 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.NegCrossLongNonpos
/-!
# The crossed negative-begin complete long clamp cell at a nonpositive end offset
A forward complete result with `end_.key < begin.key`, a negative begin offset and
`end.offset ≤ 0`, where the begin selector clamps. Unlike the short case, the gap
`[end_.key, begin.key)` lies *above* the end key, so agreement below `end_.key` does not
fix the gap. A compatible database stores `P` gap keys; the begin anchor is `P - C`
(with `C = beginSlack - reportedBelowBegin - clampNonposD`), so compatibility forces
`P ≤ C`. The upper endpoint of the minimal range is `end_.key` when no compatible
database can fill the gap (`cap < C`, or `cap = C` with the reported head at the empty
key), and `begin.key` otherwise.
-/
namespace FormalConflictRange
/-- The capacity slack `C = beginSlack - reportedBelowBegin - clampNonposD` of the
crossed negative-begin complete long clamp cell. -/
def clampLongC (r : RangeRead) (res : Result) : ℕ :=
beginSlack r - reportedBelowBegin r res - clampNonposD r
/-- The capacity `[end_.key, begin.key)` of the gap above the end key. -/
def clampLongCap (r : RangeRead) : ℕ∞ :=
intervalCard r.end_.key r.begin.key
/-- The upper endpoint of the crossed negative-begin complete long clamp cell. -/
noncomputable def clampLongUpper (r : RangeRead) (res : Result) : WithTop Key :=
if clampLongCap r < (clampLongC r res : ℕ∞) ∨
(clampLongCap r = (clampLongC r res : ℕ∞) ∧ res.keys.headD ([] : Key) = [])
then r.end_.key else r.begin.key
/-- The crossed negative-begin complete long clamp cell at `end.offset ≤ 0`. -/
abbrev negCrossClampLongNonpos (r : RangeRead) (res : Result) : Prop :=
r.reverse = false ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
r.end_.offset ≤ 0 ∧
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res ≤ beginSlack r ∧ clampNonposBottom r res ∧
r.end_.key < r.begin.key
/-- The closed form for the crossed negative-begin complete long clamp cell. -/
noncomputable def closedFormNegCrossClampLongNonpos (r : RangeRead) (res : Result) :
ConflictRange :=
⟨(([] : Key) : WithTop Key), clampLongUpper r res⟩
section Structural
variable {r : RangeRead} {res : Result}
theorem clampLong_headD_eq {hne : res.keys ≠ []} :
res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
/-- Every reported key lies below `end_.key` in the crossed negative-begin complete
long clamp cell. -/
theorem clampLong_reported_lt_end (hread : Readable r res)
(hrev : r.reverse = false) (hmore : res.more = false) (hend : r.end_.offset ≤ 0) :
∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key := by
obtain ⟨db, hcomp⟩ := hread
have hres_eq : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
intro k hk
have hklt := (RangeRead.mem_completeKeys.mp (by rw [← hres_eq]; exact hk)).2.2
exact lt_of_lt_of_le hklt (resolve_le_key_of_offset_nonpos hend)
theorem clampLong_reported_eq_length (hread : Readable r res)
(hcell : negCrossClampLongNonpos r res) :
reportedBelowBegin r res = res.keys.length := by
obtain ⟨hrev, -, hmore, -, hend, -, -, -, hlong⟩ := hcell
unfold reportedBelowBegin
rw [List.countP_eq_length]
intro k hk
rw [decide_eq_true_eq]
exact lt_trans (clampLong_reported_lt_end hread hrev hmore hend k hk) hlong
theorem clampLong_nat_bottom (hcell : negCrossClampLongNonpos r res) :
reportedBelowBegin r res + (clampNonposD r + 1) ≤ beginSlack r := by
obtain ⟨-, -, -, -, -, -, -, hbottom, hlong⟩ := hcell
have hcap0 : intervalCard r.begin.key r.end_.key = 0 :=
intervalCard_eq_zero_of_le (le_of_lt hlong)
have h := hbottom
unfold clampNonposBottom at h
rw [hcap0] at h
have h' : ((reportedBelowBegin r res + (clampNonposD r + 1) : ℕ) : ℕ∞) ≤
(beginSlack r : ℕ∞) := by
simpa [ENat.natCast_add, add_assoc] using h
exact ENat.natCast_le_natCast.mp h'
theorem clampLong_C_pos (hcell : negCrossClampLongNonpos r res) :
0 < clampLongC r res := by
have hnat := clampLong_nat_bottom hcell
unfold clampLongC
omega
/-- The complete window of a compatible database is the half-open interval between the
resolutions. -/
theorem clampLong_complete_eq_between {db : DB} (hcomp : RangeRead.Compatible db r res)
(hrev : r.reverse = false) (hmore : res.more = false) :
res.keys = between db (resolve db r.begin) (resolve db r.end_) := by
have hres_eq : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
rw [hres_eq, RangeRead.completeKeys, ite_eq_right (by simp [hrev])]
unfold RangeRead.inRange between
rfl
/-- The begin anchor in terms of the gap count, once the count below the begin
resolution is known. -/
theorem clampLong_anchor_eq {db : DB} (hread : Readable r res)
(hcell : negCrossClampLongNonpos r res) (hcomp : RangeRead.Compatible db r res)
{b : ℕ} (hb : cnt db (resolve db r.begin) = b) :
r.begin.anchor db =
(b : ℤ) + ((between db r.end_.key r.begin.key).length : ℤ) -
(clampLongC r res : ℤ) := by
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, -, -, -, hlong⟩ := hcell
have hresb := clampLong_complete_eq_between hcomp hrev hmore
have hle : resolve db r.begin ≤ resolve db r.end_ := by
obtain ⟨k, hk⟩ := List.exists_mem_of_ne_nil _ hne
have hk' : k ∈ between db (resolve db r.begin) (resolve db r.end_) := hresb ▸ hk
unfold between at hk'
rw [List.mem_filter] at hk'
rcases (of_decide_eq_true hk'.2) with ⟨h1, h2⟩
exact le_of_lt (lt_of_le_of_lt h1 h2)
have ht : (between db (resolve db r.begin) (resolve db r.end_)).length = res.keys.length := by
rw [← hresb]
have hcntR : cnt db (resolve db r.end_) = b + res.keys.length := by
have h := cnt_eq_add_between db hle
rw [hb, ht] at h
omega
have hRle : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
have hhead : res.keys.head hne ∈ between db (resolve db r.begin) (resolve db r.end_) :=
hresb ▸ List.head_mem hne
unfold between at hhead
rw [List.mem_filter] at hhead
rw [hR] at hhead
exact absurd (of_decide_eq_true hhead.2).2
(not_lt.mpr (coe_nil_le_key_withTop (res.keys.head hne)))
have hd : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 :=
between_resolve_end_length hend hRne
have hcntE : cnt db r.end_.key = b + res.keys.length + (clampNonposD r + 1) := by
have h := cnt_eq_add_between db hRle
rw [hcntR, hd] at h
omega
have hEB : r.end_.key ≤ r.begin.key := le_of_lt hlong
have hcntB : cnt db r.begin.key =
b + res.keys.length + (clampNonposD r + 1) +
(between db r.end_.key r.begin.key).length := by
have h := cnt_eq_add_between db hEB
rw [hcntE] at h
omega
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin)]
have hcntB' : db.keys.countP
(fun k => decide (((k : Key) : WithTop Key) < r.begin.key)) =
b + res.keys.length + (clampNonposD r + 1) +
(between db r.end_.key r.begin.key).length := by
simpa [cnt] using hcntB
rw [hcntB']
have hrep : reportedBelowBegin r res = res.keys.length :=
clampLong_reported_eq_length hread hcell_keep
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
rw [← hrep]
exact clampLong_nat_bottom hcell_keep
have hC : (clampLongC r res : ℤ) =
(beginSlack r : ℤ) - (res.keys.length : ℤ) - (clampNonposD r : ℤ) := by
unfold clampLongC
rw [hrep]
omega
rw [hC]
push_cast
ring
/-- In the long clamp cell the gap count equals the capacity slack for any compatible
database with a nonnegative begin anchor. Such a database is nonclamping, resolves the
begin selector onto the reported head, and its anchor is exactly the number of stored
keys below that head; the anchor identity then forces the gap count to `C`. -/
theorem clampLong_P_eq_C_of_anchor_nonneg {db : DB} (hread : Readable r res)
(hcell : negCrossClampLongNonpos r res) (hcomp : RangeRead.Compatible db r res)
(hanchor : 0 ≤ r.begin.anchor db) :
(between db r.end_.key r.begin.key).length = clampLongC r res := by
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, -, -, -, -, -⟩ := hcell
set head : Key := res.keys.head hne with hhead
have hL : resolve db r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_anchor_nonneg hcomp hrev hmore hne hanchor
have hnot_top : resolve db r.begin ≠ (⊤ : WithTop Key) := by
rw [hL]; exact WithTop.coe_ne_top
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
by_contra h
exact hnot_top (resolve_eq_top hanchor (le_of_not_gt h))
have hget := resolve_eq_getElem (db := db) (s := r.begin) hanchor hltlen
have hidx : db.keys[(r.begin.anchor db).toNat] = head := by
have hcoe : ((db.keys[(r.begin.anchor db).toNat] : Key) : WithTop Key) =
((head : Key) : WithTop Key) := by rw [← hget, hL]
exact WithTop.coe_injective hcoe
have hrank : db.keys.countP (fun k => decide (k < head)) = (r.begin.anchor db).toNat :=
countP_lt_eq_of_getElem db.sorted hltlen hidx
have hb : cnt db (resolve db r.begin) = (r.begin.anchor db).toNat := by
rw [hL]
unfold cnt
simpa using hrank
have hEq := clampLong_anchor_eq hread hcell_keep hcomp hb
have hEq' : (r.begin.anchor db : ℤ) =
((r.begin.anchor db).toNat : ℤ) +
((between db r.end_.key r.begin.key).length : ℤ) -
(clampLongC r res : ℤ) := hEq
rw [Int.toNat_of_nonneg hanchor] at hEq'
have hP : ((between db r.end_.key r.begin.key).length : ℤ) = (clampLongC r res : ℤ) := by
omega
exact_mod_cast hP
/-- In the long clamp cell a compatible database clamps exactly when its gap count is
below the capacity slack `C`. -/
theorem clampLong_anchor_neg_iff {db : DB} (hread : Readable r res)
(hcell : negCrossClampLongNonpos r res) (hcomp : RangeRead.Compatible db r res) :
r.begin.anchor db < 0 ↔ (between db r.end_.key r.begin.key).length < clampLongC r res := by
constructor
· intro hneg
have hb : cnt db (resolve db r.begin) = 0 := by
rw [resolve_eq_nil hneg]; exact cnt_nil db
have hEq := clampLong_anchor_eq hread hcell hcomp hb
have hEq' : (r.begin.anchor db : ℤ) =
(0 : ℤ) + ((between db r.end_.key r.begin.key).length : ℤ) -
(clampLongC r res : ℤ) := hEq
have : ((between db r.end_.key r.begin.key).length : ℤ) < (clampLongC r res : ℤ) := by
omega
exact_mod_cast this
· intro hP
by_contra hcon
have hanchor : 0 ≤ r.begin.anchor db := le_of_not_gt hcon
have hEq := clampLong_P_eq_C_of_anchor_nonneg hread hcell hcomp hanchor
omega
/-- **A clamping compatible database exists in the long clamp cell.** Take the reported
keys and the `d + 1` pads that any compatible database stores in
`[resolve end, end_.key)`; no gap keys are stored, so the begin anchor is `-C < 0`. -/
theorem exists_clampLong_db {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res) :
∃ db : DB, RangeRead.Compatible db r res ∧ r.begin.anchor db < 0 := by
have hread_keep : Readable r res := hread
obtain ⟨db₀, hcomp₀⟩ := hread
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hlim : RangeRead.withinLimit r res.keys := hcomp₀.1
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
have hres_eq₀ : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hlast_lt_R₀ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₀ r.end_ :=
(RangeRead.mem_completeKeys.mp (by rw [← hres_eq₀]; exact List.getLast_mem hne)).2.2
have hR_ne_nil : resolve db₀ r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hbot
rw [hbot] at hlast_lt_R₀
exact absurd hlast_lt_R₀ (not_lt.mpr (coe_nil_le_key_withTop _))
set L : List Key := between db₀ (resolve db₀ r.end_) r.end_.key with hLdef
have hLlen : L.length = clampNonposD r + 1 := by
rw [hLdef]; exact between_resolve_end_length hend hR_ne_nil
have hLne : L ≠ [] := by rw [← List.length_pos_iff, hLlen]; omega
have hLsorted : L.SortedLT :=
List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _)
have hLmem : ∀ x ∈ L, resolve db₀ r.end_ ≤ ((x : Key) : WithTop Key) ∧
((x : Key) : WithTop Key) < r.end_.key := by
intro x hx
rw [hLdef] at hx
exact of_decide_eq_true (List.mem_filter.mp hx).2
have hlast_le : ∀ x ∈ res.keys, x ≤ res.keys.getLast hne :=
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
have hres_lt_L : ∀ x ∈ res.keys, ∀ y ∈ L, x < y := by
intro x hx y hy
have hxle : ((x : Key) : WithTop Key) ≤ ((res.keys.getLast hne : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr (hlast_le x hx)
exact WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (lt_of_le_of_lt hxle hlast_lt_R₀) (hLmem y hy).1)
have hAppSorted : (res.keys ++ L).SortedLT :=
List.sortedLT_append.mpr ⟨hsort, hLsorted, hres_lt_L⟩
set db : DB := ⟨res.keys ++ L, hAppSorted⟩ with hdb
have hrep : reportedBelowBegin r res = res.keys.length :=
clampLong_reported_eq_length hread_keep ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq,
hbottom, hlong⟩
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
rw [← hrep]
exact clampLong_nat_bottom ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩
have hslack : beginSlack r = res.keys.length + clampLongC r res + clampNonposD r := by
unfold clampLongC
rw [hrep]
omega
have hR_lt_E : resolve db₀ r.end_ < r.end_.key :=
lt_of_le_of_lt (hLmem _ (List.head_mem hLne)).1 (hLmem _ (List.head_mem hLne)).2
have hdcast : (clampNonposD r : ℤ) = -r.end_.offset := by
rw [clampNonposD_eq]
rw [Int.toNat_of_nonneg (show (0 : ℤ) ≤ -r.end_.offset by omega)]
have hslackcast : (beginSlack r : ℤ) = -r.begin.offset := by
unfold beginSlack
rw [Int.toNat_of_nonneg (show (0 : ℤ) ≤ 0 - r.begin.offset by omega)]
ring
have hcntE : cnt db r.end_.key = res.keys.length + (clampNonposD r + 1) := by
unfold cnt
rw [List.countP_eq_length_filter]
have hdbk : db.keys = res.keys ++ L := by rw [hdb]
rw [hdbk]
have hf : (res.keys ++ L).filter
(fun k : Key => decide (((k : Key) : WithTop Key) < r.end_.key)) = res.keys ++ L := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rcases List.mem_append.mp hx with hx | hx
· exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hlast_le x hx))
(lt_trans hlast_lt_R₀ hR_lt_E)
· exact (hLmem x hx).2
rw [hf, List.length_append, hLlen]
have hcntB : cnt db r.begin.key = res.keys.length + (clampNonposD r + 1) := by
unfold cnt
rw [List.countP_eq_length_filter]
have hdbk : db.keys = res.keys ++ L := by rw [hdb]
rw [hdbk]
have hf : (res.keys ++ L).filter
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = res.keys ++ L := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rcases List.mem_append.mp hx with hx | hx
· exact lt_trans (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hlast_le x hx))
(lt_trans hlast_lt_R₀ hR_lt_E)) hlong
· exact lt_trans (hLmem x hx).2 hlong
rw [hf, List.length_append, hLlen]
have hanchorE : r.end_.anchor db = (res.keys.length : ℤ) := by
unfold Selector.anchor
have hc : db.keys.countP (fun k => decide (((k : Key) : WithTop Key) < r.end_.key)) =
res.keys.length + (clampNonposD r + 1) := by simpa [cnt] using hcntE
rw [hc]
push_cast
rw [hdcast]
ring
have hanchorE_nonneg : 0 ≤ r.end_.anchor db := by rw [hanchorE]; exact Int.natCast_nonneg _
have htoNatE : (r.end_.anchor db).toNat = res.keys.length := by
rw [hanchorE, Int.toNat_natCast]
have hltlenE : (r.end_.anchor db).toNat < db.keys.length := by
rw [htoNatE, hdb]
simp only [List.length_append]
omega
have hdbk : db.keys = res.keys ++ L := by rw [hdb]
have hRE : resolve db r.end_ = ((L.head hLne : Key) : WithTop Key) := by
rw [resolve_eq_getElem hanchorE_nonneg (by rw [htoNatE, hdbk]; simp only [List.length_append]; omega)]
simp only [htoNatE, hdbk]
rw [List.getElem_append_right (show res.keys.length ≤ res.keys.length by omega)]
simp [List.head_eq_getElem]
have hanchorB : r.begin.anchor db < 0 := by
unfold Selector.anchor
have hc : db.keys.countP (fun k => decide (((k : Key) : WithTop Key) < r.begin.key)) =
res.keys.length + (clampNonposD r + 1) := by simpa [cnt] using hcntB
rw [hc]
have hCpos : 0 < clampLongC r res :=
clampLong_C_pos ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩
have hbo : (r.begin.offset : ℤ) = -((res.keys.length + clampLongC r res +
clampNonposD r : ℕ) : ℤ) := by
omega
rw [hbo]
push_cast
omega
have hLB : resolve db r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hanchorB
have hcomplete : res.keys = RangeRead.completeKeys db r := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hLB, hRE, hdbk]
have hf : (res.keys ++ L).filter (fun k : Key => decide
((([] : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) :
WithTop Key))) = res.keys := by
rw [List.filter_append]
have h1 : res.keys.filter (fun k : Key => decide
((([] : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) :
WithTop Key))) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
refine ⟨coe_nil_le_key_withTop x, ?_⟩
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr (hres_lt_L x hx _
(List.head_mem _))) le_rfl
have h2 : L.filter (fun k : Key => decide
((([] : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) :
WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
simp only [decide_eq_true_eq, not_and]
intro _
exact not_lt.mpr (WithTop.coe_le_coe.mpr
((hLsorted.pairwise.imp le_of_lt).rel_head hx))
rw [h1, h2, List.append_nil]
rw [hf]
exact ⟨db, ⟨hlim, Or.inr ⟨hmore, hcomplete⟩⟩, hanchorB⟩
/-- **A compatible database with prescribed below-head keys and gap keys.** Given a
sorted list `H` of keys below the reported head and a sorted list `G` of gap keys in
`[end_.key, begin.key)` of length exactly the capacity slack `C`, the concatenation
`H ++ reported ++ pads ++ G` (with the pads coming from any compatible database) is
compatible. Its begin anchor is `H.length`, so it resolves onto the reported head. -/
theorem exists_long_compat_db {r : RangeRead} {res : Result} {db₀ : DB}
(hcomp₀ : RangeRead.Compatible db₀ r res)
(hcell : negCrossClampLongNonpos r res)
(H G : List Key)
(hHsorted : H.SortedLT)
(hHlt : ∀ x ∈ H, x < res.keys.headD ([] : Key))
(hGsorted : G.SortedLT)
(hGlo : ∀ x ∈ G, r.end_.key ≤ ((x : Key) : WithTop Key))
(hGhi : ∀ x ∈ G, ((x : Key) : WithTop Key) < r.begin.key)
(hGlen : G.length = clampLongC r res) :
∃ db : DB, RangeRead.Compatible db r res ∧
db.keys = H ++ res.keys ++ between db₀ (resolve db₀ r.end_) r.end_.key ++ G := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hlim : RangeRead.withinLimit r res.keys := hcomp₀.1
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
have hres_eq₀ : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hlast_lt_R₀ : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db₀ r.end_ :=
(RangeRead.mem_completeKeys.mp (by rw [← hres_eq₀]; exact List.getLast_mem hne)).2.2
have hR_ne_nil : resolve db₀ r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hbot
rw [hbot] at hlast_lt_R₀
exact absurd hlast_lt_R₀ (not_lt.mpr (coe_nil_le_key_withTop _))
have hR_le_E : resolve db₀ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
set L : List Key := between db₀ (resolve db₀ r.end_) r.end_.key with hLdef
have hLlen : L.length = clampNonposD r + 1 := by
rw [hLdef]; exact between_resolve_end_length hend hR_ne_nil
have hLne : L ≠ [] := by rw [← List.length_pos_iff, hLlen]; omega
have hLsorted : L.SortedLT :=
List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _)
have hLmem : ∀ x ∈ L, resolve db₀ r.end_ ≤ ((x : Key) : WithTop Key) ∧
((x : Key) : WithTop Key) < r.end_.key := by
intro x hx
rw [hLdef] at hx
exact of_decide_eq_true (List.mem_filter.mp hx).2
have hlast_le : ∀ x ∈ res.keys, x ≤ res.keys.getLast hne :=
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
have hheadD_eq : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hhead_le : ∀ x ∈ res.keys, res.keys.head hne ≤ x :=
fun x hx => (hsort.pairwise.imp le_of_lt).rel_head hx
have hhead_lt_R : ((res.keys.head hne : Key) : WithTop Key) < resolve db₀ r.end_ :=
lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hhead_le _ (List.getLast_mem hne)))
hlast_lt_R₀
have hhead_lt_E : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key :=
lt_of_lt_of_le hhead_lt_R hR_le_E
have hHlt' : ∀ x ∈ H, x < res.keys.head hne := by
intro x hx
have := hHlt x hx
rwa [hheadD_eq] at this
have hHltE : ∀ x ∈ H, ((x : Key) : WithTop Key) < r.end_.key := by
intro x hx
exact lt_trans (WithTop.coe_lt_coe.mpr (hHlt' x hx)) hhead_lt_E
have hres_lt_L : ∀ x ∈ res.keys, ∀ y ∈ L, x < y := by
intro x hx y hy
exact WithTop.coe_lt_coe.mp
(lt_of_lt_of_le (lt_of_le_of_lt
(WithTop.coe_le_coe.mpr (hlast_le x hx)) hlast_lt_R₀) (hLmem y hy).1)
have hH_lt_res : ∀ x ∈ H, ∀ y ∈ res.keys, x < y := by
intro x hx y hy
exact lt_of_lt_of_le (hHlt' x hx) (hhead_le y hy)
have hHsorted_res : (H ++ res.keys).SortedLT :=
List.sortedLT_append.mpr ⟨hHsorted, hsort, hH_lt_res⟩
have hA_lt_L : ∀ x ∈ H ++ res.keys, ∀ y ∈ L, x < y := by
intro x hx y hy
rcases List.mem_append.mp hx with hx | hx
· exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le
(lt_trans (WithTop.coe_lt_coe.mpr (hHlt' x hx)) hhead_lt_R) (hLmem y hy).1)
· exact hres_lt_L x hx y hy
have hB_sorted : ((H ++ res.keys) ++ L).SortedLT :=
List.sortedLT_append.mpr ⟨hHsorted_res, hLsorted, hA_lt_L⟩
have hB_lt_G : ∀ x ∈ (H ++ res.keys) ++ L, ∀ y ∈ G, x < y := by
intro x hx y hy
have hyE := hGlo y hy
rcases List.mem_append.mp hx with hx | hx
· rcases List.mem_append.mp hx with hx | hx
· exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltE x hx) hyE)
· exact WithTop.coe_lt_coe.mp (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hlast_le x hx))
(lt_of_lt_of_le hlast_lt_R₀ (le_trans hR_le_E hyE)))
· exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hLmem x hx).2 hyE)
have hAppSorted : (((H ++ res.keys) ++ L) ++ G).SortedLT :=
List.sortedLT_append.mpr ⟨hB_sorted, hGsorted, hB_lt_G⟩
set B : List Key := (H ++ res.keys) ++ L with hBdef
set db : DB := ⟨B ++ G, hAppSorted⟩ with hdb
have hdbk : db.keys = B ++ G := by rw [hdb]
have hrep : reportedBelowBegin r res = res.keys.length :=
clampLong_reported_eq_length ⟨db₀, hcomp₀⟩
⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
rw [← hrep]
exact clampLong_nat_bottom ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩
have hslack : beginSlack r = res.keys.length + clampLongC r res + clampNonposD r := by
unfold clampLongC
rw [hrep]
omega
have hdcast : (clampNonposD r : ℤ) = -r.end_.offset := by
rw [clampNonposD_eq]
rw [Int.toNat_of_nonneg (show (0 : ℤ) ≤ -r.end_.offset by omega)]
have hslackcast : (beginSlack r : ℤ) = -r.begin.offset := by
unfold beginSlack
rw [Int.toNat_of_nonneg (show (0 : ℤ) ≤ 0 - r.begin.offset by omega)]
ring
have hBlength : B.length = H.length + res.keys.length + (clampNonposD r + 1) := by
rw [hBdef]
simp only [List.length_append]
rw [hLlen]
have hcntE : cnt db r.end_.key = B.length := by
unfold cnt
rw [List.countP_eq_length_filter, hdbk]
have hBf : B.filter (fun k : Key => decide (((k : Key) : WithTop Key) < r.end_.key)) = B := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rw [hBdef] at hx
rcases List.mem_append.mp hx with hx | hx
· rcases List.mem_append.mp hx with hx | hx
· exact hHltE x hx
· exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hlast_le x hx))
(lt_of_lt_of_le hlast_lt_R₀ hR_le_E)
· exact (hLmem x hx).2
have hGf : G.filter (fun k : Key => decide (((k : Key) : WithTop Key) < r.end_.key)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hGlo x hx)
rw [List.filter_append, hBf, hGf, List.append_nil]
have hcntB : cnt db r.begin.key = B.length + G.length := by
unfold cnt
rw [List.countP_eq_length_filter, hdbk]
have hBf : B.filter (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = B := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rw [hBdef] at hx
rcases List.mem_append.mp hx with hx | hx
· rcases List.mem_append.mp hx with hx | hx
· exact lt_trans (hHltE x hx) hlong
· exact lt_trans (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hlast_le x hx))
(lt_of_lt_of_le hlast_lt_R₀ hR_le_E)) hlong
· exact lt_trans (hLmem x hx).2 hlong
have hGf : G.filter (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) = G := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact hGhi x hx
rw [List.filter_append, hBf, hGf, List.length_append]
have hanchorE : r.end_.anchor db = ((H.length + res.keys.length : ℕ) : ℤ) := by
unfold Selector.anchor
have hc : db.keys.countP (fun k => decide (((k : Key) : WithTop Key) < r.end_.key)) = B.length := by
simpa [cnt] using hcntE
rw [hc, hBlength]
push_cast
rw [hdcast]
ring
have htoNatE : (r.end_.anchor db).toNat = H.length + res.keys.length := by
rw [hanchorE]
exact Int.toNat_natCast _
have hanchorE_nonneg : 0 ≤ r.end_.anchor db := by rw [hanchorE]; exact Int.natCast_nonneg _
have hltlenE : (r.end_.anchor db).toNat < db.keys.length := by
rw [htoNatE, hdbk, List.length_append, hBlength]; omega
have hgetE : db.keys[(r.end_.anchor db).toNat]? = some (L.head hLne) := by
rw [htoNatE, hdbk]
rw [List.getElem?_append_left (show H.length + res.keys.length < B.length by
rw [hBlength]; omega)]
rw [hBdef]
rw [List.getElem?_append_right (show (H ++ res.keys).length ≤ H.length + res.keys.length by
simp)]
have hsub : H.length + res.keys.length - (H ++ res.keys).length = 0 := by simp
rw [hsub]
simp [List.head_eq_getElem]
have hvalE : db.keys[(r.end_.anchor db).toNat]'(hltlenE) = L.head hLne := by
apply Option.some.inj
rw [← List.getElem?_eq_getElem (h := hltlenE)]
exact hgetE
have hRE : resolve db r.end_ = ((L.head hLne : Key) : WithTop Key) := by
rw [resolve_eq_getElem hanchorE_nonneg hltlenE]
exact congrArg (fun z => ((z : Key) : WithTop Key)) hvalE
have hanchorB : r.begin.anchor db = ((H.length : ℕ) : ℤ) := by
unfold Selector.anchor
have hc : db.keys.countP (fun k => decide (((k : Key) : WithTop Key) < r.begin.key)) =
B.length + G.length := by simpa [cnt] using hcntB
rw [hc]
have hbo : (r.begin.offset : ℤ) = -((res.keys.length + clampLongC r res +
clampNonposD r : ℕ) : ℤ) := by omega
rw [hbo, hBlength, hGlen]
push_cast
ring
have hltlenB : (r.begin.anchor db).toNat < db.keys.length := by
rw [hanchorB, Int.toNat_natCast, hdbk, List.length_append, hBlength]; omega
have hgetB : db.keys[(r.begin.anchor db).toNat]? = some (res.keys.head hne) := by
rw [hanchorB, Int.toNat_natCast, hdbk]
rw [List.getElem?_append_left (show H.length < B.length by rw [hBlength]; omega)]
rw [hBdef]
rw [List.getElem?_append_left (show H.length < (H ++ res.keys).length by
rw [List.length_append]; have := List.length_pos_of_ne_nil hne; omega)]
rw [List.getElem?_append_right (show H.length ≤ H.length by omega)]
rw [show H.length - H.length = 0 by omega]
rw [List.getElem?_eq_getElem (h := List.length_pos_iff.mpr hne)]
exact congrArg some (List.head_eq_getElem hne).symm
have hvalB : db.keys[(r.begin.anchor db).toNat]'(hltlenB) = res.keys.head hne := by
apply Option.some.inj
rw [← List.getElem?_eq_getElem (h := hltlenB)]
exact hgetB
have hLB : resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
rw [resolve_eq_getElem (by rw [hanchorB]; exact Int.natCast_nonneg _) hltlenB]
exact congrArg (fun z => ((z : Key) : WithTop Key)) hvalB
have hcomplete : res.keys = RangeRead.completeKeys db r := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hLB, hRE, hdbk]
have hf : (B ++ G).filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) : WithTop Key))) = res.keys := by
rw [hBdef]
rw [List.filter_append, List.filter_append, List.filter_append]
have hHf : H.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
intro h
exact not_le.mpr (hHlt' x hx) (WithTop.coe_le_coe.mp h.1)
have hresf : res.keys.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) : WithTop Key))) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact ⟨WithTop.coe_le_coe.mpr (hhead_le x hx),
WithTop.coe_lt_coe.mpr (hres_lt_L x hx _ (List.head_mem hLne))⟩
have hLf : L.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_and.mpr (fun _ => not_lt.mpr (WithTop.coe_le_coe.mpr
((hLsorted.pairwise.imp le_of_lt).rel_head hx)))
have hGf : G.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < ((L.head hLne : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_and.mpr (fun _ => not_lt.mpr
(le_trans (le_of_lt (hLmem _ (List.head_mem hLne)).2) (hGlo x hx)))
rw [hHf, hresf, hLf, hGf]
simp
rw [hf]
exact ⟨db, ⟨hlim, Or.inr ⟨hmore, hcomplete⟩⟩, by rw [hdbk, hBdef]⟩
/-- A sorted database that stores the empty key has the empty key as its first key. -/
theorem keys_getElem_zero_eq_nil_of_mem {db : DB} (h : ([] : Key) ∈ db.keys) :
db.keys[0]'(List.length_pos_of_mem h) = ([] : Key) := by
obtain ⟨i, hi, hidx⟩ := List.getElem_of_mem h
have hcount := countP_lt_eq_of_getElem db.sorted hi hidx
have hzero : db.keys.countP (fun k => decide (k < ([] : Key))) = 0 := by
rw [List.countP_eq_zero]
intro k _
simp
rw [hzero] at hcount
have hi0 : i = 0 := hcount.symm
subst i
exact hidx
/-- Under the short-gap condition every compatible database clamps the begin selector:
below the end key the short-gap condition rules out a full gap, and the empty-key
exception makes a nonclamping resolution land on the empty key anyway. -/
theorem resolve_begin_eq_nil_of_clampLong_short {db : DB} (hread : Readable r res)
(hcell : negCrossClampLongNonpos r res) (hcomp : RangeRead.Compatible db r res)
(hbranch : clampLongCap r < (clampLongC r res : ℕ∞) ∨
(clampLongCap r = (clampLongC r res : ℕ∞) ∧ res.keys.headD ([] : Key) = [])) :
resolve db r.begin = (([] : Key) : WithTop Key) := by
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
by_cases hclamp : r.begin.anchor db < 0
· exact resolve_eq_nil hclamp
· have hnn : 0 ≤ r.begin.anchor db := le_of_not_gt hclamp
have hP := clampLong_P_eq_C_of_anchor_nonneg hread hcell_keep hcomp hnn
have hle : ((clampLongC r res : ℕ) : ℕ∞) ≤ clampLongCap r := by
rw [← hP]
simpa [clampLongCap] using
between_length_le_intervalCard (db := db) (E := r.end_.key) (B := r.begin.key)
(le_of_lt hlong)
rcases hbranch with hlt | ⟨heq, hhead⟩
· exact absurd (lt_of_le_of_lt hle hlt) (lt_irrefl _)
· rw [resolve_begin_eq_head_of_anchor_nonneg hcomp hrev hmore hne hnn,
← clampLong_headD_eq (hne := hne)]
exact congrArg (fun k : Key => ((k : Key) : WithTop Key)) hhead
/-- When the begin selector clamps, the count below the end key is the reported count
plus the `d + 1` end pads. -/
theorem clampLong_cnt_end_of_clamp {db : DB} (hcomp : RangeRead.Compatible db r res)
(hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ [])
(hend : r.end_.offset ≤ 0) (hL : resolve db r.begin = (([] : Key) : WithTop Key)) :
cnt db r.end_.key = res.keys.length + (clampNonposD r + 1) := by
have hresb := clampLong_complete_eq_between hcomp hrev hmore
have ht : (between db (resolve db r.begin) (resolve db r.end_)).length = res.keys.length := by
rw [← hresb]
rw [hL] at ht
have hcntR : cnt db (resolve db r.end_) = res.keys.length := by
have h := cnt_eq_add_between db (w₁ := (([] : Key) : WithTop Key))
(w₂ := resolve db r.end_) (coe_nil_le_key_withTop _)
rw [cnt_nil, Nat.zero_add, ht] at h
exact h
have hRle : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
have hhead : res.keys.head hne ∈ between db (resolve db r.begin) (resolve db r.end_) :=
hresb ▸ List.head_mem hne
unfold between at hhead
rw [List.mem_filter] at hhead
rw [hL, hR] at hhead
exact absurd (of_decide_eq_true hhead.2).2
(not_lt.mpr (coe_nil_le_key_withTop (res.keys.head hne)))
have hd : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 :=
between_resolve_end_length hend hRne
have h := cnt_eq_add_between db hRle
rw [hcntR, hd] at h
exact h
/-- The begin anchor of any database in terms of its gap count, once the count below the
end key is known to be the reported count plus the end pads. -/
theorem clampLong_anchor_eq_of_cnt {db : DB} (hread : Readable r res)
(hcell : negCrossClampLongNonpos r res)
(hcnt : cnt db r.end_.key = res.keys.length + (clampNonposD r + 1)) :
r.begin.anchor db =
((between db r.end_.key r.begin.key).length : ℤ) - (clampLongC r res : ℤ) := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hEB : r.end_.key ≤ r.begin.key := le_of_lt hlong
have hsplit := cnt_eq_add_between db hEB
have hcntB : db.keys.countP
(fun k => decide (((k : Key) : WithTop Key) < r.begin.key)) =
res.keys.length + (clampNonposD r + 1) +
(between db r.end_.key r.begin.key).length := by
have h := hsplit
rw [hcnt] at h
unfold cnt at h
exact h
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), hcntB]
have hrep : reportedBelowBegin r res = res.keys.length :=
clampLong_reported_eq_length hread
⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
rw [← hrep]
exact clampLong_nat_bottom
⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩
have hC : (clampLongC r res : ℤ) =
(beginSlack r : ℤ) - (res.keys.length : ℤ) - (clampNonposD r : ℤ) := by
unfold clampLongC
rw [hrep]
omega
rw [hC]
push_cast
ring
/-- **Soundness of `[⊥, end_.key)` in the crossed negative-begin complete long clamp
cell.** Under the short-gap condition every database with the same keys below
`end_.key` also clamps the begin selector: the gap can contribute at most `cap ≤ C`
keys, and in the equality case the reported head is the empty key, which the agreed
prefix stores below `end_.key`. The end selector is fixed by agreement below
`end_.key`, and the complete window below it is then determined. -/
theorem sound_clampLong_nonpos_end {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res)
(hbranch : clampLongCap r < (clampLongC r res : ℕ∞) ∨
(clampLongCap r = (clampLongC r res : ℕ∞) ∧ res.keys.headD ([] : Key) = [])) :
Sound r res (⟨(([] : Key) : WithTop Key), r.end_.key⟩ : ConflictRange) := by
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hhead_eq : res.keys.headD ([] : Key) = res.keys.head hne :=
clampLong_headD_eq (hne := hne)
have hhead_mem : res.keys.head hne ∈ res.keys := List.head_mem hne
have step : ∀ db₁ db₂, AgreeOn (⟨(([] : Key) : WithTop Key), r.end_.key⟩ :
ConflictRange) db₁ db₂ → RangeRead.Compatible db₁ r res →
RangeRead.Compatible db₂ r res := by
intro db₁ db₂ hagree hcomp₁
have hlim : RangeRead.withinLimit r res.keys := hcomp₁.1
have hres_eq : res.keys = RangeRead.completeKeys db₁ r := by
rcases hcomp₁.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hfilt : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) =
db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
have h := hagree
rw [AgreeOn, keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h
exact h
have hL₁ : resolve db₁ r.begin = (([] : Key) : WithTop Key) :=
resolve_begin_eq_nil_of_clampLong_short hread hcell_keep hcomp₁ hbranch
have hcnt₁ : cnt db₁ r.end_.key = res.keys.length + (clampNonposD r + 1) :=
clampLong_cnt_end_of_clamp hcomp₁ hrev hmore hne hend hL₁
have hcnt₂ : cnt db₂ r.end_.key = res.keys.length + (clampNonposD r + 1) := by
rw [← hcnt₁]
unfold cnt
rw [List.countP_eq_length_filter, List.countP_eq_length_filter, hfilt]
have hanchor₂ : r.begin.anchor db₂ =
((between db₂ r.end_.key r.begin.key).length : ℤ) - (clampLongC r res : ℤ) :=
clampLong_anchor_eq_of_cnt hread hcell_keep hcnt₂
have hPle : ((between db₂ r.end_.key r.begin.key).length : ℕ∞) ≤ clampLongCap r :=
between_length_le_intervalCard (le_of_lt hlong)
have hL₂ : resolve db₂ r.begin = (([] : Key) : WithTop Key) := by
rcases hbranch with hlt | ⟨heq, hheadD⟩
· have hlt' : ((between db₂ r.end_.key r.begin.key).length : ℕ∞) <
(clampLongC r res : ℕ∞) := lt_of_le_of_lt hPle hlt
have hlt'' : (between db₂ r.end_.key r.begin.key).length < clampLongC r res :=
ENat.natCast_lt_natCast.mp hlt'
exact resolve_eq_nil (by rw [hanchor₂]; omega)
· have hPle' : (between db₂ r.end_.key r.begin.key).length ≤ clampLongC r res := by
have h := hPle
rw [heq] at h
exact ENat.natCast_le_natCast.mp h
have hAle : r.begin.anchor db₂ ≤ 0 := by rw [hanchor₂]; omega
have hhead_nil : res.keys.head hne = ([] : Key) := by
rw [← hhead_eq]; exact hheadD
have hltE : (([] : Key) : WithTop Key) < r.end_.key := by
rw [← hhead_nil]
exact clampLong_reported_lt_end hread hrev hmore hend _ hhead_mem
have hnil₁ : ([] : Key) ∈ db₁.keys := by
have hck : ([] : Key) ∈ RangeRead.completeKeys db₁ r := by
rw [← hres_eq, ← hhead_nil]
exact hhead_mem
revert hck
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev])]
intro hck
exact (List.mem_filter.mp hck).1
have hnil₂ : ([] : Key) ∈ db₂.keys := by
have hmem : ([] : Key) ∈
db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
rw [List.mem_filter]
refine ⟨hnil₁, ?_⟩
rw [decide_eq_true_eq]
exact hltE
rw [hfilt] at hmem
exact (List.mem_filter.mp hmem).1
rcases lt_or_eq_of_le hAle with hneg | hzero
· exact resolve_eq_nil hneg
· have hpos : 0 < db₂.keys.length := List.length_pos_of_mem hnil₂
have hltlen : (r.begin.anchor db₂).toNat < db₂.keys.length := by
rw [hzero]; simpa using hpos
rw [resolve_eq_getElem (le_of_eq hzero.symm) hltlen]
have hz? : db₂.keys[(r.begin.anchor db₂).toNat]? = some ([] : Key) := by
rw [hzero, Int.toNat_zero]
rw [List.getElem?_eq_getElem (h := List.length_pos_of_mem hnil₂)]
exact congrArg some (keys_getElem_zero_eq_nil_of_mem hnil₂)
have hz : db₂.keys[(r.begin.anchor db₂).toNat]'(hltlen) = ([] : Key) := by
apply Option.some.inj
rw [← List.getElem?_eq_getElem (h := hltlen)]
exact hz?
exact congrArg (fun z : Key => ((z : Key) : WithTop Key)) hz
have hR : resolve db₁ r.end_ = resolve db₂ r.end_ :=
resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := r.end_.key) (s := r.end_)
hend le_rfl hfilt
have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
rw [completeKeys_eq_filter_of_end_nonpos (db := db₁) hrev hend,
completeKeys_eq_filter_of_end_nonpos (db := db₂) hrev hend,
hfilt, hL₁, hL₂, hR]
exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- **Soundness of `[⊥, begin.key)` in the crossed negative-begin complete long clamp
cell.** Agreement below `begin.key` fixes both selector resolutions (both selector
keys are at or below it) and every complete window lies below `begin.key`. -/
theorem sound_clampLong_nonpos_begin {r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hbegin : r.begin.offset < 0)
(hend : r.end_.offset ≤ 0) (hmore : res.more = false)
(hlong : r.end_.key < r.begin.key) :
Sound r res (⟨(([] : Key) : WithTop Key), r.begin.key⟩ : ConflictRange) := by
have step : ∀ db₁ db₂, AgreeOn (⟨(([] : Key) : WithTop Key), r.begin.key⟩ :
ConflictRange) db₁ db₂ → RangeRead.Compatible db₁ r res →
RangeRead.Compatible db₂ r res := by
intro db₁ db₂ hagree hcomp₁
have hlim : RangeRead.withinLimit r res.keys := hcomp₁.1
have hres_eq : res.keys = RangeRead.completeKeys db₁ r := by
rcases hcomp₁.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hfilt : db₁.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) =
db₂.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) := by
have h := hagree
rw [AgreeOn, keys_bottomRange_eq_filter, keys_bottomRange_eq_filter] at h
exact h
have hL : resolve db₁ r.begin = resolve db₂ r.begin :=
resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := r.begin.key) (s := r.begin)
(le_of_lt hbegin) le_rfl hfilt
have hR : resolve db₁ r.end_ = resolve db₂ r.end_ :=
resolve_eq_of_keys_below (db₁ := db₁) (db₂ := db₂) (E := r.begin.key) (s := r.end_)
hend (le_of_lt hlong) hfilt
have hres_le : resolve db₁ r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
have hP : 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 (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_)) := by
have h₁ : 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) < r.begin.key))).filter
(fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_)) := by
rw [List.filter_filter]
apply List.filter_congr
intro k _
by_cases hk : resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_
· have hkE : (k : WithTop Key) < r.end_.key := lt_of_lt_of_le hk.2 hres_le
have hkB : (k : WithTop Key) < r.begin.key := lt_trans hkE hlong
simp [hk, hkB]
· simp [hk]
have h₂ : 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) < r.begin.key))).filter
(fun k : Key => decide (resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_)) := by
rw [List.filter_filter]
apply List.filter_congr
intro k _
by_cases hk : resolve db₁ r.begin ≤ (k : WithTop Key) ∧
(k : WithTop Key) < resolve db₁ r.end_
· have hkE : (k : WithTop Key) < r.end_.key := lt_of_lt_of_le hk.2 hres_le
have hkB : (k : WithTop Key) < r.begin.key := lt_trans hkE hlong
simp [hk, hkB]
· simp [hk]
rw [h₁, h₂, hfilt]
have hck : RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), ite_eq_right (by simp [hrev]), ← hL, ← hR]
exact hP
exact ⟨hlim, Or.inr ⟨hmore, by rw [hres_eq, hck]⟩⟩
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- A database of `m` keys in `[B, E)` that contains a prescribed key `k ∈ [B, E)`,
whenever the interval has exactly `m` keys. -/
theorem exists_db_keysIn_mem {B E : WithTop Key} {k : Key} {m : ℕ}
(hcard : (m : ℕ∞) = intervalCard B E) (hk : k ∈ keysIn B E) :
∃ db : DB, (∀ x ∈ db.keys, x ∈ keysIn B E) ∧ k ∈ db.keys ∧
db.keys.length = m := by
obtain ⟨db, hrange, hlen⟩ := exists_db_keysIn (B := B) (E := E) (m := m) (le_of_eq hcard)
have hkdb : k ∈ db.keys := by
by_contra hknot
have hsub : ((db.keys.toFinset ∪ {k} : Finset Key) : Set Key) ⊆ keysIn B E := by
intro x hx
simp only [Finset.mem_coe, Finset.mem_union, List.mem_toFinset,
Finset.mem_singleton] at hx
rcases hx with hx | rfl
· exact hrange x hx
· exact hk
have hcardle : ((db.keys.toFinset ∪ {k} : Finset Key).card : ℕ∞) ≤ intervalCard B E := by
rw [intervalCard_eq_encard_keysIn, ← Set.encard_coe_eq_coe_finsetCard]
exact Set.encard_le_encard hsub
have hcard' : (db.keys.toFinset ∪ {k} : Finset Key).card = m + 1 := by
rw [Finset.card_union_of_disjoint]
· rw [List.toFinset_card_of_nodup db.nodup, hlen]; simp
· rw [Finset.disjoint_singleton_right, List.mem_toFinset]
exact hknot
rw [hcard', ← hcard] at hcardle
exact absurd hcardle
(not_le.mpr (ENat.natCast_lt_natCast.mpr (Nat.lt_succ_self m)))
exact ⟨db, hrange, hkdb, hlen⟩
/-- A database whose keys are the reported keys followed by a nonempty tail, with begin
anchor one, is incompatible: the begin resolution moves to the second stored key, so the
reported head leaves the complete window. -/
theorem clampLong_not_compat_of_anchor_one {db : DB} {Tail : List Key}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res)
(hkeys : db.keys = res.keys ++ Tail) (hTail : Tail ≠ [])
(hanchor : r.begin.anchor db = 1) :
¬ RangeRead.Compatible db r res := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hlenpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
have hlen : 1 < db.keys.length := by
rw [hkeys, List.length_append]
have := List.length_pos_of_ne_nil hTail
omega
have h0 : db.keys[0]'(by omega) = res.keys.head hne := by
have h0? : db.keys[0]? = some (res.keys.head hne) := by
rw [hkeys, List.getElem?_append_left hlenpos, ← List.head?_eq_getElem?,
List.head?_eq_some_head hne]
have hlen0 : 0 < db.keys.length := by omega
rw [List.getElem?_eq_getElem hlen0] at h0?
exact Option.some.inj h0?
have hstep : db.keys[0]'(by omega) < db.keys[1]'(by omega) :=
(db.sorted.getElem_lt_getElem_iff).mpr (by omega)
have hgt : ((res.keys.head hne : Key) : WithTop Key) <
((db.keys[1] : Key) : WithTop Key) := by
rw [← h0]
exact WithTop.coe_lt_coe.mpr hstep
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
rw [hanchor]; simpa using hlen
have hget : db.keys[(r.begin.anchor db).toNat]? = some (db.keys[1]'(by omega)) := by
rw [hanchor]
norm_num
have hval : db.keys[(r.begin.anchor db).toNat]'(hltlen) = db.keys[1]'(by omega) := by
apply Option.some.inj
rw [← List.getElem?_eq_getElem (h := hltlen)]
exact hget
have hres_begin : resolve db r.begin = ((db.keys[1] : Key) : WithTop Key) := by
rw [resolve_eq_getElem (by rw [hanchor]; norm_num) hltlen]
exact congrArg (fun z : Key => ((z : Key) : WithTop Key)) hval
have hhead_lt_E : ((res.keys.head hne : Key) : WithTop Key) < r.end_.key :=
clampLong_reported_lt_end hread hrev hmore hend _ (List.head_mem hne)
intro hcomp
have hres_eq : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hnot : res.keys.head hne ∉ RangeRead.completeKeys db r := by
rw [completeKeys_eq_filter_of_end_nonpos (db := db) hrev hend]
intro hmem
simp only [List.mem_filter, decide_eq_true_eq] at hmem
have hle : ((db.keys[1] : Key) : WithTop Key) ≤
((res.keys.head hne : Key) : WithTop Key) := by
rw [← hres_begin]; exact hmem.2.1
exact absurd hle (not_le.mpr hgt)
exact hnot (by rw [← hres_eq]; exact List.head_mem hne)
/-- A database whose least key is the empty key, with begin anchor zero, is incompatible
with a complete result whose head is not the empty key: the begin resolution moves to the
empty key, which enters the complete window. -/
theorem clampLong_not_compat_of_anchor_zero_bottom {db : DB} {Tail : List Key}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res)
(hheadne : res.keys.headD ([] : Key) ≠ ([] : Key))
(hkeys : db.keys = ([] : Key) :: Tail)
(hanchor : r.begin.anchor db = 0) :
¬ RangeRead.Compatible db r res := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hhead : res.keys.head hne ≠ ([] : Key) := by
rw [← clampLong_headD_eq (hne := hne)]; exact hheadne
have hbot_lt_head : ([] : Key) < res.keys.head hne := by
cases hh : res.keys.head hne with
| nil => exact absurd hh hhead
| cons a t => exact List.nil_lt_cons a t
have hnil_lt_E : (([] : Key) : WithTop Key) < r.end_.key := by
have hh := clampLong_reported_lt_end hread hrev hmore hend _ (List.head_mem hne)
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (le_of_lt hbot_lt_head)) hh
have hlen : 0 < db.keys.length := by rw [hkeys]; simp
have hltlen : (r.begin.anchor db).toNat < db.keys.length := by
rw [hanchor]; simpa using hlen
have hget : db.keys[(r.begin.anchor db).toNat]? = some ([] : Key) := by
rw [hanchor]
norm_num
rw [hkeys]
simp
have hval : db.keys[(r.begin.anchor db).toNat]'(hltlen) = ([] : Key) := by
apply Option.some.inj
rw [← List.getElem?_eq_getElem (h := hltlen)]
exact hget
have hres_begin : resolve db r.begin = (([] : Key) : WithTop Key) := by
rw [resolve_eq_getElem (by rw [hanchor]) hltlen]
exact congrArg (fun z : Key => ((z : Key) : WithTop Key)) hval
intro hcomp
have hres_eq : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db r := by
rw [← hres_eq]; exact List.head_mem hne
rw [completeKeys_eq_filter_of_end_nonpos (db := db) hrev hend] at hhead_ck
simp only [List.mem_filter, decide_eq_true_eq] at hhead_ck
have hhead_lt_resEnd : ((res.keys.head hne : Key) : WithTop Key) < resolve db r.end_ :=
hhead_ck.2.2
have hnil_lt_resEnd : (([] : Key) : WithTop Key) < resolve db r.end_ :=
lt_of_le_of_lt (WithTop.coe_le_coe.mpr (le_of_lt hbot_lt_head)) hhead_lt_resEnd
have hnil_ck : ([] : Key) ∈ RangeRead.completeKeys db r := by
rw [completeKeys_eq_filter_of_end_nonpos (db := db) hrev hend]
rw [List.mem_filter]
refine ⟨?_, ?_⟩
· rw [List.mem_filter]
exact ⟨by rw [hkeys]; exact List.mem_cons_self ..
, by rw [decide_eq_true_eq]; exact hnil_lt_E⟩
· rw [decide_eq_true_eq]
exact ⟨by rw [hres_begin], hnil_lt_resEnd⟩
have hnil_not_res : ([] : Key) ∉ res.keys := by
intro h
have hle := head_le_of_sortedLT' (RangeRead.compatible_sortedLT hcomp hrev) hne h
exact absurd hle (not_le.mpr hbot_lt_head)
exact hnil_not_res (by rw [hres_eq]; exact hnil_ck)
/-- **Every gap key is necessary when the gap is strictly larger than the slack.** Use
a compatible database storing exactly `C` gap keys and avoiding `k`, then insert `k`:
the begin anchor rises to one, so the reported head leaves the complete window. -/
theorem clampLong_necessary_gap_of_cap_gt {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res)
(hgt : (clampLongC r res : ℕ∞) < clampLongCap r)
(hkE : r.end_.key ≤ ((k : Key) : WithTop Key))
(hkB : ((k : Key) : WithTop Key) < r.begin.key) :
Necessary r res k := by
have hread_keep : Readable r res := hread
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hcard : ((clampLongC r res + 1 : ℕ) : ℕ∞) ≤ clampLongCap r := by
rw [Nat.cast_add, Nat.cast_one]
exact (ENat.add_one_le_iff (by simp)).mpr hgt
obtain ⟨dbJ, hJrange, hkJ, hJlen⟩ :=
exists_db_keysIn_avoid (B := r.end_.key) (E := r.begin.key) (k := k)
(m := clampLongC r res) hcard
have hJlo : ∀ x ∈ dbJ.keys, r.end_.key ≤ ((x : Key) : WithTop Key) :=
fun x hx => (hJrange x hx).1
have hJhi : ∀ x ∈ dbJ.keys, ((x : Key) : WithTop Key) < r.begin.key :=
fun x hx => (hJrange x hx).2
obtain ⟨dbA, hAcomp, hAkeys⟩ :=
exists_long_compat_db hcomp₀ hcell_keep [] dbJ.keys List.sortedLT_nil
(by intro x hx; simp at hx) dbJ.sorted hJlo hJhi hJlen
have hres_lt_E := clampLong_reported_lt_end hread_keep hrev hmore hend
have hPads_lt : ∀ x ∈ between db₀ (resolve db₀ r.end_) r.end_.key,
((x : Key) : WithTop Key) < r.end_.key := by
intro x hx
exact (of_decide_eq_true (List.mem_filter.mp hx).2).2
have hkA : k ∉ dbA.keys := by
rw [hAkeys]
intro hk
simp only [List.nil_append, List.mem_append] at hk
rcases hk with (hk | hk) | hk
· exact absurd hkE (not_le.mpr (hres_lt_E k hk))
· exact absurd hkE (not_le.mpr (hPads_lt k hk))
· exact hkJ hk
let Lb : List Key := dbJ.keys.orderedInsert (· ≤ ·) k
have hall_lt : ∀ a ∈ res.keys ++ between db₀ (resolve db₀ r.end_) r.end_.key, a < k := by
intro a ha
have haE : ((a : Key) : WithTop Key) < r.end_.key := by
rcases List.mem_append.mp ha with ha | ha
· exact hres_lt_E a ha
· exact hPads_lt a ha
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le haE hkE)
have hBkeys : (toggle dbA k).keys =
res.keys ++ between db₀ (resolve db₀ r.end_) r.end_.key ++ Lb := by
rw [toggle_eq_insert_of_not_mem hkA, DB.insert_keys, hAkeys]
simp only [List.nil_append]
rw [orderedInsert_append_of_all_lt hall_lt]
have hLblo : ∀ x ∈ Lb, r.end_.key ≤ ((x : Key) : WithTop Key) := by
intro x hx
rw [List.mem_orderedInsert] at hx
rcases hx with rfl | hx
· exact hkE
· exact hJlo x hx
have hLbhi : ∀ x ∈ Lb, ((x : Key) : WithTop Key) < r.begin.key := by
intro x hx
rw [List.mem_orderedInsert] at hx
rcases hx with rfl | hx
· exact hkB
· exact hJhi x hx
have hLblen : Lb.length = clampLongC r res + 1 := by
simp [Lb, List.orderedInsert_length, hJlen]
have hpadlen : (between db₀ (resolve db₀ r.end_) r.end_.key).length =
clampNonposD r + 1 := by
have hres_eq₀ : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := by
rw [← hres_eq₀]; exact List.head_mem hne
have hhead_lt_resEnd : ((res.keys.head hne : Key) : WithTop Key) < resolve db₀ r.end_ :=
(RangeRead.mem_completeKeys.mp hhead_ck).2.2
have hRne : resolve db₀ r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
rw [hR] at hhead_lt_resEnd
exact absurd hhead_lt_resEnd
(not_lt.mpr (coe_nil_le_key_withTop (res.keys.head hne)))
exact between_resolve_end_length hend hRne
have hcntB : (toggle dbA k).keys.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
res.keys.length + (clampNonposD r + 1) + Lb.length := by
rw [hBkeys]
rw [List.countP_append, List.countP_append]
have h1 : res.keys.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) = res.keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact lt_of_lt_of_le (hres_lt_E x hx) (le_of_lt hlong)
have h2 : (between db₀ (resolve db₀ r.end_) r.end_.key).countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
(between db₀ (resolve db₀ r.end_) r.end_.key).length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact lt_trans (hPads_lt x hx) hlong
have h3 : Lb.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) = Lb.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hLbhi x hx
rw [h1, h2, h3, hpadlen]
have hreplen : reportedBelowBegin r res = res.keys.length :=
clampLong_reported_eq_length hread_keep hcell_keep
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
rw [← hreplen]; exact clampLong_nat_bottom hcell_keep
have hanchor : r.begin.anchor (toggle dbA k) = 1 := by
rw [anchor_eq_count_sub_slack _ r (le_of_lt hbegin), hcntB]
have hslack : beginSlack r =
res.keys.length + clampLongC r res + clampNonposD r := by
unfold clampLongC
rw [hreplen]
omega
rw [hLblen, hslack]
push_cast
ring
have hnot : ¬ RangeRead.Compatible (toggle dbA k) r res :=
clampLong_not_compat_of_anchor_one (Tail := between db₀ (resolve db₀ r.end_) r.end_.key ++ Lb)
hread_keep hcell_keep (by rw [hBkeys, List.append_assoc]) (by
intro h
have hlen := congrArg List.length h
rw [List.length_append, hLblen] at hlen
simp at hlen) hanchor
exact necessary_of_toggle ⟨dbA, hAcomp, hnot⟩
/-- **Every gap key is necessary when the gap exactly matches the slack and the reported
head is not the empty key.** Use a compatible database with one bottom key below the
head and all gap keys stored, then erase `k`: the begin anchor returns to zero, the
resolution lands on the bottom key, which enters the complete window although it is not
reported. -/
theorem clampLong_necessary_gap_of_cap_eq {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res)
(hcap : clampLongCap r = (clampLongC r res : ℕ∞))
(hheadne : res.keys.headD ([] : Key) ≠ ([] : Key))
(hkE : r.end_.key ≤ ((k : Key) : WithTop Key))
(hkB : ((k : Key) : WithTop Key) < r.begin.key) :
Necessary r res k := by
have hread_keep : Readable r res := hread
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
obtain ⟨db₀, hcomp₀⟩ := hread
have hhead : res.keys.head hne ≠ ([] : Key) := by
rw [← clampLong_headD_eq (hne := hne)]; exact hheadne
have hbot_lt_head : ([] : Key) < res.keys.head hne := by
cases hh : res.keys.head hne with
| nil => exact absurd hh hhead
| cons a t => exact List.nil_lt_cons a t
have hk_interval : k ∈ keysIn r.end_.key r.begin.key := ⟨hkE, hkB⟩
obtain ⟨dbJ, hJrange, hkJmem, hJlen⟩ :=
exists_db_keysIn_mem (B := r.end_.key) (E := r.begin.key) (k := k)
(m := clampLongC r res) (by unfold clampLongCap at hcap; exact hcap.symm) hk_interval
have hJlo : ∀ x ∈ dbJ.keys, r.end_.key ≤ ((x : Key) : WithTop Key) :=
fun x hx => (hJrange x hx).1
have hJhi : ∀ x ∈ dbJ.keys, ((x : Key) : WithTop Key) < r.begin.key :=
fun x hx => (hJrange x hx).2
have hnil_lt_head : (([] : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key) :=
WithTop.coe_lt_coe.mpr hbot_lt_head
obtain ⟨dbA, hAcomp, hAkeys⟩ :=
exists_long_compat_db hcomp₀ hcell_keep [(([] : Key))] dbJ.keys
(sortedLT_singleton _)
(by
intro x hx
simp only [List.mem_singleton] at hx
subst x
have hheadD : res.keys.headD ([] : Key) = res.keys.head hne :=
clampLong_headD_eq (hne := hne)
rw [hheadD]
exact hbot_lt_head)
dbJ.sorted hJlo hJhi hJlen
have hres_lt_E := clampLong_reported_lt_end hread_keep hrev hmore hend
have hPads_lt : ∀ x ∈ between db₀ (resolve db₀ r.end_) r.end_.key,
((x : Key) : WithTop Key) < r.end_.key := by
intro x hx
exact (of_decide_eq_true (List.mem_filter.mp hx).2).2
have hkA : k ∈ dbA.keys := by
rw [hAkeys]
simp only [List.singleton_append]
exact List.mem_append.mpr (Or.inr hkJmem)
have hk_res : k ∉ res.keys := fun h => absurd hkE (not_le.mpr (hres_lt_E k h))
have hk_pads : k ∉ between db₀ (resolve db₀ r.end_) r.end_.key :=
fun h => absurd hkE (not_le.mpr (hPads_lt k h))
have hnil_ne_k : ([] : Key) ≠ k := by
intro h
have hlt : (([] : Key) : WithTop Key) < r.end_.key :=
lt_of_le_of_lt (WithTop.coe_le_coe.mpr (le_of_lt hbot_lt_head))
(hres_lt_E _ (List.head_mem hne))
rw [h] at hlt
exact absurd hkE (not_le.mpr hlt)
have hnil_beq : ¬(([] : Key) == k) = true := by
rw [beq_iff_eq]; exact hnil_ne_k
have hnot : ¬ RangeRead.Compatible (toggle dbA k) r res := by
have hBkeys : (toggle dbA k).keys = ([] : Key) ::
(res.keys ++ between db₀ (resolve db₀ r.end_) r.end_.key ++ dbJ.keys.erase k) := by
rw [toggle_eq_erase_of_mem hkA, DB.erase_keys, hAkeys]
simp only [List.cons_append, List.nil_append]
rw [List.erase_cons_tail hnil_beq]
congr 1
rw [List.erase_append_right (l₁ := res.keys ++ between db₀ (resolve db₀ r.end_) r.end_.key)
(a := k) dbJ.keys]
intro h
rcases List.mem_append.mp h with h | h
· exact hk_res h
· exact hk_pads h
have hanchor : r.begin.anchor (toggle dbA k) = 0 := by
have hpadlen : (between db₀ (resolve db₀ r.end_) r.end_.key).length =
clampNonposD r + 1 := by
have hres_eq₀ : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp₀.2 with ⟨hm, _, _⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hhead_ck : res.keys.head hne ∈ RangeRead.completeKeys db₀ r := by
rw [← hres_eq₀]; exact List.head_mem hne
have hhead_lt_resEnd : ((res.keys.head hne : Key) : WithTop Key) <
resolve db₀ r.end_ := (RangeRead.mem_completeKeys.mp hhead_ck).2.2
have hRne : resolve db₀ r.end_ ≠ (([] : Key) : WithTop Key) := by
intro hR
rw [hR] at hhead_lt_resEnd
exact absurd hhead_lt_resEnd
(not_lt.mpr (coe_nil_le_key_withTop (res.keys.head hne)))
exact between_resolve_end_length hend hRne
have herase_len : (dbJ.keys.erase k).length = clampLongC r res - 1 := by
rw [List.length_erase_of_mem hkJmem, hJlen]
-- count below begin.key after erasure
have hcntB : (toggle dbA k).keys.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
res.keys.length + (clampNonposD r + 1) + clampLongC r res := by
rw [hBkeys, List.countP_cons_of_pos]
· rw [List.countP_append, List.countP_append]
have h1 : res.keys.countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
res.keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact lt_of_lt_of_le (hres_lt_E x hx) (le_of_lt hlong)
have h2 : (between db₀ (resolve db₀ r.end_) r.end_.key).countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
(between db₀ (resolve db₀ r.end_) r.end_.key).length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact lt_trans (hPads_lt x hx) hlong
have h3 : (dbJ.keys.erase k).countP
(fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
(dbJ.keys.erase k).length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hJhi x (List.mem_of_mem_erase hx)
rw [h1, h2, h3, hpadlen, herase_len]
have hCpos : 0 < clampLongC r res := clampLong_C_pos hcell_keep
omega
· rw [decide_eq_true_eq]
have hlt : (([] : Key) : WithTop Key) <
((res.keys.headD ([] : Key) : Key) : WithTop Key) := by
rw [clampLong_headD_eq (hne := hne)]
exact WithTop.coe_lt_coe.mpr hbot_lt_head
exact lt_trans hlt hcrossD
have hreplen : reportedBelowBegin r res = res.keys.length :=
clampLong_reported_eq_length hread_keep hcell_keep
have hnat : res.keys.length + (clampNonposD r + 1) ≤ beginSlack r := by
rw [← hreplen]; exact clampLong_nat_bottom hcell_keep
rw [anchor_eq_count_sub_slack _ r (le_of_lt hbegin), hcntB]
have hslack : beginSlack r =
res.keys.length + clampLongC r res + clampNonposD r := by
unfold clampLongC
rw [hreplen]
have hle : res.keys.length + clampNonposD r ≤ beginSlack r := by omega
omega
rw [hslack]
omega
exact clampLong_not_compat_of_anchor_zero_bottom hread_keep hcell_keep hheadne
hBkeys hanchor
exact necessary_of_toggle ⟨dbA, hAcomp, hnot⟩
/-- **Every key below the end key is necessary in the crossed negative-begin complete
long clamp cell.** Below the reported head it is necessary because a clamping witness
stores nothing there; between reported keys it is convex; above the last reported key it
is fixed by the complete window. -/
theorem necessary_below_end_clampLong {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res) {k : Key}
(hkE : ((k : Key) : WithTop Key) < r.end_.key) :
Necessary r res k := by
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
by_cases hkhead : ((k : Key) : WithTop Key) < ((res.keys.head hne : Key) : WithTop Key)
· obtain ⟨db, hcomp, hneg⟩ := exists_clampLong_db hread hcell_keep
exact necessary_below_head_of_anchor_nonpos_negCross db hcomp hrev hne hneg hkhead
· have hkhead_le : ((res.keys.head hne : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
le_of_not_gt hkhead
by_cases hklast : k ≤ res.keys.getLast hne
· exact necessary_of_between_result hread (List.head_mem hne) (List.getLast_mem hne)
(WithTop.coe_le_coe.mp hkhead_le) hklast
· have hkgt : res.keys.getLast hne < k := lt_of_not_ge hklast
exact fun cr hs => necessary_last_to_end_key hread hrev hmore hne (by omega) cr hs
(le_of_lt hkgt) hkE
/-- **Minimality of the crossed negative-begin complete long clamp cell.** -/
theorem minimal_closedForm_of_negCross_clamp_long_nonpos {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossClampLongNonpos r res) :
Minimal r res (closedFormNegCrossClampLongNonpos r res) := by
have hcell_keep : negCrossClampLongNonpos r res := hcell
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
by_cases hb : clampLongCap r < (clampLongC r res : ℕ∞) ∨
(clampLongCap r = (clampLongC r res : ℕ∞) ∧ res.keys.headD ([] : Key) = [])
· have hcr : closedFormNegCrossClampLongNonpos r res =
(⟨(([] : Key) : WithTop Key), r.end_.key⟩ : ConflictRange) := by
unfold closedFormNegCrossClampLongNonpos clampLongUpper
rw [ite_eq_left hb]
rw [hcr]
exact minimal_iff_sound_and_necessaryRange.mpr
⟨sound_clampLong_nonpos_end hread hcell_keep hb,
fun k _ hk => necessary_below_end_clampLong hread hcell_keep hk⟩
· have hcr : closedFormNegCrossClampLongNonpos r res =
(⟨(([] : Key) : WithTop Key), r.begin.key⟩ : ConflictRange) := by
unfold closedFormNegCrossClampLongNonpos clampLongUpper
rw [ite_eq_right hb]
rw [hcr]
refine minimal_iff_sound_and_necessaryRange.mpr
⟨sound_clampLong_nonpos_begin hrev hbegin hend hmore hlong, ?_⟩
intro k _ hkB
by_cases hkE : ((k : Key) : WithTop Key) < r.end_.key
· exact necessary_below_end_clampLong hread hcell_keep hkE
· have hkE_le : r.end_.key ≤ ((k : Key) : WithTop Key) := le_of_not_gt hkE
have hle : (clampLongC r res : ℕ∞) ≤ clampLongCap r := by
by_contra h
exact hb (Or.inl (lt_of_not_ge h))
rcases lt_or_eq_of_le hle with hlt | heq
· exact clampLong_necessary_gap_of_cap_gt hread hcell_keep hlt hkE_le hkB
· have hheadne : res.keys.headD ([] : Key) ≠ [] := by
intro h
exact hb (Or.inr ⟨heq.symm, h⟩)
exact clampLong_necessary_gap_of_cap_eq hread hcell_keep heq.symm hheadne hkE_le hkB
end Structural
/-- The reversed crossed negative-begin complete long clamp cell at `end.offset ≤ 0`. -/
abbrev negCrossClampLongNonposRev (r : RangeRead) (res : Result) : Prop :=
r.reverse = true ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
r.end_.offset ≤ 0 ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
reportedBelowBegin r res ≤ beginSlack r ∧ clampNonposBottom r res ∧
r.end_.key < r.begin.key
/-- The reversed closed form for the crossed negative-begin complete long clamp cell. -/
noncomputable def closedFormNegCrossClampLongNonposRev (r : RangeRead) (res : Result) :
ConflictRange :=
closedFormNegCrossClampLongNonpos { r with reverse := false }
{ keys := res.keys.reverse, more := false }
/-- **The reversed crossed negative-begin complete long clamp cell is minimal**, by
flipping the traversal. -/
theorem minimal_closedForm_of_negCross_clamp_long_nonpos_rev {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossClampLongNonposRev r res) :
Minimal r res (closedFormNegCrossClampLongNonposRev r res) := by
obtain ⟨hrev, hbegin, hmore, hne, hend, hcrossD, hmq, hbottom, hlong⟩ := hcell
have hne' : res.keys.reverse ≠ [] := by simpa using hne
have hheadD : res.keys.reverse.headD ([] : Key) = res.keys.getLastD ([] : Key) := by
rw [List.headD_eq_head?, List.getLastD_eq_getLast?, List.head?_reverse]
have hcount : reportedBelowBegin { r with reverse := false }
{ keys := res.keys.reverse, more := false } = reportedBelowBegin r res := by
unfold reportedBelowBegin
exact List.Perm.countP_eq _ (List.reverse_perm res.keys)
have hbottom' : clampNonposBottom { r with reverse := false }
{ keys := res.keys.reverse, more := false } ↔ clampNonposBottom r res := by
unfold clampNonposBottom
rw [hcount]
rfl
have hcell' : negCrossClampLongNonpos { r with reverse := false }
{ keys := res.keys.reverse, more := false } := by
refine ⟨rfl, hbegin, rfl, hne', hend, ?_, ?_, ?_, hlong⟩
· rw [hheadD]; exact hcrossD
· rw [hcount]; exact hmq
· exact hbottom'.mpr hbottom
have hread' : Readable { r with reverse := false }
{ keys := res.keys.reverse, more := false } := by
obtain ⟨db, hcomp⟩ := hread
exact ⟨db, (compatible_flip (db := db) (b := true) hrev hmore).mpr hcomp⟩
have hmin := minimal_closedForm_of_negCross_clamp_long_nonpos hread' hcell'
exact (minimal_flip (b := true) hrev hmore).mp hmin
end FormalConflictRange