- Correct stale references and headline-path wording in READMEs and Lean docstrings - Document build steps, comparator requirements, sweep scope, and coverage - Unify Apache headers across Lean and C++ sources - Add a bwrap-free axiom audit for the headline theorems - Add a Gitea workflow running lake build, the axiom audit, C++ tests, and coverage - Match LLVM coverage tool versions to the compiler and recreate stale build dirs
1126 lines
55 KiB
Lean4
1126 lines
55 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.CrossedGeneral
|
||
|
||
/-!
|
||
# Forward crossed truncated general cells.
|
||
-/
|
||
|
||
open FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- Slicing a sorted list at `b` and taking `t` elements: the filter up to the last
|
||
taken element is exactly the first `b + t` elements. -/
|
||
theorem filter_le_getElem_eq_take {A : List Key} (hAs : A.SortedLT) {b t : ℕ}
|
||
(ht : 0 < t) (hbt : b + t ≤ A.length) :
|
||
A.filter (fun k : Key => decide (k ≤ A[b + t - 1]'(by omega))) = A.take (b + t) := by
|
||
have hidx : b + t - 1 < A.length := by omega
|
||
have hgne : A.take (b + t) ≠ [] :=
|
||
List.ne_nil_of_length_pos (by rw [List.length_take]; omega)
|
||
have hglast : (A.take (b + t)).getLast hgne = A[b + t - 1]'hidx := by
|
||
rw [List.getLast_eq_getElem, List.getElem_take]
|
||
simp only [List.length_take, Nat.min_eq_left hbt]
|
||
have h := filter_le_getLast_eq_of_prefix (α := Key) (g := A.take (b + t)) (W := A)
|
||
hAs.pairwise (List.take_prefix (b + t) A) hgne
|
||
rw [hglast] at h
|
||
exact h
|
||
|
||
theorem completeKeys_eq_filter_ge_drop_take {db : DB} {r : RangeRead}
|
||
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset) :
|
||
RangeRead.completeKeys db r =
|
||
((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).drop
|
||
(r.begin.offset - 1).toNat).take
|
||
(min (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
|
||
(r.end_.offset - 1).toNat) db.keys.length
|
||
- (db.keys.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) +
|
||
(r.begin.offset - 1).toNat)) := by
|
||
set l := db.keys with hl
|
||
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
|
||
set b := (r.begin.offset - 1).toNat with hb
|
||
have hls : l.SortedLT := by rw [hl]; exact db.sorted
|
||
have hAeq : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = l.drop p := by
|
||
rw [hp]
|
||
have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key
|
||
rw [← hdrop]
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact not_lt.symm
|
||
rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend, ← hl, ← hp, ← hb]
|
||
rw [hAeq, List.drop_drop]
|
||
|
||
/-- The last element of `(A.drop b).take t` is `A[b+t-1]`. -/
|
||
theorem getLast_take_drop {A : List Key} {b t : ℕ} {res : List Key}
|
||
(ht : 0 < t) (hres : res = (A.drop b).take t) (hbt : b + t ≤ A.length) :
|
||
res.getLastD [] = A[b + t - 1]'(by omega) := by
|
||
have hne : res ≠ [] := by
|
||
rw [hres]
|
||
apply List.ne_nil_of_length_pos
|
||
rw [List.length_take, Nat.min_eq_left]
|
||
· omega
|
||
· rw [List.length_drop]; omega
|
||
have hlastD : res.getLastD [] = res.getLast hne := by
|
||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||
rw [hlastD]
|
||
have hne' : (A.drop b).take t ≠ [] := by rw [← hres]; exact hne
|
||
calc res.getLast hne
|
||
= ((A.drop b).take t).getLast hne' := List.getLast_congr hne hne' hres
|
||
_ = A[b + t - 1]'(by omega) := by
|
||
rw [List.getLast_eq_getElem, List.getElem_take]
|
||
simp only [List.length_take, List.length_drop, Nat.min_eq_left (by omega : t ≤ A.length - b)]
|
||
rw [List.getElem_drop]
|
||
congr 1
|
||
omega
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- In the crossed forward truncated B-branch, agreement on the truncated range
|
||
forced the reported last to stay strictly below the resolved end. -/
|
||
theorem crossed_truncated_hlr_of_drop_gap {db : DB} {r : RangeRead} {res : Result}
|
||
(_hrev : r.reverse = false) (_hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hne : res.keys ≠ [])
|
||
(hgap : (between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat +
|
||
res.keys.length ≤ (r.end_.offset - 1).toNat)
|
||
(hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop
|
||
(r.begin.offset - 1).toNat = res.keys) :
|
||
((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := 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 := (r.begin.offset - 1).toNat with hb
|
||
set e := (r.end_.offset - 1).toNat with he
|
||
set t := res.keys.length with ht
|
||
set last := res.keys.getLast hne with hlast
|
||
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hA
|
||
set S := A.filter (fun k : Key => decide (k ≤ last)) with hS
|
||
have hls : l.SortedLT := by rw [hl]; exact db.sorted
|
||
have hAs : A.SortedLT := by
|
||
rw [hA]
|
||
exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _)
|
||
have htrunc : (truncatedRange r last).keys db = S := by
|
||
rw [truncatedRange_keys_eq_filter_le]
|
||
have hdrop' : S.drop b = res.keys := by
|
||
rw [← htrunc]
|
||
simpa [hb] using hdrop
|
||
have htpos : 0 < t := by rw [ht]; exact List.length_pos_of_ne_nil hne
|
||
have hSlen : S.length = b + t := by
|
||
have := congrArg List.length hdrop'
|
||
rw [List.length_drop, ← ht] at this
|
||
omega
|
||
have hStake : S = A.take (b + t) := by
|
||
rw [hS, filter_le_eq_take_countP hAs last]
|
||
congr 1
|
||
rw [List.countP_eq_length_filter]
|
||
simpa [S] using hSlen
|
||
have hAbt : b + t ≤ A.length := by
|
||
rw [hStake, List.length_take] at hSlen
|
||
omega
|
||
have hresdrop : res.keys = (A.drop b).take t := by
|
||
rw [← hdrop', hStake, List.drop_take]
|
||
congr 1
|
||
omega
|
||
have hlastD : res.keys.getLastD [] = res.keys.getLast hne := by
|
||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||
have hlastA : last = A[b + t - 1]'(by omega) := by
|
||
rw [hlast, ← hlastD]
|
||
exact getLast_take_drop htpos hresdrop hAbt
|
||
set g := (between db r.end_.key r.begin.key).length with hgdef
|
||
have hcnt : p = cE + g := by
|
||
rw [hp, hcE, hgdef]
|
||
simpa [cnt, hl] using cnt_eq_add_between (db := db) (le_of_lt hcross)
|
||
have hA_eq : A = l.drop p := by
|
||
rw [hA, hp]
|
||
have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key
|
||
rw [← hdrop]
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact not_lt.symm
|
||
have hjlt : p + (b + t - 1) < l.length := by
|
||
have := hAbt
|
||
rw [hA_eq, List.length_drop] at this
|
||
omega
|
||
have hlast_l : last = l[p + (b + t - 1)]'hjlt := by
|
||
rw [hlastA]
|
||
have hidx : b + t - 1 < A.length := by omega
|
||
have h1 : A[b + t - 1]'hidx = (l.drop p)[b + t - 1]'(by rw [List.length_drop]; omega) :=
|
||
List.getElem_of_eq hA_eq hidx
|
||
rw [h1, List.getElem_drop]
|
||
have hgbt : g + (t + b) ≤ e := by
|
||
have h := hgap
|
||
omega
|
||
have hj_anchor : p + (b + t - 1) < (r.end_.anchor db).toNat := by
|
||
rw [anchor_toNat_eq (s := r.end_) hend, ← hl, ← hcE, hcnt]
|
||
have hble : b + t - 1 < t + b := by omega
|
||
omega
|
||
have hj_clamp : p + (b + t - 1) < clampIndex db r.end_ := by
|
||
unfold clampIndex
|
||
exact Nat.lt_min.mpr ⟨hj_anchor, hjlt⟩
|
||
rw [hlast_l]
|
||
exact (getElem_lt_resolve_iff (db := db) (s := r.end_)
|
||
(j := p + (b + t - 1)) hjlt).mpr hj_clamp
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- A compatible crossed truncated result bounds the number of stored keys in the
|
||
selector gap: `gap + begin-offset-padding + reported-length ≤ end-overshoot`. -/
|
||
theorem compatible_gap_bound {db : DB} {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (_hmore : res.more = true) (hne : res.keys ≠ [])
|
||
(hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
|
||
(hcross : r.end_.key < r.begin.key)
|
||
(hc : RangeRead.Compatible db r res) :
|
||
(between db r.end_.key r.begin.key).length + (r.begin.offset - 1).toNat +
|
||
res.keys.length ≤ (r.end_.offset - 1).toNat := by
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc
|
||
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 := (r.begin.offset - 1).toNat with hb
|
||
set e := (r.end_.offset - 1).toNat with he
|
||
set t := res.keys.length with ht
|
||
set g := (between db r.end_.key r.begin.key).length with hg
|
||
have hck := completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend
|
||
rw [← hl, ← hp, ← hcE, ← hb, ← he] at hck
|
||
have ht_le : t ≤ min (cE + e) l.length - (p + b) := by
|
||
have := hpre.length_le
|
||
rw [hck, List.length_take, ← ht] at this
|
||
exact le_trans this (Nat.min_le_left _ _)
|
||
have hcnt : p = cE + g := by
|
||
rw [hp, hcE, hg]
|
||
simpa [cnt, hl] using cnt_eq_add_between (db := db) (le_of_lt hcross)
|
||
have hsub : cE + e - (p + b) = e - g - b := by
|
||
rw [hcnt, add_assoc, Nat.add_sub_add_left, Nat.sub_sub]
|
||
have hminle : min (cE + e) l.length - (p + b) ≤ e - g - b := by
|
||
rw [← hsub]
|
||
exact Nat.sub_le_sub_right (Nat.min_le_left _ _) _
|
||
have ht_le' : t ≤ e - g - b := le_trans ht_le hminle
|
||
have htpos : 0 < t := by rw [ht]; exact List.length_pos_of_ne_nil hne
|
||
have hgbe : g + b ≤ e := by
|
||
by_contra h
|
||
have hz : e - g - b = 0 := by omega
|
||
omega
|
||
have hfinal : g + b + t ≤ e := by
|
||
calc g + b + t = t + (g + b) := by omega
|
||
_ ≤ (e - (g + b)) + (g + b) := by
|
||
have h1 : t ≤ e - (g + b) := by rwa [Nat.sub_sub] at ht_le'
|
||
exact Nat.add_le_add_right h1 _
|
||
_ = e := Nat.sub_add_cancel hgbe
|
||
simpa [hg, hb, ht, he] using hfinal
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- The hcard form of the crossed truncated height lemma, derived from the actual
|
||
gap-count form. -/
|
||
theorem crossed_truncated_hlr_of_drop {db : DB} {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hne : res.keys ≠ [])
|
||
(hcard : intervalCard r.end_.key r.begin.key ≤
|
||
(((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞))
|
||
(hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop
|
||
(r.begin.offset - 1).toNat = res.keys) :
|
||
((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ := by
|
||
refine crossed_truncated_hlr_of_drop_gap hrev hbegin hend hcross hne ?_ hdrop
|
||
set g := (between db r.end_.key r.begin.key).length with hg
|
||
set t := res.keys.length with ht
|
||
set b := (r.begin.offset - 1).toNat with hb
|
||
set e := (r.end_.offset - 1).toNat with he
|
||
have hgcard : ((g : ℕ) : ℕ∞) ≤ (((e - t - b : ℕ)) : ℕ∞) := by
|
||
refine le_trans ?_ (by simpa [e, t, b, g] using hcard)
|
||
simpa [g] using between_length_le_intervalCard (db := db) (le_of_lt hcross)
|
||
have hgle0 : g ≤ e - t - b := by exact_mod_cast hgcard
|
||
have hgle : g ≤ e - (t + b) := by rwa [Nat.sub_sub] at hgle0
|
||
have htb : t + b ≤ e := by
|
||
by_contra h
|
||
have hzero : e - t - b = 0 := by omega
|
||
have hle0 : intervalCard r.end_.key r.begin.key ≤ 0 := by simpa [hzero] using hcard
|
||
have hzero2 : intervalCard r.end_.key r.begin.key = 0 := le_antisymm hle0 zero_le
|
||
exact absurd (intervalCard_eq_zero_iff.mp hzero2) (not_le.mpr hcross)
|
||
have hgbt : g + (t + b) ≤ e := by
|
||
calc g + (t + b) ≤ (e - (t + b)) + (t + b) := Nat.add_le_add_right hgle _
|
||
_ = e := Nat.sub_add_cancel htb
|
||
omega
|
||
|
||
end FormalConflictRange
|
||
|
||
|
||
open FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- General crossed complete keys filtered at or below the last reported key. -/
|
||
theorem completeKeys_filter_le_eq_crossed_general {db : DB} {r : RangeRead} {last : Key}
|
||
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
|
||
(hEB : r.end_.key ≤ r.begin.key) (_hBlast : r.begin.key ≤ (last : WithTop Key)) :
|
||
(RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) =
|
||
(((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter
|
||
(fun k : Key => decide (k ≤ last))).take
|
||
(min ((r.end_.offset - 1).toNat - (between db r.end_.key r.begin.key).length)
|
||
((db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter
|
||
(fun k : Key => decide (k ≤ last))).length)).drop
|
||
(r.begin.offset - 1).toNat := 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 := (r.begin.offset - 1).toNat with hb
|
||
set e := (r.end_.offset - 1).toNat with he
|
||
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
|
||
set C := A.filter (fun k : Key => decide (k ≤ last)) with hCdef
|
||
set q := A.countP (fun k : Key => decide (k ≤ last)) with hqdef
|
||
set gap := (between db r.end_.key r.begin.key).length with hgapdef
|
||
set K := min (cE + e) l.length - (p + b) with hK
|
||
set L := min (e - gap) q with hL
|
||
have hls : l.SortedLT := by rw [hl]; exact db.sorted
|
||
have hAs : A.SortedLT := by
|
||
rw [hAdef]
|
||
exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _)
|
||
have hA : A = l.drop p := by
|
||
rw [hAdef, hp]
|
||
have hdrop := filter_not_lt_eq_drop_countP hls r.begin.key
|
||
rw [← hdrop]
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact not_lt.symm
|
||
have hCtake : C = A.take q := by
|
||
rw [hCdef, hqdef]
|
||
exact filter_le_eq_take_countP hAs last
|
||
have hqA : q ≤ A.length := by rw [hqdef]; exact List.countP_le_length
|
||
have hqC : C.length = q := by
|
||
rw [hCtake, List.length_take]
|
||
exact Nat.min_eq_left hqA
|
||
have hp_le : p ≤ l.length := by rw [hp]; exact List.countP_le_length
|
||
have hcB : p = cE + gap := by
|
||
rw [hp, hcE, hgapdef]
|
||
simpa [cnt, hl] using cnt_eq_add_between (db := db) hEB
|
||
have hqN : q + p ≤ l.length := by
|
||
have := hqA
|
||
rw [hA, List.length_drop] at this
|
||
omega
|
||
-- filter of a drop of `A`
|
||
have hfilter_drop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) =
|
||
(A.drop b).take (q - b) := by
|
||
have hsplit : A.filter (fun k : Key => decide (k ≤ last)) =
|
||
(A.take b).filter (fun k : Key => decide (k ≤ last)) ++
|
||
(A.drop b).filter (fun k : Key => decide (k ≤ last)) := by
|
||
conv_lhs => rw [← List.take_append_drop b A]
|
||
rw [List.filter_append]
|
||
have htakeb : (A.take b).filter (fun k : Key => decide (k ≤ last)) =
|
||
A.take (min b q) :=
|
||
filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hCtake b
|
||
have hCtake' : A.filter (fun k : Key => decide (k ≤ last)) = A.take q := hCtake
|
||
rw [hCtake', htakeb] at hsplit
|
||
have hsplit2 : A.take q = A.take (min b q) ++ (A.take q).drop (min b q) := by
|
||
conv_lhs => rw [← List.take_append_drop (min b q) (A.take q)]
|
||
rw [List.take_take, Nat.min_eq_left (Nat.min_le_right b q)]
|
||
rw [hsplit2] at hsplit
|
||
have hdrop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) =
|
||
(A.take q).drop (min b q) := (List.append_cancel_left hsplit).symm
|
||
have htakeq : (A.take q).drop (min b q) = (A.drop b).take (q - b) := by
|
||
by_cases hbq : b ≤ q
|
||
· rw [Nat.min_eq_left hbq, List.drop_take]
|
||
· have hbq' : q ≤ b := by omega
|
||
rw [Nat.min_eq_right hbq', Nat.sub_eq_zero_of_le hbq', List.take_zero]
|
||
exact List.drop_eq_nil_of_le (by rw [List.length_take]; exact Nat.min_le_left _ _)
|
||
exact hdrop.trans htakeq
|
||
have htake_filter : ((A.drop b).take K).filter (fun k : Key => decide (k ≤ last)) =
|
||
(A.drop b).take (min K (q - b)) :=
|
||
filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hfilter_drop K
|
||
have harith : min K (q - b) = L - b := by
|
||
rw [hK, hL]
|
||
omega
|
||
have hAtake : A.take L = C.take L := by
|
||
rw [hCtake, List.take_take]
|
||
congr 1
|
||
exact (Nat.min_eq_left (Nat.min_le_right (e - gap) q)).symm
|
||
rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend]
|
||
rw [← hl, ← hp, ← hcE, ← hb, ← he]
|
||
have hdropA : List.drop (p + b) l = A.drop b := by rw [hA, List.drop_drop]
|
||
rw [hdropA, show min (cE + e) l.length - (p + b) = K from rfl]
|
||
rw [htake_filter, harith]
|
||
rw [← List.drop_take, hAtake, hqC]
|
||
|
||
end FormalConflictRange
|
||
|
||
|
||
namespace FormalConflictRange
|
||
|
||
private theorem crossedTrunc_keys_lo_keyAfter_eq_filter_le {db : DB} {lo : WithTop Key} {last :
|
||
Key} :
|
||
(⟨lo, (keyAfter last : Key)⟩ : ConflictRange).keys db =
|
||
(db.keys.filter (fun k : Key => decide (lo ≤ (k : WithTop Key)))).filter
|
||
(fun k : Key => decide (k ≤ last)) := by
|
||
unfold ConflictRange.keys
|
||
rw [show db.keys.filter (fun (k : Key) => decide (lo ≤ (k : WithTop Key) ∧
|
||
(k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) =
|
||
db.keys.filter (fun (k : Key) =>
|
||
decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) &&
|
||
decide (lo ≤ (k : WithTop Key))) from
|
||
List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]]
|
||
rw [← List.filter_filter]
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff]
|
||
|
||
private theorem crossedTrunc_filter_ge_last_eq_filter_of_keys_eq {db : DB} {E B : WithTop Key}
|
||
{last : Key}
|
||
(hEB : E ≤ B) (_hBlast : B ≤ (last : WithTop Key)) :
|
||
(db.keys.filter (fun k : Key => decide (B ≤ (k : WithTop Key)))).filter
|
||
(fun k : Key => decide (k ≤ last)) =
|
||
((⟨E, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
|
||
(fun k : Key => decide (B ≤ (k : WithTop Key))) := by
|
||
rw [crossedTrunc_keys_lo_keyAfter_eq_filter_le]
|
||
simp only [List.filter_filter]
|
||
apply List.filter_congr
|
||
intro k _
|
||
simp only [← Bool.decide_and]
|
||
rw [decide_eq_decide]
|
||
constructor
|
||
· rintro ⟨hl, hB⟩
|
||
exact ⟨hB, hl, le_trans hEB hB⟩
|
||
· rintro ⟨hB, hl, _⟩
|
||
exact ⟨hl, hB⟩
|
||
|
||
private theorem crossedTrunc_between_eq_filter_of_keys_eq {db : DB} {E B : WithTop Key} {last : Key}
|
||
(_hEB : E ≤ B) (hBlast : B ≤ (last : WithTop Key)) :
|
||
between db E B =
|
||
((⟨E, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
|
||
(fun k : Key => decide ((k : WithTop Key) < B)) := by
|
||
rw [crossedTrunc_keys_lo_keyAfter_eq_filter_le]
|
||
simp only [List.filter_filter]
|
||
unfold between
|
||
rw [show db.keys.filter (fun k : Key => decide (E ≤ (k : WithTop Key) ∧ (k : WithTop Key) < B)) =
|
||
db.keys.filter (fun k : Key => decide ((k : WithTop Key) < B) && decide (E ≤ (k : WithTop
|
||
Key))) from
|
||
List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]]
|
||
apply List.filter_congr
|
||
intro k _
|
||
simp only [← Bool.decide_and]
|
||
rw [decide_eq_decide]
|
||
constructor
|
||
· rintro ⟨hkB, hE⟩
|
||
have hklt : (k : WithTop Key) < (last : WithTop Key) := lt_of_lt_of_le hkB hBlast
|
||
exact ⟨hkB, le_of_lt (WithTop.coe_lt_coe.mp hklt), hE⟩
|
||
· rintro ⟨hkB, _, hE⟩
|
||
exact ⟨hkB, hE⟩
|
||
|
||
/-- A compatible crossed truncated result reports only keys at or above `begin_.key`,
|
||
at any positive begin offset. -/
|
||
theorem le_begin_key_of_compatible_crossed_general {db : DB} {r : RangeRead} {res : Result}
|
||
(_hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hne : res.keys ≠ [])
|
||
(hc : RangeRead.Compatible db r res) :
|
||
r.begin.key ≤ (res.keys.getLast hne : WithTop Key) := by
|
||
have hmem : res.keys.getLast hne ∈ RangeRead.completeKeys db r :=
|
||
(RangeRead.compatible_keys_prefix hc).subset (List.getLast_mem hne)
|
||
exact le_trans (key_le_resolve_of_one_le (db := db) (s := r.begin) hbegin)
|
||
(RangeRead.mem_completeKeys.mp hmem).2.1
|
||
|
||
/-- Agreement on `[r.end_.key, keyAfter last)` fixes the complete keys filtered at or
|
||
below `last`, for any positive begin offset on a crossed read with `end_.key ≤
|
||
begin_.key`. -/
|
||
theorem completeKeys_filter_le_eq_of_agree_crossed_general {r : RangeRead} {last : Key}
|
||
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hend : 1 ≤ r.end_.offset)
|
||
(hEB : r.end_.key ≤ r.begin.key) (hBlast : r.begin.key ≤ (last : WithTop Key))
|
||
{db₁ db₂ : DB}
|
||
(hagree : (⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db₁ =
|
||
(⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db₂) :
|
||
(RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last)) =
|
||
(RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ last)) := by
|
||
let C : DB → List Key := fun db =>
|
||
(db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key)))).filter
|
||
(fun k : Key => decide (k ≤ last))
|
||
let gap : DB → ℕ := fun db => (between db r.end_.key r.begin.key).length
|
||
have hC (db : DB) : C db =
|
||
((⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
|
||
(fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) :=
|
||
crossedTrunc_filter_ge_last_eq_filter_of_keys_eq (db := db) hEB hBlast
|
||
have hG (db : DB) : between db r.end_.key r.begin.key =
|
||
((⟨r.end_.key, (keyAfter last : Key)⟩ : ConflictRange).keys db).filter
|
||
(fun k : Key => decide ((k : WithTop Key) < r.begin.key)) :=
|
||
crossedTrunc_between_eq_filter_of_keys_eq (db := db) hEB hBlast
|
||
have hCeq : C db₁ = C db₂ := by
|
||
rw [hC db₁, hC db₂, hagree]
|
||
have hGeq : gap db₁ = gap db₂ := by
|
||
unfold gap
|
||
rw [hG db₁, hG db₂, hagree]
|
||
have hformula (db : DB) :
|
||
(RangeRead.completeKeys db r).filter (fun k : Key => decide (k ≤ last)) =
|
||
((C db).take (min ((r.end_.offset - 1).toNat - gap db) (C db).length)).drop
|
||
(r.begin.offset - 1).toNat := by
|
||
simpa [C, gap] using completeKeys_filter_le_eq_crossed_general
|
||
(db := db) (r := r) (last := last) hrev hbegin hend hEB hBlast
|
||
calc
|
||
(RangeRead.completeKeys db₁ r).filter (fun k : Key => decide (k ≤ last))
|
||
= ((C db₁).take (min ((r.end_.offset - 1).toNat - gap db₁) (C db₁).length)).drop
|
||
(r.begin.offset - 1).toNat := hformula db₁
|
||
_ = ((C db₂).take (min ((r.end_.offset - 1).toNat - gap db₂) (C db₂).length)).drop
|
||
(r.begin.offset - 1).toNat := by rw [hCeq, hGeq]
|
||
_ = (RangeRead.completeKeys db₂ r).filter (fun k : Key => decide (k ≤ last)) :=
|
||
(hformula db₂).symm
|
||
|
||
/-- **E-branch soundness for the forward truncated crossed read at any positive begin
|
||
offset.** Agreement on `[end_.key, keyAfter (last reported))` fixes the reported prefix
|
||
of the complete keys. -/
|
||
theorem sound_truncatedRange_of_crossed_E_general {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
|
||
(hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key)
|
||
(hend : 2 ≤ r.end_.offset) :
|
||
Sound r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by
|
||
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
|
||
constructor
|
||
· intro hc₁
|
||
have hBlast := le_begin_key_of_compatible_crossed_general (db := db₁) hrev hbegin hne hc₁
|
||
have hceq := completeKeys_filter_le_eq_of_agree_crossed_general (r := r)
|
||
(last := res.keys.getLast hne) hrev hbegin (by omega) (le_of_lt hcross) hBlast hagree
|
||
rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] at hc₁
|
||
rw [compatible_iff_truncated_keys (db := db₂) hrev hmore hne]
|
||
refine ⟨hc₁.1, ?_⟩
|
||
rw [← hceq]
|
||
exact hc₁.2
|
||
· intro hc₂
|
||
have hBlast := le_begin_key_of_compatible_crossed_general (db := db₂) hrev hbegin hne hc₂
|
||
have hceq := completeKeys_filter_le_eq_of_agree_crossed_general (r := r)
|
||
(last := res.keys.getLast hne) hrev hbegin (by omega) (le_of_lt hcross) hBlast hagree
|
||
rw [compatible_iff_truncated_keys (db := db₂) hrev hmore hne] at hc₂
|
||
rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne]
|
||
refine ⟨hc₂.1, ?_⟩
|
||
rw [hceq]
|
||
exact hc₂.2
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- For a sorted key list, dropping `b` from the prefix at or below `last` is the
|
||
same as filtering the dropped tail at or below `last`. -/
|
||
theorem filter_drop_eq_drop_filter_le {A : List Key} (hAs : A.SortedLT) (last : Key) (b : ℕ) :
|
||
(A.filter (fun k : Key => decide (k ≤ last))).drop b =
|
||
(A.drop b).filter (fun k : Key => decide (k ≤ last)) := by
|
||
set q := A.countP (fun k : Key => decide (k ≤ last)) with hq
|
||
have hqA : q ≤ A.length := by rw [hq]; exact List.countP_le_length
|
||
have hC : A.filter (fun k : Key => decide (k ≤ last)) = A.take q := by
|
||
rw [hq]; exact filter_le_eq_take_countP hAs last
|
||
have hdrop : (A.drop b).filter (fun k : Key => decide (k ≤ last)) =
|
||
(A.take q).drop (min b q) := by
|
||
have hsplit : A.filter (fun k : Key => decide (k ≤ last)) =
|
||
(A.take b).filter (fun k : Key => decide (k ≤ last)) ++
|
||
(A.drop b).filter (fun k : Key => decide (k ≤ last)) := by
|
||
conv_lhs => rw [← List.take_append_drop b A]
|
||
rw [List.filter_append]
|
||
have htakeb : (A.take b).filter (fun k : Key => decide (k ≤ last)) =
|
||
A.take (min b q) :=
|
||
filter_take_eq_take_min (p := fun k : Key => decide (k ≤ last)) hC b
|
||
rw [hC, htakeb] at hsplit
|
||
have hsplit2 : A.take q = A.take (min b q) ++ (A.take q).drop (min b q) := by
|
||
conv_lhs => rw [← List.take_append_drop (min b q) (A.take q)]
|
||
rw [List.take_take, Nat.min_eq_left (Nat.min_le_right b q)]
|
||
rw [hsplit2] at hsplit
|
||
exact (List.append_cancel_left hsplit).symm
|
||
rw [hC, hdrop]
|
||
by_cases hbq : b ≤ q
|
||
· rw [Nat.min_eq_left hbq, List.drop_take]
|
||
· have hbq' : q ≤ b := by omega
|
||
rw [Nat.min_eq_right hbq']
|
||
rw [List.drop_eq_nil_of_le (by rw [List.length_take, Nat.min_eq_left hqA]; exact hbq'),
|
||
List.drop_eq_nil_of_le (by rw [List.length_take, Nat.min_eq_left hqA])]
|
||
|
||
/-- Compatibility with a truncated crossed read is equivalent to the limit and the
|
||
begin-offset-dropped truncated range storing exactly the reported keys, provided the
|
||
last reported key is strictly below the resolved end. -/
|
||
theorem compatible_iff_truncated_drop_of_hlr {db : DB} {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset) (hmore : res.more = true)
|
||
(hne : res.keys ≠ [])
|
||
(hlr : ((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_) :
|
||
RangeRead.Compatible db r res ↔
|
||
RangeRead.withinLimit r res.keys ∧
|
||
((truncatedRange r (res.keys.getLast hne)).keys db).drop
|
||
(r.begin.offset - 1).toNat = res.keys := by
|
||
rw [compatible_iff_truncated_keys (db := db) hrev hmore hne]
|
||
have hbridge := completeKeys_filter_le_drop (db := db) (r := r)
|
||
(last := res.keys.getLast hne) hrev hbegin hlr
|
||
constructor
|
||
· rintro ⟨hlim, hfil⟩
|
||
exact ⟨hlim, hbridge.symm.trans hfil⟩
|
||
· rintro ⟨hlim, hdrop⟩
|
||
exact ⟨hlim, hbridge.trans hdrop⟩
|
||
|
||
/-- **B-branch soundness for the forward truncated crossed read, at any positive begin
|
||
offset.** When the gap `[end_.key, begin_.key)` has at least the remaining overshoot
|
||
`e - t - (begin.offset - 1)` keys, the truncated range `[begin.key, keyAfter (last
|
||
reported))` is sound. -/
|
||
theorem sound_truncatedRange_of_crossed_B_general {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
|
||
(hbegin : 1 ≤ r.begin.offset) (hcross : r.end_.key < r.begin.key)
|
||
(hend : 2 ≤ r.end_.offset)
|
||
(hcard : intervalCard r.end_.key r.begin.key ≤
|
||
(((r.end_.offset - 1).toNat - res.keys.length - (r.begin.offset - 1).toNat : ℕ) : ℕ∞)) :
|
||
Sound r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by
|
||
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]
|
||
set b := (r.begin.offset - 1).toNat with hbdef
|
||
intro db₁ db₂ hagree
|
||
have keyF (db : DB) (hc : RangeRead.Compatible db r res) :
|
||
RangeRead.withinLimit r res.keys ∧
|
||
((truncatedRange r (res.keys.getLast hne)).keys db).drop b = res.keys := by
|
||
refine ⟨hc.1, ?_⟩
|
||
set l := db.keys with hl
|
||
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
|
||
have hls : l.SortedLT := by rw [hl]; exact db.sorted
|
||
have hAs : A.SortedLT := by
|
||
rw [hAdef]
|
||
exact List.sortedLT_iff_pairwise.mpr (hls.pairwise.filter _)
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc
|
||
have hck : RangeRead.completeKeys db r = (A.drop b).take
|
||
(min (l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
|
||
(r.end_.offset - 1).toNat) l.length
|
||
- (l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) + b)) := by
|
||
simpa [A, b, hl] using completeKeys_eq_filter_ge_drop_take (db := db) (r := r)
|
||
hrev hbegin (by omega)
|
||
have hpreA : res.keys <+: A.drop b := by
|
||
rw [hck] at hpre
|
||
exact List.IsPrefix.trans hpre (List.take_prefix _ _)
|
||
have hAsDrop : (A.drop b).SortedLT :=
|
||
List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := b) hAs.pairwise)
|
||
have hfil : (A.drop b).filter (fun k : Key => decide (k ≤ res.keys.getLast hne)) = res.keys :=
|
||
filter_le_getLast_eq_of_prefix hAsDrop.pairwise hpreA hne
|
||
have hAeq : db.keys.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) = A := by
|
||
rw [hAdef, hl]
|
||
rw [truncatedRange_keys_eq_filter_le, hAeq, filter_drop_eq_drop_filter_le hAs _ b]
|
||
exact hfil
|
||
have hlrOf (db : DB)
|
||
(hdrop : ((truncatedRange r (res.keys.getLast hne)).keys db).drop b = res.keys) :
|
||
((res.keys.getLast hne : Key) : WithTop Key) < resolve db r.end_ :=
|
||
crossed_truncated_hlr_of_drop hrev hbegin (by omega) hcross hne (by simpa [b] using hcard) hdrop
|
||
constructor
|
||
· intro hc₁
|
||
have hF₁ := keyF db₁ hc₁
|
||
have hdrop₂ : ((truncatedRange r (res.keys.getLast hne)).keys db₂).drop b = res.keys := by
|
||
rw [← hagree]; exact hF₁.2
|
||
exact (compatible_iff_truncated_drop_of_hlr (db := db₂) hrev hbegin hmore hne
|
||
(hlrOf db₂ hdrop₂)).mpr ⟨hc₁.1, hdrop₂⟩
|
||
· intro hc₂
|
||
have hF₂ := keyF db₂ hc₂
|
||
have hdrop₁ : ((truncatedRange r (res.keys.getLast hne)).keys db₁).drop b = res.keys := by
|
||
rw [hagree]; exact hF₂.2
|
||
exact (compatible_iff_truncated_drop_of_hlr (db := db₁) hrev hbegin hmore hne
|
||
(hlrOf db₁ hdrop₁)).mpr ⟨hc₂.1, hdrop₁⟩
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- Extract the begin-offset padding `P` from a compatible truncated crossed read. -/
|
||
theorem crossed_pad_truncated_general {db : DB} {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hbegin : 1 ≤ r.begin.offset)
|
||
(_hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
|
||
(hne : res.keys ≠ []) (hc : RangeRead.Compatible db r res) :
|
||
∃ P : List Key, P.length = (r.begin.offset - 1).toNat ∧ P.SortedLT ∧
|
||
(∀ x ∈ P, r.begin.key ≤ (x : WithTop Key)) ∧
|
||
(∀ x ∈ P, ∀ y ∈ res.keys, x < y) ∧
|
||
(P ++ res.keys).SortedLT := by
|
||
set l := db.keys with hl
|
||
set p := l.countP (fun k : Key => decide ((k : WithTop Key) < r.begin.key)) with hp
|
||
set b := (r.begin.offset - 1).toNat with hb
|
||
set A := l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) with hAdef
|
||
set K := min (l.countP (fun k : Key => decide ((k : WithTop Key) < r.end_.key)) +
|
||
(r.end_.offset - 1).toNat) l.length - (p + b) with hK
|
||
have hls : l.SortedLT := by rw [hl]; exact db.sorted
|
||
have hA : A = l.drop p := by
|
||
rw [hAdef]
|
||
have hnot : l.filter (fun k : Key => decide (r.begin.key ≤ (k : WithTop Key))) =
|
||
l.filter (fun k : Key => decide (¬ ((k : WithTop Key) < r.begin.key))) := by
|
||
apply List.filter_congr
|
||
intro k _
|
||
rw [decide_eq_decide]
|
||
exact not_lt.symm
|
||
rw [hnot, filter_not_lt_eq_drop_countP hls r.begin.key, ← hp]
|
||
have hAs : A.SortedLT := by
|
||
rw [hA]
|
||
exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.drop (i := p) hls.pairwise)
|
||
have hAge : ∀ x ∈ A, r.begin.key ≤ (x : WithTop Key) := by
|
||
intro x hx
|
||
rw [hAdef] at hx
|
||
exact of_decide_eq_true (List.mem_filter.mp hx).2
|
||
have hck : RangeRead.completeKeys db r = (A.drop b).take K := by
|
||
rw [completeKeys_eq_drop_take_general (db := db) (r := r) hrev hbegin hend]
|
||
rw [← hl, ← hp, ← hb, hA, List.drop_drop, hK]
|
||
have hpre : res.keys <+: RangeRead.completeKeys db r := RangeRead.compatible_keys_prefix hc
|
||
have hpreA : res.keys <+: A.drop b := by
|
||
rw [hck] at hpre
|
||
exact List.IsPrefix.trans hpre (List.take_prefix _ _)
|
||
have hbA : b ≤ A.length := by
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
have := hpreA.length_le
|
||
rw [List.length_drop] at this
|
||
omega
|
||
let P := A.take b
|
||
have hPdef : P = A.take b := rfl
|
||
have hPlen : P.length = b := by
|
||
rw [hPdef, List.length_take, Nat.min_eq_left hbA]
|
||
have hPs : P.SortedLT := by
|
||
rw [hPdef]
|
||
exact List.sortedLT_iff_pairwise.mpr (List.Pairwise.take (i := b)
|
||
(List.sortedLT_iff_pairwise.mp hAs))
|
||
have hPge : ∀ x ∈ P, r.begin.key ≤ (x : WithTop Key) := by
|
||
intro x hx
|
||
exact hAge x (List.take_subset _ _ (by rw [← hPdef]; exact hx))
|
||
have happend : A = P ++ A.drop b := by rw [hPdef, List.take_append_drop]
|
||
have hcrossA : ∀ x ∈ P, ∀ y ∈ A.drop b, x < y := by
|
||
have := List.sortedLT_append.mp (by rw [← happend]; exact hAs)
|
||
exact this.2.2
|
||
have hP_lt_res : ∀ x ∈ P, ∀ y ∈ res.keys, x < y := by
|
||
intro x hx y hy
|
||
exact hcrossA x hx y (hpreA.subset hy)
|
||
have hresS : res.keys.SortedLT := RangeRead.compatible_sortedLT hc hrev
|
||
refine ⟨P, ?_, hPs, hPge, hP_lt_res, ?_⟩
|
||
· rw [hPlen, hb]
|
||
· exact List.sortedLT_append.mpr ⟨hPs, hresS, hP_lt_res⟩
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
private theorem crossedTrunc_enat_succ_le_of_lt {s : ℕ} {h : ℕ∞} (hs : (s : ℕ∞) < h) :
|
||
((s + 1 : ℕ) : ℕ∞) ≤ h := by
|
||
cases h with
|
||
| top => exact le_top
|
||
| coe n =>
|
||
rw [ENat.natCast_lt_natCast] at hs
|
||
exact_mod_cast Nat.succ_le_of_lt hs
|
||
|
||
/-- **Gap-key necessity for the forward truncated crossed read at any positive begin
|
||
offset.** When the gap is too small to absorb `e - t - b`, every key in
|
||
`[end_.key, begin_.key)` is necessary. -/
|
||
theorem necessary_of_mem_gap_crossed_truncated_general {r : RangeRead} {res : Result} {k : Key}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
|
||
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
|
||
(hlt : (((r.end_.offset - 1).toNat - res.keys.length -
|
||
(r.begin.offset - 1).toNat : ℕ) : ℕ∞) < intervalCard r.end_.key r.begin.key)
|
||
(hkE : r.end_.key ≤ (k : WithTop Key))
|
||
(hkB : (k : WithTop Key) < r.begin.key) :
|
||
Necessary r res k := by
|
||
set t : ℕ := res.keys.length with htdef
|
||
set eo : ℕ := (r.end_.offset - 1).toNat with heodef
|
||
set b : ℕ := (r.begin.offset - 1).toNat with hbdef
|
||
set s : ℕ := eo - t - b with hsdef
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
have hpre₀ : res.keys <+: RangeRead.completeKeys db₀ r :=
|
||
RangeRead.compatible_keys_prefix hcomp₀
|
||
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp₀ hrev
|
||
have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by
|
||
intro x hx
|
||
have hmem : x ∈ RangeRead.completeKeys db₀ r := hpre₀.subset hx
|
||
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin)
|
||
(RangeRead.mem_completeKeys.mp hmem).2.1
|
||
have hlast_ge_B : r.begin.key ≤ (res.keys.getLast hne : WithTop Key) :=
|
||
hall_ge _ (List.getLast_mem hne)
|
||
have hgap : (between db₀ r.end_.key r.begin.key).length + b + t ≤ eo := by
|
||
have := compatible_gap_bound (db := db₀) hrev hmore hne hbegin (by omega) hcross hcomp₀
|
||
simpa [hbdef, htdef, heodef] using this
|
||
have hbt : b + t ≤ eo := by omega
|
||
have hse : eo = s + t + b := by rw [hsdef]; omega
|
||
have hcard : ((s + 1 : ℕ) : ℕ∞) ≤ intervalCard r.end_.key r.begin.key :=
|
||
crossedTrunc_enat_succ_le_of_lt (s := s)
|
||
(by simpa [s, htdef, heodef, hbdef] using hlt)
|
||
obtain ⟨dbH, hHrange, hkH, hHlen⟩ :=
|
||
exists_db_keysIn_avoid (B := r.end_.key) (E := r.begin.key) (k := k) (m := s) hcard
|
||
have hHgeE : ∀ x ∈ dbH.keys, r.end_.key ≤ (x : WithTop Key) :=
|
||
fun x hx => (hHrange x hx).1
|
||
have hHltB : ∀ x ∈ dbH.keys, (x : WithTop Key) < r.begin.key :=
|
||
fun x hx => (hHrange x hx).2
|
||
obtain ⟨P, hPlen, hPs, hPge, hPlt, hPsortPR⟩ :=
|
||
crossed_pad_truncated_general (db := db₀) hrev hbegin hcross (by omega) hne hcomp₀
|
||
have hPlen' : P.length = b := by simpa [hbdef] using hPlen
|
||
have hPge' : ∀ x ∈ P, r.begin.key ≤ (x : WithTop Key) := by
|
||
intro x hx; simpa using hPge x hx
|
||
have hH_lt_P : ∀ x ∈ dbH.keys, ∀ y ∈ P, x < y := by
|
||
intro x hx y hy
|
||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltB x hx) (hPge' y hy))
|
||
obtain ⟨C, hCge, hCnotin⟩ :=
|
||
exists_le_not_mem (res.keys ++ dbH.keys) (res.keys.getLast hne)
|
||
have hCnotres : C ∉ res.keys := fun h => hCnotin (List.mem_append_left _ h)
|
||
have hCnotH : C ∉ dbH.keys := fun h => hCnotin (List.mem_append_right _ h)
|
||
have hCgtRes : ∀ a ∈ res.keys, a < C := by
|
||
intro a ha
|
||
have hle : a ≤ res.keys.getLast hne :=
|
||
(hsort.pairwise.imp le_of_lt).rel_getLast ha
|
||
exact lt_of_le_of_ne (le_trans hle hCge) (fun h => hCnotres (h ▸ ha))
|
||
have hHltC : ∀ a ∈ dbH.keys, a < C := by
|
||
intro a ha
|
||
have h1 : (a : WithTop Key) < (C : WithTop Key) :=
|
||
lt_of_lt_of_le (hHltB a ha)
|
||
(le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
|
||
exact WithTop.coe_lt_coe.mp h1
|
||
have hHP : (dbH.keys ++ P).SortedLT :=
|
||
List.sortedLT_append.mpr ⟨dbH.sorted, hPs, hH_lt_P⟩
|
||
have hHPres_lt : ∀ x ∈ (dbH.keys ++ P), ∀ y ∈ res.keys, x < y := by
|
||
intro x hx y hy
|
||
rcases List.mem_append.mp hx with hxH | hxP
|
||
· exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hHltB x hxH) (hall_ge y hy))
|
||
· exact hPlt x hxP y hy
|
||
have hHPres : (dbH.keys ++ P ++ res.keys).SortedLT :=
|
||
List.sortedLT_append.mpr ⟨hHP, hsort, hHPres_lt⟩
|
||
have hsingle : ([C] : List Key).SortedLT := by
|
||
rw [List.sortedLT_cons]
|
||
exact ⟨by simp, List.sortedLT_nil⟩
|
||
have hcrossList : ∀ a ∈ (dbH.keys ++ P ++ res.keys), ∀ y ∈ ([C] : List Key), a < y := by
|
||
intro a ha y hy
|
||
rw [List.mem_singleton] at hy
|
||
subst hy
|
||
rcases List.mem_append.mp ha with ha' | haR
|
||
· rcases List.mem_append.mp ha' with haH | haP
|
||
· exact hHltC a haH
|
||
· exact lt_of_lt_of_le (hPlt a haP _ (List.getLast_mem hne)) hCge
|
||
· exact hCgtRes a haR
|
||
have hsort₂ : (dbH.keys ++ P ++ res.keys ++ [C]).SortedLT :=
|
||
List.sortedLT_append.mpr ⟨hHPres, hsingle, hcrossList⟩
|
||
let db₂ : DB := ⟨dbH.keys ++ P ++ res.keys ++ [C], hsort₂⟩
|
||
have hdb₂ : db₂.keys = dbH.keys ++ P ++ res.keys ++ [C] := rfl
|
||
have hfil₂ : db₂.keys.filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P ++ res.keys ++ [C] := by
|
||
rw [hdb₂, List.filter_append, List.filter_append, List.filter_append]
|
||
have hHf : dbH.keys.filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = [] := by
|
||
rw [List.filter_eq_nil_iff]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact not_le.mpr (hHltB x hx)
|
||
have hPf : P.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact hPge' x hx
|
||
have hresf : res.keys.filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = res.keys := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact hall_ge x hx
|
||
have hCf : ([C] : List Key).filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = [C] := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
rw [List.mem_singleton] at hx
|
||
subst hx
|
||
rw [decide_eq_true_eq]
|
||
exact le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge)
|
||
rw [hHf, hPf, hresf, hCf]
|
||
simp
|
||
have hcE₂ : cnt db₂ r.end_.key = 0 := by
|
||
apply cnt_eq_zero_of_forall_ge
|
||
intro x hx
|
||
rw [hdb₂] at hx
|
||
rcases List.mem_append.mp hx with hx' | hxC
|
||
· rcases List.mem_append.mp hx' with hx'' | hxR
|
||
· rcases List.mem_append.mp hx'' with hxH | hxP
|
||
· exact hHgeE x hxH
|
||
· exact le_trans (le_of_lt hcross) (hPge' x hxP)
|
||
· exact le_trans (le_of_lt hcross) (hall_ge x hxR)
|
||
· rw [List.mem_singleton] at hxC
|
||
subst hxC
|
||
exact le_trans (le_of_lt hcross)
|
||
(le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
|
||
have hcB₂ : cnt db₂ r.begin.key = s := by
|
||
change db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = s
|
||
rw [hdb₂, List.countP_append, List.countP_append, List.countP_append]
|
||
have hHc : dbH.keys.countP
|
||
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = dbH.keys.length :=
|
||
cnt_eq_length_of_forall_lt dbH hHltB
|
||
have hPc : P.countP
|
||
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by
|
||
rw [List.countP_eq_zero]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact not_lt.mpr (hPge' x hx)
|
||
have hresc : res.keys.countP
|
||
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by
|
||
rw [List.countP_eq_zero]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact not_lt.mpr (hall_ge x hx)
|
||
have hCc : ([C] : List Key).countP
|
||
(fun x : Key => decide ((x : WithTop Key) < r.begin.key)) = 0 := by
|
||
rw [List.countP_eq_zero]
|
||
intro x hx
|
||
rw [List.mem_singleton] at hx
|
||
subst hx
|
||
rw [decide_eq_true_eq]
|
||
exact not_lt.mpr (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
|
||
rw [hHc, hPc, hresc, hCc, hHlen]
|
||
simp
|
||
have hn₂ : db₂.keys.length = s + b + t + 1 := by
|
||
rw [hdb₂, List.length_append, List.length_append, List.length_append,
|
||
hHlen, hPlen', htdef, List.length_singleton]
|
||
have hdropP : (P ++ res.keys ++ [C]).drop b = res.keys ++ [C] := by
|
||
have hbP : b = P.length := hPlen'.symm
|
||
rw [hbP, List.append_assoc]
|
||
rw [List.drop_append_of_le_length le_rfl, List.drop_length]
|
||
simp
|
||
have hck₂ : RangeRead.completeKeys db₂ r = res.keys := by
|
||
rw [completeKeys_eq_filter_ge_drop_take (db := db₂) (r := r) hrev hbegin (by omega),
|
||
hfil₂, hdropP]
|
||
have hK : min (cnt db₂ r.end_.key + (r.end_.offset - 1).toNat) db₂.keys.length -
|
||
(cnt db₂ r.begin.key + b) = t := by
|
||
have hE : (r.end_.offset - 1).toNat = eo := heodef.symm
|
||
rw [hcE₂, hcB₂, hn₂, hE, hse]
|
||
rw [Nat.min_eq_left (by omega)]
|
||
omega
|
||
have hK' : min (db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) +
|
||
(r.end_.offset - 1).toNat) db₂.keys.length -
|
||
(db₂.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) + b) = t := by
|
||
simpa [cnt] using hK
|
||
rw [hK', List.take_append_of_le_length (le_of_eq htdef), htdef, List.take_length]
|
||
have hcomp₂ : RangeRead.Compatible db₂ r res := by
|
||
refine ⟨hcomp₀.1, Or.inl ⟨hmore, ?_, hne⟩⟩
|
||
rw [hck₂]
|
||
have hk_db₂ : k ∉ db₂.keys := by
|
||
rw [hdb₂]
|
||
intro hmem
|
||
rcases List.mem_append.mp hmem with hmem' | hmemC
|
||
· rcases List.mem_append.mp hmem' with hmem'' | hmemR
|
||
· rcases List.mem_append.mp hmem'' with hmemH | hmemP
|
||
· exact hkH hmemH
|
||
· exact absurd (hPge' k hmemP) (not_le.mpr hkB)
|
||
· exact absurd (hall_ge k hmemR) (not_le.mpr hkB)
|
||
· rw [List.mem_singleton] at hmemC
|
||
have hkC : k = C := hmemC
|
||
have h1 : (k : WithTop Key) < (C : WithTop Key) :=
|
||
lt_of_lt_of_le hkB (le_trans hlast_ge_B (WithTop.coe_le_coe.mpr hCge))
|
||
rw [hkC] at h1
|
||
exact (lt_irrefl (C : WithTop Key)) h1
|
||
let db₁ : DB := db₂.insert k hk_db₂
|
||
have hcE₁ : cnt db₁ r.end_.key = 0 := by
|
||
rw [show db₁ = db₂.insert k hk_db₂ from rfl,
|
||
cnt_insert_not_lt db₂ k hk_db₂ (v := r.end_.key) (not_lt.mpr hkE)]
|
||
exact hcE₂
|
||
have hcB₁ : cnt db₁ r.begin.key = s + 1 := by
|
||
rw [show db₁ = db₂.insert k hk_db₂ from rfl,
|
||
cnt_insert_lt db₂ k hk_db₂ (v := r.begin.key) hkB, hcB₂]
|
||
have hn₁ : db₁.keys.length = s + b + t + 2 := by
|
||
rw [show db₁ = db₂.insert k hk_db₂ from rfl, DB.insert_keys,
|
||
List.orderedInsert_length, hn₂]
|
||
have hfil₁ : db₁.keys.filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) = P ++ res.keys ++ [C] := by
|
||
have hsingle_filter : List.filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) (k :: db₂.keys) =
|
||
db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))) := by
|
||
rw [List.filter_cons]
|
||
have hkf : decide (r.begin.key ≤ (k : WithTop Key)) = false := by
|
||
rw [decide_eq_false_iff_not]
|
||
exact not_le.mpr hkB
|
||
rw [hkf]
|
||
rfl
|
||
have hperm : List.Perm ((List.orderedInsert (· ≤ ·) k db₂.keys).filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key))))
|
||
(db₂.keys.filter (fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))) := by
|
||
have h := (List.perm_orderedInsert (· ≤ ·) k db₂.keys).filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))
|
||
rwa [hsingle_filter] at h
|
||
have hs₁ : ((List.orderedInsert (· ≤ ·) k db₂.keys).filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))).SortedLT :=
|
||
List.sortedLT_iff_pairwise.mpr ((db₂.insert k hk_db₂).sorted.pairwise.filter _)
|
||
have hs₂ : (db₂.keys.filter
|
||
(fun x : Key => decide (r.begin.key ≤ (x : WithTop Key)))).SortedLT :=
|
||
List.sortedLT_iff_pairwise.mpr (db₂.sorted.pairwise.filter _)
|
||
rw [show db₁ = db₂.insert k hk_db₂ from rfl, DB.insert_keys]
|
||
exact (List.SortedLT.eq_of_mem_iff hs₁ hs₂ (fun x => hperm.mem_iff)).trans hfil₂
|
||
have hck₁ : RangeRead.completeKeys db₁ r = res.keys.take (t - 1) := by
|
||
rw [completeKeys_eq_filter_ge_drop_take (db := db₁) (r := r) hrev hbegin (by omega),
|
||
hfil₁, hdropP]
|
||
have hK : min (cnt db₁ r.end_.key + (r.end_.offset - 1).toNat) db₁.keys.length -
|
||
(cnt db₁ r.begin.key + b) = t - 1 := by
|
||
have hE : (r.end_.offset - 1).toNat = eo := heodef.symm
|
||
rw [hcE₁, hcB₁, hn₁, hE, hse]
|
||
rw [Nat.min_eq_left (by omega)]
|
||
omega
|
||
have hK' : min (db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) +
|
||
(r.end_.offset - 1).toNat) db₁.keys.length -
|
||
(db₁.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.begin.key)) + b) = t - 1 :=
|
||
by
|
||
simpa [cnt] using hK
|
||
rw [hK', List.take_append_of_le_length (by omega : t - 1 ≤ res.keys.length)]
|
||
have hnot₁ : ¬ RangeRead.Compatible db₁ r res := by
|
||
intro hc
|
||
rw [compatible_iff_truncated_keys (db := db₁) hrev hmore hne] at hc
|
||
rw [hck₁] at hc
|
||
have hf : List.filter (fun k : Key => decide (k ≤ res.keys.getLast hne))
|
||
(res.keys.take (t - 1)) = res.keys.take (t - 1) := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.mem_of_mem_take hx)
|
||
rw [hf] at hc
|
||
have heq : res.keys.take (t - 1) = res.keys := hc.2
|
||
have hlen := congrArg List.length heq
|
||
rw [List.length_take, htdef] at hlen
|
||
have htpos : 0 < t := by rw [htdef]; exact List.length_pos_of_ne_nil hne
|
||
omega
|
||
intro cr hs
|
||
by_contra hkcr
|
||
have hagree : AgreeOn cr db₂ db₁ :=
|
||
(ConflictRange.keys_insert_of_not_mem cr db₂ hk_db₂ hkcr).symm
|
||
exact hnot₁ ((hs db₂ db₁ hagree).mp hcomp₂)
|
||
|
||
end FormalConflictRange
|
||
|
||
namespace FormalConflictRange
|
||
|
||
private theorem crossedTrunc_begin_key_exists_coe {r : RangeRead}
|
||
(h : r.begin.key ≠ (⊤ : WithTop Key)) :
|
||
∃ v : Key, r.begin.key = (↑v : WithTop Key) := by
|
||
cases hk : r.begin.key with
|
||
| top => exact absurd hk h
|
||
| coe v => exact ⟨v, rfl⟩
|
||
|
||
/-- **Large-gap branch minimality for the forward truncated crossed read at any positive
|
||
begin offset.** -/
|
||
theorem minimal_truncatedRange_of_crossed_B_general {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
|
||
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
|
||
(hbig : intervalCard r.end_.key r.begin.key ≤
|
||
(((r.end_.offset - 1).toNat - res.keys.length -
|
||
(r.begin.offset - 1).toNat : ℕ) : ℕ∞)) :
|
||
Minimal r res (truncatedRange r (res.keys.getLastD ([] : Key))) := by
|
||
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]
|
||
rw [minimal_iff_sound_and_necessaryRange]
|
||
refine ⟨?_, ?_⟩
|
||
· have hs := sound_truncatedRange_of_crossed_B_general (r := r) (res := res)
|
||
hrev hmore hne hbegin hcross hend hbig
|
||
rwa [hlast] at hs
|
||
· intro k hkB hklt
|
||
have hklast : k ≤ res.keys.getLast hne :=
|
||
(lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hklt)
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by
|
||
intro x hx
|
||
have hmem : x ∈ RangeRead.completeKeys db₀ r :=
|
||
(RangeRead.compatible_keys_prefix hcomp₀).subset hx
|
||
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin)
|
||
(RangeRead.mem_completeKeys.mp hmem).2.1
|
||
have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
|
||
obtain ⟨x, hx⟩ : ∃ x, x ∈ res.keys := by
|
||
cases h : res.keys with
|
||
| nil => exact absurd h hne
|
||
| cons a tl => exact ⟨a, by simp⟩
|
||
have h1 : r.begin.key ≤ (x : WithTop Key) := hall_ge x hx
|
||
intro htop
|
||
rw [htop] at h1
|
||
exact not_le.mpr (WithTop.coe_lt_top x) h1
|
||
obtain ⟨v, hv⟩ := crossedTrunc_begin_key_exists_coe hbk_ne_top
|
||
have hbegin_nec : Necessary r res v :=
|
||
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv
|
||
have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hkB)
|
||
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
|
||
|
||
/-- **Small-gap branch minimality for the forward truncated crossed read at any positive
|
||
begin offset.** -/
|
||
theorem minimal_truncatedForward_of_crossed_general {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
|
||
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
|
||
(hsmall : (((r.end_.offset - 1).toNat - res.keys.length -
|
||
(r.begin.offset - 1).toNat : ℕ) : ℕ∞) < intervalCard r.end_.key r.begin.key) :
|
||
Minimal r res ⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩ := by
|
||
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]
|
||
rw [minimal_iff_sound_and_necessaryRange]
|
||
refine ⟨?_, ?_⟩
|
||
· have hs := sound_truncatedRange_of_crossed_E_general (r := r) (res := res)
|
||
hrev hmore hne hbegin hcross hend
|
||
rwa [hlast] at hs
|
||
· intro k hkE hklt
|
||
have hklast : k ≤ res.keys.getLast hne :=
|
||
(lt_keyAfter_iff k (res.keys.getLast hne)).mp (WithTop.coe_lt_coe.mp hklt)
|
||
by_cases hkB : (k : WithTop Key) < r.begin.key
|
||
· exact necessary_of_mem_gap_crossed_truncated_general hread hmore hrev hne hbegin
|
||
hcross hend hsmall hkE hkB
|
||
· have hkBle : r.begin.key ≤ (k : WithTop Key) := not_lt.mp hkB
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
have hall_ge : ∀ x ∈ res.keys, r.begin.key ≤ (x : WithTop Key) := by
|
||
intro x hx
|
||
have hmem : x ∈ RangeRead.completeKeys db₀ r :=
|
||
(RangeRead.compatible_keys_prefix hcomp₀).subset hx
|
||
exact le_trans (key_le_resolve_of_one_le (db := db₀) (s := r.begin) hbegin)
|
||
(RangeRead.mem_completeKeys.mp hmem).2.1
|
||
have hbk_ne_top : r.begin.key ≠ (⊤ : WithTop Key) := by
|
||
obtain ⟨x, hx⟩ : ∃ x, x ∈ res.keys := by
|
||
cases h : res.keys with
|
||
| nil => exact absurd h hne
|
||
| cons a tl => exact ⟨a, by simp⟩
|
||
have h1 : r.begin.key ≤ (x : WithTop Key) := hall_ge x hx
|
||
intro htop
|
||
rw [htop] at h1
|
||
exact not_le.mpr (WithTop.coe_lt_top x) h1
|
||
obtain ⟨v, hv⟩ := crossedTrunc_begin_key_exists_coe hbk_ne_top
|
||
have hbegin_nec : Necessary r res v :=
|
||
necessary_begin_key ⟨db₀, hcomp₀⟩ hrev (List.length_pos_of_ne_nil hne) hbegin hv
|
||
have hvk : v ≤ k := WithTop.coe_le_coe.mp (hv ▸ hkBle)
|
||
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
|
||
|
||
/-- The forward truncated crossed closed form at any positive begin offset. -/
|
||
noncomputable def truncatedForwardCrossedGeneral (r : RangeRead) (res : Result) : ConflictRange :=
|
||
if intervalCard r.end_.key r.begin.key ≤
|
||
(((r.end_.offset - 1).toNat - res.keys.length -
|
||
(r.begin.offset - 1).toNat : ℕ) : ℕ∞) then
|
||
truncatedRange r (res.keys.getLastD ([] : Key))
|
||
else
|
||
⟨r.end_.key, (keyAfter (res.keys.getLastD ([] : Key)) : WithTop Key)⟩
|
||
|
||
/-- The forward truncated crossed closed form is minimal on the whole region. -/
|
||
theorem minimal_truncatedForwardCrossedGeneral {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
|
||
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) :
|
||
Minimal r res (truncatedForwardCrossedGeneral r res) := by
|
||
unfold truncatedForwardCrossedGeneral
|
||
by_cases hbig : intervalCard r.end_.key r.begin.key ≤
|
||
(((r.end_.offset - 1).toNat - res.keys.length -
|
||
(r.begin.offset - 1).toNat : ℕ) : ℕ∞)
|
||
· rw [ite_eq_left hbig]
|
||
exact minimal_truncatedRange_of_crossed_B_general hread hmore hrev hne hbegin hcross hend hbig
|
||
· rw [ite_eq_right hbig]
|
||
exact minimal_truncatedForward_of_crossed_general hread hmore hrev hne hbegin hcross hend
|
||
(not_le.mp hbig)
|
||
|
||
/-- The forward truncated crossed general rule denotes the general conflict range. -/
|
||
theorem truncatedForwardCrossedGeneral_toSet_eq_general {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
|
||
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) :
|
||
(truncatedForwardCrossedGeneral r res).toSet = (conflictRangeGeneral r res).toSet :=
|
||
(minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcross hend).toSet_eq
|
||
(conflictRangeGeneral_minimal hread)
|
||
|
||
/-- The same identification with the executable algorithm. -/
|
||
theorem truncatedForwardCrossedGeneral_toSet_eq_simple {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = false)
|
||
(hne : res.keys ≠ []) (hbegin : 1 ≤ r.begin.offset)
|
||
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset) :
|
||
(truncatedForwardCrossedGeneral r res).toSet = (simpleConflictRange r res).toSet :=
|
||
(minimal_truncatedForwardCrossedGeneral hread hmore hrev hne hbegin hcross hend).toSet_eq
|
||
(simpleConflictRange_minimal hread)
|
||
|
||
end FormalConflictRange
|