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,777 @@
|
||||
/-
|
||||
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.NegCrossTruncClamp
|
||||
|
||||
/-!
|
||||
# Reversed negative-begin truncated, sentinel-end cell
|
||||
|
||||
This module closes the reversed traversal analogue of the forward crossed
|
||||
negative-begin truncated cells, in the first and simplest subcell: the end selector's
|
||||
key is the sentinel `⊤` and its offset is at least one, so the end resolves to `⊤` in
|
||||
every database. The minimal sound conflict range is then `[last, ⊤)`, where `last` is
|
||||
the smallest reported key (the last entry of the descending reversed result).
|
||||
|
||||
The proof does not need the clamping/nonclamping split. The key observation is that
|
||||
agreement on `[last, ⊤)` fixes the whole set of stored keys at or above `last`, and at
|
||||
a negative begin offset the count of stored keys below `last` cancels in the begin
|
||||
anchor, so the resolved begin stays at or below `last` on both sides. Hence the
|
||||
complete keys are `res.keys` followed by keys below `last`, which keeps `res.keys` a
|
||||
prefix.
|
||||
|
||||
Above the reported head, necessity uses the database made of the reported keys in
|
||||
ascending order: it is compatible, and inserting a fresh key above the head puts it at
|
||||
the front of the (reversed) complete keys, so the reported keys are no longer a prefix.
|
||||
-/
|
||||
|
||||
open FormalConflictRange
|
||||
|
||||
set_option maxHeartbeats 1200000
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
/-- If the end selector's key is the sentinel `⊤` and its offset is at least one, the
|
||||
end selector resolves to the sentinel in every database. -/
|
||||
theorem resolve_end_eq_top_of_key_top {db : DB} {r : RangeRead}
|
||||
(hkey : r.end_.key = (⊤ : WithTop Key)) (hoff : 1 ≤ r.end_.offset) :
|
||||
resolve db r.end_ = (⊤ : WithTop Key) := by
|
||||
have hcnt : db.keys.countP
|
||||
(fun (k : Key) => decide (((k : Key) : WithTop Key) < r.end_.key)) =
|
||||
db.keys.length := by
|
||||
rw [hkey]
|
||||
exact List.countP_eq_length.mpr fun k _ => by simp
|
||||
have hann : r.end_.anchor db = (db.keys.length : Int) + r.end_.offset - 1 := by
|
||||
unfold Selector.anchor
|
||||
rw [hcnt]
|
||||
refine resolve_eq_top ?_ ?_
|
||||
· rw [hann]; omega
|
||||
· have htoNat : (r.end_.anchor db).toNat =
|
||||
db.keys.length + (r.end_.offset - 1).toNat := by
|
||||
rw [hann, show ((db.keys.length : Int) + r.end_.offset - 1) =
|
||||
((db.keys.length : Int) + (r.end_.offset - 1)) by ring,
|
||||
Int.toNat_add (Int.natCast_nonneg _) (by omega), Int.toNat_natCast]
|
||||
rw [htoNat]
|
||||
omega
|
||||
|
||||
/-- When the resolved end is the sentinel and the resolved begin lies at or below
|
||||
`last`, filtering the reversed complete keys at or above `last` is the reversal of the
|
||||
stored keys at or above `last`. -/
|
||||
theorem completeKeys_filter_ge_eq_of_resolve_le {db : DB} {r : RangeRead} {last : Key}
|
||||
(hrev : r.reverse = true) (hre : resolve db r.end_ = (⊤ : WithTop Key))
|
||||
(hrb : resolve db r.begin ≤ ((last : Key) : WithTop Key)) :
|
||||
(RangeRead.completeKeys db r).filter (fun k => decide (last ≤ k)) =
|
||||
(db.keys.filter (fun k => decide (last ≤ k))).reverse := by
|
||||
unfold RangeRead.completeKeys RangeRead.inRange
|
||||
rw [hrev, hre]
|
||||
simp only [ite_true]
|
||||
rw [List.filter_reverse, List.reverse_inj, List.filter_filter]
|
||||
apply List.filter_congr
|
||||
intro k _hk
|
||||
by_cases hLk : last ≤ k
|
||||
· have hres : decide (resolve db r.begin ≤ ((k : Key) : WithTop Key)) = true := by
|
||||
rw [decide_eq_true_eq]
|
||||
exact le_trans hrb (WithTop.coe_le_coe.mpr hLk)
|
||||
simp [hLk, hres]
|
||||
· simp [hLk]
|
||||
|
||||
/-- **The begin anchor bound.** In a compatible crossed reversed truncated result the
|
||||
number of stored keys in `[last, begin.key)`, plus the begin offset minus one, is at
|
||||
most zero. This is the cancellation that makes agreement on `[last, ⊤)` sound: adding
|
||||
or removing keys below `last` shifts the anchor index and the position of `last` in
|
||||
lockstep. -/
|
||||
theorem between_add_offset_le_one {r : RangeRead} {res : Result} {db : DB}
|
||||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||||
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key) :
|
||||
((between db ((res.keys.getLast hne : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 := 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 hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfil]; exact hLmem
|
||||
have hLcomplete : L ∈ RangeRead.completeKeys db r := (List.mem_filter.mp hLfilt).1
|
||||
have hLmem' := RangeRead.mem_completeKeys.mp hLcomplete
|
||||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) := hLmem'.2.1
|
||||
have hLdb : L ∈ db.keys := hLmem'.1
|
||||
obtain ⟨j, hjlt, hjeq⟩ := List.mem_iff_getElem.mp hLdb
|
||||
have hclamp : clampIndex db r.begin ≤ j :=
|
||||
(resolve_le_getElem_iff (db := db) (s := r.begin) hjlt).mp (by rw [hjeq]; exact hrb)
|
||||
have htoNat : (r.begin.anchor db).toNat ≤ j := by
|
||||
have h1 : min (r.begin.anchor db).toNat db.keys.length ≤ j := hclamp
|
||||
by_cases h : (r.begin.anchor db).toNat ≤ db.keys.length
|
||||
· rwa [Nat.min_eq_left h] at h1
|
||||
· rw [Nat.min_eq_right (by omega)] at h1
|
||||
omega
|
||||
have hanchor_le : r.begin.anchor db ≤ (j : Int) := by
|
||||
have h1 : r.begin.anchor db ≤ ((r.begin.anchor db).toNat : Int) := by
|
||||
by_cases h : 0 ≤ r.begin.anchor db
|
||||
· rw [Int.toNat_of_nonneg h]
|
||||
· omega
|
||||
have h2 : ((r.begin.anchor db).toNat : Int) ≤ (j : Int) := by exact_mod_cast htoNat
|
||||
linarith
|
||||
have hcntL : cnt db ((L : Key) : WithTop Key) = j := by
|
||||
rw [cnt_coe]
|
||||
exact countP_lt_eq_of_getElem db.sorted hjlt hjeq
|
||||
have hLleBegin : ((L : Key) : WithTop Key) ≤ r.begin.key := le_of_lt hcross
|
||||
have hcnt_begin : cnt db r.begin.key = j + (between db ((L : Key) : WithTop Key) r.begin.key).length := by
|
||||
rw [cnt_eq_add_between db hLleBegin, hcntL]
|
||||
have hanchor : r.begin.anchor db = (j : Int) +
|
||||
((between db ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 := by
|
||||
change (cnt db r.begin.key : Int) + r.begin.offset - 1 = _
|
||||
rw [hcnt_begin]; push_cast; ring
|
||||
have hmain := hanchor_le
|
||||
rw [hanchor] at hmain
|
||||
linarith
|
||||
|
||||
/-- **The reported-below-begin offset bound.** With a sentinel end, the number of
|
||||
reported keys below `begin.key` plus the begin offset minus one is at most zero. -/
|
||||
theorem reportedBelowBegin_add_offset_le_one {r : RangeRead} {res : Result} {db : DB}
|
||||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||||
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
|
||||
(reportedBelowBegin r res : Int) + r.begin.offset - 1 ≤ 0 := by
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
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 hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||||
have hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfil]; exact hLmem
|
||||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
(RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt).1).2.1
|
||||
have htop : db.keys.filter (fun k => decide (L ≤ k)) = res.keys.reverse := by
|
||||
have hre : resolve db r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
have h1 := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r) (last := L) hrev hre hrb
|
||||
rw [hfil] at h1
|
||||
have h2 : res.keys.reverse = db.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
have hrev1 := congrArg List.reverse h1
|
||||
simpa using hrev1
|
||||
exact h2.symm
|
||||
have hbetween : (between db ((L : Key) : WithTop Key) r.begin.key).length
|
||||
= reportedBelowBegin r res := by
|
||||
have hbeq : between db ((L : Key) : WithTop Key) r.begin.key =
|
||||
(db.keys.filter (fun k => decide (L ≤ k))).filter
|
||||
(fun k => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
|
||||
unfold between
|
||||
rw [List.filter_filter]
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
rw [Bool.decide_and, Bool.and_comm]
|
||||
by_cases h : L ≤ k
|
||||
· simp [h, WithTop.coe_le_coe.mpr h]
|
||||
· have h' : ¬ (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
|
||||
simpa [WithTop.coe_le_coe] using h
|
||||
simp [h, h']
|
||||
rw [hbeq, htop, ← List.countP_eq_length_filter, List.countP_reverse, reportedBelowBegin]
|
||||
have hmain := between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
|
||||
rw [hbetween] at hmain
|
||||
exact hmain
|
||||
|
||||
/-- **The begin resolution stays at or below the reported last under agreement on
|
||||
`[last, ⊤)`.** This is the generic counting step used by both sentinel-end soundness
|
||||
branches; it does not involve the end selector. -/
|
||||
theorem resolve_begin_le_of_agree_topOfLast {r : RangeRead} {res : Result} {db db' : DB}
|
||||
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
|
||||
(hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||||
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
||||
(hag : AgreeOn (topOfLast (res.keys.getLast hne)) db db') :
|
||||
resolve db' r.begin ≤ ((res.keys.getLast hne : Key) : WithTop 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 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 hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
|
||||
db.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
have h := hag
|
||||
unfold AgreeOn at h
|
||||
rw [topOfLast_keys, topOfLast_keys] at h
|
||||
exact h.symm
|
||||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||||
have hLdb' : L ∈ db'.keys := by
|
||||
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfilEq]
|
||||
exact List.mem_filter.mpr ⟨hLdb, by simp⟩
|
||||
exact (List.mem_filter.mp hmem).1
|
||||
obtain ⟨j', hj'lt, hj'eq⟩ := List.mem_iff_getElem.mp hLdb'
|
||||
have hcntL' : cnt db' ((L : Key) : WithTop Key) = j' := by
|
||||
rw [cnt_coe]
|
||||
exact countP_lt_eq_of_getElem db'.sorted hj'lt hj'eq
|
||||
have hbeq : ∀ d : DB, between d ((L : Key) : WithTop Key) r.begin.key =
|
||||
(d.keys.filter (fun k : Key => decide (L ≤ k))).filter
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
|
||||
intro d
|
||||
unfold between
|
||||
rw [List.filter_filter]
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
rw [Bool.decide_and, Bool.and_comm]
|
||||
by_cases h : L ≤ k
|
||||
· simp [h, WithTop.coe_le_coe.mpr h]
|
||||
· have h' : ¬ (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
|
||||
simpa [WithTop.coe_le_coe] using h
|
||||
simp [h, h']
|
||||
have hbetween : between db' ((L : Key) : WithTop Key) r.begin.key =
|
||||
between db ((L : Key) : WithTop Key) r.begin.key := by
|
||||
rw [hbeq db', hbeq db, hfilEq]
|
||||
have hΔ : ((between db ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 :=
|
||||
between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
|
||||
have hΔ' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 := by
|
||||
rw [hbetween]; exact hΔ
|
||||
have hanchor' : r.begin.anchor db' = (j' : Int) +
|
||||
((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 := by
|
||||
have hcnt : cnt db' r.begin.key =
|
||||
j' + (between db' ((L : Key) : WithTop Key) r.begin.key).length := by
|
||||
rw [cnt_eq_add_between db' (le_of_lt hLcross), hcntL']
|
||||
change (cnt db' r.begin.key : Int) + r.begin.offset - 1 = _
|
||||
rw [hcnt]; push_cast; ring
|
||||
have hanchor_le' : r.begin.anchor db' ≤ (j' : Int) := by
|
||||
rw [hanchor']; linarith
|
||||
have htoNat' : (r.begin.anchor db').toNat ≤ j' := by
|
||||
by_cases h : 0 ≤ r.begin.anchor db'
|
||||
· exact (Int.toNat_le).mpr hanchor_le'
|
||||
· have hz : (r.begin.anchor db').toNat = 0 := by omega
|
||||
rw [hz]; omega
|
||||
have hclamp' : clampIndex db' r.begin ≤ j' := by
|
||||
unfold clampIndex
|
||||
exact le_trans (Nat.min_le_left _ _) htoNat'
|
||||
have hle := (resolve_le_getElem_iff (db := db') (s := r.begin) hj'lt).mpr hclamp'
|
||||
rwa [hj'eq] at hle
|
||||
|
||||
/-- **Two reversed reads with the same end selector and begin resolutions at or below
|
||||
`last` see the same stored keys at or above `last`.** -/
|
||||
theorem completeKeys_filter_ge_eq_of_both_le {db : DB} {r₁ r₂ : RangeRead} {last : Key}
|
||||
(hrev₁ : r₁.reverse = true) (hrev₂ : r₂.reverse = true)
|
||||
(hend : r₁.end_ = r₂.end_)
|
||||
(h₁ : resolve db r₁.begin ≤ ((last : Key) : WithTop Key))
|
||||
(h₂ : resolve db r₂.begin ≤ ((last : Key) : WithTop Key)) :
|
||||
(RangeRead.completeKeys db r₁).filter (fun k => decide (last ≤ k)) =
|
||||
(RangeRead.completeKeys db r₂).filter (fun k => decide (last ≤ k)) := by
|
||||
unfold RangeRead.completeKeys RangeRead.inRange
|
||||
rw [hrev₁, hrev₂]
|
||||
simp only [ite_true]
|
||||
rw [hend]
|
||||
rw [List.filter_reverse, List.filter_reverse, List.reverse_inj,
|
||||
List.filter_filter, List.filter_filter]
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
by_cases hlk : last ≤ k
|
||||
· have hlk' : ((last : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key) :=
|
||||
WithTop.coe_le_coe.mpr hlk
|
||||
have hb₁ : resolve db r₁.begin ≤ ((k : Key) : WithTop Key) := le_trans h₁ hlk'
|
||||
have hb₂ : resolve db r₂.begin ≤ ((k : Key) : WithTop Key) := le_trans h₂ hlk'
|
||||
simp [hlk, hb₁, hb₂]
|
||||
· simp [hlk]
|
||||
|
||||
/-- **Soundness of the top-of-last range in the reversed negative-begin truncated
|
||||
sentinel-end cell.** Agreement on `[last, ⊤)` fixes the stored keys at or above `last`,
|
||||
and the resolved begin stays at or below `last` on both sides because the count of
|
||||
stored keys in `[last, begin.key)` is shared. -/
|
||||
theorem sound_topOfLast_of_rev_negTrunc_top {r : RangeRead} {res : Result}
|
||||
(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)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
|
||||
Sound r res (topOfLast (res.keys.getLast hne)) := 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 := hcross
|
||||
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
|
||||
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
|
||||
intro db db' hag' hcomp
|
||||
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 hre : resolve db r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
have hre' : resolve db' r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) := by
|
||||
have hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfil]; exact hLmem
|
||||
exact (RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt).1).2.1
|
||||
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
|
||||
db.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
have h := hag'
|
||||
unfold AgreeOn at h
|
||||
rw [topOfLast_keys, topOfLast_keys] at h
|
||||
exact h.symm
|
||||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||||
have hLdb' : L ∈ db'.keys := by
|
||||
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfilEq]
|
||||
exact List.mem_filter.mpr ⟨hLdb, by simp⟩
|
||||
exact (List.mem_filter.mp hmem).1
|
||||
obtain ⟨j', hj'lt, hj'eq⟩ := List.mem_iff_getElem.mp hLdb'
|
||||
have hcntL' : cnt db' ((L : Key) : WithTop Key) = j' := by
|
||||
rw [cnt_coe]
|
||||
exact countP_lt_eq_of_getElem db'.sorted hj'lt hj'eq
|
||||
have hbeq : ∀ d : DB, between d ((L : Key) : WithTop Key) r.begin.key =
|
||||
(d.keys.filter (fun k : Key => decide (L ≤ k))).filter
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < r.begin.key)) := by
|
||||
intro d
|
||||
unfold between
|
||||
rw [List.filter_filter]
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
rw [Bool.decide_and, Bool.and_comm]
|
||||
by_cases h : L ≤ k
|
||||
· simp [h, WithTop.coe_le_coe.mpr h]
|
||||
· have h' : ¬ (((L : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)) := by
|
||||
simpa [WithTop.coe_le_coe] using h
|
||||
simp [h, h']
|
||||
have hbetween : between db' ((L : Key) : WithTop Key) r.begin.key =
|
||||
between db ((L : Key) : WithTop Key) r.begin.key := by
|
||||
rw [hbeq db', hbeq db, hfilEq]
|
||||
have hΔ : ((between db ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 :=
|
||||
between_add_offset_le_one (db := db) hcomp hmore hrev hne hcross
|
||||
have hΔ' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 ≤ 0 := by
|
||||
rw [hbetween]; exact hΔ
|
||||
have hanchor' : r.begin.anchor db' = (j' : Int) +
|
||||
((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
|
||||
r.begin.offset - 1 := by
|
||||
have hcnt : cnt db' r.begin.key =
|
||||
j' + (between db' ((L : Key) : WithTop Key) r.begin.key).length := by
|
||||
rw [cnt_eq_add_between db' (le_of_lt hLcross), hcntL']
|
||||
change (cnt db' r.begin.key : Int) + r.begin.offset - 1 = _
|
||||
rw [hcnt]; push_cast; ring
|
||||
have hanchor_le' : r.begin.anchor db' ≤ (j' : Int) := by
|
||||
rw [hanchor']; linarith
|
||||
have htoNat' : (r.begin.anchor db').toNat ≤ j' := by
|
||||
by_cases h : 0 ≤ r.begin.anchor db'
|
||||
· exact (Int.toNat_le).mpr hanchor_le'
|
||||
· have hz : (r.begin.anchor db').toNat = 0 := by omega
|
||||
rw [hz]; omega
|
||||
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) := by
|
||||
have hclamp' : clampIndex db' r.begin ≤ j' := by
|
||||
unfold clampIndex
|
||||
exact le_trans (Nat.min_le_left _ _) htoNat'
|
||||
have hle := (resolve_le_getElem_iff (db := db') (s := r.begin) hj'lt).mpr hclamp'
|
||||
rwa [hj'eq] at hle
|
||||
have hdb'filt := completeKeys_filter_ge_eq_of_resolve_le (db := db') (r := r) (last := L)
|
||||
hrev hre' hrb'
|
||||
have hdbfilt := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r) (last := L)
|
||||
hrev hre hrb
|
||||
refine (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr ⟨hcomp.1, ?_⟩
|
||||
rw [hdb'filt, hfilEq, ← hdbfilt, hfil]
|
||||
intro db₁ db₂ hagree
|
||||
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
|
||||
|
||||
/-- **Above-head necessity in the reversed negative-begin truncated sentinel-end
|
||||
cell.** The database made of the reported keys in ascending order is compatible;
|
||||
inserting a fresh key above the reported head puts it at the front of the reversed
|
||||
complete keys, so the reported keys are no longer a prefix. -/
|
||||
theorem necessary_above_head_of_rev_negTrunc_top {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)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset)
|
||||
{k : Key} (hkH : res.keys.head hne < k) :
|
||||
Necessary r res k := by
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
set H : Key := res.keys.head hne with hHdef
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
have hoff : (reportedBelowBegin r res : Int) + r.begin.offset - 1 ≤ 0 :=
|
||||
reportedBelowBegin_add_offset_le_one hcomp₀ hmore hrev hne hcross hendkey hendoff
|
||||
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp₀ hrev
|
||||
have hHge : ∀ x ∈ res.keys, x ≤ H := by
|
||||
intro x hx; rw [hHdef]; exact (hsort.pairwise.imp le_of_lt).rel_head hx
|
||||
have hLle : ∀ x ∈ res.keys, L ≤ x := by
|
||||
intro x hx; rw [hLdef]; exact (hsort.pairwise.imp le_of_lt).rel_getLast hx
|
||||
have hk_notin : k ∉ res.keys := by
|
||||
intro hx
|
||||
have hle := hHge k hx
|
||||
have hleH : k ≤ res.keys.head hne := by rw [← hHdef]; exact hle
|
||||
exact absurd hleH (not_le.mpr hkH)
|
||||
-- the witness database of reported keys in ascending order
|
||||
have ha_sorted : res.keys.reverse.SortedLT := hsort.reverse
|
||||
let db_a : DB := ⟨res.keys.reverse, ha_sorted⟩
|
||||
have ha_keys : db_a.keys = res.keys.reverse := rfl
|
||||
have haresolve : resolve db_a r.begin ≤ ((L : Key) : WithTop Key) := by
|
||||
have hanchor : r.begin.anchor db_a = (reportedBelowBegin r res : Int) + r.begin.offset - 1 := by
|
||||
have hcnt : cnt db_a r.begin.key = reportedBelowBegin r res := by
|
||||
unfold cnt reportedBelowBegin
|
||||
rw [ha_keys, List.countP_reverse]
|
||||
change (cnt db_a r.begin.key : Int) + r.begin.offset - 1 = _
|
||||
rw [hcnt]
|
||||
have hle : r.begin.anchor db_a ≤ 0 := by rw [hanchor]; linarith
|
||||
by_cases hneg : r.begin.anchor db_a < 0
|
||||
· rw [resolve_eq_nil hneg]
|
||||
exact WithTop.coe_le_coe.mpr (nil_le_key L)
|
||||
· have hanc0 : r.begin.anchor db_a = 0 := le_antisymm hle (le_of_not_gt hneg)
|
||||
have hlen : 0 < db_a.keys.length := by
|
||||
rw [ha_keys, List.length_reverse]
|
||||
exact List.length_pos_of_ne_nil hne
|
||||
have h0lt : (r.begin.anchor db_a).toNat < db_a.keys.length := by
|
||||
rw [hanc0]; simpa using hlen
|
||||
have hget0 : db_a.keys[(r.begin.anchor db_a).toNat] = L := by
|
||||
have hidx : (r.begin.anchor db_a).toNat = 0 := by rw [hanc0]; rfl
|
||||
have h0 : db_a.keys[(r.begin.anchor db_a).toNat]? = some L := by
|
||||
rw [hidx, ha_keys, ← List.head?_eq_getElem?]
|
||||
rw [List.head?_reverse, List.getLast?_eq_some_getLast hne]
|
||||
have h1 := List.getElem?_eq_getElem h0lt
|
||||
rw [h0] at h1
|
||||
exact (Option.some.inj h1).symm
|
||||
rw [resolve_eq_getElem (le_of_not_gt hneg) h0lt, hget0]
|
||||
have hre : resolve db_a r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
have hck_a : RangeRead.completeKeys db_a r = res.keys := by
|
||||
unfold RangeRead.completeKeys RangeRead.inRange
|
||||
rw [hrev, hre]
|
||||
simp only [ite_true]
|
||||
have hpred : db_a.keys.filter (fun x => decide
|
||||
(resolve db_a r.begin ≤ ((x : Key) : WithTop Key) ∧
|
||||
((x : Key) : WithTop Key) < (⊤ : WithTop Key))) = db_a.keys := by
|
||||
rw [List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
have hx' : L ≤ x := by
|
||||
rw [ha_keys] at hx
|
||||
exact hLle x (List.mem_reverse.mp hx)
|
||||
exact ⟨le_trans haresolve (WithTop.coe_le_coe.mpr hx'), WithTop.coe_lt_top x⟩
|
||||
rw [hpred, ha_keys, List.reverse_reverse]
|
||||
have hacompat : RangeRead.Compatible db_a r res := by
|
||||
refine (compatible_iff_truncated_keys_rev (db := db_a) hrev hmore hne).mpr ⟨hcomp₀.1, ?_⟩
|
||||
rw [hck_a, List.filter_eq_self]
|
||||
intro x hx
|
||||
rw [decide_eq_true_eq]
|
||||
exact hLle x hx
|
||||
have hk_notin_a : k ∉ db_a.keys := by
|
||||
rw [ha_keys, List.mem_reverse]
|
||||
exact hk_notin
|
||||
-- insert the target key above the head
|
||||
let db_b : DB := db_a.insert k hk_notin_a
|
||||
have hb_keys : db_b.keys = res.keys.reverse ++ [k] := by
|
||||
rw [DB.insert_keys]
|
||||
exact orderedInsert_append_of_forall_lt' (fun x hx => by
|
||||
have hx' : x ∈ res.keys := by
|
||||
have hx'' : x ∈ res.keys.reverse := by simpa [db_a] using hx
|
||||
exact List.mem_reverse.mp hx''
|
||||
exact lt_of_le_of_lt (hHge x hx') hkH)
|
||||
have hcnt_b : cnt db_b r.begin.key ≤ reportedBelowBegin r res + 1 := by
|
||||
unfold cnt reportedBelowBegin
|
||||
rw [hb_keys, List.countP_append]
|
||||
have h1 : res.keys.reverse.countP
|
||||
(fun x => decide (((x : Key) : WithTop Key) < r.begin.key)) =
|
||||
res.keys.countP (fun x => decide (((x : Key) : WithTop Key) < r.begin.key)) :=
|
||||
List.countP_reverse
|
||||
rw [h1]
|
||||
have h2 : ([k].countP (fun x => decide (((x : Key) : WithTop Key) < r.begin.key))) ≤ 1 := by
|
||||
rw [List.countP_singleton]
|
||||
split <;> omega
|
||||
omega
|
||||
have hanchor_b : r.begin.anchor db_b ≤ ((res.keys.reverse.length : ℕ) : Int) := by
|
||||
change (cnt db_b r.begin.key : Int) + r.begin.offset - 1 ≤ _
|
||||
have h1 : (cnt db_b r.begin.key : Int) ≤ (reportedBelowBegin r res : Int) + 1 := by
|
||||
exact_mod_cast hcnt_b
|
||||
have hlen1 : (1 : Int) ≤ ((res.keys.reverse.length : ℕ) : Int) := by
|
||||
have hp : 0 < res.keys.reverse.length := by
|
||||
rw [List.length_reverse]
|
||||
exact List.length_pos_of_ne_nil hne
|
||||
omega
|
||||
linarith
|
||||
have hrb_b : resolve db_b r.begin ≤ ((k : Key) : WithTop Key) := by
|
||||
have hlenpos : 0 < res.keys.reverse.length := by
|
||||
rw [List.length_reverse]
|
||||
exact List.length_pos_of_ne_nil hne
|
||||
have hkb : res.keys.reverse.length < db_b.keys.length := by
|
||||
rw [hb_keys, List.length_append]; simp
|
||||
have hkget : db_b.keys[res.keys.reverse.length] = k := by
|
||||
have hkget? : db_b.keys[res.keys.reverse.length]? = some k := by
|
||||
rw [hb_keys]
|
||||
simp
|
||||
have h1 := List.getElem?_eq_getElem hkb
|
||||
rw [hkget?] at h1
|
||||
exact (Option.some.inj h1).symm
|
||||
have hclamp : clampIndex db_b r.begin ≤ res.keys.reverse.length := by
|
||||
unfold clampIndex
|
||||
have htoNat : (r.begin.anchor db_b).toNat ≤ res.keys.reverse.length := by
|
||||
by_cases h : 0 ≤ r.begin.anchor db_b
|
||||
· exact (Int.toNat_le).mpr hanchor_b
|
||||
· have hz : (r.begin.anchor db_b).toNat = 0 := by omega
|
||||
rw [hz]; omega
|
||||
exact le_trans (Nat.min_le_left _ _) htoNat
|
||||
have hle := (resolve_le_getElem_iff (db := db_b) (s := r.begin) hkb).mpr hclamp
|
||||
rwa [hkget] at hle
|
||||
have hkb_mem : k ∈ RangeRead.completeKeys db_b r := by
|
||||
rw [RangeRead.mem_completeKeys]
|
||||
have hre_b : resolve db_b r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
exact ⟨DB.mem_insert_self db_a k hk_notin_a, hrb_b, by rw [hre_b]; exact WithTop.coe_lt_top k⟩
|
||||
have hck_pair : (RangeRead.completeKeys db_b r).Pairwise (· > ·) := by
|
||||
have h := RangeRead.completeKeys_pairwise (db := db_b) (r := r)
|
||||
rw [hrev] at h
|
||||
exact h
|
||||
have hhead_max : ∀ x ∈ RangeRead.completeKeys db_b r, x ≤ k := by
|
||||
intro x hx
|
||||
have hxdb := (RangeRead.mem_completeKeys.mp hx).1
|
||||
rw [hb_keys, List.mem_append, List.mem_singleton] at hxdb
|
||||
rcases hxdb with hx' | rfl
|
||||
· have hx'' : x ∈ res.keys := by
|
||||
have hxx : x ∈ res.keys.reverse := by simpa [db_a] using hx'
|
||||
exact List.mem_reverse.mp hxx
|
||||
exact le_of_lt (lt_of_le_of_lt (hHge x hx'') hkH)
|
||||
· exact le_rfl
|
||||
have hhead_eq : (RangeRead.completeKeys db_b r).head (List.ne_nil_of_mem hkb_mem) = k := by
|
||||
apply le_antisymm (hhead_max _ (List.head_mem _))
|
||||
exact (hck_pair.imp le_of_lt).rel_head hkb_mem
|
||||
intro cr hs
|
||||
by_contra hkcr
|
||||
have hagree : AgreeOn cr db_a db_b :=
|
||||
(ConflictRange.keys_insert_of_not_mem cr db_a hk_notin_a hkcr).symm
|
||||
have hcomp_b : RangeRead.Compatible db_b r res := (hs db_a db_b hagree).mp hacompat
|
||||
have hpre := RangeRead.compatible_keys_prefix hcomp_b
|
||||
have hhead := hpre.head hne
|
||||
have hHk : H = k := by
|
||||
rw [hHdef]
|
||||
exact hhead.trans hhead_eq
|
||||
have hHklt : H < k := by
|
||||
rw [hHdef]; exact hkH
|
||||
exact absurd hHk (ne_of_lt hHklt)
|
||||
|
||||
/-- Every key at or above the least reported key is necessary in the reversed
|
||||
negative-begin truncated sentinel-end cell. -/
|
||||
theorem necessary_of_ge_last_of_rev_negTrunc_top {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)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset)
|
||||
{k : Key} (hk : ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key)) :
|
||||
Necessary r res k := by
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
set H : Key := res.keys.head hne with hHdef
|
||||
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 hLk : L ≤ k := WithTop.coe_le_coe.mp hk
|
||||
by_cases hkres : k ∈ res.keys
|
||||
· exact necessary_of_mem_result hread hkres
|
||||
· by_cases hkH : k ≤ H
|
||||
· exact necessary_of_between_result hread hLmem hHmem hLk hkH
|
||||
· exact necessary_above_head_of_rev_negTrunc_top hread hmore hrev hne hbeg hcross
|
||||
hendkey hendoff (by rw [← hHdef]; exact lt_of_not_ge hkH)
|
||||
|
||||
/-- **Minimality of `[last, ⊤)` in the reversed negative-begin truncated sentinel-end
|
||||
cell.** -/
|
||||
theorem minimal_topOfLast_of_rev_negTrunc_top {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)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
|
||||
Minimal r res (topOfLast (res.keys.getLast hne)) := by
|
||||
refine minimal_iff_sound_and_necessary.mpr
|
||||
⟨sound_topOfLast_of_rev_negTrunc_top hmore hrev hne hbeg hcross hendkey hendoff, ?_⟩
|
||||
intro k hk
|
||||
have hk' := ConflictRange.mem_iff.mp hk
|
||||
exact necessary_of_ge_last_of_rev_negTrunc_top hread hmore hrev hne hbeg hcross
|
||||
hendkey hendoff hk'.1
|
||||
|
||||
/-- **Soundness of `[last, ⊤)` when the sentinel end has a nonpositive offset.** The
|
||||
reduced read with begin set to offset one on `last` has the same stored keys at or above
|
||||
`last`, so its already-total nonpositive-end reversed rule transfers soundness. -/
|
||||
theorem sound_topOfLast_of_rev_negTrunc_top_endNonpos {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)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : r.end_.offset ≤ 0) :
|
||||
Sound r res (topOfLast (res.keys.getLast hne)) := by
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
have hLmem : L ∈ res.keys := by rw [hLdef]; exact List.getLast_mem hne
|
||||
let r' : RangeRead :=
|
||||
{ r with begin := { key := ((L : Key) : WithTop Key), offset := 1 } }
|
||||
have hr'_rev : r'.reverse = true := by simp [r', hrev]
|
||||
have hr'_end : r'.end_ = r.end_ := rfl
|
||||
have hr'_beg : r'.begin = ({ key := ((L : Key) : WithTop Key), offset := 1 } : Selector) := rfl
|
||||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||||
have hcomp₀' : RangeRead.Compatible db₀ r' res := by
|
||||
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 hLfilt₀ : L ∈ (RangeRead.completeKeys db₀ r).filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfil₀]; exact hLmem
|
||||
have hrb₀ : resolve db₀ r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
(RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt₀).1).2.1
|
||||
have hLdb₀ : L ∈ db₀.keys := RangeRead.compatible_keys_subset hcomp₀ hLmem
|
||||
have hres'₀ : resolve db₀ r'.begin = ((L : Key) : WithTop Key) := by
|
||||
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb₀
|
||||
have hfeq := completeKeys_filter_ge_eq_of_both_le (db := db₀) (r₁ := r) (r₂ := r')
|
||||
hrev hr'_rev hr'_end hrb₀ (le_of_eq hres'₀)
|
||||
rw [compatible_iff_truncated_keys_rev (db := db₀) hr'_rev hmore hne]
|
||||
exact ⟨by simpa [r', RangeRead.withinLimit] using hcomp₀.1, by rw [← hfeq]; exact hfil₀⟩
|
||||
have hread' : Readable r' res := ⟨db₀, hcomp₀'⟩
|
||||
have hgetLast : res.keys.getLastD ([] : Key) = L := by
|
||||
rw [hLdef, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
|
||||
have hS' : Sound r' res (topOfLast L) := by
|
||||
have hmin' := minimal_truncatedRangeRev_of_end_offset_nonpos (r := r') hread' hmore
|
||||
hr'_rev (by rfl : r'.begin.offset = 1) hendoff
|
||||
rw [hgetLast] at hmin'
|
||||
have hcr : truncatedRangeRev r' L = topOfLast L := by
|
||||
unfold truncatedRangeRev topOfLast
|
||||
rw [hr'_end, hendkey]
|
||||
rw [hcr] at hmin'
|
||||
exact hmin'.sound
|
||||
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
|
||||
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
|
||||
intro db db' hag' hcomp
|
||||
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 hLfilt : L ∈ (RangeRead.completeKeys db r).filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfil]; exact hLmem
|
||||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
(RangeRead.mem_completeKeys.mp (List.mem_filter.mp hLfilt).1).2.1
|
||||
have hLdb : L ∈ db.keys := RangeRead.compatible_keys_subset hcomp hLmem
|
||||
have hLdb' : L ∈ db'.keys := by
|
||||
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
|
||||
db.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
have h := hag'
|
||||
unfold AgreeOn at h
|
||||
rw [topOfLast_keys, topOfLast_keys] at h
|
||||
exact h.symm
|
||||
have hmem : L ∈ db'.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
rw [hfilEq]; exact List.mem_filter.mpr ⟨hLdb, by simp⟩
|
||||
exact (List.mem_filter.mp hmem).1
|
||||
have hres'_db : resolve db r'.begin = ((L : Key) : WithTop Key) := by
|
||||
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb
|
||||
have hres'_db' : resolve db' r'.begin = ((L : Key) : WithTop Key) := by
|
||||
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb'
|
||||
have hfeq_db := completeKeys_filter_ge_eq_of_both_le (db := db) (r₁ := r) (r₂ := r')
|
||||
hrev hr'_rev hr'_end hrb (le_of_eq hres'_db)
|
||||
have hcomp'_db : RangeRead.Compatible db r' res := by
|
||||
rw [compatible_iff_truncated_keys_rev (db := db) hr'_rev hmore hne]
|
||||
exact ⟨by simpa [r', RangeRead.withinLimit] using hcomp.1, by rw [← hfeq_db]; exact hfil⟩
|
||||
have hcomp'_db' : RangeRead.Compatible db' r' res := (hS' db db' hag').mp hcomp'_db
|
||||
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
resolve_begin_le_of_agree_topOfLast hcomp hmore hrev hne hcross hag'
|
||||
have hfil' : (RangeRead.completeKeys db' r').filter (fun k => decide (L ≤ k)) = res.keys :=
|
||||
(compatible_iff_truncated_keys_rev (db := db') hr'_rev hmore hne).mp hcomp'_db' |>.2
|
||||
have hfeq_db' := completeKeys_filter_ge_eq_of_both_le (db := db') (r₁ := r) (r₂ := r')
|
||||
hrev hr'_rev hr'_end hrb' (le_of_eq hres'_db')
|
||||
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
|
||||
exact ⟨by simpa [r', RangeRead.withinLimit] using hcomp'_db'.1, by rw [hfeq_db']; exact hfil'⟩
|
||||
intro db₁ db₂ hagree
|
||||
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
|
||||
|
||||
/-- **Above-head necessity at a sentinel end for any end offset.** The general
|
||||
`necessary_of_end_key_top_rev` already covers both signs of the end offset. -/
|
||||
theorem necessary_of_ge_last_of_rev_negTrunc_top_any {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hrev : r.reverse = true) (hne : res.keys ≠ [])
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key))
|
||||
{k : Key} (hk : ((res.keys.getLast hne : Key) : WithTop Key) ≤ (k : WithTop Key)) :
|
||||
Necessary r res k := by
|
||||
set L : Key := res.keys.getLast hne with hLdef
|
||||
set H : Key := res.keys.head hne with hHdef
|
||||
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 hLk : L ≤ k := WithTop.coe_le_coe.mp hk
|
||||
by_cases hkres : k ∈ res.keys
|
||||
· exact necessary_of_mem_result hread hkres
|
||||
· by_cases hkH : k ≤ H
|
||||
· exact necessary_of_between_result hread hLmem hHmem hLk hkH
|
||||
· exact necessary_of_end_key_top_rev hread hrev hne hendkey
|
||||
(le_of_lt (lt_of_not_ge hkH))
|
||||
|
||||
/-- **Minimality of `[last, ⊤)` at a sentinel end for any end offset.** -/
|
||||
theorem minimal_topOfLast_of_rev_negTrunc_top_any {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)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) :
|
||||
Minimal r res (topOfLast (res.keys.getLast hne)) := by
|
||||
refine minimal_iff_sound_and_necessary.mpr ⟨?_, ?_⟩
|
||||
· rcases lt_or_ge r.end_.offset 1 with hoff | hoff
|
||||
· exact sound_topOfLast_of_rev_negTrunc_top_endNonpos hread hmore hrev hne hcross
|
||||
hendkey (by omega)
|
||||
· exact sound_topOfLast_of_rev_negTrunc_top hmore hrev hne hbeg hcross hendkey hoff
|
||||
· intro k hk
|
||||
exact necessary_of_ge_last_of_rev_negTrunc_top_any hread hrev hne hendkey
|
||||
(ConflictRange.mem_iff.mp hk).1
|
||||
|
||||
/-- **Soundness of `[last, ⊤)` with a sentinel end and no cross hypothesis.** When the
|
||||
begin key lies at or below the reported last, the begin resolution is at or below the
|
||||
last because the begin offset is nonpositive; otherwise the counting argument of
|
||||
`sound_topOfLast_of_rev_negTrunc_top` applies. -/
|
||||
theorem sound_topOfLast_of_rev_negTrunc_top_nocross {r : RangeRead} {res : Result}
|
||||
(hmore : res.more = true) (hrev : r.reverse = true)
|
||||
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
|
||||
Sound r res (topOfLast (res.keys.getLast hne)) := by
|
||||
by_cases hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key
|
||||
· exact sound_topOfLast_of_rev_negTrunc_top hmore hrev hne hbeg hcross hendkey hendoff
|
||||
· set L : Key := res.keys.getLast hne with hLdef
|
||||
have hkeyle : r.begin.key ≤ ((L : Key) : WithTop Key) := le_of_not_gt hcross
|
||||
have step : ∀ db db', AgreeOn (topOfLast L) db db' →
|
||||
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
|
||||
intro db db' hag' hcomp
|
||||
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 hre : resolve db r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
have hre' : resolve db' r.end_ = (⊤ : WithTop Key) :=
|
||||
resolve_end_eq_top_of_key_top hendkey hendoff
|
||||
have hrb : resolve db r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
le_trans (resolve_le_key_of_offset_nonpos (le_of_lt hbeg)) hkeyle
|
||||
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
|
||||
le_trans (resolve_le_key_of_offset_nonpos (le_of_lt hbeg)) hkeyle
|
||||
have hfilEq : db'.keys.filter (fun k => decide (L ≤ k)) =
|
||||
db.keys.filter (fun k => decide (L ≤ k)) := by
|
||||
have h := hag'
|
||||
unfold AgreeOn at h
|
||||
rw [topOfLast_keys, topOfLast_keys] at h
|
||||
exact h.symm
|
||||
have hdb'filt := completeKeys_filter_ge_eq_of_resolve_le (db := db') (r := r)
|
||||
(last := L) hrev hre' hrb'
|
||||
have hdbfilt := completeKeys_filter_ge_eq_of_resolve_le (db := db) (r := r)
|
||||
(last := L) hrev hre hrb
|
||||
refine (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr
|
||||
⟨hcomp.1, ?_⟩
|
||||
rw [hdb'filt, hfilEq, ← hdbfilt, hfil]
|
||||
intro db₁ db₂ hagree
|
||||
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
|
||||
|
||||
/-- **Minimality of `[last, ⊤)` at a sentinel end with no cross hypothesis.** Only the
|
||||
begin key relative to the reported last changes; necessity is independent of it. -/
|
||||
theorem minimal_topOfLast_of_rev_negTrunc_top_nocross {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
||||
(hne : res.keys ≠ []) (hbeg : r.begin.offset < 0)
|
||||
(hendkey : r.end_.key = (⊤ : WithTop Key)) (hendoff : 1 ≤ r.end_.offset) :
|
||||
Minimal r res (topOfLast (res.keys.getLast hne)) := by
|
||||
refine minimal_iff_sound_and_necessary.mpr
|
||||
⟨sound_topOfLast_of_rev_negTrunc_top_nocross hmore hrev hne hbeg hendkey hendoff, ?_⟩
|
||||
intro k hk
|
||||
exact necessary_of_ge_last_of_rev_negTrunc_top_any hread hrev hne hendkey
|
||||
(ConflictRange.mem_iff.mp hk).1
|
||||
|
||||
/-- The reversed, crossed, negative-begin, truncated cell with sentinel end key. -/
|
||||
abbrev negCrossTruncRevTop (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 = (⊤ : WithTop Key)
|
||||
|
||||
/-- The closed form of the reversed negative-begin truncated sentinel-end cell. -/
|
||||
noncomputable def closedFormNegCrossTruncRevTop (_r : RangeRead) (res : Result) :
|
||||
ConflictRange :=
|
||||
topOfLast (res.keys.getLastD ([] : Key))
|
||||
|
||||
/-- **The reversed negative-begin truncated sentinel-end closed form is minimal.** -/
|
||||
theorem minimal_closedForm_of_negCross_trunc_rev_top {r : RangeRead} {res : Result}
|
||||
(hread : Readable r res) (h : negCrossTruncRevTop r res) :
|
||||
Minimal r res (closedFormNegCrossTruncRevTop r res) := by
|
||||
obtain ⟨hmore, hrev, hbeg, hne, hcrossD, hendkey⟩ := 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 closedFormNegCrossTruncRevTop
|
||||
rw [hlast]
|
||||
exact minimal_topOfLast_of_rev_negTrunc_top_any hread hmore hrev hne hbeg hcross hendkey
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user