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:
1 parent
7a0826e873
commit
a54a5f82f8
78 files changed
+91636
-2
No files matched your search
@@ -0,0 +1,709 @@
|
||||
/-
|
||||
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.NegCrossTruncRevResidualFinite
|
||||
|
||||
/-!
|
||||
# The finite *over* cell of the reversed crossed negative-begin truncated residual
|
||||
|
||||
This module starts closing the last reversed crossed negative-begin truncated cell of
|
||||
the total closed form: the finite branch of the residual on which the reported last lies
|
||||
strictly above `end_.key`.
|
||||
|
||||
The setting is
|
||||
|
||||
* `res.more = true`, `r.reverse = true`, `r.begin.offset < 0`, `res.keys ≠ []`;
|
||||
* `2 ≤ r.end_.offset`;
|
||||
* `r.end_.key < last` (the reported last `L` is above the end key);
|
||||
* `last < begin.key` (the begin selector lies above the reported last);
|
||||
* the finite count `|res.keys| = end_.offset - 1`.
|
||||
|
||||
Since all reported keys lie above `end_.key`, the finite count says exactly that the
|
||||
stored keys in `[end_.key, resolve end_)` are the reported ones. The first structural
|
||||
fact is that no compatible database stores a key in `[end_.key, last)`.
|
||||
|
||||
The main reduction is that compatibility with `r` is the same as compatibility with the
|
||||
read whose end key is `last` (same offset), *provided* the database stores nothing in
|
||||
`[end_.key, last)`. The reduced read lies in the already-closed finite under cell, so
|
||||
minimality transfers. When `begin.key ≤ head`, the capacity condition `finiteUnderCond`
|
||||
holds automatically, so the upper endpoint is `keyAfter head`; when the head lies below
|
||||
`begin.key`, the remaining gap keys are supplied by a toggle witness.
|
||||
-/
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
set_option maxHeartbeats 1600000
|
||||
|
||||
/-- A subset of a duplicate-free list is no longer than it. -/
|
||||
theorem length_le_of_nodup_subset {l₁ l₂ : List Key} (h : l₁.Nodup) (hsub : l₁ ⊆ l₂) :
|
||||
l₁.length ≤ l₂.length := by
|
||||
obtain ⟨l, hperm, hsub'⟩ := List.subperm_iff.mp (h.subperm hsub)
|
||||
calc l₁.length ≤ l.length := hsub'.length_le
|
||||
_ = l₂.length := hperm.length_eq
|
||||
|
||||
/-- **No stored key lies in `[end_.key, last)` in the finite over cell.** The end
|
||||
resolution window `[end_.key, resolve end_)` is exactly as long as the reported list and
|
||||
already contains every reported key, so it cannot also contain a key strictly below the
|
||||
reported last. -/
|
||||
theorem between_end_key_last_eq_nil {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hEL : r.end_.key < ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||||
(ht : res.keys.length = (r.end_.offset - 1).toNat) :
|
||||
between db r.end_.key ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) = [] := by
|
||||
classical
|
||||
have hLlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne :=
|
||||
getLastD_eq_getLast_of_ne hne
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
have hLmem : L ∈ res.keys := List.getLast_mem hne
|
||||
have hEL' : r.end_.key < ((L : Key) : WithTop Key) := by rw [← hLlast]; exact hEL
|
||||
have hELE : r.end_.key ≤ ((L : Key) : WithTop Key) := le_of_lt hEL'
|
||||
set e : ℕ := (r.end_.offset - 1).toNat with hedef
|
||||
have ht' : res.keys.length = e := by rw [ht, hedef]
|
||||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
|
||||
have hLle : ∀ x ∈ res.keys, L ≤ x :=
|
||||
fun x hx => (hsort.pairwise.imp (fun h => le_of_lt h)).rel_getLast hx
|
||||
have hLR : ((L : Key) : WithTop Key) < resolve db r.end_ := by
|
||||
have hck : L ∈ RangeRead.completeKeys db r :=
|
||||
(RangeRead.compatible_keys_prefix hcomp).subset hLmem
|
||||
exact (RangeRead.mem_completeKeys.mp hck).2.2
|
||||
have hLRle : ((L : Key) : WithTop Key) ≤ resolve db r.end_ := le_of_lt hLR
|
||||
have hoff : 1 ≤ r.end_.offset := by omega
|
||||
have hnsub : res.keys.Nodup :=
|
||||
List.Nodup.sublist (RangeRead.compatible_keys_prefix hcomp).sublist (RangeRead.completeKeys_nodup db r)
|
||||
rcases eq_or_ne (resolve db r.end_) (⊤ : WithTop Key) with hRtop | hRne
|
||||
· -- the end resolution is the sentinel
|
||||
have hresend := resolve_eq_filter_getElem? (db := db) (s := r.end_) hoff
|
||||
have hgetnone : (db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))))[e]? = none := by
|
||||
cases hq : (db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))))[e]? with
|
||||
| none => rfl
|
||||
| some k =>
|
||||
rw [hq] at hresend
|
||||
exact absurd hresend (by simp [hRtop])
|
||||
have hQle : (db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).length ≤ e :=
|
||||
List.getElem?_eq_none_iff.mp hgetnone
|
||||
-- every reported key is stored at or above `end_.key`
|
||||
have hsubQ : res.keys ⊆ db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by
|
||||
intro k hk
|
||||
exact List.mem_filter.mpr ⟨RangeRead.compatible_keys_subset hcomp hk,
|
||||
by rw [decide_eq_true_eq]; exact le_trans hELE (WithTop.coe_le_coe.mpr (hLle k hk))⟩
|
||||
have htQ : res.keys.length ≤ (db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).length :=
|
||||
length_le_of_nodup_subset hnsub hsubQ
|
||||
-- so `[end_.key, last)` is empty: any key there would enlarge the above-list
|
||||
rw [List.eq_nil_iff_forall_not_mem]
|
||||
intro x hx
|
||||
rw [between_eq_filter_above] at hx
|
||||
obtain ⟨hxA, hxL⟩ := List.mem_filter.mp hx
|
||||
rw [hLlast] at hxL
|
||||
have hxL' : ((x : Key) : WithTop Key) < ((L : Key) : WithTop Key) :=
|
||||
of_decide_eq_true hxL
|
||||
have hxnotres : x ∉ res.keys := fun hres =>
|
||||
absurd (WithTop.coe_le_coe.mpr (hLle x hres)) (not_le.mpr hxL')
|
||||
have hnsub2 : (x :: res.keys).Nodup := by
|
||||
rw [List.nodup_cons]; exact ⟨hxnotres, hnsub⟩
|
||||
have hsub2 : (x :: res.keys) ⊆ db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) := by
|
||||
intro y hy
|
||||
rcases List.mem_cons.mp hy with rfl | hy
|
||||
· exact hxA
|
||||
· exact hsubQ hy
|
||||
have hlen : (x :: res.keys).length ≤ (db.keys.filter
|
||||
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key)))).length :=
|
||||
length_le_of_nodup_subset hnsub2 hsub2
|
||||
simp only [List.length_cons, ht'] at hlen
|
||||
omega
|
||||
· -- a genuine end resolution
|
||||
have hlenER : (between db r.end_.key (resolve db r.end_)).length = e :=
|
||||
length_between_end_resolve_eq_of_ne_top hend hRne
|
||||
have hLRrev : res.keys = (between db ((L : Key) : WithTop Key)
|
||||
(resolve db r.end_)).reverse :=
|
||||
res_keys_eq_reverse_between_resolve_end hcomp hmore hrev hne
|
||||
have hlenLR : (between db ((L : Key) : WithTop Key) (resolve db r.end_)).length =
|
||||
res.keys.length := by
|
||||
have h := congrArg List.length hLRrev
|
||||
rw [List.length_reverse] at h
|
||||
exact h.symm
|
||||
have h1 := cnt_eq_add_between (db := db) hELE
|
||||
have h2 := cnt_eq_add_between (db := db) hLRle
|
||||
have h3 := cnt_eq_add_between (db := db) (le_trans hELE hLRle)
|
||||
rw [ht'] at hlenLR
|
||||
have : (between db r.end_.key ((L : Key) : WithTop Key)).length = 0 := by
|
||||
omega
|
||||
rw [hLlast]
|
||||
exact List.eq_nil_of_length_eq_zero this
|
||||
|
||||
/-- When the interval `[E, L)` stores no key, the lists of keys at or above `E` and at
|
||||
or above `L` coincide. -/
|
||||
theorem above_eq_of_between_eq_nil {db : DB} {E L : WithTop Key} (hE : E ≤ L)
|
||||
(h : between db E L = []) : above db E = above db L := by
|
||||
rw [above_B_eq_filter hE]
|
||||
exact (List.filter_eq_self.mpr fun x hx => by
|
||||
rw [decide_eq_true_eq]
|
||||
by_contra hlt
|
||||
push Not at hlt
|
||||
have hmem : x ∈ between db E L := by
|
||||
rw [between_eq_filter_above]
|
||||
exact List.mem_filter.mpr ⟨hx, by rw [decide_eq_true_eq]; exact hlt⟩
|
||||
rw [h] at hmem
|
||||
exact absurd hmem List.not_mem_nil).symm
|
||||
|
||||
/-- **The finite over cell reduces to the read whose end key is the reported last.**
|
||||
Provided no key is stored in `[end_.key, last)`, replacing the end key by the reported
|
||||
last at the same offset leaves the complete keys — hence compatibility — unchanged. -/
|
||||
theorem compatible_iff_over_reduce {r : RangeRead} {res : Result}
|
||||
(hmore : res.more = true) (hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hEL : r.end_.key < ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||||
(ht : res.keys.length = (r.end_.offset - 1).toNat) :
|
||||
∀ db, RangeRead.Compatible db r res ↔
|
||||
(between db r.end_.key ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) = []) ∧
|
||||
RangeRead.Compatible db
|
||||
{ r with end_ := ⟨((res.keys.getLastD ([] : Key) : Key) : WithTop Key),
|
||||
r.end_.offset⟩ } res := by
|
||||
intro db
|
||||
set Lk : Key := res.keys.getLastD ([] : Key) with hLk
|
||||
have hLlast : Lk = res.keys.getLast hne := getLastD_eq_getLast_of_ne hne
|
||||
have hELE : r.end_.key ≤ ((Lk : Key) : WithTop Key) := le_of_lt hEL
|
||||
have hoff : 1 ≤ r.end_.offset := by omega
|
||||
let r' : RangeRead :=
|
||||
{ r with end_ := ⟨((Lk : Key) : WithTop Key), r.end_.offset⟩ }
|
||||
have hr'end : r'.end_ = ⟨((Lk : Key) : WithTop Key), r.end_.offset⟩ := rfl
|
||||
have hr'beg : r'.begin = r.begin := rfl
|
||||
have hr'rev : r'.reverse = r.reverse := rfl
|
||||
have hr'lim : r'.limit = r.limit := rfl
|
||||
have hresolve : ∀ (_ : between db r.end_.key ((Lk : Key) : WithTop Key) = []),
|
||||
resolve db r.end_ = resolve db r'.end_ := by
|
||||
intro hnil
|
||||
have habove : above db r.end_.key = above db ((Lk : Key) : WithTop Key) :=
|
||||
above_eq_of_between_eq_nil hELE hnil
|
||||
rw [resolve_eq_filter_getElem? (db := db) (s := r.end_) hoff,
|
||||
resolve_eq_filter_getElem? (db := db) (s := r'.end_) hoff, hr'end]
|
||||
simp only [above] at habove
|
||||
rw [habove]
|
||||
have hck : ∀ (_ : between db r.end_.key ((Lk : Key) : WithTop Key) = []),
|
||||
RangeRead.completeKeys db r = RangeRead.completeKeys db r' := by
|
||||
intro hnil
|
||||
have hres := hresolve hnil
|
||||
unfold RangeRead.completeKeys
|
||||
rw [hr'rev, hrev]
|
||||
simp only [Bool.not_true, ite_false, ite_true]
|
||||
rw [hres]
|
||||
constructor
|
||||
· intro hcomp
|
||||
have hnil := between_end_key_last_eq_nil hcomp hmore hrev hne hend hEL ht
|
||||
exact ⟨hnil, (compatible_congr_completeKeys (hck hnil) hr'lim).mp hcomp⟩
|
||||
· rintro ⟨hnil, hcomp'⟩
|
||||
exact (compatible_congr_completeKeys (hck hnil) hr'lim).mpr hcomp'
|
||||
|
||||
/-- A key absent from every compatible database is necessary: a sound range omitting it
|
||||
would see a compatible database and the same database with the key inserted as agreeing,
|
||||
though only the former is compatible. -/
|
||||
theorem necessary_of_forall_not_mem {r : RangeRead} {res : Result} {k : Key}
|
||||
(hread : Readable r res)
|
||||
(habs : ∀ db, RangeRead.Compatible db r res → k ∉ db.keys) :
|
||||
Necessary r res k := by
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
intro cr hs
|
||||
by_contra hkcr
|
||||
have hkdb : k ∉ db₀.keys := habs db₀ hcomp₀
|
||||
have hagree : AgreeOn cr db₀ (db₀.insert k hkdb) :=
|
||||
(ConflictRange.keys_insert_of_not_mem cr db₀ hkdb hkcr).symm
|
||||
have hcomp₁ : RangeRead.Compatible (db₀.insert k hkdb) r res :=
|
||||
(hs db₀ (db₀.insert k hkdb) hagree).mp hcomp₀
|
||||
exact habs (db₀.insert k hkdb) hcomp₁ (DB.mem_insert_self db₀ k hkdb)
|
||||
|
||||
/-- If one database stores no key in `[E, L)` and two databases agree on `[E, U)` with
|
||||
`L ≤ U`, then neither does the other. -/
|
||||
theorem between_eq_nil_of_agreeOn {db₁ db₂ : DB} {E L U : WithTop Key}
|
||||
(hE : E ≤ L) (hLU : L ≤ U) (hnil : between db₁ E L = [])
|
||||
(hagree : AgreeOn ⟨E, U⟩ db₁ db₂) :
|
||||
between db₂ E L = [] := by
|
||||
rw [List.eq_nil_iff_forall_not_mem]
|
||||
intro k hk
|
||||
rw [between_eq_filter_above] at hk
|
||||
obtain ⟨hkA, hkL⟩ := List.mem_filter.mp hk
|
||||
have hkE : E ≤ ((k : Key) : WithTop Key) := (mem_above.mp hkA).2
|
||||
have hkL' : ((k : Key) : WithTop Key) < L := of_decide_eq_true hkL
|
||||
have hkdb₂ : k ∈ db₂.keys := (mem_above.mp hkA).1
|
||||
have hkcr₂ : k ∈ (⟨E, U⟩ : ConflictRange).keys db₂ :=
|
||||
ConflictRange.mem_keys_iff.mpr ⟨hkdb₂, hkE, lt_of_lt_of_le hkL' hLU⟩
|
||||
rw [← hagree] at hkcr₂
|
||||
obtain ⟨hkdb₁, _hkE', hkU'⟩ := ConflictRange.mem_keys_iff.mp hkcr₂
|
||||
have hkbetween : k ∈ between db₁ E L := by
|
||||
rw [between_eq_filter_above]
|
||||
exact List.mem_filter.mpr ⟨mem_above.mpr ⟨hkdb₁, hkE⟩,
|
||||
by rw [decide_eq_true_eq]; exact hkL'⟩
|
||||
rw [hnil] at hkbetween
|
||||
exact absurd hkbetween List.not_mem_nil
|
||||
|
||||
/-- The finite over cell of the reversed crossed negative-begin truncated residual:
|
||||
the finite branch with the reported last strictly above `end_.key`, with the reported last
|
||||
below `begin.key`. -/
|
||||
abbrev negCrossTruncRevResidualFiniteOver (r : RangeRead) (res : Result) : Prop :=
|
||||
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
|
||||
2 ≤ r.end_.offset ∧
|
||||
r.end_.key < ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧
|
||||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
||||
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
|
||||
(r.end_.offset - 1).toNat
|
||||
|
||||
/-- The closed form of the finite over cell: the reduced under-cell rule with its lower
|
||||
endpoint lifted to `end_.key`. -/
|
||||
noncomputable def closedFormNegCrossTruncRevResidualFiniteOver
|
||||
(r : RangeRead) (res : Result) : ConflictRange := by
|
||||
classical
|
||||
let U : WithTop Key :=
|
||||
if finiteUnderCond r res then
|
||||
(((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
|
||||
else r.begin.key
|
||||
exact ⟨r.end_.key, U⟩
|
||||
|
||||
/-- **Gap-key necessity in the finite over cell.** The witness database stores the
|
||||
reported keys in ascending order together with `beginSlack + 1 - t` gap keys in
|
||||
`[keyAfter head, begin.key)` avoiding the target, so its begin anchor is exactly zero,
|
||||
resolving onto the reported last, while its end resolution is the first gap key and
|
||||
excludes them. Inserting the target raises the begin 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 hypothesis is the negation of `finiteUnderCond`. -/
|
||||
theorem necessary_of_mem_gap_of_negCross_trunc_rev_residualFiniteOver
|
||||
{r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||||
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
|
||||
(hend : 2 ≤ r.end_.offset)
|
||||
(hEL : r.end_.key < ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||||
(hheadB : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key)
|
||||
(hcount : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
|
||||
(r.end_.offset - 1).toNat)
|
||||
(hcond : ¬ finiteUnderCond r res)
|
||||
{k : Key}
|
||||
(hkH : ((res.keys.headD ([] : Key) : Key) : WithTop Key) < (k : WithTop Key))
|
||||
(hkB : ((k : Key) : WithTop Key) < r.begin.key) :
|
||||
Necessary r res k := by
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
set H : Key := res.keys.head hne with hHdef
|
||||
set t : ℕ := res.keys.length with htdef
|
||||
set e : ℕ := (r.end_.offset - 1).toNat with hedef
|
||||
have hlastD : res.keys.getLastD ([] : Key) = L := by
|
||||
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]
|
||||
exact hLdef.symm
|
||||
have hheadD : res.keys.headD ([] : Key) = H := by
|
||||
rw [List.headD_eq_head?_getD, List.head?_eq_some_head hne]
|
||||
exact hHdef.symm
|
||||
have hheadOpt : res.keys.head?.getD ([] : Key) = H := by
|
||||
rw [List.head?_eq_some_head hne]
|
||||
exact hHdef.symm
|
||||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||||
have hHmem : H ∈ res.keys := by rw [hHdef]; exact List.head_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 hHge : ∀ x ∈ res.keys, x ≤ H := by
|
||||
intro x hx; rw [hHdef]; exact (hsort.pairwise.imp le_of_lt).rel_head hx
|
||||
have hEL' : r.end_.key < ((L : Key) : WithTop Key) := by rw [← hlastD]; exact hEL
|
||||
have hheadB' : ((H : Key) : WithTop Key) < r.begin.key := by rw [← hheadD]; exact hheadB
|
||||
have hkH' : ((H : Key) : WithTop Key) < (k : WithTop Key) := by rw [← hheadD]; exact hkH
|
||||
have hHk : H < k := WithTop.coe_lt_coe.mp hkH'
|
||||
have hE_le_reported : ∀ x ∈ res.keys, r.end_.key ≤ ((x : Key) : WithTop Key) := by
|
||||
intro x hx
|
||||
exact le_trans (le_of_lt hEL') (WithTop.coe_le_coe.mpr (hLle x hx))
|
||||
have hreported_lt_B : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < r.begin.key := by
|
||||
intro x hx
|
||||
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hHge x hx)) hheadB'
|
||||
have hcount_t : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
|
||||
t := by
|
||||
rw [htdef, List.countP_eq_length]
|
||||
intro x hx; rw [decide_eq_true_eq]; exact hE_le_reported x hx
|
||||
have ht_e : t = e := by rw [← hcount_t, hcount, hedef]
|
||||
have hrepB : reportedBelowBegin r res = t := by
|
||||
unfold reportedBelowBegin
|
||||
rw [htdef, List.countP_eq_length]
|
||||
intro x hx; rw [decide_eq_true_eq]; exact hreported_lt_B x hx
|
||||
have ht_le : t ≤ beginSlack r + 1 := by
|
||||
have h := reportedBelowBegin_le_beginSlack_succ hcomp₀ hbeg
|
||||
rwa [hrepB] at h
|
||||
-- the negation of the capacity condition gives one more gap slot than witness keys
|
||||
have hcond_ineq : (beginSlack r : ℕ∞) <
|
||||
((t - 1 : ℕ) : ℕ∞) +
|
||||
intervalCard (((keyAfter H : Key)) : WithTop Key) r.begin.key := by
|
||||
have h := not_le.mp (by simpa [finiteUnderCond] using hcond)
|
||||
rwa [hrepB, hheadOpt] at h
|
||||
have hcard : (((beginSlack r + 1 - t) + 1 : ℕ) : ℕ∞) ≤
|
||||
intervalCard (((keyAfter H : Key)) : WithTop Key) r.begin.key := by
|
||||
cases hcap : intervalCard (((keyAfter H : Key)) : WithTop Key) r.begin.key with
|
||||
| top => exact le_top
|
||||
| coe n =>
|
||||
have h' : (beginSlack r : ℕ∞) < ((t - 1 : ℕ) : ℕ∞) + ((n : ℕ) : ℕ∞) := by
|
||||
rw [hcap] at hcond_ineq; exact hcond_ineq
|
||||
rw [← ENat.natCast_add] at h'
|
||||
have hnat : beginSlack r < (t - 1) + n := by exact_mod_cast h'
|
||||
have hn : beginSlack r + 1 - t + 1 ≤ n := by omega
|
||||
exact_mod_cast hn
|
||||
obtain ⟨dbG, hGrange, hkG, hGlen⟩ :=
|
||||
exists_db_keysIn_avoid (B := (((keyAfter H : Key)) : WithTop Key))
|
||||
(E := r.begin.key) (k := k) (m := beginSlack r + 1 - t) hcard
|
||||
set G : List Key := dbG.keys with hGdef
|
||||
have hGmem : ∀ x ∈ G, (((keyAfter H : Key)) : WithTop 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 = beginSlack r + 1 - t := by rw [hGdef]; exact hGlen
|
||||
have hH_lt_G : ∀ x ∈ G, ((H : Key) : WithTop Key) < (x : WithTop Key) := by
|
||||
intro x hx
|
||||
exact lt_of_lt_of_le (by exact_mod_cast keyAfter_self_lt H) (hGmem x hx).1
|
||||
-- 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_le_of_lt (WithTop.coe_le_coe.mpr (hHge x hx')) (hH_lt_G y hy))
|
||||
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 hreported_lt_B x hx
|
||||
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 + (beginSlack r + 1 - t) = beginSlack r + 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_trans (hLle H hHmem) (le_of_lt (WithTop.coe_lt_coe.mp (hH_lt_G x hxG)))
|
||||
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
|
||||
-- the end filter is the whole ascending list
|
||||
have hEfilt : db_a.keys.filter (fun x : Key => decide (r.end_.key ≤ (x : WithTop Key))) =
|
||||
res.keys.reverse ++ G := by
|
||||
rw [hdb_a]
|
||||
apply List.filter_eq_self.mpr
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
rcases List.mem_append.mp hx with hxr | hxG
|
||||
· exact hE_le_reported x (List.mem_reverse.mp hxr)
|
||||
· exact le_of_lt (lt_of_lt_of_le hEL' (WithTop.coe_le_coe.mpr
|
||||
(le_trans (hLle H hHmem) (le_of_lt (WithTop.coe_lt_coe.mp (hH_lt_G x hxG))))))
|
||||
have hresEnd : resolve db_a r.end_ =
|
||||
(match G[0]? with
|
||||
| some x => ((x : Key) : WithTop Key)
|
||||
| none => (⊤ : WithTop Key)) := by
|
||||
rw [resolve_eq_filter_getElem? (db := db_a) (s := r.end_) (by omega)]
|
||||
rw [hEfilt]
|
||||
have hidx : (r.end_.offset - 1).toNat = t := by omega
|
||||
rw [hidx]
|
||||
have h1 : (res.keys.reverse ++ G)[t]? = G[0]? := by
|
||||
rw [List.getElem?_append_right (by rw [List.length_reverse, htdef])]
|
||||
rw [htdef, List.length_reverse, Nat.sub_self]
|
||||
rw [h1]
|
||||
rfl
|
||||
-- every reported key is below the end resolution, no gap key is
|
||||
have hrep_lt_res : ∀ x ∈ res.keys, ((x : Key) : WithTop Key) < resolve db_a r.end_ := by
|
||||
intro x hx
|
||||
rw [hresEnd]
|
||||
cases hG : G with
|
||||
| nil => exact WithTop.coe_lt_top _
|
||||
| cons g gs =>
|
||||
simp only [List.getElem?_cons_zero]
|
||||
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hHge x hx)) (hH_lt_G g (by rw [hG]; exact List.mem_cons_self))
|
||||
have hG_not_lt_res : ∀ y ∈ G, ¬ ((y : Key) : WithTop Key) < resolve db_a r.end_ := by
|
||||
intro y hy
|
||||
rw [hresEnd]
|
||||
cases hG : G with
|
||||
| nil => rw [hG] at hy; exact absurd hy List.not_mem_nil
|
||||
| cons g gs =>
|
||||
simp only [List.getElem?_cons_zero]
|
||||
have hgle : g ≤ y := by
|
||||
have hpair : (g :: gs).Pairwise (· < ·) := by
|
||||
rw [← List.sortedLT_iff_pairwise]; rw [← hG]; exact hGsorted
|
||||
have := (hpair.imp le_of_lt).rel_head (by rw [hG] at hy; exact hy)
|
||||
simpa using this
|
||||
exact not_lt.mpr (WithTop.coe_le_coe.mpr hgle)
|
||||
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)),
|
||||
hrep_lt_res x (List.mem_reverse.mp hx)⟩
|
||||
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
|
||||
exact hG_not_lt_res x hx 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 (WithTop.coe_le_coe.mpr (hHge k (List.mem_reverse.mp hx))) (not_le.mpr hkH')
|
||||
· exact hkG (by simpa [hGdef] using hx)
|
||||
-- insert the target: it lands above the reported keys and at the gap bottom
|
||||
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_le_of_lt (WithTop.coe_le_coe.mpr (hHge x (List.mem_reverse.mp hx))) hkH')
|
||||
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_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 hreported_lt_B x (List.mem_reverse.mp hx')
|
||||
· rw [List.mem_orderedInsert] at hx'
|
||||
rcases hx' with rfl | hxG
|
||||
· exact hkB
|
||||
· exact (hGmem x hxG).2
|
||||
have hb_len : db_b.keys.length = t + (beginSlack r + 1 - t) + 1 := by
|
||||
rw [hb_keys, List.length_append, List.length_reverse, List.orderedInsert_length,
|
||||
hGlen', htdef]
|
||||
omega
|
||||
have hb_cntB : db_b.keys.countP (fun x : Key =>
|
||||
decide (((x : Key) : WithTop Key) < r.begin.key)) = t + (beginSlack r + 1 - t) + 1 := 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]
|
||||
have hts : t + (beginSlack r + 1 - t) = beginSlack r + 1 := Nat.add_sub_of_le ht_le
|
||||
rw [hts]; push_cast; ring
|
||||
have hb_min : ∀ 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_trans (hLle H hHmem) (le_of_lt (WithTop.coe_lt_coe.mp hkH'))
|
||||
· exact le_trans (hLle H hHmem) (le_of_lt (WithTop.coe_lt_coe.mp (hH_lt_G x hxG)))
|
||||
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
|
||||
have hget0_b : db_b.keys[(0 : ℕ)] = L :=
|
||||
getElem_zero_eq_of_forall_le db_b.sorted hb_min 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
|
||||
obtain ⟨_, hck, _⟩ := RangeRead.mem_completeKeys.mp hmem
|
||||
rw [hresBegin_b] at hck
|
||||
exact absurd hck (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
|
||||
|
||||
/-- **The finite over cell of the reversed residual is minimal.** The closed form is
|
||||
`[end_.key, U)` with `U` the under-cell upper endpoint. Keys in `[end_.key, last)` are
|
||||
absent from every compatible database, keys in `[last, head]` are reported (hence
|
||||
necessary), and keys in `(head, U)` are necessary by the gap-toggle witness when `U` is
|
||||
`begin.key`; the alternative `U = keyAfter head` leaves no key in that gap. Soundness
|
||||
transfers from the reduced finite-under read, using that agreement on `[end_.key, U)`
|
||||
also fixes the absence in `[end_.key, last)`. -/
|
||||
theorem minimal_closedForm_of_negCross_trunc_rev_residualFinite_over
|
||||
{r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hcell : negCrossTruncRevResidualFiniteOver r res) :
|
||||
Minimal r res (closedFormNegCrossTruncRevResidualFiniteOver r res) := by
|
||||
classical
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
obtain ⟨hmore, hrev, hbeg, hne, hend, hEL, hLB, hcount⟩ := hcell
|
||||
set L : Key := res.keys.getLastD ([] : Key) with hLdef
|
||||
set H : Key := res.keys.headD ([] : Key) with hHdef
|
||||
have hLg : L = res.keys.getLast hne := by
|
||||
rw [hLdef, getLastD_eq_getLast_of_ne hne]
|
||||
have hHg : H = res.keys.head hne := by
|
||||
rw [hHdef, headD_eq_head_of_ne hne]
|
||||
have hLmem : L ∈ res.keys := by rw [hLg]; exact List.getLast_mem hne
|
||||
have hHmem : H ∈ res.keys := by rw [hHg]; exact List.head_mem hne
|
||||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
|
||||
have hLle : ∀ x ∈ res.keys, L ≤ x := by
|
||||
intro x hx; rw [hLg]; exact (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
||||
have hHge : ∀ x ∈ res.keys, x ≤ H := by
|
||||
intro x hx; rw [hHg]; exact (hsort.pairwise.imp le_of_lt).rel_head hx
|
||||
have hEL' : r.end_.key < ((L : Key) : WithTop Key) := hEL
|
||||
have hLB' : ((L : Key) : WithTop Key) < r.begin.key := hLB
|
||||
-- the finite count is the length, because every reported key is at or above `L`
|
||||
have ht : res.keys.length = (r.end_.offset - 1).toNat := by
|
||||
rw [← hcount]
|
||||
exact (List.countP_eq_length.mpr (fun x hx => by
|
||||
rw [decide_eq_true_eq]
|
||||
exact le_trans (le_of_lt hEL') (WithTop.coe_le_coe.mpr (hLle x hx)))).symm
|
||||
let U : WithTop Key :=
|
||||
if finiteUnderCond r res then
|
||||
(((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key)
|
||||
else r.begin.key
|
||||
let r' : RangeRead :=
|
||||
{ r with end_ := ⟨((L : Key) : WithTop Key), r.end_.offset⟩ }
|
||||
have hcompat : ∀ db, RangeRead.Compatible db r res ↔
|
||||
between db r.end_.key ((L : Key) : WithTop Key) = [] ∧
|
||||
RangeRead.Compatible db r' res := by
|
||||
intro db
|
||||
simpa [r', hLdef] using
|
||||
compatible_iff_over_reduce (r := r) (res := res) hmore hrev hne hend hEL ht db
|
||||
have hread' : Readable r' res :=
|
||||
⟨db₀, ((hcompat db₀).mp hcomp₀).2⟩
|
||||
-- the reduced read lies in the finite under cell
|
||||
have hr'beg : r'.begin = r.begin := rfl
|
||||
have hr'rev : r'.reverse = true := hrev
|
||||
have hr'endoff : r'.end_.offset = r.end_.offset := rfl
|
||||
have hr'endkey : r'.end_.key = ((L : Key) : WithTop Key) := by
|
||||
change ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) = ((L : Key) : WithTop Key)
|
||||
exact congrArg (fun x : Key => (x : WithTop Key)) hLdef.symm
|
||||
have hcountL : res.keys.countP (fun k : Key =>
|
||||
decide (((L : Key) : WithTop Key) ≤ (k : WithTop Key))) =
|
||||
(r.end_.offset - 1).toNat := by
|
||||
rw [← ht]
|
||||
exact List.countP_eq_length.mpr (fun x hx => by
|
||||
rw [decide_eq_true_eq]; exact WithTop.coe_le_coe.mpr (hLle x hx))
|
||||
have hbase : negCrossTruncRevResidualFiniteUnder r' res := by
|
||||
refine ⟨hmore, hr'rev, ?_, hne, ?_, ?_, ?_, ?_⟩
|
||||
· rw [hr'beg]; exact hbeg
|
||||
· rw [hr'endoff]; exact hend
|
||||
· rw [hr'endkey]
|
||||
· rw [hr'beg]; rw [← hLdef]; exact hLB
|
||||
· rw [hr'endoff, hr'endkey]; exact hcountL
|
||||
have hcrUnder : closedFormNegCrossTruncRevResidualFiniteUnder r' res =
|
||||
(⟨((L : Key) : WithTop Key), U⟩ : ConflictRange) := by
|
||||
have hcondEq : finiteUnderCond r' res = finiteUnderCond r res := rfl
|
||||
simp only [closedFormNegCrossTruncRevResidualFiniteUnder, U, hcondEq, hLdef]
|
||||
rfl
|
||||
have hcrOver : closedFormNegCrossTruncRevResidualFiniteOver r res =
|
||||
(⟨r.end_.key, U⟩ : ConflictRange) := by
|
||||
simp only [closedFormNegCrossTruncRevResidualFiniteOver, U]
|
||||
have hLU : ((L : Key) : WithTop Key) ≤ U := by
|
||||
simp only [U]
|
||||
split
|
||||
· exact le_of_lt (lt_of_le_of_lt (WithTop.coe_le_coe.mpr (hLle H hHmem))
|
||||
(by exact_mod_cast keyAfter_self_lt H))
|
||||
· exact le_of_lt hLB'
|
||||
have hmain : Sound r' res (⟨((L : Key) : WithTop Key), U⟩ : ConflictRange) →
|
||||
Minimal r res (closedFormNegCrossTruncRevResidualFiniteOver r res) := by
|
||||
intro hsnd'
|
||||
rw [hcrOver]
|
||||
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
|
||||
· intro db₁ db₂ hagree
|
||||
rw [hcompat db₁, hcompat db₂]
|
||||
constructor
|
||||
· rintro ⟨hnil₁, hcomp₁⟩
|
||||
exact ⟨between_eq_nil_of_agreeOn (le_of_lt hEL') hLU hnil₁ hagree,
|
||||
(hsnd' db₁ db₂ (agreeOn_of_subrange
|
||||
(subrange_of_le (le_of_lt hEL') (le_refl U)) hagree)).mp hcomp₁⟩
|
||||
· rintro ⟨hnil₂, hcomp₂⟩
|
||||
exact ⟨between_eq_nil_of_agreeOn (le_of_lt hEL') hLU hnil₂ (AgreeOn.symm hagree),
|
||||
(hsnd' db₁ db₂ (agreeOn_of_subrange
|
||||
(subrange_of_le (le_of_lt hEL') (le_refl U)) hagree)).mpr hcomp₂⟩
|
||||
· intro k hk
|
||||
rw [ConflictRange.mem_iff] at hk
|
||||
obtain ⟨hkE, hkU⟩ := hk
|
||||
by_cases hkL : ((k : Key) : WithTop Key) < ((L : Key) : WithTop Key)
|
||||
· refine necessary_of_forall_not_mem ⟨db₀, hcomp₀⟩ ?_
|
||||
intro db hcomp hkdb
|
||||
obtain ⟨hnil, _⟩ := (hcompat db).mp hcomp
|
||||
have hkbet : k ∈ between db r.end_.key ((L : Key) : WithTop Key) := by
|
||||
rw [between_eq_filter_above]
|
||||
exact List.mem_filter.mpr ⟨mem_above.mpr ⟨hkdb, hkE⟩,
|
||||
by rw [decide_eq_true_eq]; exact hkL⟩
|
||||
rw [hnil] at hkbet
|
||||
exact absurd hkbet List.not_mem_nil
|
||||
· push Not at hkL
|
||||
by_cases hkH : k ≤ H
|
||||
· exact Necessary.of_between (necessary_of_mem_result ⟨db₀, hcomp₀⟩ hLmem)
|
||||
(necessary_of_mem_result ⟨db₀, hcomp₀⟩ hHmem) (WithTop.coe_le_coe.mp hkL) hkH
|
||||
· push Not at hkH
|
||||
have hnotcond : ¬ finiteUnderCond r res := by
|
||||
intro hcond
|
||||
have hUeq : U = (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) := by
|
||||
simp only [U, hcond, ite_true]
|
||||
rw [hUeq] at hkU
|
||||
have hHk' : res.keys.headD ([] : Key) < k := by rw [← hHdef]; exact hkH
|
||||
have hkK : k < keyAfter (res.keys.headD ([] : Key)) := WithTop.coe_lt_coe.mp hkU
|
||||
exact absurd hHk' (not_lt.mpr ((lt_keyAfter_iff k _).mp hkK))
|
||||
have hkUI : ((k : Key) : WithTop Key) < r.begin.key := by
|
||||
simp only [U, hnotcond, ite_false] at hkU
|
||||
exact hkU
|
||||
exact necessary_of_mem_gap_of_negCross_trunc_rev_residualFiniteOver
|
||||
⟨db₀, hcomp₀⟩ hmore hrev hne hbeg hend (by rw [← hLdef]; exact hEL)
|
||||
(by rw [← hHdef]; exact lt_trans (WithTop.coe_lt_coe.mpr hkH) hkUI)
|
||||
hcount hnotcond
|
||||
(WithTop.coe_lt_coe.mpr hkH) hkUI
|
||||
by_cases hcross : (((keyAfter (res.keys.headD ([] : Key)) : Key)) : WithTop Key) <
|
||||
r'.begin.key
|
||||
· refine hmain ?_
|
||||
rw [← hcrUnder]
|
||||
exact (minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_crossed hread'
|
||||
⟨hbase, hcross⟩).sound
|
||||
· refine hmain ?_
|
||||
rw [← hcrUnder]
|
||||
exact (minimal_closedForm_of_negCross_trunc_rev_residualFinite_under_notCrossed hread'
|
||||
⟨hbase, hcross⟩).sound
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user