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
This commit is contained in:
andrew committed 2026-11-16 21:53:59 -05:00
1 parent 7a0826e873
commit a54a5f82f8
78 files changed
+91636 -2

No files matched your search

@@ -0,0 +1,930 @@
/-
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.NegCrossTruncNonclamp
/-!
# Crossed negative-begin truncated nonclamping nonpositive-end cell
This module closes the forward, crossed, truncated, nonclamping cell at a negative
begin offset with a nonpositive end offset. In this cell the begin selector resolves
onto the reported head, there are no *unreported* stored keys between the reported last
and `begin.key`, and the minimal sound conflict range is
`[head, max begin.key end.key)`. When `end.key < begin.key` no compatible database
exists, so the maximal branch reduces to `[head, end.key)`.
The proof adapts the begin-zero nonpositive-end argument of `ZeroCrossTrunc.lean`. The
begin-zero fact "no stored key lies between the reported head and `begin.key`" is
replaced by the count identity
`count_lt_begin_eq_of_negCross_trunc_nonclamp`, which says the stored keys in that gap
are exactly the reported ones, and by an anchor computation locating the begin
resolution at the reported head.
-/
open FormalConflictRange
namespace FormalConflictRange
/-- In the compatible nonclamping crossed truncated negative-begin cell, the stored
keys in `[head, begin.key)` are exactly the reported keys there. Equivalently, no
unreported stored key lies above the reported last and below `begin.key`. -/
theorem filter_between_head_begin_eq_of_negCross_trunc_nonclamp
{db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1) :
db.keys.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) =
res.keys.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) := by
set head : Key := res.keys.head hne with hhead
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := hcross
-- The count of stored keys below `begin.key` splits at the head.
have hsplit := countP_lt_eq_add_filter_withTop db.keys db.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross')
have hsplit' : db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) =
db.keys.countP (fun k : Key => decide (k < head)) +
db.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hsplit]
rw [← List.countP_eq_length_filter]
-- The count identity from the nonclamping cell.
have hcount := count_lt_begin_eq_of_negCross_trunc_nonclamp hcomp hrev hmore hne hbegin
hcross' hnonclamp
rw [← hhead] at hcount
-- The reported count in the gap.
have hres_count : res.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = reportedBelowBegin r res := by
unfold reportedBelowBegin
rw [List.countP_eq_length_filter, List.countP_eq_length_filter]
congr 1
apply List.filter_congr
intro k hk
have hhead_le : ((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr
((RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt |>.rel_head hk)
rw [decide_eq_decide]
exact and_iff_right hhead_le
-- Equal counts and a sublist give equal filters.
have hlen_eq : (db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length =
(res.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length := by
have h1 : (db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length =
db.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [List.countP_eq_length_filter]
have h2 : (res.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))).length =
res.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [List.countP_eq_length_filter]
rw [h1, h2, hres_count]
omega
have hsub : List.Sublist (res.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)))
(db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key))) :=
List.Sublist.filter _ (result_sublist_db_of_compatible hcomp hrev)
exact (hsub.eq_of_length hlen_eq.symm).symm
/-- In the compatible nonclamping crossed truncated negative-begin cell, no stored key
lies strictly above the reported last and strictly below `begin.key`. -/
theorem not_stored_between_last_begin_of_negCross_trunc_nonclamp
{db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1)
{x : Key} (hx : x ∈ db.keys) (hxlast : res.keys.getLast hne < x)
(hxB : (x : WithTop Key) < r.begin.key) : False := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact (RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt
|>.rel_getLast (List.head_mem hne)
have hxhead : ((head : Key) : WithTop Key) ≤ (x : WithTop Key) :=
WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hhead_le_last hxlast))
have heq := filter_between_head_begin_eq_of_negCross_trunc_nonclamp hcomp hrev hmore
hne hbegin hcross hnonclamp
have hxdb : x ∈ db.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) := by
rw [List.mem_filter]
exact ⟨hx, by rw [decide_eq_true_eq]; exact ⟨hxhead, hxB⟩⟩
rw [heq] at hxdb
have hxres : x ∈ res.keys := (List.mem_filter.mp hxdb).1
have hxle : x ≤ last :=
((RangeRead.compatible_sortedLT hcomp hrev).pairwise.imp le_of_lt).rel_getLast hxres
exact absurd hxle (not_le.mpr hxlast)
/-- In the compatible nonclamping crossed truncated negative-begin cell with a
nonpositive end offset, the end key lies at or above `begin.key`. Otherwise the
complete window `[head, resolve end)` would hold at most `beginSlack` keys, while the
reported prefix has at least `beginSlack + 1`. -/
theorem begin_le_end_of_negCross_trunc_nonclamp_nonpos
{db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false)
(hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1)
(hend : r.end_.offset ≤ 0) :
r.begin.key ≤ r.end_.key := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := hcross
have hpre : res.keys <+: RangeRead.completeKeys db r :=
RangeRead.compatible_keys_prefix hcomp
by_contra hcon
have hEB : r.end_.key < r.begin.key := lt_of_not_ge hcon
-- The reported prefix is nonempty, so the complete window is nonempty.
have hck_ne : RangeRead.completeKeys db r ≠ [] := by
intro hnil
have : res.keys = [] := by
have hpre' := hpre
rw [hnil] at hpre'
exact List.eq_nil_of_prefix_nil hpre'
exact hne this
obtain ⟨k, hkck⟩ := List.exists_mem_of_ne_nil _ hck_ne
obtain ⟨-, hkb, hke⟩ := RangeRead.mem_completeKeys.mp hkck
have hlt_res : resolve db r.begin < resolve db r.end_ := lt_of_le_of_lt hkb hke
-- The begin resolution is the reported head.
have hrb : resolve db r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_negCross_trunc_nonclamp hcomp hrev hmore hne hbegin hcross'
(by omega)
have hcnt_head : cnt db (resolve db r.begin) =
db.keys.countP (fun k : Key => decide (k < head)) := by
rw [hrb]
simp only [cnt, WithTop.coe_lt_coe]
-- The end resolution is a genuine stored key; name it and its rank.
have hne_top : resolve db r.end_ ≠ (⊤ : WithTop Key) :=
resolve_ne_top_of_offset_nonpos hend
obtain ⟨q, hq⟩ := WithTop.ne_top_iff_exists.mp hne_top
have hanchor_nonneg : 0 ≤ r.end_.anchor db := by
by_contra hneg
have hnil : resolve db r.end_ = (([] : Key) : WithTop Key) :=
resolve_eq_nil (lt_of_not_ge hneg)
rw [hnil] at hq
have hqnil : q = [] := WithTop.coe_inj.mp hq
rw [hrb, hnil] at hlt_res
exact absurd hlt_res (not_lt.mpr (WithTop.coe_le_coe.mpr (nil_le_key head)))
have hltlen : (r.end_.anchor db).toNat < db.keys.length := by
by_contra hle
exact hne_top (resolve_eq_top hanchor_nonneg (le_of_not_gt hle))
have hresget : resolve db r.end_ = ((db.keys[(r.end_.anchor db).toNat] : Key) : WithTop Key) :=
resolve_eq_getElem hanchor_nonneg hltlen
have hqval : db.keys[(r.end_.anchor db).toNat] = q := by
apply WithTop.coe_inj.mp
rw [← hresget, hq]
have hcnt_q : cnt db (resolve db r.end_) = (r.end_.anchor db).toNat := by
rw [hresget]
simp only [cnt, WithTop.coe_lt_coe, hqval]
exact countP_lt_eq_of_getElem db.sorted hltlen hqval
-- Bound the complete window length by the begin slack.
have hlen : (RangeRead.completeKeys db r).length =
cnt db (resolve db r.end_) - cnt db (resolve db r.begin) := by
have hb : RangeRead.completeKeys db r =
between db (resolve db r.begin) (resolve db r.end_) := by
unfold RangeRead.completeKeys RangeRead.inRange between
rw [ite_eq_right (by simp [hrev])]
rw [hb]
exact (cnt_sub_eq_between_length (le_of_lt hlt_res)).symm
-- Count below `begin.key` and below `end.key`.
set cB := db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key))
with hcB
set cE := db.keys.countP (fun k : Key => decide (((k : Key) : WithTop Key) < r.end_.key))
with hcE
set cH := db.keys.countP (fun k : Key => decide (k < head)) with hcH
have hcount : cB = cH + reportedBelowBegin r res := by
have h := count_lt_begin_eq_of_negCross_trunc_nonclamp hcomp hrev hmore hne hbegin hcross'
hnonclamp
rw [← hhead] at h
exact h
have hcE_le : cE ≤ cB := by
apply countP_le_countP_of_imp
intro k _
rw [decide_eq_true_eq, decide_eq_true_eq]
exact fun h => lt_trans h hEB
-- The end anchor in terms of the end count.
cases hE : r.end_.key with
| top =>
rw [hE] at hEB
exact absurd hEB (not_lt.mpr (le_top))
| coe e =>
have hcE' : cE = db.keys.countP (fun k : Key => decide (k < e)) := by
rw [hcE, hE, countP_lt_coe]
have hance : r.end_.anchor db = (cE : ℤ) - ((-r.end_.offset).toNat : ℤ) - 1 := by
rw [anchor_of_coe (s := r.end_) hE, ← hcE']
have hoff : ((-r.end_.offset).toNat : ℤ) = -r.end_.offset :=
Int.toNat_of_nonneg (by omega)
rw [hoff]
ring
-- From `cE ≤ cB = cH + (beginSlack + 1)` and the end anchor bound.
have hreport : reportedBelowBegin r res = beginSlack r + 1 := hnonclamp
have hqle : (r.end_.anchor db).toNat ≤ cE - (-r.end_.offset).toNat - 1 := by
rw [hance]
have : 0 ≤ (cE : ℤ) - ((-r.end_.offset).toNat : ℤ) - 1 := by
have := hanchor_nonneg; rw [hance] at this; exact this
omega
have hlenle : (RangeRead.completeKeys db r).length ≤ beginSlack r := by
rw [hlen, hcnt_q, hcnt_head]
have hcE_bound : cE ≤ cH + beginSlack r + 1 := by
have h1 : cE ≤ cH + reportedBelowBegin r res := le_trans hcE_le (le_of_eq hcount)
rw [hreport] at h1
omega
have hnat : cE - (-r.end_.offset).toNat - 1 ≤ cH + beginSlack r := by omega
omega
have ht_ge : beginSlack r + 1 ≤ (RangeRead.completeKeys db r).length := by
have := hpre.length_le
have hrep : beginSlack r + 1 ≤ res.keys.length := by
rw [← hreport]
unfold reportedBelowBegin
exact List.countP_le_length
omega
omega
/-- Given agreement on the gap `[head, begin.key)`, the begin selector of a compatible
nonclamping database resolves onto the reported head in every database that also stores
the head. Both counts below `begin.key` split at the head, and the gap length is exactly
`beginSlack + 1`, so the anchor is the rank of the head. -/
theorem resolve_begin_eq_head_of_agree_negCross_trunc_nonclamp_nonpos
{db₁ db₂ : DB} {r : RangeRead} {res : Result}
(hcomp₁ : RangeRead.Compatible db₁ r res) (hrev : r.reverse = false)
(hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1)
(hagree : db₁.keys.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) =
db₂.keys.filter (fun k : Key => decide
(((res.keys.head hne : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)))
(hhead_mem₂ : res.keys.head hne ∈ db₂.keys) :
resolve db₂ r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
set head : Key := res.keys.head hne with hhead
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := hcross
-- Split the stored keys below `begin.key` at the head in both databases.
have hsplit₁ := countP_lt_eq_add_filter_withTop db₁.keys db₁.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross')
have hsplit₂ := countP_lt_eq_add_filter_withTop db₂.keys db₂.nodup
(a := head) (B := r.begin.key) (le_of_lt hcross')
have hsplit₁' : db₁.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db₁.keys.countP (fun k : Key => decide (k < head)) +
db₁.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hsplit₁, ← List.countP_eq_length_filter]
have hsplit₂' : db₂.keys.countP (fun k : Key => decide
(((k : Key) : WithTop Key) < r.begin.key)) =
db₂.keys.countP (fun k : Key => decide (k < head)) +
db₂.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) := by
rw [hsplit₂, ← List.countP_eq_length_filter]
have hcount₁ := count_lt_begin_eq_of_negCross_trunc_nonclamp hcomp₁ hrev hmore hne hbegin
hcross' hnonclamp
rw [← hhead] at hcount₁
-- The gap length is `beginSlack + 1`.
have hgap₁ : db₁.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := by
omega
-- Agreement preserves the gap count.
have hgap₂ : db₂.keys.countP (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < r.begin.key)) = beginSlack r + 1 := by
rw [List.countP_eq_length_filter, ← hagree, ← List.countP_eq_length_filter]
exact hgap₁
-- The anchor is the rank of the head.
have hanchor₂ : r.begin.anchor db₂ =
(db₂.keys.countP (fun k : Key => decide (k < head)) : ℤ) := by
rw [anchor_eq_count_sub_slack db₂ r (le_of_lt hbegin), hsplit₂', hgap₂]
push_cast
ring
have hlt : db₂.keys.countP (fun k : Key => decide (k < head)) < db₂.keys.length := by
obtain ⟨i, hi, hix⟩ := List.mem_iff_getElem.mp hhead_mem₂
rw [countP_lt_eq_of_getElem db₂.sorted hi hix]
exact hi
have hnat : (r.begin.anchor db₂).toNat =
db₂.keys.countP (fun k : Key => decide (k < head)) := by
rw [hanchor₂, Int.toNat_natCast]
have h0 : 0 ≤ r.begin.anchor db₂ := by
rw [hanchor₂]; exact Int.natCast_nonneg _
have hlt' : (r.begin.anchor db₂).toNat < db₂.keys.length := by
rw [hnat]; exact hlt
have hget : db₂.keys[(r.begin.anchor db₂).toNat] = head := by
rw [getElem_congr_idx (h' := hnat)]
exact getElem_countP_lt db₂.sorted hhead_mem₂
rw [resolve_eq_getElem h0 hlt']
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hget
/-- The closed form for the crossed negative-begin truncated nonclamping cell with a
nonpositive end offset: the reported head up to the larger of `begin.key` and
`end_.key`. -/
noncomputable def closedFormNegCrossTruncNonclampNonpos (r : RangeRead) (res : Result) :
ConflictRange :=
⟨((res.keys.headD ([] : Key) : Key) : WithTop Key),
max r.begin.key r.end_.key⟩
/-- **Compatibility transfers across agreement on the nonpositive-end crossed
truncated negative-begin nonclamping range.** -/
theorem compatible_of_agree_negCross_trunc_nonclamp_nonpos
{r : RangeRead} {res : Result}
(hrev : r.reverse = false) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1)
(hend : r.end_.offset ≤ 0)
{db1 db2 : DB} (hc1 : RangeRead.Compatible db1 r res)
(hagree : AgreeOn (closedFormNegCrossTruncNonclampNonpos r res) db1 db2) :
RangeRead.Compatible db2 r res := by
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hlastD : res.keys.getLastD ([] : Key) = last := by
rw [hlast, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hres1 : resolve db1 r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_negCross_trunc_nonclamp hc1 hrev hmore hne hbegin hcross
(by omega)
have hcr : closedFormNegCrossTruncNonclampNonpos r res =
⟨((head : Key) : WithTop Key), max r.begin.key r.end_.key⟩ := by
unfold closedFormNegCrossTruncNonclampNonpos
rw [hheadD]
set upper : WithTop Key := max r.begin.key r.end_.key with hupper
have hhead_upper : ((head : Key) : WithTop Key) < upper := by
rw [hupper]
exact lt_of_lt_of_le hcross' (le_max_left _ _)
have hlast_mem_res : last ∈ res.keys := by
rw [hlast]; exact List.getLast_mem hne
have hlast_ck1 : last ∈ RangeRead.completeKeys db1 r :=
(RangeRead.compatible_keys_prefix hc1).subset hlast_mem_res
have hlt1 : ((last : Key) : WithTop Key) < resolve db1 r.end_ :=
(RangeRead.mem_completeKeys.mp hlast_ck1).2.2
have hsort := (RangeRead.compatible_sortedLT hc1 hrev).pairwise.imp le_of_lt
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
have hlast_upper : ((last : Key) : WithTop Key) < upper := by
have hle := resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend
exact lt_of_lt_of_le (lt_of_lt_of_le hlt1 hle) (by rw [hupper]; exact le_max_right _ _)
have hmem := (agreeOn_iff (closedFormNegCrossTruncNonclampNonpos r res) db1 db2).mp hagree
have hmk : ∀ k : Key, ((head : Key) : WithTop Key) ≤ (k : WithTop Key) →
(k : WithTop Key) < upper → (k ∈ db1.keys ↔ k ∈ db2.keys) := by
intro k hk1 hk2
refine hmem k ?_
rw [hcr]
exact ⟨hk1, hk2⟩
have hhead_db1 : head ∈ db1.keys :=
RangeRead.compatible_keys_subset hc1 (by rw [hhead]; exact List.head_mem hne)
have hhead_db2 : head ∈ db2.keys := (hmk head le_rfl hhead_upper).mp hhead_db1
-- Agreement on the gap `[head, begin.key)` forces the second begin resolution.
have hB_upper : r.begin.key ≤ upper := by rw [hupper]; exact le_max_left _ _
have hgap : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧
(k : WithTop Key) < r.begin.key)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hB_upper)).mp hk1, hge, hlt⟩
· rintro ⟨hk2, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hB_upper)).mpr hk2, hge, hlt⟩
have hres2 : resolve db2 r.begin = ((head : Key) : WithTop Key) :=
resolve_begin_eq_head_of_agree_negCross_trunc_nonclamp_nonpos hc1 hrev hmore hne hbegin
hcross hnonclamp hgap hhead_db2
-- The end resolution transfers through the agreement filter below `end_.key`.
have hne_top : resolve db1 r.end_ ≠ (⊤ : WithTop Key) :=
resolve_ne_top_of_offset_nonpos hend
obtain ⟨q, hq⟩ := WithTop.ne_top_iff_exists.mp hne_top
have hlast_q : last < q := by
have h := hlt1
rw [← hq] at h
exact WithTop.coe_lt_coe.mp h
have hqne : q ≠ ([] : Key) := by
intro hnil
have h : last < ([] : Key) := by rwa [hnil] at hlast_q
exact absurd h (List.not_lt_nil last)
have hq_le_E : ((q : Key) : WithTop Key) ≤ r.end_.key := by
rw [hq]
exact resolve_le_key_of_offset_nonpos (db := db1) (s := r.end_) hend
have hhead_q : ((head : Key) : WithTop Key) ≤ ((q : Key) : WithTop Key) :=
WithTop.coe_le_coe.mpr (le_of_lt (lt_of_le_of_lt hhead_le_last hlast_q))
have hEnd_upper : r.end_.key ≤ upper := by
rw [hupper]; exact le_max_right _ _
have hagreeEnd : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : WithTop Key) < r.end_.key)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mp hk1, hge, hlt⟩
· rintro ⟨hk2, hge, hlt⟩
exact ⟨(hmk k hge (lt_of_lt_of_le hlt hEnd_upper)).mpr hk2, hge, hlt⟩
have hqget := resolve_filter_reverse_eq_some_of_ne_nil (db := db1) (s := r.end_) hend hqne hq.symm
have hresEnd2 : resolve db2 r.end_ = ((q : Key) : WithTop Key) :=
resolve_eq_of_agree_between (db₁ := db1) (db₂ := db2) (s := r.end_) hend
(E := r.end_.key) rfl (le_trans hhead_q hq_le_E) hagreeEnd hqget hhead_q
have hlt2 : ((last : Key) : WithTop Key) < resolve db2 r.end_ := by
rw [hresEnd2]
exact WithTop.coe_lt_coe.mpr hlast_q
have hres1len : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
have h := ((compatible_iff_truncated_keys (db := db1) hrev hmore hne).mp hc1).2
rwa [← hlast] at h
have hck1 : (RangeRead.completeKeys db1 r).filter
(fun k : Key => decide (k ≤ last)) =
db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db1) hrev hres1 hlt1
have hck2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) :=
completeKeys_filter_le_of_resolve_begin (db := db2) hrev hres2 hlt2
have heq : db1.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) =
db2.keys.filter (fun k : Key => decide
(((head : Key) : WithTop Key) ≤ (k : WithTop Key) ∧ (k : Key) ≤ last)) := by
apply eq_of_forall_mem_iff_of_pairwise
· exact db1.sorted.pairwise.filter _
· exact db2.sorted.pairwise.filter _
· intro k
simp only [List.mem_filter, decide_eq_true_eq]
constructor
· rintro ⟨hk1, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mp hk1,
hge, hle⟩
· rintro ⟨hk2, hge, hle⟩
exact ⟨(hmk k hge (lt_of_le_of_lt (WithTop.coe_le_coe.mpr hle) hlast_upper)).mpr hk2,
hge, hle⟩
have h2 : (RangeRead.completeKeys db2 r).filter
(fun k : Key => decide (k ≤ last)) = res.keys := by
rw [hck2, ← heq, ← hck1, hres1len]
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨by simpa using hc1.1, h2⟩
/-- When the database is the reported keys followed by fillers at or above
`begin.key`, the negative begin anchor lands on the reported head. -/
theorem resolve_begin_eq_head_of_append_ge_begin {db : DB} {r : RangeRead} {res : Result}
{F : List Key} (hdb : db.keys = res.keys ++ F)
(hF : ∀ x ∈ F, r.begin.key ≤ (x : WithTop Key))
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1) :
resolve db r.begin = ((res.keys.head hne : Key) : WithTop Key) := by
have hFzero : F.countP (fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hF x hx)
have hcnt : db.keys.countP (fun x : Key => decide (((x : Key) : WithTop Key) < r.begin.key)) =
reportedBelowBegin r res := by
rw [hdb, List.countP_append, hFzero, Nat.add_zero]
rfl
have hanchor : r.begin.anchor db = 0 := by
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin), hcnt, hnonclamp]
push_cast
ring
have htoNat : (r.begin.anchor db).toNat = 0 := by rw [hanchor]; rfl
have hpos : 0 < db.keys.length := by
rw [hdb, List.length_append]
exact Nat.lt_of_lt_of_le (List.length_pos_of_ne_nil hne) (Nat.le_add_right _ _)
have hlt : (r.begin.anchor db).toNat < db.keys.length := by rw [htoNat]; exact hpos
have hopt0 : db.keys[0]? = some (res.keys.head hne) := by
rw [hdb, List.getElem?_append]
rw [if_pos (List.length_pos_of_ne_nil hne)]
rw [← List.head?_eq_getElem?]
exact List.head?_eq_some_head hne
have hopt : db.keys[(r.begin.anchor db).toNat]? = some (res.keys.head hne) := by
rw [htoNat]
exact hopt0
have hval : db.keys[(r.begin.anchor db).toNat] = res.keys.head hne :=
Option.some.inj ((List.getElem?_eq_getElem hlt).symm.trans hopt)
rw [resolve_eq_getElem (db := db) (s := r.begin) (by rw [hanchor]) hlt]
exact congrArg (fun x : Key => ((x : Key) : WithTop Key)) hval
/-- **Above-begin keys are necessary in the nonpositive-end crossed truncated
nonclamping cell.** A witness stores the reported keys together with
`(1 - end.offset)` fillers above the reported last; erasing any filler lowers the end
anchor by one, so the end resolution drops from above the last reported key to the last
reported key itself. -/
theorem exists_witness_negCross_trunc_nonclamp_nonposEnd {r : RangeRead} {res : Result}
{k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1)
(hend : r.end_.offset ≤ 0)
(hkgt : res.keys.getLast hne < k) (hkE : (k : WithTop Key) < r.end_.key)
(hkge : r.begin.key ≤ (k : WithTop Key)) :
∃ dbw : DB, RangeRead.Compatible dbw r res ∧ k ∈ dbw.keys ∧
¬ RangeRead.Compatible (dbw.erase k) r res := by
obtain ⟨db, hcomp⟩ := hread
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hsort : res.keys.SortedLT := RangeRead.compatible_sortedLT hcomp hrev
have hle_last : ∀ x ∈ res.keys, x ≤ last := fun x hx =>
(hsort.pairwise.imp le_of_lt).rel_getLast hx
have hhead_le_last : head ≤ last := by
simp only [hhead, hlast]
exact (hsort.pairwise.imp le_of_lt).rel_getLast (List.head_mem hne)
have hcross' : ((head : Key) : WithTop Key) < r.begin.key := by
rw [hhead]; exact hcross
have hlast_ck : last ∈ RangeRead.completeKeys db r :=
(RangeRead.compatible_keys_prefix hcomp).subset (List.getLast_mem hne)
obtain ⟨hlast_mem, -, hlast_res⟩ := RangeRead.mem_completeKeys.mp hlast_ck
have hlastE : ((last : Key) : WithTop Key) < r.end_.key :=
lt_end_key_of_lt_resolve_end_nonpos hend hlast_mem hlast_res
have hfill := filler_count_nonpos_more_nonpos_end hcomp hrev hmore hne
(le_of_lt hbegin) hend
set m := (1 - r.end_.offset).toNat with hm
have hm1 : 1 ≤ m := by rw [hm]; omega
set G : List Key := db.keys.filter
(fun x : Key => decide (last < x ∧ (x : WithTop Key) < r.end_.key)) with hG
have hGlen : m ≤ G.length := hfill
have hGnodup : G.Nodup := by
rw [hG]; exact db.sorted.pairwise.nodup.filter _
have hGmem : ∀ x ∈ G, last < x ∧ (x : WithTop Key) < r.end_.key := by
intro x hx
rw [hG] at hx
exact of_decide_eq_true (List.mem_filter.mp hx).2
have hGdb : ∀ x ∈ G, x ∈ db.keys := by
intro x hx
rw [hG] at hx
exact (List.mem_filter.mp hx).1
-- Nonclamping places every stored key above the reported last at or above `begin.key`.
have hGge : ∀ x ∈ G, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
by_contra hcon
exact not_stored_between_last_begin_of_negCross_trunc_nonclamp hcomp hrev hmore hne hbegin
hcross hnonclamp (hGdb x hx) (hGmem x hx).1 (lt_of_not_ge hcon)
set raw : List Key := (k :: G.erase k).take m with hraw
have hrawNodup : raw.Nodup := by
rw [hraw]
refine (List.take_sublist m (k :: G.erase k)).nodup ?_
exact List.nodup_cons.mpr ⟨hGnodup.not_mem_erase, hGnodup.erase k⟩
have hrawLen : raw.length = m := by
rw [hraw, List.length_take]
apply Nat.min_eq_left
by_cases hkG : k ∈ G
· rw [List.length_cons, List.length_erase_of_mem hkG]; omega
· rw [List.length_cons, List.erase_of_not_mem hkG]; omega
have hrawSub : ∀ x ∈ raw, x = k ∨ x ∈ G := by
intro x hx
rw [hraw] at hx
rcases List.mem_cons.mp (List.mem_of_mem_take hx) with rfl | hx'
· exact Or.inl rfl
· exact Or.inr (List.mem_of_mem_erase hx')
have hrawk : k ∈ raw := by
rw [hraw, List.mem_take_iff_getElem]
refine ⟨0, ?_, rfl⟩
rw [List.length_cons]
omega
have hrawGt : ∀ x ∈ raw, last < x := by
intro x hx
rcases hrawSub x hx with rfl | hx'
· exact hkgt
· exact (hGmem x hx').1
have hrawLt : ∀ x ∈ raw, (x : WithTop Key) < r.end_.key := by
intro x hx
rcases hrawSub x hx with rfl | hx'
· exact hkE
· exact (hGmem x hx').2
have hrawGe : ∀ x ∈ raw, r.begin.key ≤ (x : WithTop Key) := by
intro x hx
rcases hrawSub x hx with rfl | hx'
· exact hkge
· exact hGge x hx'
set F : List Key := raw.insertionSort (· ≤ ·) with hF
have hFperm : raw.Perm F := (List.perm_insertionSort (· ≤ ·) raw).symm
have hFsorted : F.SortedLT := by
rw [hF, List.sortedLT_iff_pairwise]
exact DB.pairwise_lt_of_le_of_nodup
(List.pairwise_insertionSort (r := (· ≤ ·)) raw)
(hFperm.nodup_iff.mp hrawNodup)
have hFlen : F.length = m := by rw [hF, List.length_insertionSort, hrawLen]
have hFk : k ∈ F := hFperm.mem_iff.mp hrawk
have hFmem : ∀ x ∈ F, last < x ∧ (x : WithTop Key) < r.end_.key := by
intro x hx
exact ⟨hrawGt x (hFperm.mem_iff.mpr hx), hrawLt x (hFperm.mem_iff.mpr hx)⟩
have hFge : ∀ x ∈ F, r.begin.key ≤ (x : WithTop Key) := fun x hx =>
hrawGe x (hFperm.mem_iff.mpr hx)
have hFne : F ≠ [] := by
intro h; rw [h] at hFlen; simp at hFlen; omega
set D : List Key := res.keys ++ F with hD
have hDsort : D.SortedLT := by
rw [hD]
refine List.sortedLT_append.mpr ⟨hsort, hFsorted, ?_⟩
intro a ha b hb
exact lt_of_le_of_lt (hle_last a ha) (hFmem b hb).1
let dbw : DB := ⟨D, hDsort⟩
have hdbw_keys : dbw.keys = D := rfl
-- The begin selector still resolves to the reported head.
have hrb : resolve dbw r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_append_ge_begin hdbw_keys hFge hne hbegin hnonclamp
-- every stored key is below the end key
have hDlt : ∀ x ∈ D, (x : WithTop Key) < r.end_.key := by
intro x hx
rw [hD] at hx
rcases List.mem_append.mp hx with hx | hx
· exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hle_last x hx)) hlastE
· exact (hFmem x hx).2
have hlenD : D.length = res.keys.length + m := by
rw [hD, List.length_append, hFlen]
have hm_int : (m : Int) = 1 - r.end_.offset := by
rw [hm]; exact Int.toNat_of_nonneg (by omega)
have hcount_end : D.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) =
D.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hDlt x hx
have hanchor_end : r.end_.anchor dbw = (res.keys.length : Int) := by
cases hE : r.end_.key with
| top =>
rw [anchor_of_top (s := r.end_) hE, hlenD]
push_cast
rw [hm_int]
ring
| coe e =>
have hce : D.countP (fun x : Key => decide (x < e)) = D.length := by
rw [← countP_lt_coe (l := D) e, ← hE]
exact hcount_end
rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlenD]
push_cast
rw [hm_int]
ring
have ht_lt : res.keys.length < D.length := by rw [hlenD]; omega
have hDget? : dbw.keys[res.keys.length]? = some (F.head hFne) := by
change D[res.keys.length]? = some (F.head hFne)
rw [hD, List.getElem?_append]
rw [if_neg (not_lt.mpr (le_refl _)), Nat.sub_self]
rw [List.getElem?_eq_getElem (by rw [hFlen]; omega), List.head_eq_getElem hFne]
have hre : resolve dbw r.end_ = ((F.head hFne : Key) : WithTop Key) := by
rw [resolve, ite_eq_right (by rw [hanchor_end]; omega)]
rw [hanchor_end, Int.toNat_natCast, hDget?]
have hltF : ((last : Key) : WithTop Key) < resolve dbw r.end_ := by
rw [hre]
exact WithTop.coe_lt_coe.mpr (hFmem (F.head hFne) (List.head_mem hFne)).1
-- complete keys of the witness are the reported keys
have hckw : (RangeRead.completeKeys dbw r).filter
(fun x : Key => decide (x ≤ last)) = res.keys := by
rw [completeKeys_filter_le_of_resolve_begin (db := dbw) hrev hrb hltF]
rw [hdbw_keys, hD, List.filter_append]
have hres_fil : res.keys.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ (x : Key) ≤ last)) = res.keys := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact ⟨WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx), hle_last x hx⟩
have hF_fil : F.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ (x : Key) ≤ last)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
exact fun _ => not_le.mpr (hFmem x hx).1
rw [hres_fil, hF_fil, List.append_nil]
have hcompw : RangeRead.Compatible dbw r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
exact ⟨hcomp.1, hckw⟩
have hkdbw : k ∈ dbw.keys := by
rw [hdbw_keys, hD]
exact List.mem_append.mpr (Or.inr hFk)
-- now the erased database
have hk_not_mem_res : k ∉ res.keys := by
intro hk
exact absurd (hle_last k hk) (not_le.mpr hkgt)
have hD' : (dbw.erase k).keys = res.keys ++ F.erase k := by
rw [DB.erase_keys, hdbw_keys, hD]
exact List.erase_append_right F hk_not_mem_res
have hF'ge : ∀ x ∈ F.erase k, r.begin.key ≤ (x : WithTop Key) :=
fun x hx => hFge x (List.mem_of_mem_erase hx)
have hrb' : resolve (dbw.erase k) r.begin = ((head : Key) : WithTop Key) := by
rw [hhead]
exact resolve_begin_eq_head_of_append_ge_begin hD' hF'ge hne hbegin hnonclamp
have hD'lt : ∀ x ∈ (dbw.erase k).keys, (x : WithTop Key) < r.end_.key := by
intro x hx
exact hDlt x (by
rw [DB.erase_keys, hdbw_keys] at hx
exact List.mem_of_mem_erase hx)
have hlenD' : (dbw.erase k).keys.length = res.keys.length + m - 1 := by
rw [hD', List.length_append, List.length_erase_of_mem hFk, hFlen]
omega
have hcount_end' : (dbw.erase k).keys.countP
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = (dbw.erase k).keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq]
exact hD'lt x hx
have hanchor_end' : r.end_.anchor (dbw.erase k) = (res.keys.length : Int) - 1 := by
cases hE : r.end_.key with
| top =>
rw [anchor_of_top (s := r.end_) hE, hlenD']
rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)]
push_cast
rw [hm_int]
ring
| coe e =>
have hce : (dbw.erase k).keys.countP (fun x : Key => decide (x < e)) =
(dbw.erase k).keys.length := by
rw [← countP_lt_coe (l := (dbw.erase k).keys) e, ← hE]
exact hcount_end'
rw [anchor_of_coe (s := r.end_) (v := e) hE, hce, hlenD']
rw [Nat.cast_sub (by omega : 1 ≤ res.keys.length + m)]
push_cast
rw [hm_int]
ring
have ht1 : 1 ≤ res.keys.length := List.length_pos_of_ne_nil hne
have hEqInt : (res.keys.length : Int) - 1 = ((res.keys.length - 1 : ℕ) : Int) := by
rw [Nat.cast_sub ht1]; norm_num
have htoNat' : (r.end_.anchor (dbw.erase k)).toNat = res.keys.length - 1 := by
rw [hanchor_end', hEqInt, Int.toNat_natCast]
have hD'get? : (dbw.erase k).keys[res.keys.length - 1]? = some last := by
rw [hD', List.getElem?_append]
rw [if_pos (by omega : res.keys.length - 1 < res.keys.length)]
rw [List.getElem?_eq_getElem (by omega : res.keys.length - 1 < res.keys.length)]
congr 1
rw [hlast, List.getLast_eq_getElem hne]
have hre' : resolve (dbw.erase k) r.end_ = ((last : Key) : WithTop Key) := by
rw [resolve, ite_eq_right (by rw [hanchor_end']; omega)]
rw [hanchor_end', hEqInt, Int.toNat_natCast, hD'get?]
have hckE : RangeRead.completeKeys (dbw.erase k) r = res.keys.dropLast := by
unfold RangeRead.completeKeys RangeRead.inRange
rw [ite_eq_right (by simp [hrev]), hrb', hre']
have hpred : ∀ x ∈ (dbw.erase k).keys,
decide (((↑head : WithTop Key)) ≤ (x : WithTop Key) ∧
(x : WithTop Key) < ((↑last : Key) : WithTop Key)) =
decide (((↑head : WithTop Key)) ≤ (x : WithTop Key) ∧ x < last) := by
intro x _
rw [decide_eq_decide]
exact and_congr_right fun _ => WithTop.coe_lt_coe
rw [List.filter_congr hpred, hD', List.filter_append]
have hhead_le_all : ∀ x ∈ res.keys, ((head : Key) : WithTop Key) ≤ (x : WithTop Key) := by
intro x hx
exact WithTop.coe_le_coe.mpr ((hsort.pairwise.imp le_of_lt).rel_head hx)
rw [show res.keys.filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ x < last)) =
res.keys.filter (fun x : Key => decide (x < last)) from by
apply List.filter_congr
intro x hx
rw [decide_eq_decide]
exact ⟨fun h => h.2, fun h => ⟨hhead_le_all x hx, h⟩⟩]
conv_lhs => rw [← List.dropLast_append_getLast hne, hlast]
rw [List.filter_append]
have hfil : res.keys.dropLast.filter (fun x : Key => decide (x < last)) = res.keys.dropLast := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
have h := hsort.pairwise.rel_dropLast_getLast hx
simpa [hlast] using h
rw [hfil]
have hFnil : (F.erase k).filter (fun x : Key => decide
(((head : Key) : WithTop Key) ≤ (x : WithTop Key) ∧ x < last)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
simp only [Bool.not_eq_true, decide_eq_false_iff_not, not_and]
intro _
exact not_lt.mpr (le_of_lt (hFmem x (List.mem_of_mem_erase hx)).1)
rw [hFnil, List.append_nil]
simp
have hnot : ¬ RangeRead.Compatible (dbw.erase k) r res := by
rw [compatible_iff_truncated_keys hrev hmore hne]
intro h
have heq := h.2
rw [hckE] at heq
have hfil : res.keys.dropLast.filter
(fun x : Key => decide (x ≤ res.keys.getLast hne)) = res.keys.dropLast := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
rw [← hlast]
exact hle_last x (List.mem_of_mem_dropLast hx)
rw [hfil] at heq
have hlen := congrArg List.length heq
rw [List.length_dropLast] at hlen
omega
exact ⟨dbw, hcompw, hkdbw, hnot⟩
/-- A key at or above `begin.key` and below `end.key` is necessary in the crossed
negative-begin truncated nonclamping cell with a nonpositive end offset. -/
theorem necessary_negCross_trunc_above_begin_nonposEnd {r : RangeRead} {res : Result} {k : Key}
(hread : Readable r res) (hrev : r.reverse = false) (hmore : res.more = true)
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0)
(hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key)
(hnonclamp : reportedBelowBegin r res = beginSlack r + 1)
(hend : r.end_.offset ≤ 0)
(hkgt : res.keys.getLast hne < k)
(hkE : (k : WithTop Key) < r.end_.key)
(hkge : r.begin.key ≤ (k : WithTop Key)) :
Necessary r res k := by
obtain ⟨dbw, hcompw, hkdbw, hnot⟩ :=
exists_witness_negCross_trunc_nonclamp_nonposEnd hread hrev hmore hne hbegin hcross
hnonclamp hend hkgt hkE hkge
exact necessary_of_toggle ⟨dbw, hcompw, by
rw [toggle_eq_erase_of_mem hkdbw]
exact hnot⟩
/-- The crossed negative-begin truncated nonclamping cell with a nonpositive end
offset. -/
def negCrossTruncNonclampNonposEnd (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = false ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
((leastReported r res : Key) : WithTop Key) < r.begin.key ∧
r.end_.offset ≤ 0 ∧ reportedBelowBegin r res = beginSlack r + 1
/-- **The crossed negative-begin truncated nonclamping nonpositive-end closed form is
minimal.** -/
theorem minimal_closedForm_of_negCross_trunc_nonclamp_nonposEnd {r : RangeRead} {res : Result}
(hread : Readable r res) (h : negCrossTruncNonclampNonposEnd r res) :
Minimal r res (closedFormNegCrossTruncNonclampNonpos r res) := by
obtain ⟨hmore, hrev, hbegin, hne, hcrossD, hend, hnonclamp⟩ := h
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
set head : Key := res.keys.head hne with hhead
set last : Key := res.keys.getLast hne with hlast
have hheadD : res.keys.headD ([] : Key) = head := by
rw [hhead, List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcross : ((head : Key) : WithTop Key) < r.begin.key := by
have hleast : leastReported r res = res.keys.headD ([] : Key) := by
simp [leastReported, hrev]
rw [hleast, hheadD] at hcrossD
exact hcrossD
have hcr : closedFormNegCrossTruncNonclampNonpos r res =
⟨((head : Key) : WithTop Key), max r.begin.key r.end_.key⟩ := by
unfold closedFormNegCrossTruncNonclampNonpos
rw [hheadD]
refine minimal_iff_sound_and_necessaryRange.mpr ⟨?_, ?_⟩
· intro db1 db2 hagree
constructor
· intro hc1
exact compatible_of_agree_negCross_trunc_nonclamp_nonpos hrev hmore hne hbegin hcross
hnonclamp hend hc1 hagree
· intro hc2
exact compatible_of_agree_negCross_trunc_nonclamp_nonpos hrev hmore hne hbegin hcross
hnonclamp hend hc2 (AgreeOn.symm hagree)
· intro k hklo hkhi
rw [hcr] at hklo hkhi
have hhead_nec : Necessary r res head :=
necessary_of_mem_result hread' (by rw [hhead]; exact List.head_mem hne)
have hlast_nec : Necessary r res last :=
necessary_of_mem_result hread' (by rw [hlast]; exact List.getLast_mem hne)
have hhead_le_last : head ≤ last := by
have hsort := (RangeRead.compatible_sortedLT hcomp₀ hrev).pairwise.imp le_of_lt
simp only [hhead, hlast]
exact hsort.rel_getLast (List.head_mem hne)
by_cases hkle : k ≤ last
· exact Necessary.of_between hhead_nec hlast_nec (WithTop.coe_le_coe.mp hklo) hkle
· have hkgt : last < k := lt_of_not_ge hkle
by_cases hkB : (k : WithTop Key) < r.begin.key
· exact necessary_negCross_trunc_gap_general hread' hrev hmore hne hbegin hcross
hnonclamp (by rw [← hlast]; exact hkgt) hkB
· have hkge : r.begin.key ≤ (k : WithTop Key) := le_of_not_gt hkB
by_cases hleE : r.begin.key ≤ r.end_.key
· have hmax : max r.begin.key r.end_.key = r.end_.key := max_eq_right hleE
have hkE : (k : WithTop Key) < r.end_.key := by rw [← hmax]; exact hkhi
exact necessary_negCross_trunc_above_begin_nonposEnd hread' hrev hmore hne hbegin
hcross hnonclamp hend (by rw [← hlast]; exact hkgt) hkE hkge
· exfalso
have hltE : r.end_.key < r.begin.key := lt_of_not_ge hleE
have hmax : max r.begin.key r.end_.key = r.begin.key := max_eq_left (le_of_lt hltE)
rw [hmax] at hkhi
exact absurd hkhi (not_lt.mpr hkge)
end FormalConflictRange