- 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.
1439 lines
71 KiB
Lean4
1439 lines
71 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.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
|