Files
conflict-range/FormalConflictRange/CrossedRev.lean
T

1480 lines
70 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.CrossedTruncated
/-!
# Crossed reversed truncated reads at begin offset one
This module closes the last cell of the offset-one closed form: a truncated result
whose traversal is reversed and whose selector keys are crossed, `end_.key <
begin_.key`.
Because the traversal is reversed, the reported keys are the largest keys of the
complete window. Writing `E = end_.key`, `B = begin_.key`, `e = (end_.offset -
1).toNat`, and `t = res.keys.length`, all reported keys lie at or above `B > E`, so
`t` is also the number of reported keys at or above `E`. The complete window,
relative to the stored keys at or above `E`, is the block obtained by dropping the
gap `[E, B)` and taking the first `e` keys.
A compatible result is a prefix of the reversed window. Compatibility forces the
gap to be empty when `t = e`; then the window is exactly the reported keys and the
minimal range is `[E, keyAfter (head reported))`. When `t < e` the resolved end
outruns the reported block, and the minimal range is the unbounded `[E, ⊤)`.
-/
open FormalConflictRange
namespace FormalConflictRange
theorem completeKeys_rev_eq_reverse (db : DB) (r : RangeRead) (hrev : r.reverse = true) :
RangeRead.completeKeys db r =
(RangeRead.completeKeys db { r with reverse := false }).reverse := by
simp [RangeRead.completeKeys, hrev]
/-- A compatible crossed reversed result has all reported keys at or above `end_.key`. -/
theorem crossed_rev_res_ge_end {db : DB} {r : RangeRead} {res : Result}
(hc : RangeRead.Compatible db r res)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
∀ k ∈ res.keys, r.end_.key ≤ (k : WithTop Key) := by
intro k hk
have hmem := (RangeRead.compatible_keys_prefix hc).subset hk
rw [completeKeys_rev_eq_reverse db r hrev] at hmem
have hmem' := List.mem_reverse.mp hmem
rw [completeKeys_eq_filter_take_of_offset_one (db := db)
(r := { r with reverse := false }) (by simp) hbegin hend] at hmem'
have hfil := List.mem_of_mem_take hmem'
have hge := (List.mem_filter.mp hfil).2
rw [decide_eq_true_eq] at hge
exact le_trans (le_of_lt hcross) hge
theorem crossed_rev_count_ge_eq_length {r : RangeRead} {res : Result}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hread : Readable r res) :
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
res.keys.length := by
obtain ⟨db, hc⟩ := hread
rw [List.countP_eq_length]
intro k hk
rw [decide_eq_true_eq]
exact crossed_rev_res_ge_end hc hrev hbegin hcross hend k hk
/-- The keys at or above `B` are the keys at or above `E` with the gap `[E, B)` dropped. -/
theorem above_eq_drop_between {db : DB} {E B : WithTop Key} (hEB : E ≤ B) :
above db B = (above db E).drop (between db E B).length := by
rw [above_B_eq_filter hEB, between_eq_filter_above]
have hs : (above db E).SortedLT :=
List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
have hL : (above db E).filter (fun k : Key => decide (B ≤ (k : WithTop Key))) =
(above db E).filter (fun k : Key => decide (¬ ((k : WithTop Key) < B))) := by
apply List.filter_congr
intro k _
rw [decide_eq_decide]
exact not_lt.symm
rw [hL, filter_not_lt_eq_drop_countP hs B, List.countP_eq_length_filter]
private theorem take_sub_drop {α : Type*} (l : List α) (e g : Nat) :
(l.drop g).take (min e l.length - g) = (l.take e).drop g := by
rw [List.drop_take, List.take_eq_take_iff]
simp only [List.length_drop]
omega
/-- The complete keys of a crossed reversed read are the reversed block of the
keys at or above `end_.key` from which the gap is dropped. -/
theorem completeKeys_crossed_rev_eq {db : DB} {r : RangeRead}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
RangeRead.completeKeys db r =
(((above db r.end_.key).take ((r.end_.offset - 1).toNat)).drop
(between db r.end_.key r.begin.key).length).reverse := by
set E : WithTop Key := r.end_.key with hE
set B : WithTop Key := r.begin.key with hB
set e : Nat := (r.end_.offset - 1).toNat with he
have hEB : E ≤ B := le_of_lt hcross
have hfwd : RangeRead.completeKeys db r =
((above db B).take (min (cnt db E + e) db.keys.length - cnt db B)).reverse := by
rw [completeKeys_rev_eq_reverse db r hrev]
rw [completeKeys_eq_filter_take_of_offset_one (db := db)
(r := { r with reverse := false }) (by simp) hbegin hend]
have hfilB : db.keys.filter (fun k : Key =>
decide (({ r with reverse := false } : RangeRead).begin.key ≤
(k : WithTop Key))) = above db B := rfl
rw [hfilB]
rfl
have hcalc : min (cnt db E + e) db.keys.length - cnt db B =
min e (above db E).length - (between db E B).length := by
rw [← cnt_add_above_length db E, cnt_eq_add_between db hEB,
Nat.add_min_add_left, Nat.add_sub_add_left]
rw [hfwd, hcalc, above_eq_drop_between hEB, take_sub_drop]
/-- Agreement on the keys at or above `end_.key` fixes the complete keys of a
crossed reversed read. -/
theorem completeKeys_eq_of_agree_above_crossed_rev {db₁ db₂ : DB} {r : RangeRead}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(habove : above db₁ r.end_.key = above db₂ r.end_.key) :
RangeRead.completeKeys db₁ r = RangeRead.completeKeys db₂ r := by
set E : WithTop Key := r.end_.key with hE
set B : WithTop Key := r.begin.key with hB
set e : Nat := (r.end_.offset - 1).toNat with he
have hEB : E ≤ B := le_of_lt hcross
have hfwd (db : DB) :
RangeRead.completeKeys db r =
((above db B).take
(min (cnt db E + e) db.keys.length - cnt db B)).reverse := by
rw [completeKeys_rev_eq_reverse db r hrev]
rw [completeKeys_eq_filter_take_of_offset_one (db := db)
(r := { r with reverse := false }) (by simp) hbegin hend]
have hfilB : db.keys.filter (fun k : Key =>
decide (({ r with reverse := false } : RangeRead).begin.key ≤
(k : WithTop Key))) = above db B := rfl
rw [hfilB]
rfl
have hU : above db₁ E = above db₂ E := habove
have hB_eq : above db₁ B = above db₂ B := by
rw [above_B_eq_filter (db := db₁) hEB, above_B_eq_filter (db := db₂) hEB, hU]
have hg_eq : (between db₁ E B).length = (between db₂ E B).length := by
rw [between_eq_filter_above (db := db₁) E B,
between_eq_filter_above (db := db₂) E B, hU]
have hUlen : (above db₁ E).length = (above db₂ E).length := by rw [hU]
have hcalc (db : DB) :
min (cnt db E + e) db.keys.length - cnt db B =
min e (above db E).length - (between db E B).length := by
rw [← cnt_add_above_length db E, cnt_eq_add_between db hEB,
Nat.add_min_add_left, Nat.add_sub_add_left]
have hlen_eq :
min (cnt db₁ E + e) db₁.keys.length - cnt db₁ B =
min (cnt db₂ E + e) db₂.keys.length - cnt db₂ B := by
rw [hcalc db₁, hcalc db₂, hUlen, hg_eq]
rw [hfwd db₁, hfwd db₂, hB_eq, hlen_eq]
/-- The stored keys of `[lo, keyAfter last)` are the keys at or above `lo` that are
at most `last`. -/
private theorem keys_lo_keyAfter_eq_filter_le {db : DB} {lo : WithTop Key} {last : Key} :
(⟨lo, (keyAfter last : Key)⟩ : ConflictRange).keys db =
(db.keys.filter (fun k : Key => decide (lo ≤ (k : WithTop Key)))).filter
(fun k : Key => decide (k ≤ last)) := by
unfold ConflictRange.keys
rw [show db.keys.filter (fun (k : Key) => decide (lo ≤ (k : WithTop Key) ∧
(k : WithTop Key) < ((keyAfter last : Key) : WithTop Key))) =
db.keys.filter (fun (k : Key) =>
decide ((k : WithTop Key) < ((keyAfter last : Key) : WithTop Key)) &&
decide (lo ≤ (k : WithTop Key))) from
List.filter_congr fun k _ => by rw [Bool.decide_and, Bool.and_comm]]
rw [← List.filter_filter]
apply List.filter_congr
intro k _
rw [decide_eq_decide, WithTop.coe_lt_coe, lt_keyAfter_iff]
/-- In the finite branch the candidate range contains exactly the reported keys,
reversed. -/
theorem crossed_rev_finite_keys_eq {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (_hmore : res.more = true)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ [])
(ht : res.keys.length = (r.end_.offset - 1).toNat) :
(⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ : ConflictRange).keys db =
res.keys.reverse := by
set E : WithTop Key := r.end_.key with hE
set B : WithTop Key := r.begin.key with hB
set e : Nat := (r.end_.offset - 1).toNat with he
set lE : List Key := above db E with hlE
set g : Nat := (between db E B).length with hg
have hEB : E ≤ B := le_of_lt hcross
have hformula : RangeRead.completeKeys db r = ((lE.take e).drop g).reverse := by
simpa [E, B, e, lE, g] using
completeKeys_crossed_rev_eq (db := db) (r := r) hrev hbegin hcross hend
have hpre : res.keys <+: RangeRead.completeKeys db r :=
RangeRead.compatible_keys_prefix hcomp
have hlen_ck : (RangeRead.completeKeys db r).length = min e lE.length - g := by
rw [hformula, List.length_reverse, List.length_drop, List.length_take]
have hepos : 0 < e := by
have h := List.length_pos_of_ne_nil hne
omega
have htle : e ≤ min e lE.length - g := by
have h := hpre.length_le
rw [hlen_ck, ht] at h
exact h
have hg0 : g = 0 := by omega
have hmin : min e lE.length = e := by omega
have hckeq : RangeRead.completeKeys db r = (lE.take e).reverse := by
rw [hformula, hg0, List.drop_zero]
have hlenck_e : (RangeRead.completeKeys db r).length = e := by
rw [hckeq, List.length_reverse, List.length_take, hmin]
have hreseq : res.keys = (lE.take e).reverse := by
have h := hpre.eq_of_length (by rw [ht, hlenck_e])
rw [h] at *
exact hckeq
have htake_ne : lE.take e ≠ [] := by
intro hnil
rw [hnil, List.reverse_nil] at hreseq
exact hne hreseq
have hH : res.keys.head hne = (lE.take e).getLast htake_ne := by
apply (List.head_eq_iff_head?_eq_some hne).mpr
rw [hreseq, List.head?_reverse]
exact List.getLast?_eq_getLast_of_ne_nil htake_ne
have hsE : lE.SortedLT := by
rw [hlE]
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
have htake_sorted : (lE.take e).SortedLT :=
List.sortedLT_iff_pairwise.mpr
(List.Pairwise.take (i := e) (List.sortedLT_iff_pairwise.mp hsE))
have hle_take : ∀ x ∈ lE.take e, x ≤ (lE.take e).getLast htake_ne :=
fun x hx => (htake_sorted.pairwise.imp le_of_lt).rel_getLast hx
have hsplit : lE = lE.take e ++ lE.drop e := (List.take_append_drop e lE).symm
have hcross_lt : ∀ x ∈ lE.take e, ∀ y ∈ lE.drop e, x < y := by
have hs' : (lE.take e ++ lE.drop e).SortedLT := by rw [← hsplit]; exact hsE
exact (List.sortedLT_append.mp hs').2.2
have hfil_take : (lE.take e).filter (fun k : Key => decide (k ≤ res.keys.head hne)) =
lE.take e := by
rw [List.filter_eq_self]
intro x hx
rw [hH]
exact decide_eq_true (hle_take x hx)
have hfil_drop : (lE.drop e).filter (fun k : Key => decide (k ≤ res.keys.head hne)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [hH, decide_eq_true_eq]
exact not_le.mpr (hcross_lt _ (List.getLast_mem htake_ne) x hx)
rw [keys_lo_keyAfter_eq_filter_le]
change lE.filter (fun k : Key => decide (k ≤ res.keys.head hne)) = res.keys.reverse
conv_lhs => rw [hsplit]
rw [List.filter_append, hfil_take, hfil_drop, List.append_nil]
rw [hreseq, List.reverse_reverse]
/-- A compatible crossed reversed result has all reported keys at or above `begin.key`. -/
theorem crossed_rev_res_ge_begin {db : DB} {r : RangeRead} {res : Result}
(hc : RangeRead.Compatible db r res) (hbegin : r.begin.offset = 1) :
∀ k ∈ res.keys, r.begin.key ≤ (k : WithTop Key) := by
intro k hk
have hmem := (RangeRead.compatible_keys_prefix hc).subset hk
exact le_trans (key_le_resolve_of_one_le (db := db) (s := r.begin) (by omega))
(RangeRead.mem_completeKeys.mp hmem).2.1
/-- If the range `[E, keyAfter H)` contains exactly the reported keys reversed, then
the first `e` keys at or above `E` are those reported keys and the gap `[E, B)` is
empty. -/
theorem take_above_eq_of_range_keys_eq {db : DB} {r : RangeRead} {res : Result}
(_hrev : r.reverse = true) (_hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (_hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ [])
(ht : res.keys.length = (r.end_.offset - 1).toNat)
(hBR : ∀ k ∈ res.keys, r.begin.key ≤ (k : WithTop Key))
(hR : (⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ :
ConflictRange).keys db = res.keys.reverse) :
(above db r.end_.key).take ((r.end_.offset - 1).toNat) = res.keys.reverse ∧
between db r.end_.key r.begin.key = [] := by
set E : WithTop Key := r.end_.key with hE
set B : WithTop Key := r.begin.key with hB
set e : Nat := (r.end_.offset - 1).toNat with he
set H : Key := res.keys.head hne with hHdef
set lE : List Key := above db E with hlE
have hEB : E ≤ B := le_of_lt hcross
have hsE : lE.SortedLT := by
rw [hlE]
exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
have hRfil : lE.filter (fun k : Key => decide (k ≤ H)) = res.keys.reverse := by
have h := hR
rw [keys_lo_keyAfter_eq_filter_le] at h
simpa only [lE, above] using h
have htake_c : lE.take (lE.countP (fun k : Key => decide (k ≤ H))) = res.keys.reverse := by
rw [← filter_le_eq_take_countP hsE H, hRfil]
have hc_le : lE.countP (fun k : Key => decide (k ≤ H)) ≤ lE.length :=
List.countP_le_length
have hc_eq : lE.countP (fun k : Key => decide (k ≤ H)) = e := by
have hlen := congrArg List.length htake_c
rw [List.length_take, List.length_reverse, ht] at hlen
omega
have htakeE : lE.take e = res.keys.reverse := by
rw [← hc_eq]
exact htake_c
have hbnil : between db E B = [] := by
rw [between_eq_filter_above]
change lE.filter (fun k : Key => decide ((k : WithTop Key) < B)) = []
have hsplit : lE = res.keys.reverse ++ lE.drop e := by
rw [← htakeE]
exact (List.take_append_drop e lE).symm
rw [hsplit]
have hRnil : res.keys.reverse.filter
(fun k : Key => decide ((k : WithTop Key) < B)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_lt.mpr (hBR x (List.mem_reverse.mp hx))
have htailnil : (lE.drop e).filter
(fun k : Key => decide ((k : WithTop Key) < B)) = [] := by
rw [List.filter_eq_nil_iff]
intro y hy
rw [decide_eq_true_eq]
have hs' : (res.keys.reverse ++ lE.drop e).SortedLT := by
rw [← hsplit]; exact hsE
have hcross := (List.sortedLT_append.mp hs').2.2
have hrevne : res.keys.reverse ≠ [] := by
rwa [List.reverse_ne_nil_iff]
obtain ⟨x, hx⟩ := List.exists_mem_of_ne_nil _ hrevne
exact not_lt.mpr (le_of_lt (lt_of_le_of_lt (hBR x (List.mem_reverse.mp hx))
(WithTop.coe_lt_coe.mpr (hcross x hx y hy))))
rw [List.filter_append, hRnil, htailnil]
rfl
refine ⟨by simpa [E, e, lE] using htakeE, by simpa [E, B] using hbnil⟩
/-- If the finite candidate range contains exactly the reported keys reversed, then the
complete keys are exactly the reported keys. -/
theorem completeKeys_eq_of_range_keys_eq_crossed_rev {db : DB} {r : RangeRead}
{res : Result}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ [])
(ht : res.keys.length = (r.end_.offset - 1).toNat)
(hBR : ∀ k ∈ res.keys, r.begin.key ≤ (k : WithTop Key))
(hR : (⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ :
ConflictRange).keys db = res.keys.reverse) :
RangeRead.completeKeys db r = res.keys := by
obtain ⟨htake, hbnil⟩ := take_above_eq_of_range_keys_eq hrev hbegin hcross hend hne ht hBR hR
rw [completeKeys_crossed_rev_eq (db := db) (r := r) hrev hbegin hcross hend]
rw [htake, hbnil]
simp
/-- Soundness of the finite crossed reversed branch. -/
theorem sound_truncatedRevCrossed_finite {r : RangeRead} {res : Result}
(hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ [])
(ht : res.keys.length = (r.end_.offset - 1).toNat) :
Sound r res ⟨r.end_.key, (keyAfter (res.keys.headD ([] : Key)) : WithTop Key)⟩ := by
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
rw [hhead]
intro db₁ db₂ hagree
have hBR₁ := crossed_rev_res_ge_begin (db := db₁) (r := r) (res := res)
have hBR₂ := crossed_rev_res_ge_begin (db := db₂) (r := r) (res := res)
constructor
· intro hc₁
have hBR := hBR₁ hc₁ hbegin
have hT₁ := crossed_rev_finite_keys_eq (db := db₁) hc₁ hmore hrev hbegin hcross
hend hne ht
have hT₂ : (⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ :
ConflictRange).keys db₂ = res.keys.reverse := by
rw [← hagree]; exact hT₁
have hck := completeKeys_eq_of_range_keys_eq_crossed_rev hrev hbegin hcross hend
hne ht hBR hT₂
exact ⟨hc₁.1, Or.inl ⟨hmore, by rw [hck], hne⟩⟩
· intro hc₂
have hBR := hBR₂ hc₂ hbegin
have hT₂ := crossed_rev_finite_keys_eq (db := db₂) hc₂ hmore hrev hbegin hcross
hend hne ht
have hT₁ : (⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ :
ConflictRange).keys db₁ = res.keys.reverse := by
rw [hagree]; exact hT₂
have hck := completeKeys_eq_of_range_keys_eq_crossed_rev hrev hbegin hcross hend
hne ht hBR hT₁
exact ⟨hc₂.1, Or.inl ⟨hmore, by rw [hck], hne⟩⟩
/-- Soundness of the top crossed reversed branch: agreement on `[end_.key, ⊤)` fixes
the complete keys. -/
theorem sound_truncatedRevCrossed_top {r : RangeRead} {res : Result}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
Sound r res ⟨r.end_.key, ⊤⟩ := by
intro db₁ db₂ hagree
have habove : above db₁ r.end_.key = above db₂ r.end_.key := by
have h := hagree
rw [AgreeOn] at h
simpa [ConflictRange.keys, above] using h
have hck := completeKeys_eq_of_agree_above_crossed_rev (db₁ := db₁) (db₂ := db₂)
hrev hbegin hcross hend habove
constructor
· intro hc
simpa [RangeRead.Compatible, hck] using hc
· intro hc
simpa [RangeRead.Compatible, hck] using hc
/-- In the finite reversed-truncated branch, inserting an unstored key `k` with
`end_.key ≤ k < last reported` makes the end selector resolve onto the reported head.
The head then leaves the complete keys, so the truncated result can no longer be
compatible. -/
theorem crossed_rev_insert_between_incompatible {db : DB} {r : RangeRead} {res : Result}
{k : Key}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
(hne : res.keys ≠ [])
(ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat)
(hk0 : k ∉ db.keys)
(hEk : r.end_.key ≤ (k : WithTop Key))
(hkL : (k : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) :
¬ RangeRead.Compatible (db.insert k hk0) r res := by
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
let L : Key := res.keys.getLast hne
let H : Key := res.keys.head hne
let E : WithTop Key := r.end_.key
let e : Nat := (r.end_.offset - 1).toNat
let P : Key → Bool := fun k => decide (E ≤ (k : WithTop Key) ∧
(k : WithTop Key) ≤ ((H : Key) : WithTop Key))
let Q : Key → Bool := fun k => decide (E ≤ (k : WithTop Key))
let BT : Key → Bool := fun k => decide (E ≤ (k : WithTop Key) ∧
(k : WithTop Key) < ((keyAfter H : Key) : WithTop Key))
have htlen : res.keys.length = (r.end_.offset - 1).toNat := by
have hcount := crossed_rev_count_ge_eq_length (r := r) (res := res) hrev hbegin
hcross (by omega) ⟨db, hcomp⟩
rw [← hcount]
exact ht
have hT : (⟨r.end_.key, (keyAfter (res.keys.head hne) : WithTop Key)⟩ :
ConflictRange).keys db = res.keys.reverse :=
crossed_rev_finite_keys_eq (db := db) hcomp hmore hrev hbegin hcross (by omega) hne htlen
have hT' : db.keys.filter BT = res.keys.reverse := by
simpa only [BT, L, H, E, ConflictRange.keys] using hT
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
have hLH : L ≤ H := by
dsimp only [L, H]
exact (hsort.pairwise.imp le_of_lt).rel_head (List.getLast_mem hne)
have hepos : 0 < e := by dsimp only [e]; omega
-- `H ≥ E`, from a reported key at or above `E`.
have htpos : 0 < res.keys.countP Q := by
dsimp only [Q]
rw [ht]
exact hepos
obtain ⟨k₀, hk₀mem, hk₀Q⟩ := List.countP_pos_iff.mp htpos
have hk₀E : E ≤ (k₀ : WithTop Key) := by
dsimp only [Q] at hk₀Q
exact of_decide_eq_true hk₀Q
have hk₀H : k₀ ≤ H := by
dsimp only [H]
exact (hsort.pairwise.imp le_of_lt).rel_head hk₀mem
have hHE : E ≤ ((H : Key) : WithTop Key) := le_trans hk₀E (WithTop.coe_le_coe.mpr hk₀H)
have hHmemC : H ∈ res.keys.reverse := by
dsimp only [H]
exact List.mem_reverse.mpr (List.head_mem hne)
have hHdb : H ∈ db.keys := by
have h := hHmemC
rw [← hT'] at h
exact List.mem_of_mem_filter h
-- The number of stored keys in `[E, H]` is `e`.
have hcountEH : db.keys.countP P = e := by
have h1 : db.keys.countP P = db.keys.countP (fun k => Q k && BT k) := by
apply List.countP_congr
intro k hk
dsimp only [P, Q, BT]
simp only [decide_eq_true_eq, Bool.and_eq_true]
constructor
· rintro ⟨hEk, hkH⟩
refine ⟨hEk, hEk, ?_⟩
exact WithTop.coe_lt_coe.mpr ((lt_keyAfter_iff k H).mpr (WithTop.coe_le_coe.mp hkH))
· rintro ⟨hEk, -, hkH⟩
exact ⟨hEk, WithTop.coe_le_coe.mpr
((lt_keyAfter_iff k H).mp (WithTop.coe_lt_coe.mp hkH))⟩
have h2 : db.keys.countP (fun k => Q k && BT k) = e := by
rw [← List.countP_filter]
rw [hT', List.Perm.countP_eq _ (List.reverse_perm res.keys)]
dsimp only [Q, e]
exact ht
rw [h1, h2]
-- Split at `E` and `H` to compute the index of `H`.
have hEne : E ≠ (⊤ : WithTop Key) := by
intro htop
rw [htop] at hHE
exact absurd hHE (not_le.mpr (WithTop.coe_lt_top H))
obtain ⟨v, hv⟩ := WithTop.ne_top_iff_exists.mp hEne
have hvH : v ≤ H := by
rw [← hv] at hHE
exact WithTop.coe_le_coe.mp hHE
have hcountP_split : db.keys.countP P =
(db.keys.filter (fun k => decide (v ≤ k ∧ k < H))).length + 1 := by
rw [List.countP_eq_length_filter]
have hlist : db.keys.filter P =
(db.keys.filter (fun k => decide (v ≤ k ∧ k < H))) ++ [H] := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
· apply List.sortedLT_append.mpr
refine ⟨List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _),
sortedLT_singleton H, ?_⟩
intro a ha b hb
rw [List.mem_singleton] at hb
subst hb
exact (of_decide_eq_true (List.mem_filter.mp ha).2).2
· intro x
dsimp only [P]
rw [← hv]
simp only [List.mem_filter, List.mem_append, List.mem_singleton,
decide_eq_true_eq, WithTop.coe_le_coe]
constructor
· rintro ⟨hx, hvx, hxH⟩
by_cases hxH' : x = H
· exact Or.inr hxH'
· exact Or.inl ⟨hx, hvx, lt_of_le_of_ne hxH hxH'⟩
· rintro (⟨hx, hvx, hxH⟩ | rfl)
· exact ⟨hx, hvx, le_of_lt hxH⟩
· exact ⟨hHdb, hvH, le_refl H⟩
rw [hlist, List.length_append, List.length_singleton]
have hfilter_len : (db.keys.filter (fun k => decide (v ≤ k ∧ k < H))).length = e - 1 := by
omega
have hsplit := countP_lt_eq_add_filter db.keys db.nodup hvH
have hcE : db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) =
db.keys.countP (fun k : Key => decide (k < v)) := by
rw [← hv]
exact countP_lt_coe v
have hcH : db.keys.countP (fun k : Key => decide (k < H)) =
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e - 1 := by
have h := hsplit
rw [← hcE, hfilter_len] at h
omega
obtain ⟨j, hjlt, hj⟩ := List.mem_iff_getElem.mp hHdb
have hcj : db.keys.countP (fun k : Key => decide (k < H)) = j :=
countP_lt_eq_of_getElem db.sorted hjlt hj
have hj_eq : j = db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e - 1 := by
rw [← hcj]
exact hcH
have hEanchor : (r.end_.anchor db).toNat =
db.keys.countP (fun k : Key => decide ((k : WithTop Key) < E)) + e := by
rw [anchor_toNat_eq (s := r.end_) (by omega)]
-- Inserting `k` at or above `E` does not change the count below `E`, so the
-- anchor still targets the successor of `H`; the new key lies below `H`, which
-- shifts `H` into that target index.
have hinskeys : (db.insert k hk0).keys =
db.keys.insertIdx (db.keys.countP (fun x => decide (x < k))) k := by
rw [DB.insert_keys, orderedInsert_eq_insertIdx db.sorted hk0]
have hcountnew : (db.insert k hk0).keys.countP
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) =
db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) := by
rw [hinskeys]
exact countP_insertIdx _ _ _ (by
rw [decide_eq_false_iff_not]
exact not_lt.mpr hEk)
have hanchornew : (r.end_.anchor (db.insert k hk0)).toNat =
db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e := by
rw [anchor_toNat_eq (s := r.end_) (by omega), hcountnew]
have hJeq : (r.end_.anchor (db.insert k hk0)).toNat = j + 1 := by
rw [hanchornew]
have hb : db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e =
(db.keys.countP (fun x : Key => decide ((x : WithTop Key) < r.end_.key)) + e - 1) + 1 := by
omega
rw [hb, ← hj_eq]
have hpj : db.keys.countP (fun x : Key => decide (x < k)) ≤ j := by
rw [← hcj]
apply countP_le_countP_of_imp
intro x hx hlt
rw [decide_eq_true_eq] at hlt ⊢
have hkH : k < H := lt_of_lt_of_le (WithTop.coe_lt_coe.mp hkL) hLH
exact lt_trans hlt hkH
have hnewlen : (r.end_.anchor (db.insert k hk0)).toNat <
(db.insert k hk0).keys.length := by
rw [hinskeys, hJeq, List.length_insertIdx_of_le_length List.countP_le_length]
omega
have hnewget? : (db.insert k hk0).keys[(r.end_.anchor (db.insert k hk0)).toNat]? =
some H := by
rw [hinskeys, hJeq, List.getElem?_insertIdx]
have hlt : ¬ j + 1 < db.keys.countP (fun x => decide (x < k)) := by omega
have heq : ¬ j + 1 = db.keys.countP (fun x => decide (x < k)) := by omega
rw [ite_eq_right hlt, ite_eq_right heq, Nat.add_sub_cancel, List.getElem?_eq_getElem hjlt, hj]
obtain ⟨_, hnewget⟩ := List.getElem?_eq_some_iff.mp hnewget?
have hHresolve : resolve (db.insert k hk0) r.end_ = ((H : Key) : WithTop Key) := by
rw [resolve_eq_getElem (anchor_nonneg_of_one_le (by omega)) hnewlen]
exact congrArg (fun x : Key => (x : WithTop Key)) hnewget
intro hcompNew
have hpre := RangeRead.compatible_keys_prefix hcompNew
have hHmem : H ∈ res.keys := by
dsimp only [H]
exact List.head_mem hne
have hHcomp : H ∈ RangeRead.completeKeys (db.insert k hk0) r := hpre.subset hHmem
have hlt := (RangeRead.mem_completeKeys.mp hHcomp).2.2
rw [hHresolve] at hlt
exact (lt_irrefl ((H : Key) : WithTop Key)) hlt
/-- In the finite crossed reversed branch no compatible database stores a key in
`[end_.key, last reported)`: the candidate range `[end_.key, keyAfter head)` contains
exactly the reported keys reversed, so any stored key below the reported last would be
one of those reported keys. -/
theorem crossed_rev_no_key_between {db : DB} {r : RangeRead} {res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 2 ≤ r.end_.offset)
(hne : res.keys ≠ [])
(ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat)
{k : Key} (hkdb : k ∈ db.keys)
(hEk : r.end_.key ≤ (k : WithTop Key))
(hkL : k < res.keys.getLast hne) : False := by
have hsort : res.keys.SortedGT := RangeRead.compatible_sortedGT hcomp hrev
have hLle : ∀ x ∈ res.keys, res.keys.getLast hne ≤ x :=
fun x hx => (hsort.pairwise.imp le_of_lt).rel_getLast hx
have hLH : res.keys.getLast hne ≤ res.keys.head hne :=
hLle _ (List.head_mem hne)
have hkH : k < res.keys.head hne := lt_of_lt_of_le hkL hLH
have hklt : (k : WithTop Key) <
((keyAfter (res.keys.head hne) : Key) : WithTop Key) :=
WithTop.coe_lt_coe.mpr (lt_trans hkH (keyAfter_self_lt _))
have htlen : res.keys.length = (r.end_.offset - 1).toNat := by
have hcount := crossed_rev_count_ge_eq_length (r := r) (res := res) hrev hbegin
hcross (by omega) ⟨db, hcomp⟩
rw [← hcount]
exact ht
have hT := crossed_rev_finite_keys_eq (db := db) hcomp hmore hrev hbegin hcross (by omega) hne
htlen
have hmem : k ∈ (⟨r.end_.key,
(keyAfter (res.keys.head hne) : WithTop Key)⟩ : ConflictRange).keys db := by
rw [ConflictRange.mem_keys_iff]
exact ⟨hkdb, hEk, hklt⟩
rw [hT] at hmem
have hkres : k ∈ res.keys := List.mem_reverse.mp hmem
exact absurd (hLle k hkres) (not_le.mpr hkL)
/-- In the finite crossed reversed branch, every key in `[end_.key, last reported)` is
necessary. -/
theorem necessary_finite_below_last_crossed_rev {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ [])
(ht : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat)
{k : Key} (hEk : r.end_.key ≤ (k : WithTop Key))
(hkL : ((k : Key) : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key)) :
Necessary r res k := by
obtain ⟨db₀, hcomp₀⟩ := hread
intro cr hs
by_contra hkcr
have hk0 : k ∉ db₀.keys := by
intro hkdb
exact crossed_rev_no_key_between (db := db₀) hcomp₀ hmore hrev hbegin hcross
hend hne ht hkdb hEk (WithTop.coe_lt_coe.mp hkL)
have hagree : AgreeOn cr db₀ (db₀.insert k hk0) :=
(ConflictRange.keys_insert_of_not_mem cr db₀ hk0 hkcr).symm
have hcompNew : RangeRead.Compatible (db₀.insert k hk0) r res :=
(hs db₀ _ hagree).mp hcomp₀
exact crossed_rev_insert_between_incompatible (db := db₀) hcomp₀ hmore hrev hbegin
hcross hend hne ht hk0 hEk hkL hcompNew
/-- Length partition of `above E` at `L`. -/
theorem length_above_eq_between_add_above {db : DB} {E L : WithTop Key}
(hEL : E ≤ L) :
(above db E).length = (between db E L).length + (above db L).length := by
have h1 := cnt_eq_add_between db hEL
have h2 := cnt_add_above_length db E
have h3 := cnt_add_above_length db L
omega
/-- Under the room condition, the complete crossed reversed window is all keys at or
above `begin.key`, reversed. -/
theorem completeKeys_eq_above_begin_rev_of_room {db : DB} {r : RangeRead}
{res : Result} {L : Key}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hBL : r.begin.key ≤ (L : WithTop Key))
(habove : above db (L : WithTop Key) = res.keys.reverse)
(hroom : (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key)))).length + res.keys.length <
(r.end_.offset - 1).toNat) :
RangeRead.completeKeys db r = (above db r.begin.key).reverse := by
set E : WithTop Key := r.end_.key with hE
set B : WithTop Key := r.begin.key with hB
set e : Nat := (r.end_.offset - 1).toNat with he
have hEB : E ≤ B := le_of_lt hcross
have hEL : E ≤ (L : WithTop Key) := le_trans hEB hBL
have hbet : between db E (L : WithTop Key) =
db.keys.filter (fun k : Key => decide (E ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key))) := rfl
have hlenE : (above db E).length = (between db E (L : WithTop Key)).length +
res.keys.length := by
rw [length_above_eq_between_add_above hEL, habove, List.length_reverse]
have hroom' : (between db E (L : WithTop Key)).length + res.keys.length < e := by
rw [hbet]; exact hroom
have htake : (above db E).take e = above db E := by
rw [List.take_eq_self_iff]
omega
rw [completeKeys_crossed_rev_eq (db := db) (r := r) hrev hbegin hcross hend, htake,
← above_eq_drop_between hEB]
/-- The filter at or above `L` of the complete crossed reversed window is `res`. -/
theorem completeKeys_filter_ge_crossed_rev_of_room {db : DB} {r : RangeRead}
{res : Result} {L : Key}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hBL : r.begin.key ≤ (L : WithTop Key))
(habove : above db (L : WithTop Key) = res.keys.reverse)
(hroom : (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key)))).length + res.keys.length <
(r.end_.offset - 1).toNat) :
(RangeRead.completeKeys db r).filter (fun k : Key => decide (L ≤ k)) = res.keys := by
rw [completeKeys_eq_above_begin_rev_of_room hrev hbegin hcross hend hBL habove hroom,
List.filter_reverse]
have hfilter : (above db r.begin.key).filter (fun k : Key => decide (L ≤ k)) =
above db (L : WithTop Key) := by
rw [above_eq_filter, above_eq_filter, List.filter_filter]
apply List.filter_congr
intro k _
by_cases hL : L ≤ k
· have hB : r.begin.key ≤ (k : WithTop Key) := le_trans hBL (WithTop.coe_le_coe.mpr hL)
simp [hL, hB]
· simp [hL]
rw [hfilter, habove, List.reverse_reverse]
/-- The complete keys of a crossed reversed read as a reversed prefix of the keys at
or above `begin.key`. -/
theorem completeKeys_crossed_rev_eq_take_above_begin {db : DB} {r : RangeRead}
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(_hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset) :
RangeRead.completeKeys db r =
((above db r.begin.key).take
(min (cnt db r.end_.key + (r.end_.offset - 1).toNat) db.keys.length -
cnt db r.begin.key)).reverse := by
set B : WithTop Key := r.begin.key with hB
set E : WithTop Key := r.end_.key with hE
set e : Nat := (r.end_.offset - 1).toNat with he
rw [completeKeys_rev_eq_reverse db r hrev]
rw [completeKeys_eq_filter_take_of_offset_one (db := db)
(r := { r with reverse := false }) (by simp) hbegin hend]
have hfilB : db.keys.filter (fun k : Key =>
decide (({ r with reverse := false } : RangeRead).begin.key ≤
(k : WithTop Key))) = above db B := rfl
rw [hfilB]
rfl
private theorem length_filter_lt_eq_sub {l : List Key} {L : Key} :
(l.filter (fun k : Key => !decide (L ≤ k))).length =
l.length - (l.filter (fun k : Key => decide (L ≤ k))).length := by
have h : (l.filter (fun k : Key => decide (L ≤ k))).length +
(l.filter (fun k : Key => !decide (L ≤ k))).length = l.length := by
have hp := List.filter_append_perm (fun k : Key => decide (L ≤ k)) l
have := hp.length_eq
simpa only [List.length_append] using this
omega
/-- A compatible crossed reversed result with the room condition has its keys at or
above the reported last exactly the reported keys, reversed. -/
theorem above_last_eq_reverse_of_compatible_crossed_rev {db : DB} {r : RangeRead}
{res : Result}
(hcomp : RangeRead.Compatible db r res) (hmore : res.more = true)
(hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ [])
{L : Key} (hL : L = res.keys.getLast hne)
(hroom : (db.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key)))).length + res.keys.length <
(r.end_.offset - 1).toNat) :
above db (L : WithTop Key) = res.keys.reverse := by
set E : WithTop Key := r.end_.key with hE
set B : WithTop Key := r.begin.key with hB
set e : Nat := (r.end_.offset - 1).toNat with he
set P : List Key := above db B with hPdef
set g : Nat := (between db E B).length with hgdef
set h : Nat := (between db E (L : WithTop Key)).length with hhdef
set t : Nat := res.keys.length with htdef
set m : Nat := min (cnt db E + e) db.keys.length - cnt db B with hmdef
set b : Nat := ((P.take m).filter (fun k : Key => decide (k < L))).length with hbdef
have hEB : E ≤ B := le_of_lt hcross
have hBL : B ≤ (L : WithTop Key) := by
have := crossed_rev_res_ge_begin hcomp hbegin L (by rw [hL]; exact List.getLast_mem hne)
simpa only [B] using this
have hW : RangeRead.completeKeys db r = (P.take m).reverse := by
rw [completeKeys_crossed_rev_eq_take_above_begin (db := db) (r := r) hrev hbegin
hcross hend]
have hWf := ((compatible_iff_truncated_keys_rev (db := db) hrev hmore hne).mp hcomp).2
have hPf : (P.take m).filter (fun k : Key => decide (L ≤ k)) = res.keys.reverse := by
have h := hWf
rw [hW, List.filter_reverse, ← hL] at h
exact List.reverse_injective (by simpa only [List.reverse_reverse] using h)
have hcalc : m = min e (above db E).length - g := by
rw [hmdef, ← cnt_add_above_length db E, cnt_eq_add_between db hEB,
Nat.add_min_add_left, Nat.add_sub_add_left]
have hlenE : (above db E).length = g + P.length := by
have h1 := cnt_add_above_length db E
have h2 := cnt_add_above_length db B
have h3 := cnt_eq_add_between db hEB
dsimp only [g, P]
omega
have hm : m = min (e - g) P.length := by
rw [hcalc, hlenE, ← Nat.sub_min_sub_right e (g + P.length) g, Nat.add_sub_cancel_left]
have hm_le : m ≤ P.length := by rw [hm]; exact Nat.min_le_right _ _
have htake_len : (P.take m).length = m := by
rw [List.length_take, Nat.min_eq_left hm_le]
have hbt : m = t + b := by
have hp := List.filter_append_perm (fun k : Key => decide (L ≤ k)) (P.take m)
have hlen := hp.length_eq
rw [List.length_append] at hlen
have h1 : (P.take m).filter (fun k : Key => !decide (L ≤ k)) =
(P.take m).filter (fun k : Key => decide (k < L)) := by
apply List.filter_congr
intro k _
by_cases h : L ≤ k
· have hlt : ¬ k < L := not_lt.mpr h
simp [h, hlt]
· have hlt : k < L := not_le.mp h
simp [h, hlt]
rw [hPf, List.length_reverse, ← htdef, h1, ← hbdef, htake_len] at hlen
omega
have hgj : h = g + (between db B (L : WithTop Key)).length := by
have h1 := cnt_eq_add_between (db := db) hEB
have h2 := cnt_eq_add_between (db := db) hBL
have h3 := cnt_eq_add_between (db := db) (le_trans hEB hBL)
unfold h g
omega
have hgj' : h = (cnt db B - cnt db E) + (between db B (L : WithTop Key)).length := by
have hc := cnt_sub_eq_between_length (db := db) hEB
omega
have hb_le : b ≤ (between db B (L : WithTop Key)).length := by
have hsub : (P.take m).Sublist db.keys := by
rw [hPdef]
exact (List.take_sublist m (above db B)).trans List.filter_sublist
have hall : ∀ k ∈ P.take m, B ≤ (k : WithTop Key) := by
intro k hk
have hkP : k ∈ P := List.mem_of_mem_take hk
rw [hPdef] at hkP
exact of_decide_eq_true (List.mem_filter.mp hkP).2
have hb_eq : ((P.take m).filter (fun k : Key => decide (k < L))).length =
((P.take m).filter (fun k : Key => decide (B ≤ (k : WithTop Key) ∧
(k : Key) < L))).length := by
congr 1
apply List.filter_congr
intro k hk
rw [decide_eq_decide]
exact ⟨fun hkL => ⟨hall k hk, hkL⟩, fun hk => hk.2⟩
rw [hbdef, hb_eq]
have hb2 := (List.Sublist.filter (fun k : Key => decide (B ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key))) hsub).length_le
simpa only [between, WithTop.coe_lt_coe] using hb2
by_cases hPlen : P.length ≤ m
· have htakeP : P.take m = P := List.take_of_length_le hPlen
rw [htakeP] at hPf
have hfilter : P.filter (fun k : Key => decide (L ≤ k)) = above db (L : WithTop Key) := by
rw [hPdef, above_eq_filter, above_eq_filter, List.filter_filter]
apply List.filter_congr
intro k _
by_cases hLk : L ≤ k
· have hBk : B ≤ (k : WithTop Key) := le_trans hBL (WithTop.coe_le_coe.mpr hLk)
simp [hLk, hBk]
· simp [hLk]
rwa [hfilter] at hPf
· have hPlt : m < P.length := lt_of_not_ge hPlen
have hle : e - g ≤ P.length := by
by_contra hcon
have hmin : min (e - g) P.length = P.length := Nat.min_eq_right (le_of_not_ge hcon)
rw [hm, hmin] at hPlt
omega
have hmE : m = e - g := by rw [hm, Nat.min_eq_left hle]
have hb_val : b = e - g - t := by omega
have hroom' : h + t < e := by simpa only [h, between] using hroom
have hhle : h ≤ e - t - 1 := by omega
have hble : b ≤ (between db B (L : WithTop Key)).length := hb_le
have hgf : g ≤ e - t - 1 := by omega
have hdf : (between db B (L : WithTop Key)).length ≤ e - t - 1 - g := by omega
have hb_f : b = e - t - 1 - g + 1 := by omega
omega
/-- **Soundness of the crossed reversed truncated top branch starting at the reported
last key.** When the successor chain from `end_.key` reaches the reported last, the
room between `end_.key` and the last fits inside the end overshoot, so agreement on
`[last, ⊤)` determines all keys above `begin_.key` inside the complete window. -/
theorem sound_truncatedRevCrossed_top_last {r : RangeRead} {res : Result}
(hmore : res.more = true) (hrev : r.reverse = true) (hbegin : r.begin.offset = 1)
(hcross : r.end_.key < r.begin.key) (hend : 1 ≤ r.end_.offset)
(hne : res.keys ≠ [])
{E L : Key} {n : Nat}
(hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne)
(hn : n = (r.end_.offset - 1).toNat - res.keys.length - 1)
(hno : L ≤ keyAfterN n E) :
Sound r res ⟨(L : WithTop Key), ⊤⟩ := by
intro db₁ db₂ hagree
have hno' : res.keys.getLast hne ≤ keyAfterN n E := by rw [← hL]; exact hno
have step : ∀ db db', AgreeOn ⟨(L : WithTop Key), ⊤⟩ db db' →
RangeRead.Compatible db r res → RangeRead.Compatible db' r res := by
intro db db' hag' hcomp
have hBL : r.begin.key ≤ (L : WithTop Key) := by
have h := crossed_rev_res_ge_begin hcomp hbegin L
(by rw [hL]; exact List.getLast_mem hne)
simpa only [hL] using h
have hroom_of : ∀ (d : DB),
(d.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key)))).length + res.keys.length <
(r.end_.offset - 1).toNat := by
intro d
have hle := length_filter_between_le_of_le_keyAfterN d.nodup
(E := E) (L := res.keys.getLast hne) (n := n) hno'
have hEq : (d.keys.filter (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key) ∧
(k : WithTop Key) < (L : WithTop Key)))) =
(d.keys.filter (fun k : Key => decide (E ≤ k ∧ k < res.keys.getLast hne))) := by
apply List.filter_congr
intro k _
rw [decide_eq_decide]
rw [hE, hL]
simp
rw [hEq]
have hElt : E < res.keys.getLast hne := by
have h1 : (E : WithTop Key) < (L : WithTop Key) := by
rw [← hE]
exact lt_of_lt_of_le hcross hBL
exact WithTop.coe_lt_coe.mp (by simpa only [hL] using h1)
have hnpos : 0 < n := by
by_contra hcon
have hn0 : n = 0 := Nat.eq_zero_of_not_pos hcon
rw [hn0, keyAfterN_zero] at hno'
exact absurd hno' (not_le.mpr hElt)
have he : res.keys.length + 1 < (r.end_.offset - 1).toNat := by omega
omega
have hroom_db : (db.keys.filter (fun k : Key => decide (r.end_.key ≤
(k : WithTop Key) ∧ (k : WithTop Key) < (L : WithTop Key)))).length +
res.keys.length < (r.end_.offset - 1).toNat := hroom_of db
have hroom_db' : (db'.keys.filter (fun k : Key => decide (r.end_.key ≤
(k : WithTop Key) ∧ (k : WithTop Key) < (L : WithTop Key)))).length +
res.keys.length < (r.end_.offset - 1).toNat := hroom_of db'
have habove_db := above_last_eq_reverse_of_compatible_crossed_rev hcomp hmore hrev
hbegin hcross hend hne hL hroom_db
have hagmem : ∀ k : Key, (L : WithTop Key) ≤ (k : WithTop Key) →
(k ∈ db.keys ↔ k ∈ db'.keys) := by
intro k hk
exact (agreeOn_iff ⟨(L : WithTop Key), ⊤⟩ db db').mp hag' k
(ConflictRange.mem_iff.mpr ⟨hk, WithTop.coe_lt_top k⟩)
have habove_eq : above db (L : WithTop Key) = above db' (L : WithTop Key) := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr (db.sorted.pairwise.filter _)
· exact List.sortedLT_iff_pairwise.mpr (db'.sorted.pairwise.filter _)
· intro k
rw [mem_above, mem_above]
constructor
· rintro ⟨hk, hLk⟩
exact ⟨(hagmem k hLk).mp hk, hLk⟩
· rintro ⟨hk, hLk⟩
exact ⟨(hagmem k hLk).mpr hk, hLk⟩
have habove_db' : above db' (L : WithTop Key) = res.keys.reverse := by
rw [← habove_eq, habove_db]
have hPf := completeKeys_filter_ge_crossed_rev_of_room (db := db') hrev hbegin
hcross hend hBL habove_db' hroom_db'
exact (compatible_iff_truncated_keys_rev (db := db') hrev hmore hne).mpr
⟨hcomp.1, by simpa only [hL] using hPf⟩
exact ⟨step db₁ db₂ hagree, step db₂ db₁ hagree.symm⟩
theorem crossed_rev_pad_top_necessary {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (_hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ [])
{E : Key} (hE : r.end_.key = (E : WithTop Key))
(hEL : (E : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key))
{n : Nat}
(hlt : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) <
(r.end_.offset - 1).toNat)
(hn : n = (r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1)
(hroom : keyAfterN n E < res.keys.getLast hne)
{k : Key} (hEk : E ≤ k) (hkL : k < res.keys.getLast hne) :
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 e : Nat := (r.end_.offset - 1).toNat with hedef
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 hLH : L ≤ H := hLle H (by rw [hHdef]; exact List.head_mem hne)
have hkL' : k < L := by rw [hLdef]; exact hkL
have hk_notin_res : k ∉ res.keys := by
intro hx
exact absurd (hLle k hx) (not_le.mpr hkL')
have hk_notin_rev : k ∉ res.keys.reverse := by
rw [List.mem_reverse]; exact hk_notin_res
have htlen : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length := by
rw [List.countP_eq_length]
intro x hx
rw [decide_eq_true_eq, hE]
exact le_trans (le_of_lt hEL) (WithTop.coe_le_coe.mpr (hLle x hx))
have hn_e : e = n + res.keys.length + 1 := by
rw [hedef]
omega
-- the successor chain below `L`
set S : List Key := (List.range (n + 1)).map (chain E) with hSdef
have hS_len : S.length = n + 1 := by
rw [hSdef, List.length_map, List.length_range]
have hS_sorted : S.SortedLT := by
rw [hSdef]; exact sortedLT_map_chain E (n + 1)
have hS_nodup : S.Nodup := hS_sorted.pairwise.nodup
have hS_mem : ∀ x, x ∈ S ↔ ∃ i, i < n + 1 ∧ chain E i = x := by
intro x
rw [hSdef, List.mem_map]
constructor
· rintro ⟨i, hi, hix⟩; exact ⟨i, List.mem_range.mp hi, hix⟩
· rintro ⟨i, hi, hix⟩; exact ⟨i, List.mem_range.mpr hi, hix⟩
have hS_le : ∀ x ∈ S, x ≤ chain E n := by
intro x hx
obtain ⟨i, hi, rfl⟩ := (hS_mem x).mp hx
rcases lt_or_eq_of_le (by omega : i ≤ n) with h | h
· exact le_of_lt (chain_lt_mono h)
· rw [h]
have hS_lt_L : ∀ x ∈ S, x < L := by
intro x hx
have h := hS_le x hx
rw [chain_eq_keyAfterN E n] at h
exact lt_of_le_of_lt h hroom
have hS_ge_E : ∀ x ∈ S, E ≤ x := by
intro x hx
obtain ⟨i, hi, rfl⟩ := (hS_mem x).mp hx
exact chain_le E i
set P : List Key := (S.erase k).take n with hPdef
have hP_len : P.length = n := by
rw [hPdef, List.length_take]
have hge : n ≤ (S.erase k).length := by
by_cases hkS : k ∈ S
· rw [List.length_erase_of_mem hkS, hS_len]; omega
· rw [List.erase_of_not_mem hkS, hS_len]; omega
omega
have hP_sorted : P.SortedLT := by
rw [hPdef]
exact List.sortedLT_iff_pairwise.mpr
(List.Pairwise.take (i := n) (List.Pairwise.erase k (List.sortedLT_iff_pairwise.mp
hS_sorted)))
have hP_sub : P ⊆ S := by
intro x hx
rw [hPdef] at hx
exact List.erase_subset ((List.take_sublist n (S.erase k)).subset hx)
have hP_lt_L : ∀ x ∈ P, x < L := fun x hx => hS_lt_L x (hP_sub hx)
have hP_ge_E : ∀ x ∈ P, E ≤ x := fun x hx => hS_ge_E x (hP_sub hx)
have hk_notin_P : k ∉ P := by
intro hx
have hx' : k ∈ S.erase k := (List.take_sublist n (S.erase k)).subset hx
exact (hS_nodup.mem_erase_iff.mp hx').1 rfl
set u : Key := keyAfter H with hudef
have hHlt_u : H < u := by rw [hudef]; exact keyAfter_self_lt H
have hres_lt_u : ∀ x ∈ res.keys.reverse, x < u := by
intro x hx
exact lt_of_le_of_lt (hHge x (List.mem_reverse.mp hx)) hHlt_u
have hk_notin_a : k ∉ P ++ res.keys.reverse ++ [u] := by
intro hx
rw [List.mem_append, List.mem_append] at hx
rcases hx with (hx | hx) | hx
· exact hk_notin_P hx
· exact hk_notin_rev hx
· rw [List.mem_singleton] at hx
exact (ne_of_lt (lt_trans (lt_of_lt_of_le hkL' hLH) hHlt_u)) hx
set aList : List Key := P ++ res.keys.reverse ++ [u] with hadef
have hres_rev_sorted : res.keys.reverse.SortedLT := hsort.reverse
have hP_lt_res : ∀ x ∈ P, ∀ y ∈ res.keys.reverse, x < y := by
intro x hx y hy
exact lt_of_lt_of_le (hP_lt_L x hx) (hLle y (List.mem_reverse.mp hy))
have ha_sorted : aList.SortedLT := by
rw [hadef]
refine List.sortedLT_append.mpr ⟨?_, ?_, ?_⟩
· exact List.sortedLT_append.mpr ⟨hP_sorted, hres_rev_sorted, hP_lt_res⟩
· exact List.sortedLT_iff_pairwise.mpr (by simp)
· intro x hx y hy
rw [List.mem_singleton] at hy
rw [hy]
rw [List.mem_append] at hx
rcases hx with hx | hx
· exact lt_of_lt_of_le (hP_lt_L x hx) (le_trans hLH (le_of_lt hHlt_u))
· exact hres_lt_u x hx
let db_a : DB := ⟨aList, ha_sorted⟩
have hlen_a : aList.length = e := by
rw [hadef, List.length_append, List.length_append, hP_len,
List.length_reverse, List.length_singleton]
omega
have ha_ge_E : ∀ x ∈ aList, E ≤ x := by
intro x hx
rw [hadef, List.mem_append, List.mem_append] at hx
rcases hx with (hx | hx) | hx
· exact hP_ge_E x hx
· exact le_trans (le_of_lt (WithTop.coe_lt_coe.mp hEL))
(hLle x (List.mem_reverse.mp hx))
· rw [List.mem_singleton] at hx
rw [hx]
exact le_trans (le_of_lt (WithTop.coe_lt_coe.mp hEL))
(le_trans hLH (le_of_lt hHlt_u))
have hcount_a : aList.countP
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx hlt
rw [decide_eq_true_eq] at hlt
rw [hE] at hlt
exact absurd (WithTop.coe_le_coe.mpr (ha_ge_E x hx)) (not_le.mpr hlt)
have hanc_a : (r.end_.anchor db_a).toNat = e := by
rw [anchor_toNat_eq (db := db_a) (s := r.end_) (by omega), hcount_a]
omega
have hresend_a : resolve db_a r.end_ = (⊤ : WithTop Key) :=
resolve_eq_top (anchor_nonneg_of_one_le (db := db_a) (s := r.end_) (by omega))
(by rw [hlen_a, hanc_a])
have hbegin_le_L : r.begin.key ≤ (↑L : WithTop Key) := by
rw [hLdef]
exact crossed_rev_res_ge_begin hcomp₀ hbegin L
(by rw [hLdef]; exact List.getLast_mem hne)
have hL_mem_a : L ∈ db_a.keys := by
change L ∈ aList
rw [hadef]
simp only [List.mem_append, List.mem_singleton]
exact Or.inl (Or.inr (List.mem_reverse.mpr
(by rw [hLdef]; exact List.getLast_mem hne)))
have hrb_a : resolve db_a r.begin ≤ (↑L : WithTop Key) :=
(key_le_resolve_iff_of_offset_one (db := db_a) hbegin hL_mem_a).mp hbegin_le_L
have hck_a : RangeRead.completeKeys db_a r =
(RangeRead.inRange db_a.keys (resolve db_a r.begin) (⊤ : WithTop Key)).reverse := by
simp [RangeRead.completeKeys, hrev, hresend_a]
have hfilter_a : aList.filter (fun a : Key => decide (L ≤ a)) =
res.keys.reverse ++ [u] := by
rw [hadef, List.filter_append, List.filter_append]
have hPnil : P.filter (fun a : Key => decide (L ≤ a)) = [] := by
rw [List.filter_eq_nil_iff]
intro x hx
rw [decide_eq_true_eq]
exact not_le.mpr (hP_lt_L x hx)
have hRself : res.keys.reverse.filter (fun a : Key => decide (L ≤ a)) =
res.keys.reverse := by
rw [List.filter_eq_self]
intro x hx
rw [decide_eq_true_eq]
exact hLle x (List.mem_reverse.mp hx)
have hU : [u].filter (fun a : Key => decide (L ≤ a)) = [u] := by
simp only [List.filter_cons, List.filter_nil]
rw [decide_eq_true (le_of_lt (lt_of_le_of_lt hLH hHlt_u))]
simp
rw [hPnil, hRself, hU]
simp
have hnotcomp_a : ¬ RangeRead.Compatible db_a r res := by
intro hc
have hf := ((compatible_iff_truncated_keys_rev (db := db_a) hrev hmore hne).mp hc).2
rw [hck_a, List.filter_reverse] at hf
unfold RangeRead.inRange at hf
rw [List.filter_filter] at hf
have hpred : ∀ a ∈ db_a.keys,
(decide (L ≤ a) && decide (resolve db_a r.begin ≤ (↑a : WithTop Key) ∧
(↑a : WithTop Key) < (⊤ : WithTop Key))) = decide (L ≤ a) := by
intro a _
by_cases hLa : L ≤ a
· have hres : resolve db_a r.begin ≤ (↑a : WithTop Key) :=
le_trans hrb_a (WithTop.coe_le_coe.mpr hLa)
rw [decide_eq_true hLa, Bool.true_and, decide_eq_true]
exact ⟨hres, WithTop.coe_lt_top a⟩
· rw [decide_eq_false hLa, Bool.false_and]
rw [List.filter_congr hpred] at hf
have hda : db_a.keys = aList := rfl
rw [hda, hfilter_a, List.reverse_append, List.reverse_singleton,
List.reverse_reverse, List.singleton_append] at hf
have hlen := congrArg List.length hf
simp only [List.length_cons] at hlen
omega
-- insert the target key
let db_b : DB := db_a.insert k hk_notin_a
have hb_keys : db_b.keys = aList.orderedInsert (· ≤ ·) k := rfl
have hb_mem : ∀ x, x ∈ db_b.keys ↔ x = k ∨ x ∈ aList := by
intro x
rw [hb_keys, List.mem_orderedInsert]
have hb_len : db_b.keys.length = e + 1 := by
rw [hb_keys]
have hp := List.Perm.length_eq (List.perm_orderedInsert (· ≤ ·) k aList)
simp only [List.length_cons] at hp
rw [hp, hlen_a]
have hb_ge_E : ∀ x ∈ db_b.keys, E ≤ x := by
intro x hx
rcases (hb_mem x).mp hx with rfl | hx
· exact hEk
· exact ha_ge_E x hx
have hcount_b : db_b.keys.countP
(fun x : Key => decide ((x : WithTop Key) < r.end_.key)) = 0 := by
rw [List.countP_eq_zero]
intro x hx hlt
rw [decide_eq_true_eq] at hlt
rw [hE] at hlt
exact absurd (WithTop.coe_le_coe.mpr (hb_ge_E x hx)) (not_le.mpr hlt)
have hanc_b : (r.end_.anchor db_b).toNat = e := by
rw [anchor_toNat_eq (db := db_b) (s := r.end_) (by omega), hcount_b]
omega
have hresend_b : resolve db_b r.end_ = (↑u : WithTop Key) := by
have h0 := anchor_nonneg_of_one_le (db := db_b) (s := r.end_) (by omega)
have hidx : (r.end_.anchor db_b).toNat < db_b.keys.length := by
rw [hanc_b, hb_len]; omega
have hu_mem : u ∈ db_b.keys := by
rw [hb_mem]; exact Or.inr (by rw [hadef]; simp)
have hall_le_u : ∀ x ∈ db_b.keys, x ≤ u := by
intro x hx
rcases (hb_mem x).mp hx with rfl | hx
· exact le_of_lt (lt_trans (lt_of_lt_of_le hkL' hLH) hHlt_u)
· rw [hadef] at hx
rw [List.mem_append, List.mem_append] at hx
rcases hx with (hx | hx) | hx
· exact le_of_lt (lt_of_lt_of_le (hP_lt_L x hx)
(le_trans hLH (le_of_lt hHlt_u)))
· exact le_of_lt (hres_lt_u x hx)
· rw [List.mem_singleton] at hx
rw [hx]
have hbne : db_b.keys ≠ [] := List.ne_nil_of_length_pos (by rw [hb_len]; omega)
have hlast : db_b.keys.getLast hbne = u := by
apply le_antisymm
· exact hall_le_u _ (List.getLast_mem hbne)
· exact (List.sortedLT_iff_pairwise.mp db_b.sorted).imp le_of_lt
|>.rel_getLast hu_mem
have hidx3 : db_b.keys.length - 1 = e := by rw [hb_len]; omega
have hgl := List.getLast_eq_getElem (l := db_b.keys) (h := hbne)
have hidx_e : e < db_b.keys.length := by rw [hb_len]; omega
have hkeyu : db_b.keys[e] = u := by
rw [List.getElem_eq_iff hidx_e, ← hidx3,
List.getElem?_eq_getElem (by omega), ← hgl, hlast]
have hkey_anchor : db_b.keys[(r.end_.anchor db_b).toNat] = u := by
rw [List.getElem_eq_iff hidx, hanc_b, List.getElem?_eq_getElem hidx_e, hkeyu]
rw [resolve_eq_getElem h0 hidx, hkey_anchor]
have hcomp_b : RangeRead.Compatible db_b r res := by
refine (compatible_iff_truncated_keys_rev (db := db_b) hrev hmore hne).mpr
⟨hcomp₀.1, ?_⟩
have hL_mem_res : L ∈ res.keys := by
rw [hLdef]; exact List.getLast_mem hne
have hL_mem_b : L ∈ db_b.keys := by
rw [hb_mem]; exact Or.inr (by rw [hadef]; simp [hL_mem_res])
have hrb_b : resolve db_b r.begin ≤ (↑L : WithTop Key) :=
(key_le_resolve_iff_of_offset_one (db := db_b) hbegin hL_mem_b).mp hbegin_le_L
have hck_b : RangeRead.completeKeys db_b r =
(RangeRead.inRange db_b.keys (resolve db_b r.begin) (↑u : WithTop Key)).reverse := by
simp [RangeRead.completeKeys, hrev, hresend_b]
rw [hck_b, List.filter_reverse]
unfold RangeRead.inRange
rw [List.filter_filter]
have hpred : ∀ a ∈ db_b.keys,
(decide (L ≤ a) && decide (resolve db_b r.begin ≤ (↑a : WithTop Key) ∧
(↑a : WithTop Key) < (↑u : WithTop Key))) = decide (L ≤ a ∧ a < u) := by
intro a _
by_cases hLa : L ≤ a
· have hres : resolve db_b r.begin ≤ (↑a : WithTop Key) :=
le_trans hrb_b (WithTop.coe_le_coe.mpr hLa)
rw [decide_eq_true hLa, Bool.true_and, decide_eq_decide]
exact ⟨fun h => ⟨hLa, WithTop.coe_lt_coe.mp h.2⟩,
fun h => ⟨hres, WithTop.coe_lt_coe.mpr h.2⟩⟩
· rw [decide_eq_false hLa]
simp [hLa]
rw [List.filter_congr hpred]
have hstep : db_b.keys.filter (fun a => decide (L ≤ a ∧ a < u)) = res.keys.reverse := by
apply List.SortedLT.eq_of_mem_iff
· exact List.sortedLT_iff_pairwise.mpr (db_b.sorted.pairwise.filter _)
· exact hres_rev_sorted
· intro x
rw [List.mem_filter, List.mem_reverse]
constructor
· rintro ⟨hx, hpred⟩
have hpred' := of_decide_eq_true hpred
rcases (hb_mem x).mp hx with rfl | hx
· exact absurd hpred'.1 (not_le.mpr hkL')
· rw [hadef] at hx
rw [List.mem_append, List.mem_append] at hx
rcases hx with (hx | hx) | hx
· exact absurd hpred'.1 (not_le.mpr (hP_lt_L x hx))
· exact List.mem_reverse.mp hx
· rw [List.mem_singleton] at hx
rw [hx] at hpred'
exact absurd hpred'.2 (lt_irrefl u)
· intro hx
refine ⟨?_, ?_⟩
· rw [hb_mem]; exact Or.inr (by rw [hadef]; simp [hx])
· exact decide_eq_true ⟨hLle x hx, hres_lt_u x (List.mem_reverse.mpr hx)⟩
rw [hstep, List.reverse_reverse]
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
exact hnotcomp_a ((hs db_a db_b hagree).mpr hcomp_b)
/-- **Minimality of the crossed top branch beginning at `end_.key`.** -/
theorem minimal_topRevCrossed_begin_end {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ [])
{E L : Key} {n : Nat}
(hE : r.end_.key = (E : WithTop Key)) (hL : L = res.keys.getLast hne)
(hn : n = (r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1)
(hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) <
(r.end_.offset - 1).toNat)
(hroom : keyAfterN n E < L) :
Minimal r res ⟨(E : WithTop Key), ⊤⟩ := by
have hEL : (E : WithTop Key) < ((res.keys.getLast hne : Key) : WithTop Key) := by
rw [← hL]
exact WithTop.coe_lt_coe.mpr (lt_of_le_of_lt (keyAfterN_le_self E n) hroom)
have hroom' : keyAfterN n E < res.keys.getLast hne := by rw [← hL]; exact hroom
have hs : Sound r res ⟨(E : WithTop Key), ⊤⟩ := by
rw [← hE]
exact sound_truncatedRevCrossed_top hrev hbegin hcross (by omega)
refine (minimal_iff_sound_and_necessary).mpr ⟨hs, ?_⟩
intro k hk
have hEk : E ≤ k := WithTop.coe_le_coe.mp hk.1
by_cases hkL : k < L
· exact crossed_rev_pad_top_necessary hread hmore hrev hbegin hcross hend hne hE hEL hlt hn
hroom' hEk (by rw [← hL]; exact hkL)
· have hLk : L ≤ k := le_of_not_gt hkL
by_cases hkH : k ≤ res.keys.head hne
· exact necessary_of_between_result hread (by rw [hL]; exact List.getLast_mem hne)
(List.head_mem hne) hLk hkH
· exact necessary_above_head_top_rev hread hmore hrev hbegin hne hlt (lt_of_not_ge hkH)
/-- **Minimality of the crossed top branch beginning at the reported last key.** -/
theorem minimal_topRevCrossed_begin_last {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset)
{E L : Key} {n : Nat}
(hE : r.end_.key = (E : WithTop Key))
(hne : res.keys ≠ []) (hL : L = res.keys.getLast hne)
(hn : n = (r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) - 1)
(hlt : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) <
(r.end_.offset - 1).toNat)
(hcase : L ≤ E ∨ L ≤ keyAfterN n E) :
Minimal r res ⟨(L : WithTop Key), ⊤⟩ := by
have hcount : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length :=
crossed_rev_count_ge_eq_length hrev hbegin hcross (by omega) hread
have hn' : n = (r.end_.offset - 1).toNat - res.keys.length - 1 := by
rw [hn, hcount]
rcases hcase with hLE | hno
· have hLno : L ≤ keyAfterN n E :=
le_trans hLE (keyAfterN_le_self E n)
refine (minimal_iff_sound_and_necessary).mpr
⟨sound_truncatedRevCrossed_top_last hmore hrev hbegin hcross (by omega) hne hE hL hn' hLno,
?_⟩
intro k hk
have hLk : L ≤ k := WithTop.coe_le_coe.mp hk.1
by_cases hkH : k ≤ res.keys.head hne
· exact necessary_of_between_result hread (by rw [hL]; exact List.getLast_mem hne)
(List.head_mem hne) hLk hkH
· exact necessary_above_head_top_rev hread hmore hrev hbegin hne hlt (lt_of_not_ge hkH)
· refine (minimal_iff_sound_and_necessary).mpr
⟨sound_truncatedRevCrossed_top_last hmore hrev hbegin hcross (by omega) hne hE hL hn' hno, ?_⟩
intro k hk
have hLk : L ≤ k := WithTop.coe_le_coe.mp hk.1
by_cases hkH : k ≤ res.keys.head hne
· exact necessary_of_between_result hread (by rw [hL]; exact List.getLast_mem hne)
(List.head_mem hne) hLk hkH
· exact necessary_above_head_top_rev hread hmore hrev hbegin hne hlt (lt_of_not_ge hkH)
/-- **Minimality of the crossed finite reversed truncated branch.** -/
theorem minimal_truncatedRevCrossed_finite {r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset) (hne : res.keys ≠ [])
(ht : res.keys.length = (r.end_.offset - 1).toNat) :
Minimal r res ⟨r.end_.key, (keyAfter (res.keys.headD ([] : Key)) : WithTop Key)⟩ := by
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have ht' : res.keys.countP (fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat := by
rw [crossed_rev_count_ge_eq_length hrev hbegin hcross (by omega) hread, ht]
refine (minimal_iff_sound_and_necessary).mpr
⟨sound_truncatedRevCrossed_finite hmore hrev hbegin hcross (by omega) hne ht, ?_⟩
intro k hk
rw [ConflictRange.mem_iff] at hk
have hkH : k ≤ res.keys.head hne := by
have h2 : (k : WithTop Key) < (keyAfter (res.keys.headD ([] : Key)) : WithTop Key) := hk.2
rw [hhead] at h2
exact (lt_keyAfter_iff k (res.keys.head hne)).mp (WithTop.coe_lt_coe.mp h2)
by_cases hkL : k < res.keys.getLast hne
· exact necessary_finite_below_last_crossed_rev hread hmore hrev hbegin hcross hend hne ht'
hk.1 (WithTop.coe_lt_coe.mpr hkL)
· have hLk : res.keys.getLast hne ≤ k := le_of_not_gt hkL
exact necessary_of_between_result hread (List.getLast_mem hne) (List.head_mem hne)
hLk hkH
/-- **Minimality of the corrected reversed truncated rule on crossed reads.** -/
theorem minimal_closedForm_of_offset_one_truncated_rev_fullC_crossed
{r : RangeRead} {res : Result}
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
(hbegin : r.begin.offset = 1) (hcross : r.end_.key < r.begin.key)
(hend : 2 ≤ r.end_.offset) :
Minimal r res (closedFormOffsetOneTruncatedRevFullC r res) := by
obtain ⟨db₀, hcomp₀⟩ := hread
have hread' : Readable r res := ⟨db₀, hcomp₀⟩
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp₀ hmore
have hlast : res.keys.getLastD ([] : Key) = res.keys.getLast hne := by
rw [List.getLastD_eq_getLast?, List.getLast?_eq_some_getLast hne]; rfl
have hhead : res.keys.headD ([] : Key) = res.keys.head hne := by
rw [List.headD_eq_head?, List.head?_eq_some_head hne]; rfl
have hcount : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) = res.keys.length :=
crossed_rev_count_ge_eq_length hrev hbegin hcross (by omega) hread'
have hlen_le_e : res.keys.length ≤ (r.end_.offset - 1).toNat := by
have hpre := (RangeRead.compatible_keys_prefix hcomp₀).length_le
rw [completeKeys_crossed_rev_eq hrev hbegin hcross (by omega)] at hpre
rw [List.length_reverse, List.length_drop] at hpre
have htake : (List.take (r.end_.offset - 1).toNat (above db₀ r.end_.key)).length ≤
(r.end_.offset - 1).toNat := by
rw [List.length_take]
exact Nat.min_le_left _ _
omega
have hcount_le : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) ≤
(r.end_.offset - 1).toNat := by
rw [hcount]; exact hlen_le_e
unfold closedFormOffsetOneTruncatedRevFullC
rw [ite_eq_right (by omega : ¬ r.end_.offset ≤ 1)]
dsimp only
by_cases ht : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) =
(r.end_.offset - 1).toNat
· rw [ite_eq_left ht]
have htlen : res.keys.length = (r.end_.offset - 1).toNat := by
rw [← hcount]; exact ht
have hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by
rw [hlast]
exact le_trans (le_of_lt hcross)
(crossed_rev_res_ge_begin hcomp₀ hbegin (res.keys.getLast hne)
(List.getLast_mem hne))
have hmin_eq : min ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) r.end_.key =
r.end_.key := min_eq_right hEL
rw [hmin_eq]
exact minimal_truncatedRevCrossed_finite hread' hmore hrev hbegin hcross hend hne htlen
· rw [ite_eq_right ht]
have hlt : res.keys.countP
(fun k : Key => decide (r.end_.key ≤ (k : WithTop Key))) <
(r.end_.offset - 1).toNat := lt_of_le_of_ne hcount_le ht
cases hkey : r.end_.key with
| top =>
rw [hkey] at hcross
exact absurd hcross (not_lt_of_ge le_top)
| coe E =>
change Minimal r res (if keyAfterN ((r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide ((↑E : WithTop Key) ≤ (k : WithTop Key))) - 1)
E < res.keys.getLastD ([] : Key) then ⟨(E : WithTop Key), ⊤⟩
else ⟨((res.keys.getLastD ([] : Key) : Key) : WithTop Key), ⊤⟩)
by_cases hroom : keyAfterN ((r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide ((↑E : WithTop Key) ≤ (k : WithTop Key))) - 1)
E < res.keys.getLastD ([] : Key)
· rw [ite_eq_left hroom]
have hroom' : keyAfterN ((r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide ((↑E : WithTop Key) ≤ (k : WithTop Key))) - 1)
E < res.keys.getLast hne := by
rw [← hlast]; exact hroom
exact minimal_topRevCrossed_begin_end hread' hmore hrev hbegin hcross hend hne hkey
rfl (by rw [hkey]) hlt hroom'
· rw [ite_eq_right hroom]
have hge : res.keys.getLastD ([] : Key) ≤ keyAfterN ((r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide ((↑E : WithTop Key) ≤ (k : WithTop Key))) - 1)
E := le_of_not_gt hroom
have hge' : res.keys.getLast hne ≤ keyAfterN ((r.end_.offset - 1).toNat -
res.keys.countP (fun k : Key => decide ((↑E : WithTop Key) ≤ (k : WithTop Key))) - 1)
E := by
rw [← hlast]; exact hge
rw [hlast]
exact minimal_topRevCrossed_begin_last hread' hmore hrev hbegin hcross hend hkey
hne rfl (by rw [hkey]) hlt (Or.inr hge')
end FormalConflictRange