Files
conflict-range/FormalConflictRange/Residual.lean
T
andrew af318a7d32 Fix all Lean build warnings
- Update deprecated lemmas (ite_eq_left/right, ENat casts, List.Sublist, ...)
- Replace push_neg with push Not and resolve unused-variable warnings
- Convert flexible simp/simp_all calls to explicit simp only lists
- Remove unscoped maxHeartbeats options, open scoped Classical, and unused tactics
- Add missing module docstrings and clean up style linter hits
- Wrap over-long lines and flatten the deeply nested
  minimal_conflictRangeClosedForm_total proof

`lake build` now completes with zero warnings.
2026-11-17 10:04:35 -05:00

1439 lines
71 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.Empty
import FormalConflictRange.General
import FormalConflictRange.ComputableAlgorithm
/-!
# The residual complete-result cell
The complete-result closed form has one cross-free cell not given by the earlier
fixed offset rules: `begin.offset ≥ 2`, `end.offset ≥ 2`, `0 < t < e`, a reported key
at or above `end.key`, and `begin.key < end.key`. This file closes it with the
corrected capacity criterion. Writing `b = begin.offset - 1`, `e = end.offset - 1`,
`t` for the reported keys at or above `end.key`, and `g = intervalCard begin.key
end.key`, the minimal range is the truncated range when `(b - g) + t = e` and the top
range when `(b - g) + t < e`.
The finite branch rests on the exact count identity
`completeKeys_count_ge_eq_general`: the number of complete keys at or above
`end.key` is `min e A_E - (b - N)`, where `N` is the number of stored keys in
`[begin.key, end.key)`. Since `N ≤ g`, the finite-branch identity forces `N = g`
and `e ≤ A_E`: every compatible database fills the whole selector gap. Then the
complete window is the first `e` stored keys at or above `end.key`, shifted past
`b - g` of them, and agreement on `[begin.key, keyAfter last)` fixes exactly that
window.
The top branch is witnessed by a compatible database that prepends `b` keys below
the reported head to the reported keys, so its resolved end is `⊤` while its stored
count stays strictly below `c_E + e`. Every key above the reported last is then
necessary, since inserting it breaks compatibility. `residual_dt_le_e` proves the
two branches exhaustive, and `closedFormResidual` assembles the rule.
-/
namespace FormalConflictRange
/-- The begin overshoot `b = begin.offset - 1`. -/
def residualB (r : RangeRead) : ℕ := (r.begin.offset - 1).toNat
/-- The end offset `e = end.offset - 1`. -/
def residualE (r : RangeRead) : ℕ := (r.end_.offset - 1).toNat
/-- The number `t` of reported keys at or above `end.key`. -/
def residualT (r : RangeRead) (res : Result) : ℕ :=
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))
/-- **The finite branch fills the selector gap.** In a compatible database of the
residual cell, if `(b - g) + t = e` with `0 < t < e` and `intervalCard begin.key
end.key = g`, then the database stores all `g` keys of the gap and at least `e` keys
at or above `end.key`, and the begin overshoot exceeds the gap (`g < b`). -/
theorem residual_finite_counts {db : DB} {r : RangeRead} {res : Result} {g : ℕ}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
(hdt : (residualB r - g) + residualT r res = residualE r) :
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) = g ∧
g < residualB r ∧
residualE r ≤ db.keys.length -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
set l := db.keys with hl
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
set cE := l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hcE
set b := residualB r with hb
set e := residualE r with he
set t := residualT r res with ht
set N := cE - p with hN
set A := l.length - cE with hA
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩
· simp [hmore] at hm
· exact heq
have hcount := completeKeys_count_ge_eq_general (db := db) (r := r) hrev hbegin hcross hend
rw [← hres] at hcount
have hbto : b = r.begin.offset.toNat - 1 := by
rw [hb, residualB]; exact toNat_sub_one hbegin
have heto : e = r.end_.offset.toNat - 1 := by
rw [he, residualE]; exact toNat_sub_one hend
have hcount' : t = min e A - (b - N) := by
rw [hbto, heto]
simpa [residualT, l, p, cE, t, N, A, ht, hl, hp, hcE, hN, hA] using hcount
have hNle : N ≤ g := by
have h := cnt_sub_le_intervalCard (db := db) (w₁ := r.begin.key) (w₂ := r.end_.key) hcross
rw [hcard] at h
have hcast := ENat.natCast_le_natCast.mp h
simpa [N, p, cE, cnt, hl, hp, hcE, hN] using hcast
have hbg : g < b := by
have : 0 < b - g := by omega
omega
have hbNpos : 0 < b - N := by omega
have hmin : min e A = e := by
have hminge : b - N ≤ min e A := by
by_contra hlt
have hzero : min e A - (b - N) = 0 := Nat.sub_eq_zero_of_le (le_of_not_ge hlt)
omega
have hbge : b - g ≤ b - N := Nat.sub_le_sub_left hNle b
omega
refine ⟨?_, hbg, by omega⟩
omega
/-! ### The finite-branch window and its list decompositions
The complete window of a compatible database in the finite branch is the first `e`
stored keys at or above `end.key`, with the begin overshoot `b - g` dropped. To
compare two databases that agree on `[begin.key, keyAfter last)`, split the stored
keys of that range at `end.key` and split the keys at or above `end.key` at the
reported last. Both decompositions are proved by sortedness and membership. -/
private def rD (r : RangeRead) (last : Key) (db : DB) : List Key :=
(truncatedRange r last).keys db
private def rG (r : RangeRead) (db : DB) : List Key :=
db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.end_.key))
private def rA (r : RangeRead) (last : Key) (db : DB) : List Key :=
db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧
(k : Key) ≤ last))
private def rW (r : RangeRead) (db : DB) : List Key :=
db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))
private def rAbove (last : Key) (db : DB) : List Key :=
db.keys.filter (fun k : Key => decide (last < k))
private theorem mem_rD {r : RangeRead} {last : Key} {db : DB} {k : Key} :
k ∈ rD r last db ↔
k ∈ db.keys ∧ r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ↑last := by
rw [rD, truncatedRange_keys_eq_filter_le, List.mem_filter, List.mem_filter,
decide_eq_true_eq, decide_eq_true_eq, WithTop.coe_le_coe]
tauto
private theorem mem_rG {r : RangeRead} {db : DB} {k : Key} :
k ∈ rG r db ↔
k ∈ db.keys ∧ r.begin.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key := by
simp [rG]
private theorem mem_rA {r : RangeRead} {last : Key} {db : DB} {k : Key} :
k ∈ rA r last db ↔
k ∈ db.keys ∧ r.end_.key ≤ (k : WithTop Key) ∧ (k : WithTop Key) ≤ ↑last := by
simp [rA]
private theorem mem_rW {r : RangeRead} {db : DB} {k : Key} :
k ∈ rW r db ↔ k ∈ db.keys ∧ r.end_.key ≤ (k : WithTop Key) := by
simp [rW]
private theorem mem_rAbove {last : Key} {db : DB} {k : Key} :
k ∈ rAbove last db ↔ k ∈ db.keys ∧ ↑last < (k : WithTop Key) := by
simp [rAbove]
private theorem sorted_rD {r : RangeRead} {last : Key} {db : DB} :
(rD r last db).SortedLT := by
rw [rD, truncatedRange_keys_eq_filter_le]
exact List.sortedLT_iff_pairwise.mpr ((db.sorted.pairwise.filter _).filter _)
private theorem sorted_rG {r : RangeRead} {db : DB} : (rG r db).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
private theorem sorted_rA {r : RangeRead} {last : Key} {db : DB} :
(rA r last db).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
private theorem sorted_rW {r : RangeRead} {db : DB} : (rW r db).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
private theorem sorted_rAbove {last : Key} {db : DB} : (rAbove last db).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
private theorem rD_eq_rG_append_rA {r : RangeRead} {last : Key} {db : DB}
(hBE : r.begin.key ≤ r.end_.key) (hElast : r.end_.key ≤ (↑last : WithTop Key)) :
rD r last db = rG r db ++ rA r last db := by
refine List.SortedLT.eq_of_mem_iff (sorted_rD) ?_ ?_
· rw [List.sortedLT_append]
refine ⟨sorted_rG, sorted_rA, ?_⟩
intro x hx y hy
have hx' := (mem_rG.mp hx).2.2
have hy' := (mem_rA.mp hy).2.1
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le hx' hy')
· intro k
rw [mem_rD, List.mem_append, mem_rG, mem_rA]
constructor
· rintro ⟨hmem, hB, hklast⟩
by_cases hk : (k : WithTop Key) < r.end_.key
· exact Or.inl ⟨hmem, hB, hk⟩
· exact Or.inr ⟨hmem, le_of_not_gt hk, hklast⟩
· rintro (⟨hmem, hB, hk⟩ | ⟨hmem, hE, hklast⟩)
· exact ⟨hmem, hB, le_trans (le_of_lt hk) hElast⟩
· exact ⟨hmem, le_trans hBE hE, hklast⟩
private theorem rW_eq_rA_append_rAbove {r : RangeRead} {last : Key} {db : DB}
(hElast : r.end_.key ≤ (↑last : WithTop Key)) :
rW r db = rA r last db ++ rAbove last db := by
refine List.SortedLT.eq_of_mem_iff (sorted_rW) ?_ ?_
· rw [List.sortedLT_append]
refine ⟨sorted_rA, sorted_rAbove, ?_⟩
intro x hx y hy
have hx' := (mem_rA.mp hx).2.2
have hy' := (mem_rAbove.mp hy).2
exact WithTop.coe_lt_coe.mp (lt_of_le_of_lt hx' hy')
· intro k
rw [mem_rW, List.mem_append, mem_rA, mem_rAbove]
constructor
· rintro ⟨hmem, hE⟩
by_cases hk : (k : WithTop Key) ≤ ↑last
· exact Or.inl ⟨hmem, hE, hk⟩
· exact Or.inr ⟨hmem, lt_of_not_ge hk⟩
· rintro (⟨hmem, hE, -⟩ | ⟨hmem, hlt⟩)
· exact ⟨hmem, hE⟩
· exact ⟨hmem, le_trans hElast (le_of_lt hlt)⟩
/-- **The finite-branch window.** In the finite branch the complete keys of any
compatible database are the first `e` stored keys at or above `end.key`, with the
begin overshoot `b - g` dropped. -/
theorem residual_window {db : DB} {r : RangeRead} {res : Result} {g : ℕ}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
(hdt : (residualB r - g) + residualT r res = residualE r) :
RangeRead.completeKeys db r =
((rW r db).take (residualE r)).drop (residualB r - g) := by
obtain ⟨hN, hbg, hAle⟩ :=
residual_finite_counts hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt
have hbN : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤
(r.begin.offset - 1).toNat := by
rw [show (r.begin.offset - 1).toNat = residualB r from rfl]
calc db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) = g := hN
_ ≤ residualB r := le_of_lt hbg
have hAle' : (r.end_.offset - 1).toNat ≤ db.keys.length -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := hAle
have h := completeKeys_eq_above_take_drop (db := db) (r := r) hrev hbegin hcross hend hbN hAle'
simpa [rW, residualB, residualE, hN] using h
/-- The reported last is at or above `end.key` whenever some reported key is. -/
theorem last_ge_end_of_count_pos {r : RangeRead} {res : Result}
(hsort : res.keys.SortedLT) (hne : res.keys ≠ [])
(htpos : 0 < res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))) :
r.end_.key ≤ ((res.keys.getLast hne : Key) : WithTop Key) := by
obtain ⟨k, hk, hkge⟩ := List.countP_pos_iff.mp htpos
rw [decide_eq_true_eq] at hkge
exact le_trans hkge (WithTop.coe_le_coe.mpr
((hsort.pairwise.imp le_of_lt).rel_getLast hk))
/-- The keys in `[begin.key, end.key)` number the difference of the counts below the
two endpoints. -/
private theorem rG_length_eq_cnt {r : RangeRead} {db : DB}
(hBE : r.begin.key ≤ r.end_.key) :
(rG r db).length = cnt db r.end_.key - cnt db r.begin.key := by
have h := cnt_eq_add_between db hBE
have hr : rG r db = between db r.begin.key r.end_.key := rfl
rw [hr]
omega
/-- The keys in `[end.key, last]` number `e` in the finite branch. The complete
window is the reported result; filtering it at or below the reported last removes
nothing, and the general drop identity turns that filter into the truncated range
with the begin overshoot removed. Splitting the truncated range at `end.key` leaves
`[end.key, last]`, whose length is `e`. -/
private theorem rA_length_eq {db : DB} {r : RangeRead} {res : Result} {g : ℕ} {last : Key}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(hlast : last = res.keys.getLast hne)
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
(hdt : (residualB r - g) + residualT r res = residualE r) :
(rA r last db).length = residualE r := by
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, _, _⟩ | ⟨_, heq⟩
· simp [hmore] at hm
· exact heq
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hlast_mem : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hmemck : last ∈ RangeRead.completeKeys db r := by
rw [← hres]; exact hlast_mem
have hlr : (last : WithTop Key) < resolve db r.end_ :=
(RangeRead.mem_completeKeys.mp hmemck).2.2
have hfilt : (RangeRead.completeKeys db r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [← hres, hlast]
exact filter_le_getLast_eq_of_prefix hsort.pairwise (List.prefix_refl _) hne
have hdrop := completeKeys_filter_le_drop (db := db) (r := r) (last := last)
hrev hbegin hlr
rw [hfilt] at hdrop
obtain ⟨hN, hbg, hAle⟩ :=
residual_finite_counts hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt
have hElast : r.end_.key ≤ (↑last : WithTop Key) := by
rw [hlast]
exact last_ge_end_of_count_pos hsort hne htpos
have hGg : (rG r db).length = g := by
rw [rG_length_eq_cnt hcross]
simpa [cnt] using hN
have hDdrop : (rD r last db).drop (residualB r) = res.keys := by
rw [rD]
simpa [residualB] using hdrop.symm
have hD := rD_eq_rG_append_rA (r := r) (last := last) (db := db) hcross hElast
have hb_eq : residualB r = g + (residualB r - g) := by omega
have hA_drop : (rA r last db).drop (residualB r - g) = res.keys := by
have hstep : (rD r last db).drop (residualB r) =
((rG r db) ++ (rA r last db)).drop (g + (residualB r - g)) := by
conv_lhs =>
rw [hD]
rw [hb_eq]
rw [hstep, List.drop_append] at hDdrop
rw [List.drop_eq_nil_of_le (by omega : (rG r db).length ≤ g + (residualB r - g)),
List.nil_append] at hDdrop
have hsub : g + (residualB r - g) - (rG r db).length = residualB r - g := by
rw [hGg]; omega
rwa [hsub] at hDdrop
have hresmem : ∀ k ∈ res.keys, r.end_.key ≤ (k : WithTop Key) := by
intro k hk
have hkA : k ∈ rA r last db := by
apply List.mem_of_mem_drop
rw [hA_drop]
exact hk
exact (mem_rA.mp hkA).2.1
have htlen : residualT r res = res.keys.length := by
rw [residualT]
exact List.countP_eq_length.mpr fun k hk => by
rw [decide_eq_true_eq]; exact hresmem k hk
have hlen := congrArg List.length hA_drop
rw [List.length_drop] at hlen
omega
/-- `[begin.key, end.key)` is the part of `[begin.key, last]` below `end.key`, when
`end.key ≤ last`. -/
private theorem rG_eq_rD_filter_lt {r : RangeRead} {last : Key} {db : DB}
(hElast : r.end_.key ≤ (↑last : WithTop Key)) :
rG r db = (rD r last db).filter
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
refine List.SortedLT.eq_of_mem_iff sorted_rG ?_ ?_
· exact List.sortedLT_iff_pairwise.mpr (sorted_rD.pairwise.filter _)
· intro k
rw [mem_rG, List.mem_filter, mem_rD]
constructor
· rintro ⟨hmem, hB, hkE⟩
exact ⟨⟨hmem, hB, le_trans (le_of_lt hkE) hElast⟩,
by rw [decide_eq_true_eq]; exact hkE⟩
· rintro ⟨⟨hmem, hB, -⟩, hkE⟩
exact ⟨hmem, hB, of_decide_eq_true hkE⟩
/-- `[end.key, last]` is the part of `[begin.key, last]` at or above `end.key`, when
`begin.key ≤ end.key`. -/
private theorem rA_eq_rD_filter_ge {r : RangeRead} {last : Key} {db : DB}
(hBE : r.begin.key ≤ r.end_.key) :
rA r last db = (rD r last db).filter
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by
refine List.SortedLT.eq_of_mem_iff sorted_rA ?_ ?_
· exact List.sortedLT_iff_pairwise.mpr (sorted_rD.pairwise.filter _)
· intro k
rw [mem_rA, List.mem_filter, mem_rD]
constructor
· rintro ⟨hmem, hE, hklast⟩
exact ⟨⟨hmem, le_trans hBE hE, hklast⟩,
by rw [decide_eq_true_eq]; exact hE⟩
· rintro ⟨⟨hmem, -, hklast⟩, hE⟩
exact ⟨hmem, of_decide_eq_true hE, hklast⟩
/-- **Finite-branch completeness from agreement.** If a database agrees on the
truncated range `[begin.key, keyAfter last)` with a finite-branch compatible
database, then it is itself complete: the shared gap `[begin.key, end.key)` fills
the begin overshoot, and the first `e` stored keys at or above `end.key` reach the
reported last. -/
private theorem completeKeys_eq_of_truncated_eq_finite {db₁ db₂ : DB} {r : RangeRead}
{res : Result} {g : ℕ} {last : Key}
(hcomp : RangeRead.Compatible db₁ r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(hlast : last = res.keys.getLast hne)
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
(hdt : (residualB r - g) + residualT r res = residualE r)
(hT : (truncatedRange r last).keys db₂ = (truncatedRange r last).keys db₁) :
RangeRead.completeKeys db₂ r = res.keys := by
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
obtain ⟨hN₁, hbg, hAle₁⟩ :=
residual_finite_counts hcomp hmore hrev hbegin hcross hend hcard htpos htlt hdt
have hElast : r.end_.key ≤ (↑last : WithTop Key) := by
rw [hlast]
exact last_ge_end_of_count_pos hsort hne htpos
have hres₁ : res.keys = RangeRead.completeKeys db₁ r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
-- Agreement splits into the gap and the above-`end` parts.
have hT' : rD r last db₂ = rD r last db₁ := by simpa [rD] using hT
have hG₂ : rG r db₂ = rG r db₁ := by
rw [rG_eq_rD_filter_lt (db := db₂) hElast,
rG_eq_rD_filter_lt (db := db₁) hElast, hT']
have hA₂ : rA r last db₂ = rA r last db₁ := by
rw [rA_eq_rD_filter_ge (db := db₂) hcross,
rA_eq_rD_filter_ge (db := db₁) hcross, hT']
have hGlen₂ : (rG r db₂).length = g := by
rw [hG₂, rG_length_eq_cnt (db := db₁) hcross]
simpa [cnt] using hN₁
have hAlen₁ : (rA r last db₁).length = residualE r :=
rA_length_eq hcomp hmore hrev hne hbegin hcross hend hcard hlast htpos htlt hdt
have hAlen₂ : (rA r last db₂).length = residualE r := by rw [hA₂, hAlen₁]
-- The reference database's window.
have hW₁ := residual_window (db := db₁) hcomp hmore hrev hbegin hcross hend hcard
htpos htlt hdt
have hW₁dec := rW_eq_rA_append_rAbove (r := r) (last := last) (db := db₁) hElast
have htake₁ : (rW r db₁).take (residualE r) = rA r last db₁ := by
rw [hW₁dec, List.take_append_of_le_length (le_of_eq hAlen₁.symm),
List.take_of_length_le (le_of_eq hAlen₁)]
have hresA : (rA r last db₁).drop (residualB r - g) = res.keys := by
rw [← htake₁, ← hW₁, ← hres₁]
-- The shared decomposition supplies the count bounds for `db₂`.
have hgap₂ : db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) = g := by
have h := rG_length_eq_cnt (db := db₂) hcross
rw [← hGlen₂]
simpa [cnt] using h.symm
have hbN₂ : db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤
(r.begin.offset - 1).toNat := by
rw [hgap₂]
exact le_of_lt hbg
have hAle₂ : (r.end_.offset - 1).toNat ≤ db₂.keys.length -
db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
have h := cnt_add_above_length db₂ r.end_.key
have hsub : db₂.keys.length -
db₂.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) =
(above db₂ r.end_.key).length := by
have hcnt : db₂.keys.countP
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = cnt db₂ r.end_.key := rfl
omega
rw [hsub]
have hdec := rW_eq_rA_append_rAbove (r := r) (last := last) (db := db₂) hElast
have : above db₂ r.end_.key = rW r db₂ := rfl
rw [this, hdec, List.length_append]
have heq : (r.end_.offset - 1).toNat = residualE r := rfl
rw [heq, hAlen₂]
omega
-- The general window formula plus the shared gap/`end` split.
have hformula := completeKeys_eq_above_take_drop (db := db₂) (r := r)
hrev hbegin hcross hend hbN₂ hAle₂
rw [hgap₂] at hformula
have hrW₂ : db₂.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
rW r db₂ := rfl
rw [hrW₂] at hformula
have hW₂dec := rW_eq_rA_append_rAbove (r := r) (last := last) (db := db₂) hElast
have htake₂ : (rW r db₂).take (residualE r) = rA r last db₂ := by
rw [hW₂dec, List.take_append_of_le_length (le_of_eq hAlen₂.symm),
List.take_of_length_le (le_of_eq hAlen₂)]
change RangeRead.completeKeys db₂ r =
((rW r db₂).take (residualE r)).drop (residualB r - g) at hformula
rw [htake₂, hA₂, hresA] at hformula
exact hformula
/-- **Finite-branch soundness in the residual cell.** Agreement on
`[begin.key, keyAfter last)` fixes compatibility for a complete result whose finite
branch is `(b - g) + t = e`. -/
theorem sound_truncatedRange_of_residual_finite {r : RangeRead} {res : Result} {g : ℕ}
(hmore : res.more = false)
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
(hdt : (residualB r - g) + residualT r res = residualE r) :
Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by
have hne : res.keys ≠ [] := by
intro hnil
rw [residualT, hnil] at htpos
simp at htpos
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hlast]
intro db₁ db₂ hagree
have hcomp : ∀ db : DB, RangeRead.Compatible db r res →
RangeRead.withinLimit r res.keys ∧ RangeRead.completeKeys db r = res.keys := by
intro db hc
refine ⟨hc.1, ?_⟩
rcases hc.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq.symm
constructor
· intro hc₁
obtain ⟨hlim, hck₁⟩ := hcomp db₁ hc₁
have hT : (truncatedRange r (res.keys.getLast hne)).keys db₂ =
(truncatedRange r (res.keys.getLast hne)).keys db₁ := hagree.symm
have hck₂ := completeKeys_eq_of_truncated_eq_finite
(db₁ := db₁) (db₂ := db₂) (g := g)
⟨hlim, Or.inr ⟨hmore, hck₁.symm⟩⟩ hmore hrev hne hbegin hcross hend hcard rfl
htpos htlt hdt hT
exact ⟨hlim, Or.inr ⟨hmore, hck₂.symm⟩⟩
· intro hc₂
obtain ⟨hlim, hck₂⟩ := hcomp db₂ hc₂
have hT : (truncatedRange r (res.keys.getLast hne)).keys db₁ =
(truncatedRange r (res.keys.getLast hne)).keys db₂ := hagree
have hck₁ := completeKeys_eq_of_truncated_eq_finite
(db₁ := db₂) (db₂ := db₁) (g := g)
⟨hlim, Or.inr ⟨hmore, hck₂.symm⟩⟩ hmore hrev hne hbegin hcross hend hcard rfl
htpos htlt hdt hT
exact ⟨hlim, Or.inr ⟨hmore, hck₁.symm⟩⟩
/-- **Finite-branch minimality in the residual cell.** The truncated range
`[begin.key, keyAfter last)` is minimal for a complete result in the finite branch
`(b - g) + t = e`. -/
theorem minimal_truncatedRange_of_residual_finite {r : RangeRead} {res : Result} {g : ℕ}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r)
(hdt : (residualB r - g) + residualT r res = residualE r) :
Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by
obtain ⟨db₀, hcomp₀⟩ := hread
have hne : res.keys ≠ [] := by
intro hnil
rw [residualT, hnil] at htpos
simp at htpos
have hgetLast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
rw [hgetLast]
have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r :=
RangeRead.compatible_keys_prefix hcomp₀
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
· rw [← hgetLast]
exact sound_truncatedRange_of_residual_finite hmore hrev hbegin hcross hend hcard
htpos htlt hdt
· intro k hk cr hs
have hlast_nec : Necessary r res (res.keys.getLast hne) :=
necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)
have hBtop : r.begin.key ≠ (⊤ : WithTop Key) := by
obtain ⟨m, _, hmge⟩ := List.countP_pos_iff.mp htpos
rw [decide_eq_true_eq] at hmge
intro htop
rw [htop] at hcross
exact absurd (le_trans hcross hmge) (not_le_of_gt (WithTop.coe_lt_top m))
obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hBtop
have hvB : r.begin.key = (↑v : WithTop Key) := hv.symm
have hbegin_nec : Necessary r res v :=
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hvB
have hvk : v ≤ k := WithTop.coe_le_coe.mp (hvB ▸ hk.1)
have hkle : k ≤ res.keys.getLast hne :=
(lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hk.2)
exact hbegin_nec.of_between hlast_nec hvk hkle cr hs
private theorem residual_between_begin_head {db₀ : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) :
(between db₀ r.begin.key ((res.keys.head hne : Key) : WithTop Key)).length =
(r.begin.offset - 1).toNat := by
set H : Key := res.keys.head hne with hH
have hres : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hneCK : RangeRead.completeKeys db₀ r ≠ [] := by rw [← hres]; exact hne
have hpos : 0 ≤ r.begin.anchor db₀ := anchor_nonneg_of_one_le hbegin
obtain ⟨a, ha_mem, ha_res, ha_head⟩ :=
RangeRead.completeKeys_head_resolve (db := db₀) (r := r) hrev hneCK hpos
have hHhead? : res.keys.head? = some H := by
rw [hH, List.head?_eq_some_head hne]
have hahead? : (RangeRead.completeKeys db₀ r).head? = some a := by
rw [← ha_head, List.head?_eq_some_head hneCK]
have hsome : some H = some a := by
rw [← hHhead?, ← hahead?]
exact congrArg List.head? hres
have ha : a = H := (Option.some.inj hsome.symm)
have hresolveB : resolve db₀ r.begin = (↑H : WithTop Key) := by
rw [← ha, ha_res]
-- anchor < length
have hlt : (r.begin.anchor db₀).toNat < db₀.keys.length := by
by_contra h
have htop : resolve db₀ r.begin = (⊤ : WithTop Key) :=
resolve_eq_top hpos (le_of_not_gt h)
rw [htop] at hresolveB
exact absurd hresolveB.symm (by simp)
have hget : db₀.keys[(r.begin.anchor db₀).toNat] = H := by
have h := resolve_eq_getElem (db := db₀) (s := r.begin) hpos hlt
rw [h] at hresolveB
exact WithTop.coe_eq_coe.mp hresolveB
have hcnt : cnt db₀ (↑H : WithTop Key) = (r.begin.anchor db₀).toNat := by
rw [cnt_coe]
exact countP_lt_eq_of_getElem db₀.sorted hlt hget
have hanchor : (r.begin.anchor db₀).toNat =
cnt db₀ r.begin.key + (r.begin.offset - 1).toNat := by
rw [anchor_toNat_eq hbegin]
rfl
have hBH : r.begin.key ≤ (↑H : WithTop Key) := by
have h := begin_key_le_head_of_one_le_offset (r := r) (res := res) ⟨db₀, hcomp⟩ hne hbegin
rwa [hH]
have hadd := cnt_eq_add_between db₀ hBH
omega
private theorem residual_topWitness_of_D {db₀ : DB} {r : RangeRead} {res : Result} {g n : ℕ} {H :
Key}
(hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hend : 2 ≤ r.end_.offset)
(hHle : ∀ k ∈ res.keys, (↑H : WithTop Key) ≤ (↑k : WithTop Key))
(hBH : r.begin.key ≤ (↑H : WithTop Key))
(D : List Key)
(hDlen : D.length = residualB r)
(hDsorted : D.SortedLT)
(hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key))
(hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key))
(hDcntE : (D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n)
(hbn : residualB r - n = residualB r - g)
(htop : (residualB r - g) + residualT r res < residualE r) :
∃ w : DB, RangeRead.Compatible w r res ∧
(∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤
((res.keys.getLast hne : Key) : WithTop Key)) ∧
resolve w r.end_ = (⊤ : WithTop Key) ∧
w.keys.length < w.keys.countP
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat := by
have hRsorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hwsorted : (D ++ res.keys).SortedLT := by
rw [List.sortedLT_append]
refine ⟨hDsorted, hRsorted, ?_⟩
intro a ha b hb
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hDH a ha) (hHle b hb))
let w : DB := { keys := D ++ res.keys, sorted := hwsorted }
have hwkeys : w.keys = D ++ res.keys := rfl
have hDBw : ∀ k ∈ w.keys, r.begin.key ≤ (↑k : WithTop Key) := by
intro k hk
rw [hwkeys] at hk
rcases List.mem_append.mp hk with hkD | hkR
· exact hDB k hkD
· exact le_trans hBH (hHle k hkR)
have htopKeys : (topRange r).keys w = w.keys := by
unfold topRange ConflictRange.keys
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq]
exact ⟨hDBw k hk, WithTop.coe_lt_top k⟩
have hwlen : w.keys.length = residualB r + res.keys.length := by
rw [hwkeys, List.length_append, hDlen]
have hwcnt : w.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) =
n + res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
rw [hwkeys, List.countP_append]
have hDcnt : D.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = n := by
rw [List.countP_eq_length_filter, hDcntE]
rw [hDcnt]
have hres_split : res.keys.length =
(res.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length +
residualT r res := by
have h := List.length_eq_countP_add_countP (l := res.keys)
(p := fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))
have hc : List.countP
(fun a : Key => decide ¬(decide (r.end_.key ≤ (a : WithTop Key))) = true) res.keys
= res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) := by
apply List.countP_congr
intro k hk
simp only [decide_eq_true_eq]
exact not_le
rw [hc] at h
have h2 : res.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) =
(res.keys.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length :=
List.countP_eq_length_filter
rw [h2] at h
rw [residualT]
omega
have hlen_lt : w.keys.length < w.keys.countP
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat := by
rw [hwlen, hwcnt, List.countP_eq_length_filter]
rw [hres_split]
have hee : residualE r = (r.end_.offset - 1).toNat := rfl
rw [← hee]
omega
have hEtop : resolve w r.end_ = (⊤ : WithTop Key) := by
refine resolve_eq_top (anchor_nonneg_of_one_le (by omega)) ?_
rw [anchor_toNat_eq (s := r.end_) (by omega)]
omega
have hckW : RangeRead.completeKeys w r = res.keys := by
rw [completeKeys_eq_topRange_keys_drop (db := w) (r := r) hrev hbegin hEtop, htopKeys]
rw [hwkeys]
change List.drop (residualB r) (D ++ res.keys) = res.keys
rw [List.drop_append_of_le_length (i := residualB r) (le_of_eq hDlen.symm),
List.drop_eq_nil_of_le (le_of_eq hDlen), List.nil_append]
have hwcomp : RangeRead.Compatible w r res := by
refine ⟨hcomp.1, Or.inr ⟨hmore, hckW.symm⟩⟩
have hwsub : ∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤
((res.keys.getLast hne : Key) : WithTop Key) := by
intro k hk
rw [hwkeys] at hk
rcases List.mem_append.mp hk with hkD | hkR
· exact le_trans (le_of_lt (hDH k hkD))
(hHle _ (List.getLast_mem hne))
· exact WithTop.coe_le_coe.mpr ((hRsorted.pairwise.imp le_of_lt).rel_getLast hkR)
exact ⟨w, hwcomp, hwsub, hEtop, hlen_lt⟩
private theorem residual_exists_topWitness {db₀ : DB} {r : RangeRead} {res : Result} {g : ℕ}
(hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htop : (residualB r - g) + residualT r res < residualE r) :
∃ w : DB, RangeRead.Compatible w r res ∧
(∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤
((res.keys.getLast hne : Key) : WithTop Key)) ∧
resolve w r.end_ = (⊤ : WithTop Key) ∧
w.keys.length < w.keys.countP
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat := by
have hres : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
set H : Key := res.keys.head hne with hH
have hHmem : H ∈ res.keys := by rw [hH]; exact List.head_mem hne
have hRsorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hHle : ∀ k ∈ res.keys, (↑H : WithTop Key) ≤ (↑k : WithTop Key) := by
intro k hk
rw [hH]
exact WithTop.coe_le_coe.mpr ((hRsorted.pairwise.imp le_of_lt).rel_head hk)
have hBH : r.begin.key ≤ (↑H : WithTop Key) := by
have h := begin_key_le_head_of_one_le_offset (r := r) (res := res) ⟨db₀, hcomp⟩ hne hbegin
rwa [hH]
have hB_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
intro htop'
have hle : (⊤ : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [htop'] at hBH
exact absurd hle (not_le.mpr (WithTop.coe_lt_top H))
obtain ⟨v, hvB⟩ := WithTop.ne_top_iff_exists.mp hB_ne_top
have hvB' : r.begin.key = (↑v : WithTop Key) := hvB.symm
have hE_ne_top : r.end_.key ≠ (⊤ : WithTop Key) := by
intro htop'
rw [htop', intervalCard_top_right hB_ne_top] at hcard
exact absurd hcard (by simp)
obtain ⟨e, heE'⟩ := WithTop.ne_top_iff_exists.mp hE_ne_top
have heE : r.end_.key = (↑e : WithTop Key) := heE'.symm
have hcard' : intervalCard (↑v : WithTop Key) (↑e : WithTop Key) = (g : ℕ∞) := by
simpa [hvB', heE] using hcard
have hve : (↑v : WithTop Key) ≤ (↑e : WithTop Key) := by
rw [← hvB', ← heE]; exact hcross
have hBH' : (↑v : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [hvB'] at hBH
have hlenBH : (between db₀ (↑v) (↑H)).length = residualB r := by
have h := residual_between_begin_head (db₀ := db₀) (r := r) (res := res)
hcomp hmore hrev hne hbegin
have hh : ((res.keys.head hne : Key) : WithTop Key) = (↑H : WithTop Key) := by rw [hH]
rw [hvB', hh] at h
simpa [residualB] using h
have hleBE : (between db₀ (↑v) (↑e)).length ≤ g := by
have h := between_length_le_intervalCard (db := db₀) hve
rw [hcard'] at h
exact_mod_cast h
by_cases hEH : r.end_.key ≤ (↑H : WithTop Key)
· -- Case `end.key ≤ H`: fill `min b g` chain keys below `end.key`,
-- then take the remaining `b - min b g` database keys in `[end.key, H)`.
have hEH' : (↑e : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [heE] at hEH
have hsplit : (between db₀ (↑v) (↑H)).length =
(between db₀ (↑v) (↑e)).length + (between db₀ (↑e) (↑H)).length := by
have h1 := cnt_eq_add_between db₀ hve
have h2 := cnt_eq_add_between db₀ hBH'
have h3 := cnt_eq_add_between db₀ hEH'
omega
have hleBE_b : (between db₀ (↑v) (↑e)).length ≤ residualB r := by omega
have hleBE_n : (between db₀ (↑v) (↑e)).length ≤ min (residualB r) g :=
le_min hleBE_b hleBE
have hd_le : residualB r - min (residualB r) g ≤
(between db₀ (↑e) (↑H)).length := by omega
set n : ℕ := min (residualB r) g with hn
set D : List Key := ((List.range n).map (chain v)) ++
(between db₀ (↑e) (↑H)).take (residualB r - n) with hD
have hDlen : D.length = residualB r := by
simp only [hD, List.length_append, List.length_map, List.length_range,
List.length_take]
omega
have hbtsorted : (between db₀ (↑e) (↑H)).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _)
have hD2sorted : ((between db₀ (↑e) (↑H)).take (residualB r - n)).SortedLT :=
List.sortedLT_iff_pairwise.mpr
(List.Pairwise.take (R := (· < ·)) (List.sortedLT_iff_pairwise.mp hbtsorted))
have hDsorted : D.SortedLT := by
rw [hD, List.sortedLT_append]
refine ⟨sortedLT_map_chain v n, hD2sorted, ?_⟩
intro a ha b hb
rw [List.mem_map] at ha
obtain ⟨i, hi, rfl⟩ := ha
have hi_lt : i < g := lt_of_lt_of_le (List.mem_range.mp hi) (min_le_right _ _)
have hae : chain v i < e := by
rw [chain_lt_iff]
rw [hcard']
exact_mod_cast hi_lt
have hbmem := List.mem_of_mem_take hb
rw [between, List.mem_filter] at hbmem
exact lt_of_lt_of_le hae (WithTop.coe_le_coe.mp (of_decide_eq_true hbmem.2).1)
have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by
intro k hk
rw [hD, List.mem_append] at hk
rcases hk with hk1 | hk2
· rw [List.mem_map] at hk1
obtain ⟨i, hi, rfl⟩ := hk1
rw [hvB']
exact WithTop.coe_le_coe.mpr (chain_le v i)
· have hbmem := List.mem_of_mem_take hk2
rw [between, List.mem_filter] at hbmem
rw [hvB']
exact le_trans hve (of_decide_eq_true hbmem.2).1
have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by
intro k hk
rw [hD, List.mem_append] at hk
rcases hk with hk1 | hk2
· rw [List.mem_map] at hk1
obtain ⟨i, hi, rfl⟩ := hk1
have hi_lt : i < g := lt_of_lt_of_le (List.mem_range.mp hi) (min_le_right _ _)
have hae : chain v i < e := by
rw [chain_lt_iff]
rw [hcard']
exact_mod_cast hi_lt
exact lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hae) hEH'
· have hbmem := List.mem_of_mem_take hk2
rw [between, List.mem_filter] at hbmem
exact (of_decide_eq_true hbmem.2).2
have hDcntE : (D.filter
(fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by
rw [hD, List.filter_append]
have h1 : (List.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))
((List.range n).map (chain v))) = (List.range n).map (chain v) := by
rw [List.filter_eq_self]
intro k hk
rw [List.mem_map] at hk
obtain ⟨i, hi, rfl⟩ := hk
rw [decide_eq_true_eq, heE]
have hi_lt : i < g := lt_of_lt_of_le (List.mem_range.mp hi) (min_le_right _ _)
have hae : chain v i < e := by
rw [chain_lt_iff]
rw [hcard']
exact_mod_cast hi_lt
exact WithTop.coe_lt_coe.mpr hae
have h2 : (List.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key))
((between db₀ (↑e) (↑H)).take (residualB r - n))) = [] := by
rw [List.filter_eq_nil_iff]
intro k hk
rw [decide_eq_true_eq]
have hbmem := List.mem_of_mem_take hk
rw [between, List.mem_filter] at hbmem
have hEk : (↑e : WithTop Key) ≤ (↑k : WithTop Key) := (of_decide_eq_true hbmem.2).1
intro hklt
rw [heE] at hklt
exact absurd hklt (not_lt.mpr hEk)
rw [h1, h2, List.length_append, List.length_map, List.length_range, List.length_nil]
omega
have hbn : residualB r - n = residualB r - g := by
simp only [hn]
by_cases hbg : residualB r ≤ g
· rw [min_eq_left hbg]
have hz : residualB r - g = 0 := by omega
rw [Nat.sub_self, hz]
· rw [min_eq_right (le_of_not_ge hbg)]
exact residual_topWitness_of_D (g := g) (n := n) (H := H) hcomp hmore hrev hne hbegin hend
hHle hBH D hDlen hDsorted hDB hDH hDcntE hbn htop
· -- Case `H < end.key`: there are only `b` keys in `[B, H)`, and
-- `b ≤ g`, so use them all.
have hHE : (↑H : WithTop Key) < r.end_.key := lt_of_not_ge hEH
have hHE' : (↑H : WithTop Key) < (↑e : WithTop Key) := by rwa [heE] at hHE
have hb_le_g : residualB r ≤ g := by
have h1 := cnt_eq_add_between db₀ hBH'
have h2 := cnt_eq_add_between db₀ hve
have h3 := cnt_le_cnt_of_le db₀ (le_of_lt hHE')
omega
set n : ℕ := residualB r with hn
set D : List Key := between db₀ (↑v) (↑H) with hD
have hDlen : D.length = residualB r := by rw [hD]; exact hlenBH
have hD2sorted : D.SortedLT :=
List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _)
have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by
intro k hk
rw [hD, between, List.mem_filter] at hk
rw [hvB']
exact (of_decide_eq_true hk.2).1
have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by
intro k hk
rw [hD, between, List.mem_filter] at hk
exact (of_decide_eq_true hk.2).2
have hDcntE : (D.filter
(fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by
rw [show D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = D from by
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq, heE]
exact lt_trans (hDH k hk) hHE']
exact hDlen
have hbn : residualB r - n = residualB r - g := by
simp only [hn, Nat.sub_self]
omega
exact residual_topWitness_of_D (g := g) (n := n) (H := H) hcomp hmore hrev hne hbegin hend
hHle hBH D hDlen hD2sorted hDB hDH hDcntE hbn htop
private theorem residual_necessary_above_last_top {db₀ : DB} {r : RangeRead}
{res : Result} {g : ℕ}
(hread : Readable r res) (hcomp : RangeRead.Compatible db₀ r res)
(hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htop : (residualB r - g) + residualT r res < residualE r)
{x : Key} (hlo : res.keys.getLast hne ≤ x) :
Necessary r res x := by
by_cases hx : x ∈ res.keys
· exact necessary_of_mem_result hread hx
· intro cr hs
by_contra hcr
obtain ⟨w, hwcomp, hwsub, hwtop, hwlt⟩ :=
residual_exists_topWitness (db₀ := db₀) (r := r) (res := res) (g := g)
hcomp hmore hrev hne hbegin hcross hend hcard htop
have hx0 : x ∉ w.keys := by
intro hxw
have hxle : x ≤ res.keys.getLast hne :=
WithTop.coe_le_coe.mp (hwsub x hxw)
have hxeq : x = res.keys.getLast hne := le_antisymm hxle hlo
exact hx (hxeq ▸ List.getLast_mem hne)
have hsub : ∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) :=
fun k hk => le_trans (hwsub k hk) (WithTop.coe_le_coe.mpr hlo)
have hEins : resolve (w.insert x hx0) r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_insert_top hx0 hwlt hend
exact hx (mem_result_of_insert (db₀ := w) hwcomp hs hcr hmore hne hx0 hsub hEins)
/-- **Top-branch minimality in the residual cell.** When `(b - g) + t < e`, the
unbounded top range `[begin.key, ⊤)` is the minimal sound conflict range. Soundness is
`sound_topRange_of_one_le_le`; keys up to the reported last are necessary by the begin
key, the reported last, and convexity, while keys above it are
`necessary_above_last_of_residual_top`. -/
theorem minimal_topRange_of_residual_top {r : RangeRead} {res : Result} {g : ℕ}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res)
(htop : (residualB r - g) + residualT r res < residualE r) :
Minimal r res (topRange r) := by
obtain ⟨db₀, hcomp₀⟩ := hread
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
· exact sound_topRange_of_one_le_le (by omega) (by omega) hcross
· intro k hk cr hs
obtain ⟨hBk, -⟩ := hk
by_cases hklast : k ≤ res.keys.getLast hne
· have hBtop : r.begin.key ≠ (⊤ : WithTop Key) := by
obtain ⟨m, _, hmge⟩ := List.countP_pos_iff.mp htpos
rw [decide_eq_true_eq] at hmge
intro htop'
rw [htop'] at hcross
exact absurd (le_trans hcross hmge) (not_le_of_gt (WithTop.coe_lt_top m))
obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hBtop
have hvB : r.begin.key = (↑v : WithTop Key) := hv.symm
have hbegin_nec : Necessary r res v :=
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hvB
have hvk : v ≤ k := by
change r.begin.key ≤ (↑k : WithTop Key) at hBk
exact WithTop.coe_le_coe.mp (by rwa [hvB] at hBk)
have hlast_nec : Necessary r res (res.keys.getLast hne) :=
necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)
exact (hbegin_nec.of_between hlast_nec hvk hklast) cr hs
· have hklast' : res.keys.getLast hne < k := lt_of_not_ge hklast
exact residual_necessary_above_last_top ⟨db₀, hcomp₀⟩ hcomp₀ hmore hrev hne hbegin
hcross hend hcard htop hklast'.le cr hs
/-- **The capacity criterion never overruns the end offset.** In the residual
complete-result cell the two branches are exhaustive: `(b - g) + t ≤ e`. The proof
reads the exact count identity `completeKeys_count_ge_eq_general`: at most `g` stored
keys lie in `[begin.key, end.key)`, and a positive count of reported keys at or above
`end.key` makes the top window long enough. -/
theorem residual_dt_le_e {db : DB} {r : RangeRead} {res : Result} {g : ℕ}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
(hcross : r.begin.key ≤ r.end_.key) (hend : 1 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) :
(residualB r - g) + residualT r res ≤ residualE r := by
have hres : res.keys = RangeRead.completeKeys db r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
have hEq := completeKeys_count_ge_eq_general (db := db) (r := r) hrev hbegin hcross hend
have ht : residualT r res = (RangeRead.completeKeys db r).countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by
rw [residualT, hres]
rw [ht, hEq]
have hNle : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) ≤ g := by
have h := cnt_sub_le_intervalCard db hcross
rw [hcard] at h
exact_mod_cast h
set b := (r.begin.offset - 1).toNat with hb
set e := (r.end_.offset - 1).toNat with he
set A := db.keys.length - db.keys.countP
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) with hA
set N := db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) -
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hN
have htpos' : 0 < min e A - (b - N) := by
rw [residualT, hres] at htpos
rw [hEq] at htpos
simpa [b, e, A, N] using htpos
have hmain : (b - g) + (min e A - (b - N)) ≤ e := by
by_cases hbg : b ≤ g
· have hz : b - g = 0 := by omega
rw [hz, Nat.zero_add]
exact le_trans (Nat.sub_le _ _) (min_le_left _ _)
· have hgb : g < b := lt_of_not_ge hbg
have hNb : N ≤ g := hNle
omega
simpa [residualB, residualE, b, e, A, N] using hmain
/-- **The residual complete-result closed form.** It is the truncated range
`[begin.key, keyAfter (last reported))` in the finite branch `(b - g) + t = e`, and
the unbounded top range `[begin.key, ⊤)` in the complementary branch. -/
noncomputable def closedFormResidual (r : RangeRead) (res : Result) (g : ℕ) :
ConflictRange :=
if (residualB r - g) + residualT r res = residualE r then
truncatedRange r (res.keys.getLastD ([] : Key))
else topRange r
/-- **The residual closed form is minimal.** The dispatch is exhaustive by
`residual_dt_le_e`; the finite branch is `minimal_truncatedRange_of_residual_finite`
and the strict branch is `minimal_topRange_of_residual_top`. -/
theorem minimal_closedForm_of_residual {r : RangeRead} {res : Result} {g : ℕ}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) :
Minimal r res (closedFormResidual r res g) := by
obtain ⟨db₀, hcomp₀⟩ := hread
have hdtle := residual_dt_le_e (db := db₀) hcomp₀ hmore hrev hbegin hcross
(by omega) hcard htpos
unfold closedFormResidual
by_cases hdt : (residualB r - g) + residualT r res = residualE r
· rw [ite_eq_left hdt]
exact minimal_truncatedRange_of_residual_finite ⟨db₀, hcomp₀⟩ hmore hrev hbegin hcross
(by omega) hcard htpos htlt hdt
· rw [ite_eq_right hdt]
have htop : (residualB r - g) + residualT r res < residualE r :=
lt_of_le_of_ne hdtle hdt
exact minimal_topRange_of_residual_top ⟨db₀, hcomp₀⟩ hmore hrev hne hbegin hcross hend
hcard htpos htop
/-- The residual closed form denotes the same key set as the general conflict range. -/
theorem closedFormResidual_toSet_eq_general {r : RangeRead} {res : Result} {g : ℕ}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) :
(closedFormResidual r res g).toSet = (conflictRangeGeneral r res).toSet :=
(minimal_closedForm_of_residual hread hmore hrev hne hbegin hcross hend hcard
htpos htlt).toSet_eq (conflictRangeGeneral_minimal hread)
/-- The residual closed form denotes the same key set as the executable algorithm. -/
theorem closedFormResidual_toSet_eq_simple {r : RangeRead} {res : Result} {g : ℕ}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = (g : ℕ∞))
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) :
(closedFormResidual r res g).toSet = (simpleConflictRange r res).toSet :=
(minimal_closedForm_of_residual hread hmore hrev hne hbegin hcross hend hcard
htpos htlt).toSet_eq (simpleConflictRange_minimal hread)
/-! ## The infinite-gap case
When `intervalCard begin.key end.key = ⊤`, there are arbitrarily many chain keys
between the selector keys, so the witness for the top branch can use `b` chain keys
without any finite capacity hypothesis. The finite branch `d + t = e` is impossible
there (it would require the finite database to fill an infinite gap), so the top
branch is the only outcome. This removes the last finiteness restriction from the
residual criterion. -/
private theorem residual_exists_topWitness_infinite {db₀ : DB} {r : RangeRead}
{res : Result}
(hcomp : RangeRead.Compatible db₀ r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hinf : intervalCard r.begin.key r.end_.key = ⊤)
(htpos : 0 < residualT r res)
(htop : residualT r res < residualE r) :
∃ w : DB, RangeRead.Compatible w r res ∧
(∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤
((res.keys.getLast hne : Key) : WithTop Key)) ∧
resolve w r.end_ = (⊤ : WithTop Key) ∧
w.keys.length < w.keys.countP
(fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
(r.end_.offset - 1).toNat := by
have hres : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
set H : Key := res.keys.head hne with hH
have hRsorted : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hHle : ∀ k ∈ res.keys, (↑H : WithTop Key) ≤ (↑k : WithTop Key) := by
intro k hk
rw [hH]
exact WithTop.coe_le_coe.mpr ((hRsorted.pairwise.imp le_of_lt).rel_head hk)
have hBH : r.begin.key ≤ (↑H : WithTop Key) := by
have h := begin_key_le_head_of_one_le_offset (r := r) (res := res) ⟨db₀, hcomp⟩ hne hbegin
rwa [hH]
have hB_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
intro htop'
have hle : (⊤ : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [htop'] at hBH
exact absurd hle (not_le.mpr (WithTop.coe_lt_top H))
obtain ⟨v, hvB⟩ := WithTop.ne_top_iff_exists.mp hB_ne_top
have hvB' : r.begin.key = (↑v : WithTop Key) := hvB.symm
have hE_ne_top : r.end_.key ≠ (⊤ : WithTop Key) := by
intro htop'
simp [residualT, htop'] at htpos
obtain ⟨e, heE'⟩ := WithTop.ne_top_iff_exists.mp hE_ne_top
have heE : r.end_.key = (↑e : WithTop Key) := heE'.symm
have hinf' : intervalCard (↑v : WithTop Key) (↑e : WithTop Key) = ⊤ := by
simpa [hvB', heE] using hinf
have hve : (↑v : WithTop Key) ≤ (↑e : WithTop Key) := by
rw [← hvB', ← heE]; exact hcross
have hBH' : (↑v : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [hvB'] at hBH
have hlenBH : (between db₀ (↑v) (↑H)).length = residualB r := by
have h := residual_between_begin_head (db₀ := db₀) (r := r) (res := res)
hcomp hmore hrev hne hbegin
have hh : ((res.keys.head hne : Key) : WithTop Key) = (↑H : WithTop Key) := by rw [hH]
rw [hvB', hh] at h
simpa [residualB] using h
by_cases hEH : r.end_.key ≤ (↑H : WithTop Key)
· have hEH' : (↑e : WithTop Key) ≤ (↑H : WithTop Key) := by rwa [heE] at hEH
set n : ℕ := residualB r with hn
set D : List Key := (List.range n).map (chain v) with hD
have hDlen : D.length = residualB r := by simp [hD, hn]
have hDsorted : D.SortedLT := by
rw [hD]; exact sortedLT_map_chain v n
have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by
intro k hk
rw [hD, List.mem_map] at hk
obtain ⟨i, hi, rfl⟩ := hk
rw [hvB']
exact WithTop.coe_le_coe.mpr (chain_le v i)
have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by
intro k hk
rw [hD, List.mem_map] at hk
obtain ⟨i, hi, rfl⟩ := hk
exact lt_of_lt_of_le
(WithTop.coe_lt_coe.mpr (chain_lt_of_intervalCard_eq_top hinf' i)) hEH'
have hDcntE : (D.filter
(fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by
rw [hD]
have hfilter : (List.filter
(fun k : Key => decide ((k : WithTop Key) < r.end_.key))
((List.range n).map (chain v))) = (List.range n).map (chain v) := by
rw [List.filter_eq_self]
intro k hk
rw [List.mem_map] at hk
obtain ⟨i, hi, rfl⟩ := hk
rw [decide_eq_true_eq, heE]
exact WithTop.coe_lt_coe.mpr (chain_lt_of_intervalCard_eq_top hinf' i)
rw [hfilter, List.length_map, List.length_range]
exact residual_topWitness_of_D (g := residualB r) (n := n) (H := H)
hcomp hmore hrev hne hbegin hend hHle hBH D hDlen hDsorted hDB hDH hDcntE
(by simp [hn]) (by simpa [hn] using htop)
· have hHE : (↑H : WithTop Key) < r.end_.key := lt_of_not_ge hEH
have hHE' : (↑H : WithTop Key) < (↑e : WithTop Key) := by rwa [heE] at hHE
set n : ℕ := residualB r with hn
set D : List Key := between db₀ (↑v) (↑H) with hD
have hDlen : D.length = residualB r := by rw [hD]; exact hlenBH
have hDsorted : D.SortedLT := by
rw [hD]; exact List.sortedLT_iff_pairwise.mpr (db₀.sorted.pairwise.filter _)
have hDB : ∀ k ∈ D, r.begin.key ≤ (↑k : WithTop Key) := by
intro k hk
rw [hD, between, List.mem_filter] at hk
rw [hvB']
exact (of_decide_eq_true hk.2).1
have hDH : ∀ k ∈ D, (↑k : WithTop Key) < (↑H : WithTop Key) := by
intro k hk
rw [hD, between, List.mem_filter] at hk
exact (of_decide_eq_true hk.2).2
have hDcntE : (D.filter
(fun k : Key => decide ((k : WithTop Key) < r.end_.key))).length = n := by
rw [show D.filter (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) = D from by
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq, heE]
exact lt_trans (hDH k hk) hHE']
exact hDlen
exact residual_topWitness_of_D (g := residualB r) (n := n) (H := H)
hcomp hmore hrev hne hbegin hend hHle hBH D hDlen hDsorted hDB hDH hDcntE
(by simp [hn]) (by simpa [hn] using htop)
private theorem residual_necessary_above_last_top_infinite {db₀ : DB} {r : RangeRead}
{res : Result}
(hread : Readable r res) (hcomp : RangeRead.Compatible db₀ r res)
(hmore : res.more = false) (hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hinf : intervalCard r.begin.key r.end_.key = ⊤)
(htpos : 0 < residualT r res)
(htop : residualT r res < residualE r)
{x : Key} (hlo : res.keys.getLast hne ≤ x) :
Necessary r res x := by
by_cases hx : x ∈ res.keys
· exact necessary_of_mem_result hread hx
· intro cr hs
by_contra hcr
obtain ⟨w, hwcomp, hwsub, hwtop, hwlt⟩ :=
residual_exists_topWitness_infinite (db₀ := db₀) (r := r) (res := res)
hcomp hmore hrev hne hbegin hcross hend hinf htpos htop
have hx0 : x ∉ w.keys := by
intro hxw
have hxle : x ≤ res.keys.getLast hne :=
WithTop.coe_le_coe.mp (hwsub x hxw)
have hxeq : x = res.keys.getLast hne := le_antisymm hxle hlo
exact hx (hxeq ▸ List.getLast_mem hne)
have hsub : ∀ k ∈ w.keys, ((k : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) :=
fun k hk => le_trans (hwsub k hk) (WithTop.coe_le_coe.mpr hlo)
have hEins : resolve (w.insert x hx0) r.end_ = (⊤ : WithTop Key) :=
resolve_end_eq_top_of_insert_top hx0 hwlt hend
exact hx (mem_result_of_insert (db₀ := w) hwcomp hs hcr hmore hne hx0 hsub hEins)
/-- **Top-branch minimality with an infinite selector gap.** When
`intervalCard begin.key end.key = ⊤`, the finite branch is impossible and the
unbounded top range is minimal as soon as `t < e`. -/
theorem minimal_topRange_of_residual_top_infinite {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hinf : intervalCard r.begin.key r.end_.key = ⊤)
(htpos : 0 < residualT r res)
(htlt : residualT r res < residualE r) :
Minimal r res (topRange r) := by
obtain ⟨db₀, hcomp₀⟩ := hread
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
· exact sound_topRange_of_one_le_le (by omega) (by omega) hcross
· intro k hk cr hs
obtain ⟨hBk, -⟩ := hk
by_cases hklast : k ≤ res.keys.getLast hne
· have hBtop : r.begin.key ≠ (⊤ : WithTop Key) := by
obtain ⟨m, _, hmge⟩ := List.countP_pos_iff.mp htpos
rw [decide_eq_true_eq] at hmge
intro htop'
rw [htop'] at hcross
exact absurd (le_trans hcross hmge) (not_le_of_gt (WithTop.coe_lt_top m))
obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hBtop
have hvB : r.begin.key = (↑v : WithTop Key) := hv.symm
have hbegin_nec : Necessary r res v :=
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hvB
have hvk : v ≤ k := by
change r.begin.key ≤ (↑k : WithTop Key) at hBk
exact WithTop.coe_le_coe.mp (by rwa [hvB] at hBk)
have hlast_nec : Necessary r res (res.keys.getLast hne) :=
necessary_of_mem_result ⟨db₀, hcomp₀⟩ (List.getLast_mem hne)
exact (hbegin_nec.of_between hlast_nec hvk hklast) cr hs
· have hklast' : res.keys.getLast hne < k := lt_of_not_ge hklast
exact residual_necessary_above_last_top_infinite ⟨db₀, hcomp₀⟩ hcomp₀ hmore hrev
hne hbegin hcross hend hinf htpos htlt hklast'.le cr hs
/-- The capacity deficit `d = max 0 (b - g)`, with `g : ℕ∞`; an infinite gap leaves
nothing to fill. -/
def residualD (r : RangeRead) (g : ℕ∞) : ℕ :=
if g = ⊤ then 0 else residualB r - g.toNat
/-- For a finite gap the deficit is ordinary truncated subtraction. -/
theorem residualD_coe (r : RangeRead) (n : ℕ) :
residualD r (n : ℕ∞) = residualB r - n := by
unfold residualD
rw [ite_eq_right (by simp)]
rfl
/-- **The residual complete-result closed form with an infinite gap parameter.** It
is the truncated range in the finite branch `d + t = e` and the top range otherwise,
where `d = max 0 (b - g)` and `g` is the full interval cardinality, possibly `⊤`. -/
noncomputable def closedFormResidualGeneral (r : RangeRead) (res : Result) (g : ℕ∞) :
ConflictRange :=
if residualD r g + residualT r res = residualE r then
truncatedRange r (res.keys.getLastD ([] : Key))
else topRange r
/-- **The infinite-gap residual closed form is minimal.** The finite branch is
impossible, and `minimal_topRange_of_residual_top_infinite` gives the top range. -/
theorem minimal_closedForm_of_residual_general {r : RangeRead} {res : Result}
{g : ℕ∞}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = g)
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) :
Minimal r res (closedFormResidualGeneral r res g) := by
by_cases hg : g = ⊤
· have hinf : intervalCard r.begin.key r.end_.key = ⊤ := by rw [hcard, hg]
have hne' : residualD r g + residualT r res ≠ residualE r := by
simp [residualD, hg]
omega
unfold closedFormResidualGeneral
rw [ite_eq_right hne']
exact minimal_topRange_of_residual_top_infinite hread hmore hrev hne hbegin hcross
hend hinf htpos htlt
· obtain ⟨n, rfl⟩ := ENat.ne_top_iff_exists.mp hg
have hcardn : intervalCard r.begin.key r.end_.key = (n : ℕ∞) := hcard
unfold closedFormResidualGeneral
rw [residualD_coe]
by_cases hdt : (residualB r - n) + residualT r res = residualE r
· rw [ite_eq_left hdt]
exact minimal_truncatedRange_of_residual_finite hread hmore hrev hbegin hcross
(by omega) hcardn htpos htlt hdt
· rw [ite_eq_right hdt]
have hle := residual_dt_le_e (db := Classical.choose hread) (Classical.choose_spec hread)
hmore hrev hbegin hcross (by omega) hcardn htpos
have htop : (residualB r - n) + residualT r res < residualE r :=
lt_of_le_of_ne hle hdt
exact minimal_topRange_of_residual_top hread hmore hrev hne hbegin hcross hend
hcardn htpos htop
/-- The general residual closed form denotes the general conflict range. -/
theorem closedFormResidualGeneral_toSet_eq_general {r : RangeRead} {res : Result}
{g : ℕ∞}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = g)
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) :
(closedFormResidualGeneral r res g).toSet = (conflictRangeGeneral r res).toSet :=
(minimal_closedForm_of_residual_general hread hmore hrev hne hbegin hcross hend hcard
htpos htlt).toSet_eq (conflictRangeGeneral_minimal hread)
/-- The general residual closed form denotes the executable algorithm. -/
theorem closedFormResidualGeneral_toSet_eq_simple {r : RangeRead} {res : Result}
{g : ℕ∞}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key)
(hend : 2 ≤ r.end_.offset)
(hcard : intervalCard r.begin.key r.end_.key = g)
(htpos : 0 < residualT r res) (htlt : residualT r res < residualE r) :
(closedFormResidualGeneral r res g).toSet = (simpleConflictRange r res).toSet :=
(minimal_closedForm_of_residual_general hread hmore hrev hne hbegin hcross hend hcard
htpos htlt).toSet_eq (simpleConflictRange_minimal hread)
/-- **The total cross-free complete-result closed form.** On a complete result with
`begin.offset ≥ 1` and `begin.key ≤ end_.key`, the automatic three-branch rule covers
`end.offset ≤ 1`, the finite branch `t = e`, and the below-`end_.key` branch; the
equal-selector rule covers `begin.key = end_.key`; and
`closedFormResidualGeneral` covers the remaining strict cell `begin.key < end_.key`,
`0 < t < e`. The gap parameter is the full interval cardinality, so the infinite-gap
case is included. -/
noncomputable def closedFormCompleteCrossFree (r : RangeRead) (res : Result) :
ConflictRange :=
if r.end_.offset ≤ 1 then
closedFormOffsetOne r res
else if residualT r res = residualE r ∨
(∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) then
closedFormOffsetOne r res
else if r.begin.key = r.end_.key then
closedFormKeyEqComplete r res
else
closedFormResidualGeneral r res (intervalCard r.begin.key r.end_.key)
/-- **The total cross-free complete-result rule is minimal at every positive begin
offset.** -/
theorem minimal_closedForm_of_complete_crossFree {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) :
Minimal r res (closedFormCompleteCrossFree r res) := by
obtain ⟨db₀, hcomp₀⟩ := hread
have hres : res.keys = RangeRead.completeKeys db₀ r := by
rcases hcomp₀.2 with ⟨hm, -, -⟩ | ⟨-, heq⟩
· simp [hmore] at hm
· exact heq
unfold closedFormCompleteCrossFree
by_cases hend1 : r.end_.offset ≤ 1
· rw [ite_eq_left hend1]
exact minimal_closedForm_of_complete_general ⟨db₀, hcomp₀⟩ hmore hne hrev hbegin hcross
(Or.inl hend1)
· rw [ite_eq_right hend1]
by_cases hcase : residualT r res = residualE r ∨
(∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key)
· rw [ite_eq_left hcase]
exact minimal_closedForm_of_complete_general ⟨db₀, hcomp₀⟩ hmore hne hrev hbegin hcross
(Or.inr hcase)
· rw [ite_eq_right hcase]
have htne : residualT r res ≠ residualE r := fun h => hcase (Or.inl h)
have hbelow : ¬ (∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) :=
fun h => hcase (Or.inr h)
have ht0 : residualT r res ≠ 0 := by
intro h0
apply hbelow
intro k hk
have hk' := List.countP_eq_zero.mp h0 k hk
rw [decide_eq_true_eq] at hk'
exact not_le.mp hk'
have htpos : 0 < residualT r res := Nat.pos_of_ne_zero ht0
have htle' := completeKeys_count_ge_le_general (db := db₀) hrev hbegin hcross
(by omega : 1 ≤ r.end_.offset)
have htle : residualT r res ≤ residualE r := by
simpa [residualT, residualE, hres] using htle'
have htlt : residualT r res < residualE r := lt_of_le_of_ne htle htne
have hend2 : 2 ≤ r.end_.offset := by omega
by_cases hkey : r.begin.key = r.end_.key
· rw [ite_eq_left hkey]
exact minimal_closedForm_of_key_eq_complete_general ⟨db₀, hcomp₀⟩ hmore hrev hne hbegin
hkey hend2
· rw [ite_eq_right hkey]
have hltkey : r.begin.key < r.end_.key := lt_of_le_of_ne hcross hkey
exact minimal_closedForm_of_residual_general
(g := intervalCard r.begin.key r.end_.key) ⟨db₀, hcomp₀⟩ hmore hrev hne hbegin
hcross hend2 rfl htpos htlt
/-- The total cross-free complete rule denotes the general conflict range. -/
theorem closedFormCompleteCrossFree_toSet_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) :
(closedFormCompleteCrossFree r res).toSet = (conflictRangeGeneral r res).toSet :=
(minimal_closedForm_of_complete_crossFree hread hmore hrev hne hbegin hcross).toSet_eq
(conflictRangeGeneral_minimal hread)
/-- The total cross-free complete rule denotes the executable algorithm. -/
theorem closedFormCompleteCrossFree_toSet_eq_simple {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = false)
(hrev : r.reverse = false) (hne : res.keys ≠ [])
(hbegin : 1 ≤ r.begin.offset) (hcross : r.begin.key ≤ r.end_.key) :
(closedFormCompleteCrossFree r res).toSet = (simpleConflictRange r res).toSet :=
(minimal_closedForm_of_complete_crossFree hread hmore hrev hne hbegin hcross).toSet_eq
(simpleConflictRange_minimal hread)
end FormalConflictRange