Files
conflict-range/FormalConflictRange/NegCrossTruncRevCrossedLarge.lean
T
andrew a54a5f82f8 Prove conflict-range closed-form minimality
- Vendor the FormalConflictRange reference library needed by the proof
- Add Bridge.lean with simp lemmas connecting the Statement definitions
  to the reference library
- Prove Statement.closedFormMinimal in Proof.lean
- Register the new libraries in the Lake config
2026-11-16 21:53:59 -05:00

480 lines
25 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: FormalConflictRange contributors
-/
import FormalConflictRange.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
set_option maxHeartbeats 1200000
/-- **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