Files
conflict-range/FormalConflictRange/NegCrossTruncRevResidualFinite.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

672 lines
34 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.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