Prove conflict-range closed-form minimality

- Vendor the FormalConflictRange reference library needed by the proof
- Add Bridge.lean with simp lemmas connecting the Statement definitions
  to the reference library
- Prove Statement.closedFormMinimal in Proof.lean
- Register the new libraries in the Lake config
This commit is contained in:
andrew committed 2026-11-16 21:53:59 -05:00
1 parent 7a0826e873
commit a54a5f82f8
78 files changed
+91636 -2

No files matched your search

@@ -0,0 +1,671 @@
/-
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.NegCrossTruncRevResidualLargeSentinel
import FormalConflictRange.NegCrossTruncRevFinite
/-!
# The finite branch of the reversed crossed negative-begin truncated residual
This module closes the *under* part of the finite branch of the last reversed crossed
negative-begin truncated residual. The setting is
* `res.more = true`, `r.reverse = true`, `r.begin.offset < 0`, `res.keys ≠ []`;
* `2 ≤ r.end_.offset`;
* the reported last `L` lies at or below `end_.key` (`last ≤ end_.key`);
* the finite count `#reported ≥ end_.key = end_.offset - 1`;
* the crossed selectors `L < begin.key`.
Writing `H` for the reported head, `L` for the reported last and `cond` for the
capacity condition
`(reportedBelowBegin - 1) + intervalCard (keyAfter H) begin.key ≤ beginSlack`, the
minimal range is `[L, if cond then keyAfter H else begin.key)`.
The finite branch makes the end resolution the least stored key strictly above the
reported head. Hence compatibility with `r` is the same as compatibility with the read
whose end selector is `(keyAfter H, 1)`, and minimality transfers from the offset-one
crossed cells.
The complementary *over* part (`end_.key < last`) is not covered here.
-/
namespace FormalConflictRange
set_option maxHeartbeats 1600000
/-- The finite under cell of the reversed crossed negative-begin truncated residual:
the finite branch on the region `last ≤ end_.key < begin.key`. -/
abbrev negCrossTruncRevResidualFiniteUnder (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
2 ≤ r.end_.offset ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key ∧
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat
/-- The capacity condition of the finite under cell: after accounting for the reported
keys below the begin selector, the gap `[keyAfter head, begin.key)` still fits in the
begin slack. -/
noncomputable def finiteUnderCond (r : RangeRead) (res : Result) : Prop :=
((reportedBelowBegin r res - 1 : ℕ) : ℕ∞) +
intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
r.begin.key ≤
(beginSlack r : ℕ∞)
/-- The closed form of the finite under cell:
`[last reported, if cond then keyAfter head else begin.key)`. -/
noncomputable def closedFormNegCrossTruncRevResidualFiniteUnder
(r : RangeRead) (res : Result) : ConflictRange := by
classical
let L : WithTop Key := ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
let U : WithTop Key :=
if finiteUnderCond r res then
(((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
else r.begin.key
exact ⟨L, U⟩
/-! ### The end resolution is the least stored key above the reported head -/
/-- **Under compatibility the end resolution is the least stored key strictly above the
reported head.** The reported keys are the stored keys in `[last, resolve end_)` read
backwards, so the head is stored, the resolution lies strictly above it, and no stored
key lies between them. -/
theorem resolve_end_eq_resolve_keyAfter_head {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hne : res.keys ≠ []) :
resolve db r.end_ =
resolve db (selAt (((keyAfter (res.keys.head hne)) : Key) : WithTop Key)) := by
set H : Key := res.keys.head hne with hHdef
set K : Key := keyAfter H with hKdef
set L : Key := res.keys.getLast hne with hLdef
set R : WithTop Key := resolve db r.end_ with hRdef
have hHK : H < K := by rw [hKdef]; exact keyAfter_self_lt H
have hHKcoe : ((H : Key) : WithTop Key) < ((K : Key) : WithTop Key) :=
WithTop.coe_lt_coe.mpr hHK
have hbetween : between db ((L : Key) : WithTop Key) R = res.keys.reverse := by
have h := res_keys_eq_reverse_between_resolve_end hcomp hmore hrev hne
have h' : between db ((res.keys.getLast hne : Key) : WithTop Key) (resolve db r.end_) =
res.keys.reverse := by
have h2 := congrArg List.reverse h
rw [List.reverse_reverse] at h2
exact h2.symm
simpa [hLdef, hRdef] using h'
have hHmem : H ∈ res.keys := by rw [hHdef]; exact List.head_mem hne
have hHbetween : H ∈ between db ((L : Key) : WithTop Key) R := by
rw [hbetween]; exact List.mem_reverse.mpr hHmem
have hLH : ((L : Key) : WithTop Key) ≤ ((H : Key) : WithTop Key) :=
(of_decide_eq_true (List.mem_filter.mp hHbetween).2).1
have hHR : ((H : Key) : WithTop Key) < R :=
(of_decide_eq_true (List.mem_filter.mp hHbetween).2).2
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
have hhead_le : ∀ x ∈ res.keys, x ≤ H := by
intro x hx
rw [hHdef]
exact (hsort.pairwise.imp (fun h => le_of_lt h)).rel_head hx
-- Every stored key at or above `keyAfter H` is at or above the resolution.
have hclaim : ∀ k ∈ db.keys, ((K : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) →
R ≤ ((k : Key) : WithTop Key) := by
intro k hk hKk
by_contra hkR
push Not at hkR
have hLk : ((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
le_trans hLH (le_trans (le_of_lt hHKcoe) hKk)
have hkbetween : k ∈ between db ((L : Key) : WithTop Key) R := by
unfold between
exact List.mem_filter.mpr ⟨hk, by
rw [decide_eq_true_eq]
exact ⟨hLk, hkR⟩⟩
have hkres : k ∈ res.keys := by
rw [hbetween] at hkbetween
exact List.mem_reverse.mp hkbetween
have hkH : k ≤ H := hhead_le k hkres
exact absurd (le_trans hKk (WithTop.coe_le_coe.mpr hkH)) (not_le.mpr hHKcoe)
refine le_antisymm ?_ ?_
· -- `R ≤ resolve (selAt K)`
rcases resolve_eq_nil_or_eq_top_or_mem (db := db)
(s := selAt (((K : Key) : WithTop Key))) with hnil | htop | ⟨x, hxmem, hxeq⟩
· -- `resolve (selAt K) = ↑nil`, impossible since `↑K ≤ resolve`
have hKle : ((K : Key) : WithTop Key) ≤ (([] : Key) : WithTop Key) := by
rw [← hnil]; exact coe_le_resolve_selAt db K
have hKnil : K = [] := by
rw [WithTop.coe_le_coe] at hKle
exact le_antisymm hKle (nil_le_key K)
rw [hKnil] at hHK
exact absurd hHK (not_lt.mpr (nil_le_key H))
· rw [htop]; exact le_top
· have hKx : ((K : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) := by
rw [← hxeq]; exact coe_le_resolve_selAt db K
rw [hxeq]
exact hclaim x hxmem hKx
· -- `resolve (selAt K) ≤ R`
rcases eq_or_ne R (⊤ : WithTop Key) with hRtop | hRne
· rw [hRtop]; exact le_top
· rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := r.end_) with
hnil | htop | ⟨r, hrmem, hRr⟩
· rw [← hRdef] at hnil
rw [hnil] at hHR
exact absurd hHR (by simp)
· rw [← hRdef] at htop
exact absurd htop hRne
· rw [← hRdef] at hRr
have hKr : ((K : Key) : WithTop Key) ≤ ((r : Key) : WithTop Key) := by
rw [hRr] at hHR
exact keyAfter_le_of_lt hHR
rw [hRr]
exact resolve_selAt_le_of_mem hrmem (WithTop.coe_le_coe.mp hKr)
/-- **A finite resolution of an offset-one selector keyed at a genuine key is a stored
key.** -/
theorem mem_keys_of_resolve_selAt_eq_coe {db : DB} {b v : Key}
(h : resolve db (selAt (↑b : WithTop Key)) = (↑v : WithTop Key)) :
v ∈ db.keys := by
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := selAt (↑b : WithTop Key)) with
hnil | htop | ⟨x, hxmem, hxeq⟩
· have hv : v = [] := WithTop.coe_eq_coe.mp (h.symm.trans hnil)
have hnonneg := anchor_selAt_coe_nonneg db b
have hempty : ([] : Key) ∈ db.keys := by
rw [resolve_eq_ite] at hnil
rw [ite_eq_right (not_lt.mpr hnonneg)] at hnil
cases hk : db.keys[(selAt (↑b : WithTop Key)).anchor db |>.toNat]? with
| none => rw [hk] at hnil; simp at hnil
| some k =>
rw [hk] at hnil
have hknil : k = [] := WithTop.coe_eq_coe.mp hnil
rw [← hknil]
exact List.mem_of_getElem? hk
rw [hv]
exact hempty
· rw [htop] at h
exact absurd h (by simp)
· have hvx : v = x := WithTop.coe_eq_coe.mp (h.symm.trans hxeq)
rw [hvx]
exact hxmem
/-- **The finite under cell reduces to the read with end selector `(keyAfter head, 1)`.**
Compatibility is unchanged by replacing the end selector with the immediate successor of
the reported head at offset one. -/
theorem compatible_iff_finiteUnder_reduce {r : RangeRead} {res : Result}
(hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ [])
(hend : 2 ≤ r.end_.offset)
(hLE : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key)
(hcount : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat) :
∀ db, RangeRead.Compatible db r res ↔
RangeRead.Compatible db
{ r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) }
res := by
intro db
have hH : res.keys.headD ([] : Key) = res.keys.head hne := headD_eq_head_of_ne hne
have hL : res.keys.getLastD ([] : Key) = res.keys.getLast hne := getLastD_eq_getLast_of_ne hne
set r' : RangeRead :=
{ r with end_ := selAt (((keyAfter (res.keys.head hne) : Key)) : WithTop Key) }
with hr'def
have hr'end : r'.end_ = selAt (((keyAfter (res.keys.head hne) : Key)) : WithTop Key) := rfl
have hr'lim : r'.limit = r.limit := rfl
have hr'rev : r'.reverse = r.reverse := rfl
have hr'target : r' =
{ r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) } := by
rw [hr'def, hH]
-- forward direction
have hfwd : RangeRead.Compatible db r res → RangeRead.Compatible db r' res := by
intro hcomp
have hres := resolve_end_eq_resolve_keyAfter_head (db := db) hcomp hmore hrev hne
have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db r' := by
unfold RangeRead.completeKeys
rw [hr'rev, hrev]
simp only
rw [hres, hr'end]
exact (compatible_congr_completeKeys hck hr'lim).mp hcomp
-- backward direction
have hbwd : RangeRead.Compatible db r' res → RangeRead.Compatible db r res := by
intro hcomp'
have hres' := resolve_end_eq_resolve_keyAfter_head (db := db) (r := r') hcomp' hmore
(by rw [hr'rev, hrev]) hne
-- `resolve (r'.end_) = least stored key above H`
have hR' : resolve db r'.end_ =
resolve db (selAt (((keyAfter (res.keys.head hne)) : Key) : WithTop Key)) := hres'
-- the reported keys are the stored keys in `[L, resolve r'.end_)` read backwards
have hbetween' : between db ((res.keys.getLast hne : Key) : WithTop Key)
(resolve db r'.end_) = res.keys.reverse := by
have h := res_keys_eq_reverse_between_resolve_end hcomp' hmore
(by rw [hr'rev, hrev]) hne
have h2 := congrArg List.reverse h
rw [List.reverse_reverse] at h2
exact h2.symm
-- We show that `resolve db r.end_` also lands on the least stored key above `H`.
-- Write `R' := resolve db r'.end_`.
set R' : WithTop Key := resolve db r'.end_ with hR'def
set H : Key := res.keys.head hne with hHdef
set L : Key := res.keys.getLast hne with hLdef
have hHmem : H ∈ res.keys := by rw [hHdef]; exact List.head_mem hne
have hHbetween : H ∈ between db ((L : Key) : WithTop Key) R' := by
rw [hbetween']
exact List.mem_reverse.mpr hHmem
have hLH : ((L : Key) : WithTop Key) ≤ ((H : Key) : WithTop Key) :=
(of_decide_eq_true (List.mem_filter.mp hHbetween).2).1
have hHR' : ((H : Key) : WithTop Key) < R' :=
(of_decide_eq_true (List.mem_filter.mp hHbetween).2).2
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp' (by rw [hr'rev, hrev])
have hhead_le : ∀ x ∈ res.keys, x ≤ H := by
intro x hx
rw [hHdef]
exact (hsort.pairwise.imp (fun h => le_of_lt h)).rel_head hx
-- stored keys in `[L, R')` are exactly the reported keys
have hstoredLe : ∀ k ∈ db.keys, ((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) →
((k : Key) : WithTop Key) < R' → k ∈ res.keys := by
intro k hk hLk hkR
have hkb : k ∈ between db ((L : Key) : WithTop Key) R' := by
unfold between
exact List.mem_filter.mpr ⟨hk, by rw [decide_eq_true_eq]; exact ⟨hLk, hkR⟩⟩
rw [hbetween'] at hkb
exact List.mem_reverse.mp hkb
-- `end_.key ≤ head`: if `head < end_.key`, no reported key is at or above it
have hEH : r.end_.key ≤ ((H : Key) : WithTop Key) := by
by_contra hcon
push Not at hcon
have hzero : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = 0 := by
apply List.countP_eq_zero.mpr
intro k hk
simpa using decide_eq_false
(not_le.mpr (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hhead_le k hk)) hcon))
rw [hcount] at hzero
have : 1 ≤ (r.end_.offset - 1).toNat := by omega
omega
-- the first `e` stored keys at or above `end_.key` are the reported ones
have hbetweenE : between db r.end_.key R' = res.keys.reverse.filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by
have hLE' : ((L : Key) : WithTop Key) ≤ r.end_.key := by
rw [← hL]
exact hLE
have hfil := between_filter_ge_eq (db := db) (L := ((L : Key) : WithTop Key))
(E := r.end_.key) (B := R') hLE'
rw [← hfil, hbetween']
have hlenE : (between db r.end_.key R').length =
(r.end_.offset - 1).toNat := by
rw [hbetweenE, ← List.countP_eq_length_filter, List.countP_reverse, hcount]
-- the stored keys at or above `end_.key` split as the reported ones plus those
-- at or above `R'`
have hsplit : db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
between db r.end_.key R' ++
db.keys.filter (fun k : Key => decide (R' ≤ (k : WithTop Key))) := by
have hdecomp : db.keys =
db.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) < R')) ++
db.keys.filter (fun k : Key =>
decide (¬ ((k : Key) : WithTop Key) < R')) := by
have h1 := filter_lt_eq_take_countP db.sorted R'
have h2 := filter_not_lt_eq_drop_countP db.sorted R'
rw [h1, h2]
exact (List.take_append_drop _ _).symm
have hEB : r.end_.key ≤ R' := le_trans hEH (le_of_lt hHR')
rw [hdecomp, List.filter_append, List.filter_append]
have hK1nil : (db.keys.filter
(fun k : Key => decide (((k : Key) : WithTop Key) < R'))).filter
(fun k : Key => decide (R' ≤ ((k : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro k hk
have hklt : ((k : Key) : WithTop Key) < R' :=
of_decide_eq_true (List.mem_filter.mp hk).2
simpa using decide_eq_false (not_le.mpr hklt)
rw [hK1nil, List.nil_append]
congr 1
· rw [List.filter_filter]
unfold between
apply List.filter_congr
intro k _
by_cases hE : r.end_.key ≤ ((k : Key) : WithTop Key) <;>
by_cases hB : ((k : Key) : WithTop Key) < R' <;> simp [hE, hB]
· apply List.filter_congr
intro k hk
have hklt : ¬ ((k : Key) : WithTop Key) < R' :=
of_decide_eq_true (List.mem_filter.mp hk).2
have hkge : R' ≤ ((k : Key) : WithTop Key) := not_lt.mp hklt
have hE : r.end_.key ≤ ((k : Key) : WithTop Key) := le_trans hEB hkge
simp [hE, hkge]
have hresolve : resolve db r.end_ = R' := by
rw [resolve_eq_filter_getElem? (db := db) (s := r.end_) (by omega)]
rw [hsplit]
have hlen : (between db r.end_.key R').length = (r.end_.offset - 1).toNat := hlenE
rw [List.getElem?_append_right (le_of_eq hlen)]
rw [show (r.end_.offset - 1).toNat - (between db r.end_.key R').length = 0 by omega]
cases hR'eq : R' with
| top =>
have hnil : db.keys.filter
(fun k : Key => decide ((⊤ : WithTop Key) ≤ ((k : Key) : WithTop Key))) = [] := by
rw [List.filter_eq_nil_iff]
intro k _
simp
rw [hnil, List.getElem?_nil]
| coe r =>
have hrmem : r ∈ db.keys := by
apply mem_keys_of_resolve_selAt_eq_coe
(b := keyAfter (res.keys.head hne))
rw [← hr'end]
exact hR'def.symm.trans hR'eq
have hfilt : (db.keys.filter
(fun k : Key => decide ((↑r : WithTop Key) ≤ ((k : Key) : WithTop Key))))[0]? =
some r := by
have hsel : resolve db (selAt (↑r : WithTop Key)) = (↑r : WithTop Key) :=
resolve_selAt_self hrmem
rw [resolve_eq_filter_getElem? (db := db) (s := selAt (↑r : WithTop Key))
(by norm_num : (1 : Int) ≤ (selAt (↑r : WithTop Key)).offset)] at hsel
have hidx : ((selAt (↑r : WithTop Key)).offset - 1).toNat = 0 := by
simp [selAt]
rw [hidx, selAt_key] at hsel
cases hq : (db.keys.filter
(fun k : Key => decide ((↑r : WithTop Key) ≤ ((k : Key) : WithTop Key))))[0]? with
| none => rw [hq] at hsel; simp at hsel
| some k => rw [hq] at hsel; simpa using hsel
rw [hfilt]
have hck : RangeRead.completeKeys db r = RangeRead.completeKeys db r' := by
unfold RangeRead.completeKeys
rw [hr'rev, hrev]
simp only
rw [hresolve, hr'end]
exact (compatible_congr_completeKeys hck hr'lim).mpr hcomp'
constructor
· intro h
rw [← hr'target]
exact hfwd h
· intro h
rw [← hr'target] at h
exact hbwd h
/-- **Elementary `ℕ∞` arithmetic for the finite under cell.** For `t ≥ 1`, subtracting one
from `t` on the left of a sum costs exactly one unit of slack. -/
theorem enat_natCast_sub_one_add_le_iff {I : ℕ∞} {q t : ℕ} (ht : 1 ≤ t) :
(((t - 1 : ℕ) : ℕ∞) + I ≤ (q : ℕ∞)) ↔ (I + (t : ℕ∞) ≤ (q : ℕ∞) + 1) := by
have hts : ((t : ℕ) : ℕ∞) = ((t - 1 : ℕ) : ℕ∞) + 1 := by
rw [← ENat.natCast_one, ← ENat.natCast_add]
congr 1
omega
rw [hts]
rw [show I + (((t - 1 : ℕ) : ℕ∞) + 1) = (((t - 1 : ℕ) : ℕ∞) + I) + 1 by
rw [add_comm I]; ac_rfl]
set m : ℕ∞ := ((t - 1 : ℕ) : ℕ∞) + I
by_cases hm : m = ⊤
· rw [hm]; simp
· rw [ENat.add_one_le_iff hm, ENat.lt_add_one_iff (ENat.natCast_ne_top q)]
/-! ### A general bound on the reported keys below the begin selector
At a negative begin offset the begin anchor sits either `beginSlack + 1` places below
`begin.key` (when it is nonnegative) or before the start of the database, so the stored
keys in `[resolve begin, begin.key)` occupy at most `beginSlack + 1` slots. The reported
keys below `begin.key` are a subcollection of those slots. -/
/-- At a negative begin offset the stored keys in `[resolve begin, begin.key)` fit in
`beginSlack + 1` slots. -/
theorem between_resolve_begin_length_le_beginSlack_succ {db : DB} {r : RangeRead}
(hbegin : r.begin.offset < 0) :
(between db (resolve db r.begin) r.begin.key).length ≤ beginSlack r + 1 := by
set d : ℕ := (between db (resolve db r.begin) r.begin.key).length with hd
have hoff : r.begin.offset ≤ 0 := le_of_lt hbegin
have hEB : resolve db r.begin ≤ r.begin.key := resolve_le_key_of_offset_nonpos hoff
have hdec : cnt db r.begin.key = cnt db (resolve db r.begin) + d :=
cnt_eq_add_between db hEB
have hcntEmin : cnt db (resolve db r.begin) =
min (r.begin.anchor db).toNat db.keys.length := by
rw [cnt, countP_lt_resolve]
have hcntB : (cnt db r.begin.key : ℤ) = r.begin.anchor db + (beginSlack r : ℤ) + 1 := by
have hanc := anchor_eq_count_sub_slack db r hoff
have hc : ((List.countP (fun k : Key =>
decide (((k : Key) : WithTop Key) < r.begin.key)) db.keys : ℕ) : ℤ) =
(cnt db r.begin.key : ℤ) := rfl
rw [hc] at hanc
linarith
rcases lt_or_ge (r.begin.anchor db) 0 with hneg | hpos
· have hres : resolve db r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hneg
rw [hres, cnt_nil, Nat.zero_add] at hdec
have hcntd : (cnt db r.begin.key : ℤ) = (d : ℤ) := by rw [hdec]
have hd_int : (d : ℤ) ≤ (beginSlack r : ℤ) := by linarith
have hd_nat : d ≤ beginSlack r := by exact_mod_cast hd_int
omega
· have hcast : ((r.begin.anchor db).toNat : ℤ) = r.begin.anchor db :=
Int.toNat_of_nonneg hpos
have hcnat : cnt db r.begin.key = (r.begin.anchor db).toNat + beginSlack r + 1 := by
have h : (cnt db r.begin.key : ℤ) =
((r.begin.anchor db).toNat : ℤ) + (beginSlack r : ℤ) + 1 := by
rw [hcast]; linarith
exact_mod_cast h
have hlt : (r.begin.anchor db).toNat < db.keys.length := by
have hle : cnt db r.begin.key ≤ db.keys.length := cnt_le_length db _
omega
rw [hcntEmin, Nat.min_eq_left (le_of_lt hlt)] at hdec
omega
/-- The reported keys below the begin selector are stored in `[resolve begin, begin.key)`.
-/
theorem reportedBelowBegin_le_between_resolve_begin {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (_hbegin : r.begin.offset < 0) :
reportedBelowBegin r res ≤ (between db (resolve db r.begin) r.begin.key).length := by
have hstep1 := List.Sublist.countP_le
(p := fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))
(RangeRead.compatible_keys_prefix hcomp).sublist
have hstep2 : (RangeRead.completeKeys db r).countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
(RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) :=
(RangeRead.completeKeys_perm_inRange db r).countP_eq _
have hstep3 : (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) ≤
(between db (resolve db r.begin) r.begin.key).length := by
have hin : RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) =
db.keys.filter (fun k : Key =>
decide (resolve db r.begin ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < resolve db r.end_)) := rfl
rw [hin, List.countP_filter]
unfold between
rw [← List.countP_eq_length_filter]
apply countP_le_countP_of_imp
intro k _ hk
rw [Bool.and_eq_true] at hk
rw [decide_eq_true_eq]
exact ⟨(of_decide_eq_true hk.2).1, of_decide_eq_true hk.1⟩
calc reportedBelowBegin r res
= res.keys.countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := rfl
_ ≤ (RangeRead.completeKeys db r).countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := hstep1
_ = (RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_)).countP
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := hstep2
_ ≤ (between db (resolve db r.begin) r.begin.key).length := hstep3
/-- **The reported-below-begin bound.** At a negative begin offset, the reported keys
below `begin.key` number at most `beginSlack + 1`. -/
theorem reportedBelowBegin_le_beginSlack_succ {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hbegin : r.begin.offset < 0) :
reportedBelowBegin r res ≤ beginSlack r + 1 :=
le_trans (reportedBelowBegin_le_between_resolve_begin hcomp hbegin)
(between_resolve_begin_length_le_beginSlack_succ hbegin)
/-- Under the crossed finite under cell every reported key lies strictly below
`begin.key`, so all of them are counted by `reportedBelowBegin`. -/
theorem reportedBelowBegin_eq_length_of_crossed {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ [])
(hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key) :
reportedBelowBegin r res = res.keys.length := by
obtain ⟨db, hcomp⟩ := hread
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
have hH : res.keys.headD ([] : Key) = res.keys.head hne := headD_eq_head_of_ne hne
rw [hH] at hcross
have hHK : res.keys.head hne < keyAfter (res.keys.head hne) := keyAfter_self_lt _
unfold reportedBelowBegin
rw [List.countP_eq_length]
intro k hk
rw [decide_eq_true_eq]
have hkH : k ≤ res.keys.head hne :=
(hsort.pairwise.imp (fun h => le_of_lt h)).rel_head hk
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkH)
(lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hHK) (le_of_lt hcross))
/-- The finite under capacity condition is the small-gap condition of the reduced
offset-one read, on the crossed region. -/
theorem finiteUnderCond_iff_crossedSmall {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ [])
(hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key) :
finiteUnderCond r res ↔
intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
r.begin.key + (res.keys.length : ℕ∞) ≤ (beginSlack r : ℕ∞) + 1 := by
have hrep := reportedBelowBegin_eq_length_of_crossed hread hrev hne hcross
have ht : 1 ≤ res.keys.length := List.length_pos_iff.mpr hne
unfold finiteUnderCond
rw [hrep]
exact enat_natCast_sub_one_add_le_iff ht
/-- When the finite under capacity condition fails on the crossed region, the large-gap
condition of the reduced offset-one read holds. -/
theorem crossedLarge_of_not_finiteUnderCond {r : RangeRead} {res : Result}
(hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ [])
(hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key)
(hnot : ¬ finiteUnderCond r res) :
(beginSlack r : ℕ∞) + 2 ≤
intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
r.begin.key + (res.keys.length : ℕ∞) := by
rw [finiteUnderCond_iff_crossedSmall hread hrev hne hcross] at hnot
have hgt : (beginSlack r : ℕ∞) + 1 <
intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
r.begin.key + (res.keys.length : ℕ∞) := not_le.mp hnot
have hone : ((beginSlack r : ℕ∞) + 1) ≠ ⊤ :=
WithTop.add_ne_top.mpr ⟨ENat.natCast_ne_top _, ENat.one_ne_top⟩
have := (ENat.add_one_le_iff hone).mpr hgt
simpa [show ((beginSlack r : ℕ∞) + 1) + 1 = (beginSlack r : ℕ∞) + 2 by
rw [add_assoc]; norm_num] using this
/-- The crossed finite under cell of the reversed crossed negative-begin truncated
residual: the finite under cell with the crossed selectors `keyAfter head < begin.key`. -/
abbrev negCrossTruncRevResidualFiniteUnderCrossed (r : RangeRead) (res : Result) : Prop :=
negCrossTruncRevResidualFiniteUnder r res ∧
(((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key
/-- **The crossed finite under cell of the residual is minimal.** The crossed case makes
the end resolution the least stored key above the reported head, so the cell has the
same compatible databases as the offset-one read with end selector
`(keyAfter head, 1)`, and minimality transfers from the small- or large-gap offset-one
cells. -/
theorem minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_crossed
{r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteUnderCrossed r res) :
Minimal r res (closedFormNegCrossTruncRevResidualFiniteUnder r res) := by
obtain ⟨hbase, hcrossK⟩ := hcell
obtain ⟨hmore, hrev, hbeg, hne, hend, hLE, hcrossL, hcount⟩ := hbase
let r' : RangeRead :=
{ r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) }
have hcompat : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res :=
fun db => compatible_iff_finiteUnder_reduce hmore hrev hne hend hLE hcount db
have hread' : Readable r' res := by
obtain ⟨db, hdb⟩ := hread
exact ⟨db, (hcompat db).mp hdb⟩
have hr'end : r'.end_ =
selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl
have hr'key : r'.end_.key =
(((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl
have hr'off : r'.end_.offset = 1 := rfl
have hr'beg : r'.begin = r.begin := rfl
have hr'begoff : r'.begin.offset < 0 := hbeg
have hr'rev : r'.reverse = true := hrev
have hr'crossK : r'.end_.key < r'.begin.key := by
rw [hr'key, hr'beg]; exact hcrossK
have hr'crossL : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r'.begin.key := by
rw [hr'beg]; exact hcrossL
by_cases hcond : finiteUnderCond r res
· -- small-gap branch
have hcap : intervalCard r'.end_.key r'.begin.key + (res.keys.length : ℕ∞) ≤
(beginSlack r : ℕ∞) + 1 := by
rw [hr'key, hr'beg]
exact (finiteUnderCond_iff_crossedSmall hread hrev hne hcrossK).mp hcond
have hcell' : negCrossTruncRevCrossedSmall r' res := by
refine ⟨hmore, hr'rev, hr'begoff, hne, hr'crossL, hr'crossK, hr'off, hcap⟩
have hmin' : Minimal r' res (truncatedRangeRev r' (res.keys.getLastD ([] : Key))) :=
minimal_closedForm_of_negCross_trunc_rev_crossedSmall hread' hcell'
have hcr : closedFormNegCrossTruncRevResidualFiniteUnder r res =
truncatedRangeRev r' (res.keys.getLastD ([] : Key)) := by
simp [closedFormNegCrossTruncRevResidualFiniteUnder, truncatedRangeRev, hcond,
hr'end]
rw [hcr]
exact (minimal_congr_of_compatible_iff hcompat).mpr hmin'
· -- large-gap branch
have hcap : (beginSlack r : ℕ∞) + 2 ≤
intervalCard r'.end_.key r'.begin.key + (res.keys.length : ℕ∞) := by
rw [hr'key, hr'beg]
exact crossedLarge_of_not_finiteUnderCond hread hrev hne hcrossK hcond
have hcell' : negCrossTruncRevCrossedLarge r' res := by
refine ⟨hmore, hr'rev, hr'begoff, hne, hr'crossL, hr'crossK, hr'off, hcap⟩
have hmin' : Minimal r' res (closedFormNegCrossTruncRevCrossedLarge r' res) :=
minimal_closedForm_of_negCross_trunc_rev_crossedLarge hread' hcell'
have hcr : closedFormNegCrossTruncRevResidualFiniteUnder r res =
closedFormNegCrossTruncRevCrossedLarge r' res := by
simp [closedFormNegCrossTruncRevResidualFiniteUnder,
closedFormNegCrossTruncRevCrossedLarge, hcond, hr'beg]
rw [hcr]
exact (minimal_congr_of_compatible_iff hcompat).mpr hmin'
/-- On the complementary, non-crossed part of the finite under cell, the capacity
condition holds automatically: the interval `[keyAfter head, begin.key)` is empty, and the
reported keys below `begin.key` fit in `beginSlack + 1` slots. -/
theorem finiteUnderCond_of_not_crossed {r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteUnder r res)
(hnotcross : ¬ (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) <
r.begin.key) :
finiteUnderCond r res := by
obtain ⟨db, hcomp⟩ := hread
obtain ⟨hmore, hrev, hbeg, hne, hend, hLE, hcrossL, hcount⟩ := hcell
have hbound := reportedBelowBegin_le_beginSlack_succ hcomp hbeg
have hcard : intervalCard (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
r.begin.key = 0 :=
intervalCard_eq_zero_of_le (le_of_not_gt hnotcross)
unfold finiteUnderCond
rw [hcard, add_zero, ENat.natCast_le_natCast]
omega
/-- The non-crossed finite under cell of the reversed crossed negative-begin truncated
residual: the finite under cell with `begin.key ≤ keyAfter head`. -/
abbrev negCrossTruncRevResidualFiniteUnderNotCrossed (r : RangeRead) (res : Result) : Prop :=
negCrossTruncRevResidualFiniteUnder r res ∧
¬ (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) < r.begin.key
/-- **The non-crossed finite under cell of the residual is minimal.** Here the interval
`[keyAfter head, begin.key)` is empty, so the capacity condition holds and the closed
form is `[last reported, keyAfter head)`. The reduced offset-one read has its begin key
at or below its end key, so minimality transfers from the reversed under-end cell. -/
theorem minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_notCrossed
{r : RangeRead} {res : Result}
(hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteUnderNotCrossed r res) :
Minimal r res (closedFormNegCrossTruncRevResidualFiniteUnder r res) := by
obtain ⟨hbase, hnotcross⟩ := hcell
have hbase0 : negCrossTruncRevResidualFiniteUnder r res := hbase
obtain ⟨hmore, hrev, hbeg, hne, hend, hLE, hcrossL, hcount⟩ := hbase
let r' : RangeRead :=
{ r with end_ := selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) }
have hcompat : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res :=
fun db => compatible_iff_finiteUnder_reduce hmore hrev hne hend hLE hcount db
have hread' : Readable r' res := by
obtain ⟨db, hdb⟩ := hread
exact ⟨db, (hcompat db).mp hdb⟩
have hr'end : r'.end_ =
selAt (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl
have hr'key : r'.end_.key =
(((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := rfl
have hr'off : r'.end_.offset = 1 := rfl
have hr'beg : r'.begin = r.begin := rfl
have hr'rev : r'.reverse = true := hrev
have hr'crossL : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r'.begin.key := by
rw [hr'beg]; exact hcrossL
have hr'under : r'.begin.key ≤ r'.end_.key := by
rw [hr'key]; exact le_of_not_gt hnotcross
have hcond : finiteUnderCond r res := finiteUnderCond_of_not_crossed hread hbase0 hnotcross
have hcell' : negCrossTruncRevUnder r' res :=
⟨hmore, hr'rev, hbeg, hne, hr'crossL, hr'under, by rw [hr'off]⟩
have hmin' : Minimal r' res (closedFormNegCrossTruncRevUnder r' res) :=
minimal_closedForm_of_negCross_trunc_rev_under hread' hcell'
have hcr : closedFormNegCrossTruncRevResidualFiniteUnder r res =
closedFormNegCrossTruncRevUnder r' res := by
simp [closedFormNegCrossTruncRevResidualFiniteUnder, closedFormNegCrossTruncRevUnder,
truncatedRangeRev, hcond, hr'end]
rw [hcr]
exact (minimal_congr_of_compatible_iff hcompat).mpr hmin'
end FormalConflictRange