Files
conflict-range/FormalConflictRange/NegCrossTruncRevBeginTopGeTwo.lean
T

162 lines
8.1 KiB
Lean4
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
import FormalConflictRange.NegCrossTruncRevBeginTop
/-!
# Sentinel-begin reversed truncated cells at end offset at least two
This module extends the sentinel-begin reversed truncated cell
(`r.begin.key = ⊤`) from end offsets at most one to every end offset at least two,
under the extra hypothesis that every reported key lies strictly below `r.end_.key`.
* `reverse = true`, `more = true`, `res.keys ≠ []`, `begin.offset < 0`;
* `begin.key = ⊤`;
* `2 ≤ end_.offset`, with every reported key strictly below `end_.key`.
The minimal range is again `[last reported, ⊤)`, the top range at the reported last key.
Soundness is the sentinel-begin argument with the overshoot: the reported keys are a
prefix of an unbounded window, so agreement on `[last, ⊤)` fixes the stored keys at or
above `last` and keeps the begin resolution at or below it. Necessity is the
offset-agnostic `necessary_of_ge_last_of_negCross_trunc_rev_beginTop`: every key at or
above the reported last is necessary.
-/
namespace FormalConflictRange
/-- **Soundness of the top range at the reported last for a sentinel begin and an
end offset of at least two.** The overshoot hypothesis makes the reduced read's
window unbounded, and the sentinel begin keeps the resolved begin at or below the
reported last under agreement on `[last, ⊤)`. -/
theorem sound_topOfLast_of_negCross_trunc_rev_beginTop_ge_two {r : RangeRead}
{res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hne : res.keys ≠ []) (hend : 2 ≤ r.end_.offset)
(hB : r.begin.key = (⊤ : WithTop Key))
(hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key) :
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 hcross : ((L : Key) : WithTop Key) < r.begin.key := by
rw [hB]; exact WithTop.coe_lt_top L
obtain ⟨db₀, hcomp₀⟩ := hread
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
have hr'_off : r'.begin.offset = 1 := rfl
have hreduce : ∀ (db : DB), RangeRead.Compatible db r res →
RangeRead.Compatible db r' res := by
intro db 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 hres' : resolve db r'.begin = ((L : Key) : WithTop Key) := by
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb
have hLck_filter : (RangeRead.completeKeys db r').filter (fun k => decide (L ≤ k)) =
RangeRead.completeKeys db r' := by
rw [List.filter_eq_self]
intro k hk
rw [decide_eq_true_eq]
have hk' := (RangeRead.mem_completeKeys.mp hk).2.1
exact WithTop.coe_le_coe.mp (by rwa [hres'] at hk')
have hck' : RangeRead.completeKeys db r' = res.keys := by
rw [← hLck_filter]
exact (completeKeys_filter_ge_eq_of_both_le (db := db) (r₁ := r) (r₂ := r')
hrev hr'_rev hr'_end hrb (le_of_eq hres')).symm.trans hfil
refine ⟨by simpa [r', RangeRead.withinLimit] using hcomp.1, Or.inl ⟨hmore, ?_, hne⟩⟩
rw [hck']
have hread' : Readable r' res := ⟨db₀, hreduce db₀ hcomp₀⟩
have hgetLastD : res.keys.getLastD ([] : Key) = L := by
rw [hLdef, List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hmin' : Minimal r' res (topOfLast L) := by
have hm := minimal_topOfLast_of_end_offset_ge_two_rev (r := r') hread' hmore
hr'_rev hr'_off hend (by simpa [r'] using hhi)
rwa [hgetLastD] at hm
have hS' : Sound r' res (topOfLast L) := 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 hcomp' : RangeRead.Compatible db r' res := hreduce db hcomp
have hcomp'' : RangeRead.Compatible db' r' res := (hS' db db' hag').mp hcomp'
have hbound : ((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
-- the agreement, restricted to the stored keys at or above `L`
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 hbetween_eq : between db' ((L : Key) : WithTop Key) r.begin.key =
between db ((L : Key) : WithTop Key) r.begin.key := by
rw [hB]
unfold between
simpa [WithTop.coe_le_coe] using hfilEq
have hbound' : ((between db' ((L : Key) : WithTop Key) r.begin.key).length : Int) +
r.begin.offset - 1 ≤ 0 := by
rw [hbetween_eq]; exact hbound
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
have hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
resolve_begin_le_of_between_bound hLdb' hcross hbound'
have hres'_db' : resolve db' r'.begin = ((L : Key) : WithTop Key) := by
rw [hr'_beg]; exact resolve_offset_one_key_of_mem hLdb'
rw [compatible_iff_truncated_keys_rev (db := db') hrev hmore hne]
refine ⟨by simpa [r', RangeRead.withinLimit] using hcomp''.1, ?_⟩
have h1 := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r) hrev hrb'
have h2' := completeKeys_filter_ge_eq_resolve_end (db := db') (r := r') hr'_rev
(le_of_eq hres'_db')
have h2 := (compatible_iff_truncated_keys_rev (db := db') hr'_rev hmore hne).mp
hcomp'' |>.2
rw [h1, ← h2']
exact h2
intro db₁ db₂ hagree
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
/-- The sentinel-begin reversed truncated cell with end offset at least two and every
reported key below the end key. -/
abbrev negCrossTruncRevBeginTopGeTwo (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = true ∧ r.begin.offset < 0 ∧ res.keys ≠ [] ∧
r.begin.key = (⊤ : WithTop Key) ∧ 2 ≤ r.end_.offset ∧
r.end_.key < (⊤ : WithTop Key) ∧
∀ k ∈ res.keys, ((k : Key) : WithTop Key) < r.end_.key
/-- The closed form of the sentinel-begin reversed truncated overshoot cell:
`[last reported, ⊤)`. -/
noncomputable def closedFormNegCrossTruncRevBeginTopGeTwo (_r : RangeRead)
(res : Result) : ConflictRange :=
topOfLast (res.keys.getLastD ([] : Key))
/-- **The sentinel-begin reversed truncated overshoot closed form is minimal.** -/
theorem minimal_closedForm_of_negCross_trunc_rev_beginTop_ge_two {r : RangeRead}
{res : Result} (hread : Readable r res) (h : negCrossTruncRevBeginTopGeTwo r res) :
Minimal r res (closedFormNegCrossTruncRevBeginTopGeTwo r res) := by
obtain ⟨hmore, hrev, hbeg, hne, hB, hend, _hEtop, hhi⟩ := h
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
unfold closedFormNegCrossTruncRevBeginTopGeTwo
rw [hlast]
refine (minimal_iff_sound_and_necessary).mpr
⟨sound_topOfLast_of_negCross_trunc_rev_beginTop_ge_two hread hmore hrev hne hend hB
hhi, ?_⟩
intro k hk
exact necessary_of_ge_last_of_negCross_trunc_rev_beginTop hread hmore hrev hne hbeg hB
(k := k) (ConflictRange.mem_iff.mp hk).1
end FormalConflictRange