- 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
672 lines
34 KiB
Lean4
672 lines
34 KiB
Lean4
/-
|
||
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
|
||
Released under Apache 2.0 license as described in the file LICENSE.
|
||
Authors: FormalConflictRange contributors
|
||
-/
|
||
|
||
import FormalConflictRange.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
|