- 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.
479 lines
25 KiB
Lean4
479 lines
25 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.NegCrossTruncRevCrossedSmall
|
||
|
||
/-!
|
||
# Reversed crossed negative-begin truncated cells with a large crossed gap
|
||
|
||
This module closes the large-capacity companion of the small-gap cell. The setting is
|
||
|
||
* `reverse = true`, `more = true`, `res.keys ≠ []`, `begin.offset < 0`;
|
||
* the crossed selectors `end_.key < begin.key`, with the reported last `L < begin.key`;
|
||
* `end_.offset = 1`;
|
||
* `beginSlack + 2 ≤ intervalCard end_.key begin.key + |res.keys|`.
|
||
|
||
The minimal range is `[L, begin.key)`.
|
||
|
||
The soundness direction is the same count identity as the small-gap cell: agreement on
|
||
`[L, begin.key)` fixes the stored keys in `[L, end_.key)` (the reported keys) and the
|
||
stored keys in `[end_.key, begin.key)`, so the unresolved begin anchor keeps the same
|
||
position relative to `L`. Necessity is new: every key in `[end_.key, begin.key)` must
|
||
be in every sound range. The capacity condition supplies enough room in the gap for a
|
||
witness database that stores `beginSlack + 2 - |res.keys|` keys there, which pushes the
|
||
begin resolution past `L` and breaks the reported prefix.
|
||
-/
|
||
|
||
namespace FormalConflictRange
|
||
|
||
|
||
/-- **The inner double filter of the reversed complete keys is the stored keys in
|
||
`[L, end_.key)`.** At end offset one, a stored key lies below the end resolution exactly
|
||
when it lies below `end_.key`. -/
|
||
theorem filter_ge_filter_lt_resolve_end_eq_between {db : DB} {r : RangeRead}
|
||
(hend : r.end_.offset = 1) (L : Key) :
|
||
(db.keys.filter (fun k : Key => decide (L ≤ k))).filter
|
||
(fun k : Key => decide (((k : Key) : WithTop Key) < resolve db r.end_)) =
|
||
between db ((L : Key) : WithTop Key) r.end_.key := by
|
||
unfold between
|
||
rw [List.filter_filter]
|
||
apply List.filter_congr
|
||
intro k hk
|
||
have hL : decide (L ≤ k) = decide (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
|
||
rw [decide_eq_decide]
|
||
exact WithTop.coe_le_coe.symm
|
||
rw [hL, Bool.and_comm]
|
||
conv_rhs => rw [Bool.decide_and]
|
||
congr 1
|
||
rw [decide_eq_decide]
|
||
constructor
|
||
· intro h
|
||
exact lt_end_key_of_lt_resolve_end_one hend hk h
|
||
· intro h
|
||
exact lt_of_lt_of_le h (key_le_resolve_of_one_le (db := db) (by omega))
|
||
|
||
/-- **The reported keys of a compatible reversed truncated result are the stored keys
|
||
in `[last, end_.key)` read backwards.** -/
|
||
theorem res_keys_eq_reverse_between_of_truncated_rev {db : DB} {r : RangeRead}
|
||
{res : Result} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hne : res.keys ≠ []) (hend : r.end_.offset = 1) :
|
||
res.keys = (between db ((res.keys.getLast hne : Key) : WithTop Key) r.end_.key).reverse := by
|
||
set L : Key := res.keys.getLast hne with hLdef
|
||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||
have hfil : (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) = res.keys :=
|
||
(compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp |>.2
|
||
have hLfil : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
|
||
rw [hfil]; exact hLmem
|
||
have hLck : L ∈ RangeRead.completeKeys db r := (List.mem_filter.mp hLfil).1
|
||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||
(RangeRead.mem_completeKeys.mp hLck).2.1
|
||
have hid := completeKeys_filter_ge_eq_resolve_end (db := db) (r := r) (last := L) hrev hrb
|
||
have hinner := filter_ge_filter_lt_resolve_end_eq_between (db := db) (r := r) (L := L) hend
|
||
rw [hfil] at hid
|
||
rw [hid, hinner]
|
||
|
||
/-- **Soundness of the begin-key range in the large-gap reversed crossed cell.**
|
||
Agreement on `[last, begin.key)` preserves compatibility. -/
|
||
theorem sound_beginKeyRange_of_negCross_crossedLarge {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hne : res.keys ≠ []) (hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
||
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset = 1) :
|
||
Sound r res ⟨((res.keys.getLast hne : Key) : WithTop Key), r.begin.key⟩ := by
|
||
set L : Key := res.keys.getLast hne with hLdef
|
||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||
have hLcross : ((L : Key) : WithTop Key) < r.begin.key := by rw [hLdef]; exact hcross
|
||
have cle : L < r.end_.key := by
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
have hpre : res.keys <+: RangeRead.completeKeys db₀ r :=
|
||
RangeRead.compatible_keys_prefix hcomp₀
|
||
have hck := hpre.subset hLmem
|
||
exact lt_end_key_of_lt_resolve_end_one hend (RangeRead.mem_completeKeys.mp hck).1
|
||
(RangeRead.mem_completeKeys.mp hck).2.2
|
||
have step : ∀ db db', AgreeOn ⟨((L : Key) : WithTop Key), r.begin.key⟩ db db' →
|
||
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
|
||
intro db db' hag' hcomp
|
||
have hbetweenEq : between db ((L : Key) : WithTop Key) r.begin.key =
|
||
between db' ((L : Key) : WithTop Key) r.begin.key := by
|
||
have h := hag'
|
||
unfold AgreeOn ConflictRange.keys at h
|
||
unfold between
|
||
exact h
|
||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||
have hLdb' : L ∈ db'.keys := by
|
||
have hmem : L ∈ between db ((L : Key) : WithTop Key) r.begin.key := by
|
||
unfold between
|
||
exact List.mem_filter.mpr ⟨hLdb, by simp [hLcross]⟩
|
||
rw [hbetweenEq] at hmem
|
||
exact (List.mem_filter.mp hmem).1
|
||
have hbound := between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
|
||
have hbound' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||
r.begin.offset - 1 ≤ 0 := by
|
||
rw [← hbetweenEq]; exact hbound
|
||
have hres' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
|
||
resolve_begin_le_of_between_bound hLdb' hLcross hbound'
|
||
have hbetweenE : between db ((L : Key) : WithTop Key) r.end_.key =
|
||
between db' ((L : Key) : WithTop Key) r.end_.key :=
|
||
between_eq_of_agree (db := db) (db' := db') (last := ((L : Key) : WithTop Key))
|
||
(beginKey := r.end_.key) (endKey := r.begin.key) hag' (le_of_lt cle) (le_of_lt hcrossE)
|
||
have hresBetween := res_keys_eq_reverse_between_of_truncated_rev (db := db) (r := r)
|
||
(res := res) hcomp hmore hrev hne hend
|
||
have h1 := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r) (last := L) hrev hres'
|
||
have h2 := filter_ge_filter_lt_resolve_end_eq_between (db := db') (r := r) (L := L) hend
|
||
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
|
||
refine ⟨by simpa [RangeRead.withinLimit] using hcomp.1, ?_⟩
|
||
rw [← hLdef]
|
||
rw [h1, h2, ← hbetweenE]
|
||
rw [hLdef]
|
||
rw [← hresBetween]
|
||
intro db₁ db₂ hag
|
||
exact ⟨step db₁ db₂ hag, step db₂ db₁ hag.symm⟩
|
||
|
||
/-- **The reported length is at most `beginSlack + 1`.** The reported keys are the
|
||
stored keys in `[last, end_.key)`, which is contained in `[last, begin.key)`, and the
|
||
begin anchor bound caps that interval at `beginSlack + 1`. -/
|
||
theorem res_length_le_beginSlack_succ_of_negCross_trunc_rev {r : RangeRead} {res : Result}
|
||
{db : DB} (hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||
(hbeg : r.begin.offset < 0)
|
||
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
||
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset = 1) :
|
||
res.keys.length ≤ beginSlack r + 1 := by
|
||
set L : Key := res.keys.getLast hne with hLdef
|
||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||
have hLck : L ∈ RangeRead.completeKeys db r :=
|
||
(RangeRead.compatible_keys_prefix hcomp).subset hLmem
|
||
have hLltE : ((L : Key) : WithTop Key) < r.end_.key :=
|
||
lt_end_key_of_lt_resolve_end_one hend (RangeRead.mem_completeKeys.mp hLck).1
|
||
(RangeRead.mem_completeKeys.mp hLck).2.2
|
||
have ht_eq : res.keys.length =
|
||
(between db ((L : Key) : WithTop Key) r.end_.key).length := by
|
||
rw [res_keys_eq_reverse_between_of_truncated_rev (db := db) (r := r) (res := res)
|
||
hcomp hmore hrev hne hend, List.length_reverse]
|
||
have hsplit := between_length_add (db := db) (L := ((L : Key) : WithTop Key))
|
||
(E := r.end_.key) (B := r.begin.key) (le_of_lt hLltE) (le_of_lt hcrossE)
|
||
have hlen_le : (between db ((L : Key) : WithTop Key) r.end_.key).length ≤
|
||
(between db ((L : Key) : WithTop Key) r.begin.key).length := by
|
||
rw [hsplit]; omega
|
||
have hbound := between_add_offset_le_one (db := db) hcomp hmore hrev hne
|
||
(by rw [← hLdef]; exact hcross)
|
||
rw [← hLdef] at hbound
|
||
have hs : (beginSlack r : ℤ) = -r.begin.offset := by
|
||
unfold beginSlack
|
||
rw [Int.toNat_of_nonneg (show (0 : ℤ) ≤ 0 - r.begin.offset by omega)]
|
||
ring
|
||
have h1 : (res.keys.length : ℤ) ≤ (beginSlack r : ℤ) + 1 := by
|
||
have h2 : (res.keys.length : ℤ) =
|
||
((between db ((L : Key) : WithTop Key) r.end_.key).length : ℤ) := by
|
||
exact_mod_cast ht_eq
|
||
have h3 : ((between db ((L : Key) : WithTop Key) r.end_.key).length : ℤ) ≤
|
||
((between db ((L : Key) : WithTop Key) r.begin.key).length : ℤ) := by
|
||
exact_mod_cast hlen_le
|
||
omega
|
||
exact_mod_cast h1
|
||
|
||
/-- Inserting a key above every element of a prefix leaves the prefix untouched. -/
|
||
theorem orderedInsert_append_of_forall_lt_left {l r : List Key} {k : Key}
|
||
(h : ∀ x ∈ l, x < k) :
|
||
(l ++ r).orderedInsert (· ≤ ·) k = l ++ r.orderedInsert (· ≤ ·) k := by
|
||
induction l with
|
||
| nil => simp
|
||
| cons a l ih =>
|
||
have hka : a < k := h a (by simp)
|
||
rw [List.cons_append, List.orderedInsert_cons, ite_eq_right (not_le.mpr hka)]
|
||
rw [ih (fun x hx => h x (by simp [hx]))]
|
||
rfl
|
||
|
||
/-- In a strictly increasing list, the least key (which is the first entry) is any
|
||
element that is at most every element and itself appears in the list. -/
|
||
theorem getElem_zero_eq_of_forall_le {l : List Key} (hs : l.SortedLT) {L : Key}
|
||
(hmin : ∀ x ∈ l, L ≤ x) (hL : L ∈ l) (h0 : 0 < l.length) :
|
||
l[(0 : ℕ)] = L := by
|
||
obtain ⟨j, hj, hjx⟩ := List.mem_iff_getElem.mp hL
|
||
have h1 : l[(0 : ℕ)] ≤ l[j] :=
|
||
hs.getElem_le_getElem_iff.mpr (Nat.zero_le j)
|
||
rw [hjx] at h1
|
||
have h2 : L ≤ l[(0 : ℕ)] := hmin _ (List.getElem_mem h0)
|
||
exact le_antisymm h1 h2
|
||
|
||
/-- **Gap-key necessity in the large-gap reversed crossed truncated cell.** The witness
|
||
database stores the reported keys in ascending order together with `beginSlack + 1 - t`
|
||
gap keys in `[end_.key, begin_.key)`, so its begin anchor is exactly zero and it resolves
|
||
onto the reported last. Inserting the target raises the anchor to one: the reported last
|
||
leaves the window and the reported keys can no longer be a prefix of the complete keys.
|
||
The capacity condition supplies the `beginSlack + 2 - t` distinct gap keys (the witness
|
||
keys plus the target) needed. -/
|
||
theorem necessary_of_mem_gap_of_negCross_trunc_rev_crossedLarge {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
|
||
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
||
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset = 1)
|
||
(hlarge : (beginSlack r : ℕ∞) + 2 ≤
|
||
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞))
|
||
{k : Key} (hkE : r.end_.key ≤ (k : WithTop Key))
|
||
(hkB : (k : WithTop Key) < r.begin.key) :
|
||
Necessary r res k := by
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
set L : Key := res.keys.getLast hne with hLdef
|
||
set t : ℕ := res.keys.length with htdef
|
||
set s : ℕ := beginSlack r with hsdef
|
||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
|
||
have hLle : ∀ x ∈ res.keys, L ≤ x := by
|
||
intro x hx; rw [hLdef]; exact (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
||
have hreported_lt_E : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.end_.key := by
|
||
intro x hx
|
||
have hxck : x ∈ RangeRead.completeKeys db₀ r :=
|
||
(RangeRead.compatible_keys_prefix hcomp₀).subset hx
|
||
exact lt_end_key_of_lt_resolve_end_one hend (RangeRead.mem_completeKeys.mp hxck).1
|
||
(RangeRead.mem_completeKeys.mp hxck).2.2
|
||
have hLltE : ((L : Key) : WithTop Key) < r.end_.key := hreported_lt_E L hLmem
|
||
have ht_le : t ≤ s + 1 := by
|
||
rw [htdef, hsdef]
|
||
exact res_length_le_beginSlack_succ_of_negCross_trunc_rev hcomp₀ hmore hrev hne
|
||
hbeg hcross hcrossE hend
|
||
-- enough room in the crossed gap for the witness keys and the target
|
||
have hcard : (((s + 1 - t) + 1 : ℕ) : ℕ∞) ≤ intervalCard r.end_.key r.begin.key := by
|
||
cases hcap : intervalCard r.end_.key r.begin.key with
|
||
| top => exact le_top
|
||
| coe n =>
|
||
have hnat : s + 2 ≤ n + t := by
|
||
have h' : ((s + 2 : ℕ) : ℕ∞) ≤ ((n + t : ℕ) : ℕ∞) := by
|
||
rw [hcap] at hlarge
|
||
simpa [ENat.natCast_add] using hlarge
|
||
exact_mod_cast h'
|
||
have hn : (s + 1 - t) + 1 ≤ n := by omega
|
||
exact_mod_cast hn
|
||
obtain ⟨dbG, hGrange, hkG, hGlen⟩ :=
|
||
exists_db_keysIn_avoid (B := r.end_.key) (E := r.begin.key) (k := k)
|
||
(m := s + 1 - t) hcard
|
||
set G : List Key := dbG.keys with hGdef
|
||
have hGmem : ∀ x ∈ G, r.end_.key ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < r.begin.key := by
|
||
intro x hx
|
||
simpa only [G, keysIn, Set.mem_ofPred_eq] using hGrange x (by simpa [hGdef] using hx)
|
||
have hGlen' : G.length = s + 1 - t := by rw [hGdef]; exact hGlen
|
||
-- assemble the ascending witness database
|
||
have hresSort : res.keys.reverse.SortedLT := hsort.reverse
|
||
have hGsorted : G.SortedLT := by rw [hGdef]; exact dbG.sorted
|
||
have hcrossG : ∀ x ∈ res.keys.reverse, ∀ y ∈ G, x < y := by
|
||
intro x hx y hy
|
||
have hx' : x ∈ res.keys := List.mem_reverse.mp hx
|
||
exact WithTop.coe_lt_coe.mp (lt_of_lt_of_le (hreported_lt_E x hx') (hGmem y hy).1)
|
||
have hkeysSorted : (res.keys.reverse ++ G).SortedLT :=
|
||
List.sortedLT_append.mpr ⟨hresSort, hGsorted, hcrossG⟩
|
||
let db_a : DB := ⟨res.keys.reverse ++ G, hkeysSorted⟩
|
||
have hdb_a : db_a.keys = res.keys.reverse ++ G := rfl
|
||
have hcntB : db_a.keys.countP (fun x : Key =>
|
||
decide (((x : Key) : WithTop Key) < r.begin.key)) = t + G.length := by
|
||
rw [hdb_a, List.countP_append, List.countP_reverse]
|
||
have h1 : res.keys.countP (fun x : Key =>
|
||
decide (((x : Key) : WithTop Key) < r.begin.key)) = t := by
|
||
rw [htdef, List.countP_eq_length]
|
||
intro x hx; rw [decide_eq_true_eq]
|
||
exact lt_trans (hreported_lt_E x hx) hcrossE
|
||
have h2 : G.countP (fun x : Key =>
|
||
decide (((x : Key) : WithTop Key) < r.begin.key)) = G.length := by
|
||
rw [List.countP_eq_length]
|
||
intro x hx; rw [decide_eq_true_eq]; exact (hGmem x hx).2
|
||
rw [h1, h2]
|
||
have hanchor : r.begin.anchor db_a = 0 := by
|
||
rw [anchor_eq_count_sub_slack db_a r (le_of_lt hbeg), hcntB, hGlen']
|
||
have hts : t + (s + 1 - t) = s + 1 := Nat.add_sub_of_le ht_le
|
||
rw [hts]; push_cast; ring
|
||
have h0lt : (0 : ℕ) < db_a.keys.length := by
|
||
rw [hdb_a, List.length_append, List.length_reverse]
|
||
have htpos : 0 < res.keys.length := List.length_pos_of_ne_nil hne
|
||
omega
|
||
have hmin_a : ∀ x ∈ db_a.keys, L ≤ x := by
|
||
intro x hx
|
||
rw [hdb_a] at hx
|
||
rcases List.mem_append.mp hx with hxr | hxG
|
||
· exact hLle x (List.mem_reverse.mp hxr)
|
||
· exact le_of_lt (WithTop.coe_lt_coe.mp (lt_of_lt_of_le hLltE (hGmem x hxG).1))
|
||
have hLmem_a : L ∈ db_a.keys := by
|
||
rw [hdb_a]; exact List.mem_append_left _ (List.mem_reverse.mpr hLmem)
|
||
have hget0 : db_a.keys[(0 : ℕ)] = L :=
|
||
getElem_zero_eq_of_forall_le hkeysSorted hmin_a hLmem_a h0lt
|
||
have hresBegin : resolve db_a r.begin = ((L : Key) : WithTop Key) := by
|
||
have h0 : 0 ≤ r.begin.anchor db_a := by rw [hanchor]
|
||
have hlt : (r.begin.anchor db_a).toNat < db_a.keys.length := by
|
||
rw [hanchor]; simpa using h0lt
|
||
rw [resolve_eq_getElem h0 hlt]
|
||
have hidx : (r.begin.anchor db_a).toNat = 0 := by rw [hanchor]; rfl
|
||
simpa [hidx] using hget0
|
||
have hresEnd_ge : r.end_.key ≤ resolve db_a r.end_ :=
|
||
key_le_resolve_of_one_le (db := db_a) (s := r.end_) (by omega)
|
||
have hfilter : db_a.keys.filter (fun x : Key => decide
|
||
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < resolve db_a r.end_)) = res.keys.reverse := by
|
||
rw [hdb_a, List.filter_append]
|
||
have h1 : (res.keys.reverse).filter (fun x : Key => decide
|
||
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < resolve db_a r.end_)) = res.keys.reverse := by
|
||
rw [List.filter_eq_self]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
exact ⟨WithTop.coe_le_coe.mpr (hLle x (List.mem_reverse.mp hx)),
|
||
lt_of_lt_of_le (hreported_lt_E x (List.mem_reverse.mp hx)) hresEnd_ge⟩
|
||
have h2 : G.filter (fun x : Key => decide
|
||
(((L : Key) : WithTop Key) ≤ (x : WithTop Key) ∧
|
||
(x : WithTop Key) < resolve db_a r.end_)) = [] := by
|
||
rw [List.filter_eq_nil_iff]
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
intro hP
|
||
have hxmem : x ∈ db_a.keys := by rw [hdb_a]; exact List.mem_append_right _ hx
|
||
have hrele : resolve db_a r.end_ ≤ (x : WithTop Key) :=
|
||
(key_le_resolve_iff_of_offset_one (db := db_a) (s := r.end_) hend hxmem).mp
|
||
(hGmem x hx).1
|
||
exact not_lt.mpr hrele hP.2
|
||
rw [h1, h2, List.append_nil]
|
||
have hcomplete : RangeRead.completeKeys db_a r = res.keys := by
|
||
unfold RangeRead.completeKeys RangeRead.inRange
|
||
rw [hrev]
|
||
simp only [ite_true]
|
||
rw [hresBegin, hfilter, List.reverse_reverse]
|
||
have hcompat_a : RangeRead.Compatible db_a r res :=
|
||
⟨hcomp₀.1, Or.inl ⟨hmore, by rw [hcomplete], hne⟩⟩
|
||
have hk_a : k ∉ db_a.keys := by
|
||
rw [hdb_a]
|
||
intro hmem
|
||
rcases List.mem_append.mp hmem with hx | hx
|
||
· exact absurd (hreported_lt_E k (List.mem_reverse.mp hx)) (not_lt.mpr hkE)
|
||
· exact hkG (by simpa [hGdef] using hx)
|
||
-- insert the target: the first two sorted keys are the reported last and something above
|
||
let db_b : DB := db_a.insert k hk_a
|
||
have hins : (res.keys.reverse ++ G).orderedInsert (· ≤ ·) k =
|
||
res.keys.reverse ++ G.orderedInsert (· ≤ ·) k := by
|
||
refine orderedInsert_append_of_forall_lt_left ?_
|
||
intro x hx
|
||
exact WithTop.coe_lt_coe.mp
|
||
(lt_of_lt_of_le (hreported_lt_E x (List.mem_reverse.mp hx)) hkE)
|
||
have hb_keys : db_b.keys = res.keys.reverse ++ G.orderedInsert (· ≤ ·) k := by
|
||
rw [show db_b.keys = db_a.keys.orderedInsert (· ≤ ·) k from rfl, hdb_a, hins]
|
||
have hb_len : db_b.keys.length = s + 2 := by
|
||
rw [hb_keys, List.length_append, List.length_reverse, List.orderedInsert_length,
|
||
hGlen', htdef, hsdef]
|
||
omega
|
||
have hb_all : ∀ x ∈ db_b.keys,
|
||
decide (((x : Key) : WithTop Key) < r.begin.key) = true := by
|
||
intro x hx
|
||
rw [decide_eq_true_eq]
|
||
rw [hb_keys] at hx
|
||
rcases List.mem_append.mp hx with hx' | hx'
|
||
· exact lt_trans (hreported_lt_E x (List.mem_reverse.mp hx')) hcrossE
|
||
· rw [List.mem_orderedInsert] at hx'
|
||
rcases hx' with rfl | hxG
|
||
· exact hkB
|
||
· exact (hGmem x hxG).2
|
||
have hb_cntB : db_b.keys.countP (fun x : Key =>
|
||
decide (((x : Key) : WithTop Key) < r.begin.key)) = s + 2 := by
|
||
rw [← hb_len, List.countP_eq_length]
|
||
exact hb_all
|
||
have hanchor_b : r.begin.anchor db_b = 1 := by
|
||
rw [anchor_eq_count_sub_slack db_b r (le_of_lt hbeg), hb_cntB]; push_cast; ring
|
||
have hget0_b : db_b.keys[(0 : ℕ)] = L := by
|
||
have hmin_b : ∀ x ∈ db_b.keys, L ≤ x := by
|
||
intro x hx
|
||
rw [hb_keys] at hx
|
||
rcases List.mem_append.mp hx with hxr | hxG
|
||
· exact hLle x (List.mem_reverse.mp hxr)
|
||
· rw [List.mem_orderedInsert] at hxG
|
||
rcases hxG with rfl | hxG
|
||
· exact le_of_lt (WithTop.coe_lt_coe.mp (lt_of_lt_of_le hLltE hkE))
|
||
· exact le_of_lt (WithTop.coe_lt_coe.mp (lt_of_lt_of_le hLltE (hGmem x hxG).1))
|
||
have hLmem_b : L ∈ db_b.keys := by
|
||
rw [hb_keys]; exact List.mem_append_left _ (List.mem_reverse.mpr hLmem)
|
||
have h0lt_b : 0 < db_b.keys.length := by rw [hb_len]; omega
|
||
exact getElem_zero_eq_of_forall_le db_b.sorted hmin_b hLmem_b h0lt_b
|
||
have h1lt : (1 : ℕ) < db_b.keys.length := by
|
||
rw [hb_len]; omega
|
||
have hresBegin_b : resolve db_b r.begin = ((db_b.keys[(1 : ℕ)] : Key) : WithTop Key) := by
|
||
have h0 : 0 ≤ r.begin.anchor db_b := by rw [hanchor_b]; norm_num
|
||
have hlt : (r.begin.anchor db_b).toNat < db_b.keys.length := by
|
||
rw [hanchor_b]; simpa using h1lt
|
||
rw [resolve_eq_getElem h0 hlt]
|
||
have hidx : (r.begin.anchor db_b).toNat = 1 := by rw [hanchor_b]; rfl
|
||
simp [hidx]
|
||
have hLlt : L < db_b.keys[(1 : ℕ)] := by
|
||
have h01 : (0 : ℕ) < db_b.keys.length := by omega
|
||
have h := (List.SortedLT.getElem_lt_getElem_iff db_b.sorted (hi := h01)
|
||
(hj := h1lt)).mpr (show (0 : ℕ) < 1 by omega)
|
||
rwa [hget0_b] at h
|
||
have hLnot_ck : L ∉ RangeRead.completeKeys db_b r := by
|
||
intro hmem
|
||
have hle := (RangeRead.mem_completeKeys.mp hmem).2.1
|
||
rw [hresBegin_b] at hle
|
||
exact absurd hle (not_le.mpr (WithTop.coe_lt_coe.mpr hLlt))
|
||
have hnotCompat_b : ¬ RangeRead.Compatible db_b r res := by
|
||
intro hc
|
||
rcases hc.2 with ⟨_, hpre, _⟩ | ⟨hm, _⟩
|
||
· exact hLnot_ck (hpre.subset hLmem)
|
||
· rw [hmore] at hm; exact absurd hm (by simp)
|
||
refine necessary_of_toggle ⟨db_a, hcompat_a, ?_⟩
|
||
rw [toggle_eq_insert_of_not_mem hk_a]
|
||
exact hnotCompat_b
|
||
|
||
/-- **Minimality of `[last observed, begin.key)` in the large-gap reversed crossed
|
||
truncated cell.** Soundness is the count identity; necessity splits the range at
|
||
`end_.key`: below it the reported keys and the above-head rule cover every key, and at or
|
||
above it the gap witness applies. -/
|
||
theorem minimal_beginKeyRange_of_negCross_crossedLarge {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
|
||
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
||
(hcrossE : r.end_.key < r.begin.key) (hend : r.end_.offset = 1)
|
||
(hlarge : (beginSlack r : ℕ∞) + 2 ≤
|
||
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞)) :
|
||
Minimal r res ⟨((res.keys.getLast hne : Key) : WithTop Key), r.begin.key⟩ := by
|
||
set L : Key := res.keys.getLast hne with hLdef
|
||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
|
||
· exact sound_beginKeyRange_of_negCross_crossedLarge hread hmore hrev hne hcross hcrossE hend
|
||
· intro k hk
|
||
rw [ConflictRange.mem_iff] at hk
|
||
obtain ⟨hkL, hkB⟩ := hk
|
||
by_cases hkE : ((k : Key) : WithTop Key) < r.end_.key
|
||
· by_cases hkhead : k ≤ res.keys.head hne
|
||
· exact necessary_of_between_result hread hLmem (List.head_mem hne)
|
||
(WithTop.coe_le_coe.mp hkL) hkhead
|
||
· intro cr hs
|
||
exact necessary_head_to_end_key hread hrev hne (le_of_eq hend) cr hs
|
||
(le_of_lt (lt_of_not_ge hkhead)) hkE
|
||
· exact necessary_of_mem_gap_of_negCross_trunc_rev_crossedLarge hread hmore hrev hne hbeg
|
||
hcross hcrossE hend hlarge (not_lt.mp hkE) hkB
|
||
|
||
/-- The reversed crossed negative-begin truncated large-gap cell. -/
|
||
abbrev negCrossTruncRevCrossedLarge (r : RangeRead) (res : Result) : Prop :=
|
||
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
||
r.end_.key < r.begin.key ∧ r.end_.offset = 1 ∧
|
||
(beginSlack r : ℕ∞) + 2 ≤
|
||
intervalCard r.end_.key r.begin.key + (res.keys.length : ℕ∞)
|
||
|
||
/-- The closed form of the reversed crossed negative-begin truncated large-gap cell:
|
||
`[last reported, begin.key)`. -/
|
||
noncomputable def closedFormNegCrossTruncRevCrossedLarge (_r : RangeRead) (res : Result) :
|
||
ConflictRange :=
|
||
⟨((res.keys.getLastD ([] : Key) : Key) : WithTop Key), _r.begin.key⟩
|
||
|
||
/-- **The reversed crossed negative-begin truncated large-gap closed form is
|
||
minimal.** -/
|
||
theorem minimal_closedForm_of_negCross_trunc_rev_crossedLarge {r : RangeRead}
|
||
{res : Result} (hread : Readable r res) (h : negCrossTruncRevCrossedLarge r res) :
|
||
Minimal r res (closedFormNegCrossTruncRevCrossedLarge r res) := by
|
||
obtain ⟨hmore, hrev, hbeg, hne, hcrossD, hcrossE, hend, hlarge⟩ := h
|
||
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
|
||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||
have hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key := by
|
||
rw [← hlast]; exact hcrossD
|
||
unfold closedFormNegCrossTruncRevCrossedLarge
|
||
rw [hlast]
|
||
exact minimal_beginKeyRange_of_negCross_crossedLarge hread hmore hrev hne hbeg hcross
|
||
hcrossE hend hlarge
|
||
|
||
end FormalConflictRange
|