- Update deprecated lemmas (ite_eq_left/right, ENat casts, List.Sublist, ...) - Replace push_neg with push Not and resolve unused-variable warnings - Convert flexible simp/simp_all calls to explicit simp only lists - Remove unscoped maxHeartbeats options, open scoped Classical, and unused tactics - Add missing module docstrings and clean up style linter hits - Wrap over-long lines and flatten the deeply nested minimal_conflictRangeClosedForm_total proof `lake build` now completes with zero warnings.
263 lines
13 KiB
Lean4
263 lines
13 KiB
Lean4
/-
|
|
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.NegCrossTruncRevTop
|
|
|
|
/-!
|
|
# Reversed crossed negative-begin truncated cells with an under-end
|
|
|
|
This module closes the reversed crossed negative-begin truncated cell whose end key
|
|
lies at or above `begin.key` and whose end offset is at most one. The minimal range is
|
|
`[last reported, end_.key)`, the reversed truncated range.
|
|
|
|
The proof reduces the read to the offset-one begin keyed at the reported last, which
|
|
sees exactly the same stored keys at or above that last key. The begin-anchor count
|
|
bound `between_add_offset_le_one` shows that agreement on `[last, end_.key)` keeps the
|
|
begin resolution at or below the reported last, so the reduction is sound.
|
|
-/
|
|
|
|
namespace FormalConflictRange
|
|
|
|
|
|
/-- **The general filter identity.** If 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` and below the resolved end. -/
|
|
theorem completeKeys_filter_ge_eq_resolve_end {db : DB} {r : RangeRead} {last : Key}
|
|
(hrev : r.reverse = true)
|
|
(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))).filter
|
|
(fun k => decide (((k : Key) : WithTop Key) < resolve db r.end_))).reverse := by
|
|
unfold RangeRead.completeKeys RangeRead.inRange
|
|
simp only [hrev, ite_true]
|
|
rw [List.filter_reverse, List.reverse_inj]
|
|
rw [List.filter_filter, List.filter_filter]
|
|
apply List.filter_congr
|
|
intro k _hk
|
|
conv_lhs => rw [← Bool.decide_and]
|
|
conv_rhs => rw [← Bool.decide_and]
|
|
apply Bool.decide_congr
|
|
constructor
|
|
· rintro ⟨hl, _hb, he⟩
|
|
exact ⟨he, hl⟩
|
|
· rintro ⟨he, hl⟩
|
|
exact ⟨hl, le_trans hrb (WithTop.coe_le_coe.mpr hl), he⟩
|
|
|
|
/-- **The begin resolution stays at or below `last` from the anchor bound.** If `last`
|
|
is stored, lies strictly below `begin.key`, and the stored keys in `[last, begin.key)`
|
|
plus the begin offset minus one is at most zero, then the begin selector resolves at or
|
|
below `last`. -/
|
|
theorem resolve_begin_le_of_between_bound {db : DB} {r : RangeRead} {last : Key}
|
|
(hlast_mem : last ∈ db.keys)
|
|
(hcross : ((last : Key) : WithTop Key) < r.begin.key)
|
|
(hbound : ((between db ((last : Key) : WithTop Key) r.begin.key).length : Int) +
|
|
r.begin.offset - 1 ≤ 0) :
|
|
resolve db r.begin ≤ ((last : Key) : WithTop Key) := by
|
|
obtain ⟨j, hjlt, hjeq⟩ := List.mem_iff_getElem.mp hlast_mem
|
|
have hcnt_last : cnt db ((last : Key) : WithTop Key) = j := by
|
|
rw [cnt_coe]
|
|
exact countP_lt_eq_of_getElem db.sorted hjlt hjeq
|
|
have hLleBegin : ((last : Key) : WithTop Key) ≤ r.begin.key := le_of_lt hcross
|
|
have hcnt_begin : cnt db r.begin.key =
|
|
j + (between db ((last : Key) : WithTop Key) r.begin.key).length := by
|
|
rw [cnt_eq_add_between db hLleBegin, hcnt_last]
|
|
have hanchor : r.begin.anchor db = (j : Int) +
|
|
((between db ((last : 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 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) hjlt).mpr hclamp
|
|
rwa [hjeq] at hle
|
|
|
|
/-- **Agreement on a range fixes the stored keys in any contained key interval.** If two
|
|
databases agree on `[last, endKey)` and `beginKey ≤ endKey`, they store the same keys in
|
|
`[last, beginKey)`. -/
|
|
theorem between_eq_of_agree {db db' : DB} {last beginKey endKey : WithTop Key}
|
|
(hagree : AgreeOn ⟨last, endKey⟩ db db')
|
|
(_hlast : last ≤ beginKey) (hbegin : beginKey ≤ endKey) :
|
|
between db last beginKey = between db' last beginKey := by
|
|
have hcr : db.keys.filter (fun k : Key => decide (last ≤ ((k : Key) : WithTop Key) ∧
|
|
((k : Key) : WithTop Key) < endKey)) =
|
|
db'.keys.filter (fun k : Key => decide (last ≤ ((k : Key) : WithTop Key) ∧
|
|
((k : Key) : WithTop Key) < endKey)) := by
|
|
have h := hagree
|
|
unfold AgreeOn ConflictRange.keys at h
|
|
exact h
|
|
have h1 : db.keys.filter (fun k : Key => decide (last ≤ ((k : Key) : WithTop Key) ∧
|
|
((k : Key) : WithTop Key) < beginKey)) =
|
|
(db.keys.filter (fun k : Key => decide (last ≤ ((k : Key) : WithTop Key) ∧
|
|
((k : Key) : WithTop Key) < endKey))).filter
|
|
(fun k : Key => decide (((k : Key) : WithTop Key) < beginKey)) := by
|
|
rw [List.filter_filter]
|
|
apply List.filter_congr
|
|
intro k _hk
|
|
conv_rhs => rw [← Bool.decide_and]
|
|
apply Bool.decide_congr
|
|
constructor
|
|
· rintro ⟨hl, hb⟩
|
|
exact ⟨hb, hl, lt_of_lt_of_le hb hbegin⟩
|
|
· rintro ⟨hb, hl, _he⟩
|
|
exact ⟨hl, hb⟩
|
|
have h2 : db'.keys.filter (fun k : Key => decide (last ≤ ((k : Key) : WithTop Key) ∧
|
|
((k : Key) : WithTop Key) < beginKey)) =
|
|
(db'.keys.filter (fun k : Key => decide (last ≤ ((k : Key) : WithTop Key) ∧
|
|
((k : Key) : WithTop Key) < endKey))).filter
|
|
(fun k : Key => decide (((k : Key) : WithTop Key) < beginKey)) := by
|
|
rw [List.filter_filter]
|
|
apply List.filter_congr
|
|
intro k _hk
|
|
conv_rhs => rw [← Bool.decide_and]
|
|
apply Bool.decide_congr
|
|
constructor
|
|
· rintro ⟨hl, hb⟩
|
|
exact ⟨hb, hl, lt_of_lt_of_le hb hbegin⟩
|
|
· rintro ⟨hb, hl, _he⟩
|
|
exact ⟨hl, hb⟩
|
|
unfold between
|
|
rw [h1, h2, hcr]
|
|
|
|
/-- **The reversed crossed negative-begin truncated under-end cell.** -/
|
|
theorem minimal_truncatedRangeRev_of_negCross_underEnd {r : RangeRead} {res : Result}
|
|
(hread : Readable r res) (hmore : res.more = true) (hrev : r.reverse = true)
|
|
(_hbeg : r.begin.offset < 0) (hne : res.keys ≠ [])
|
|
(hcross : ((res.keys.getLast hne : Key) : WithTop Key) < r.begin.key)
|
|
(hunder : r.begin.key ≤ r.end_.key) (hend : r.end_.offset ≤ 1) :
|
|
Minimal r res (truncatedRangeRev r (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 := by rw [hLdef]; exact hcross
|
|
obtain ⟨db₀, hcomp₀⟩ := hread
|
|
have hreadAll : Readable r res := ⟨db₀, hcomp₀⟩
|
|
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
|
|
-- The reduced read sees exactly the reported keys.
|
|
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 (truncatedRangeRev r L) := by
|
|
rcases lt_or_eq_of_le hend with hlt | heq
|
|
· have hle : r.end_.offset ≤ 0 := by omega
|
|
have hm := minimal_truncatedRangeRev_of_end_offset_nonpos (r := r') hread' hmore
|
|
hr'_rev hr'_off (by simpa [r'] using hle)
|
|
rwa [hgetLastD] at hm
|
|
· have hm := minimal_truncatedRangeRev_of_offset_one (r := r') hread' hmore
|
|
hr'_rev hr'_off heq
|
|
rwa [hgetLastD] at hm
|
|
have hS' : Sound r' res (truncatedRangeRev r L) := hmin'.sound
|
|
refine (minimal_iff_sound_and_necessary).mpr ⟨?_, ?_⟩
|
|
· have step : ∀ db db', AgreeOn (truncatedRangeRev r 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 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 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
|
|
have hagree' : AgreeOn ⟨((L : Key) : WithTop Key), r.end_.key⟩ db db' := by
|
|
simpa [truncatedRangeRev] using hag'
|
|
have hbetween_eq : between db ((L : Key) : WithTop Key) r.begin.key =
|
|
between db' ((L : Key) : WithTop Key) r.begin.key :=
|
|
between_eq_of_agree (db := db) (db' := db') hagree' (le_of_lt hLcross) hunder
|
|
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 hrb' : resolve db' r.begin ≤ ((L : Key) : WithTop Key) :=
|
|
resolve_begin_le_of_between_bound hLdb' hLcross 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⟩
|
|
· intro k hk cr hs
|
|
have hkL : L ≤ k := WithTop.coe_le_coe.mp hk.1
|
|
have hkend : ((k : Key) : WithTop Key) < r.end_.key := hk.2
|
|
by_cases hkres : k ∈ res.keys
|
|
· exact necessary_of_mem_result hreadAll hkres cr hs
|
|
· by_cases hkhead : k ≤ res.keys.head hne
|
|
· exact necessary_of_between_result hreadAll hLmem (List.head_mem hne) hkL hkhead cr hs
|
|
· have hheadk : res.keys.head hne ≤ k := le_of_lt (lt_of_not_ge hkhead)
|
|
exact necessary_head_to_end_key hreadAll hrev hne hend cr hs hheadk hkend
|
|
|
|
/-- The reversed crossed negative-begin truncated under-end cell. -/
|
|
abbrev negCrossTruncRevUnder (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.begin.key ≤ r.end_.key ∧ r.end_.offset ≤ 1
|
|
|
|
/-- The closed form of the reversed crossed negative-begin truncated under-end cell. -/
|
|
noncomputable def closedFormNegCrossTruncRevUnder (_r : RangeRead) (res : Result) :
|
|
ConflictRange :=
|
|
truncatedRangeRev _r (res.keys.getLastD ([] : Key))
|
|
|
|
/-- **The reversed crossed negative-begin truncated under-end closed form is minimal.** -/
|
|
theorem minimal_closedForm_of_negCross_trunc_rev_under {r : RangeRead} {res : Result}
|
|
(hread : Readable r res) (h : negCrossTruncRevUnder r res) :
|
|
Minimal r res (closedFormNegCrossTruncRevUnder r res) := by
|
|
obtain ⟨hmore, hrev, hbeg, hne, hcrossD, hunder, hend⟩ := 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 closedFormNegCrossTruncRevUnder
|
|
rw [hlast]
|
|
exact minimal_truncatedRangeRev_of_negCross_underEnd hread hmore hrev hbeg hne hcross
|
|
hunder hend
|
|
|
|
end FormalConflictRange
|