Files
conflict-range/FormalConflictRange/NonposRevClosedForm.lean
T

170 lines
9.0 KiB
Lean4

/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
import FormalConflictRange.NonposClosedForm
import FormalConflictRange.ClosedFormTotal
/-!
# Cross-free nonpositive-begin reversed truncated closed form
At a nonpositive begin offset the begin selector resolves at or below `begin.key`, so
when `begin.key` lies at or below the least reported key every reported key is at or
above the resolution. For a reversed truncated result the compatible databases are
then exactly those whose stored keys at or above the reported last agree, and that
filter is unchanged by replacing the begin selector with an offset-one selector keyed
at the reported last (`completeKeys_filter_ge_eq_nonposRevReduced`). This reduces the
whole cross-free nonpositive reversed truncated region — every end offset, overshoot or
not — to the already-total begin-offset-one rule `closedFormOffsetOneTotal`. Soundness
and minimality transfer because the two reads have the same compatible databases.
-/
open FormalConflictRange
namespace FormalConflictRange
/-- The reduced read used to close cross-free nonpositive reversed truncated cells:
its begin selector sits at offset one on the reported last key. -/
noncomputable def nonposRevReduced (r : RangeRead) (res : Result) : RangeRead :=
{ r with begin := { key := ((res.keys.getLastD ([] : Key) : Key) : WithTop Key), offset := 1 } }
/-- At offset one keyed at the reported last, a stored key lies at or above the
resolution exactly when it lies at or above the reported last. -/
theorem last_le_resolve_reduced_iff {db : DB} {last : Key} {k : Key} (hk : k ∈ db.keys) :
last ≤ k ↔ resolve db ({ key := ((last : Key) : WithTop Key), offset := 1 } : Selector) ≤
((k : Key) : WithTop Key) := by
simpa using key_le_resolve_iff_of_offset_one (db := db)
(s := ({ key := ((last : Key) : WithTop Key), offset := 1 } : Selector)) rfl hk
/-- The stored keys at or above the reported last are unchanged by replacing a
nonpositive cross-free begin selector with the offset-one selector keyed at the last. -/
theorem completeKeys_filter_ge_eq_nonposRevReduced {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = true) (hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) :
(RangeRead.completeKeys db r).filter
(fun k : Key => decide (res.keys.getLastD ([] : Key) ≤ k)) =
(RangeRead.completeKeys db (nonposRevReduced r res)).filter
(fun k : Key => decide (res.keys.getLastD ([] : Key) ≤ k)) := by
set last := res.keys.getLastD ([] : Key)
have hlo' : r.begin.key ≤ ((last : Key) : WithTop Key) := hlo
have hred_rev : (nonposRevReduced r res).reverse = true := by
simp [nonposRevReduced, hrev]
have hred_beg : (nonposRevReduced r res).begin =
({ key := ((last : Key) : WithTop Key), offset := 1 } : Selector) := rfl
have hred_end : (nonposRevReduced r res).end_ = r.end_ := rfl
rw [RangeRead.completeKeys, RangeRead.completeKeys, hrev, hred_rev]
simp only [ite_true]
rw [List.filter_reverse, List.filter_reverse, List.reverse_inj]
unfold RangeRead.inRange
rw [List.filter_filter, List.filter_filter]
apply List.filter_congr
intro k hk
have hkey := last_le_resolve_reduced_iff (db := db) (last := last) (k := k) hk
have hstart : resolve db r.begin ≤ ((last : Key) : WithTop Key) :=
le_trans (resolve_le_key_of_offset_nonpos hbegin) hlo'
rw [hred_beg, hred_end]
by_cases hlk : ((last : Key) : WithTop Key) ≤ ((k : Key) : WithTop Key)
· have hred : resolve db r.begin ≤ ((k : Key) : WithTop Key) ↔
resolve db ({ key := ((last : Key) : WithTop Key), offset := 1 } : Selector) ≤
((k : Key) : WithTop Key) := by
constructor
· intro _; exact hkey.mp (WithTop.coe_le_coe.mp hlk)
· intro _; exact le_trans hstart hlk
have hconj : (resolve db r.begin ≤ ((k : Key) : WithTop Key) ∧
((k : Key) : WithTop Key) < resolve db r.end_) ↔
(resolve db ({ key := ((last : Key) : WithTop Key), offset := 1 } : Selector) ≤
((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < resolve db r.end_) := by
constructor <;> rintro ⟨h1, h2⟩
· exact ⟨hred.mp h1, h2⟩
· exact ⟨hred.mpr h1, h2⟩
rw [decide_eq_true (WithTop.coe_le_coe.mp hlk), Bool.true_and, Bool.true_and,
decide_eq_decide.mpr hconj]
· rw [show decide (last ≤ k) = false
from decide_eq_false_iff_not.mpr (fun h => hlk (WithTop.coe_le_coe.mpr h)),
Bool.false_and, Bool.false_and]
/-- Compatibility is invariant under the reversed nonpositive reduction. -/
theorem compatible_iff_nonposRevReduced {db : DB} {r : RangeRead} {res : Result}
(hrev : r.reverse = true) (hmore : res.more = true) (hne : res.keys ≠ [])
(hbegin : r.begin.offset ≤ 0)
(hlo : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) :
RangeRead.Compatible db r res ↔ RangeRead.Compatible db (nonposRevReduced r res) 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 hred_rev : (nonposRevReduced r res).reverse = true := by
simp [nonposRevReduced, hrev]
rw [compatible_iff_truncated_keys_rev hrev hmore hne,
compatible_iff_truncated_keys_rev (db := db) (r := nonposRevReduced r res) hred_rev hmore hne]
have hf := completeKeys_filter_ge_eq_nonposRevReduced (db := db) (r := r) (res := res)
hrev hbegin hlo
rw [hlast] at hf
have hlim : (nonposRevReduced r res).withinLimit res.keys ↔ r.withinLimit res.keys := by
simp [nonposRevReduced, RangeRead.withinLimit]
rw [hf]
constructor
· rintro ⟨h1, h2⟩
exact ⟨hlim.mpr h1, h2⟩
· rintro ⟨h1, h2⟩
exact ⟨hlim.mp h1, h2⟩
/-- Range soundness is invariant under a change of read that preserves compatibility. -/
theorem sound_congr_of_compatible_iff {r r' : RangeRead} {res : Result} {cr : ConflictRange}
(h : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res) :
Sound r res cr ↔ Sound r' res cr := by
unfold Sound
constructor <;> intro hs db₁ db₂ hagree
· exact (h db₁).symm.trans ((hs db₁ db₂ hagree).trans (h db₂))
· exact (h db₁).trans ((hs db₁ db₂ hagree).trans (h db₂).symm)
/-- Minimality is invariant under a change of read that preserves compatibility. -/
theorem minimal_congr_of_compatible_iff {r r' : RangeRead} {res : Result} {cr : ConflictRange}
(h : ∀ db, RangeRead.Compatible db r res ↔ RangeRead.Compatible db r' res) :
Minimal r res cr ↔ Minimal r' res cr := by
have hS : ∀ cr, Sound r res cr ↔ Sound r' res cr :=
fun cr => sound_congr_of_compatible_iff (cr := cr) h
have hN : ∀ k, Necessary r res k ↔ Necessary r' res k := by
intro k
unfold Necessary
exact ⟨fun hk cr hs => hk cr ((hS cr).mpr hs),
fun hk cr hs => hk cr ((hS cr).mp hs)⟩
rw [minimal_iff_sound_and_necessary, minimal_iff_sound_and_necessary]
constructor
· rintro ⟨hs, hnec⟩
exact ⟨(hS cr).mp hs, fun k hk => (hN k).mp (hnec k hk)⟩
· rintro ⟨hs, hnec⟩
exact ⟨(hS cr).mpr hs, fun k hk => (hN k).mpr (hnec k hk)⟩
/-- The cross-free nonpositive-begin reversed truncated closed form, via the
offset-one reduction. -/
noncomputable def closedFormNonposRevTrunc (r : RangeRead) (res : Result) : ConflictRange :=
closedFormOffsetOneTotal (nonposRevReduced r res) res
/-- A nonempty *truncated reversed* result at a nonpositive begin offset, cross-free,
with the begin key at or below the least reported key. Every end offset is allowed. -/
abbrev nonposRevTrunc (r : RangeRead) (res : Result) : Prop :=
res.more = true ∧ r.reverse = true ∧ r.begin.offset ≤ 0 ∧
r.begin.key ≤ ((leastReported r res : Key) : WithTop Key)
/-- **The cross-free nonpositive-begin reversed truncated closed form is minimal.** -/
theorem minimal_closedForm_of_nonpos_revTrunc {r : RangeRead} {res : Result}
(hread : Readable r res) (h : nonposRevTrunc r res) :
Minimal r res (closedFormNonposRevTrunc r res) := by
obtain ⟨hmore, hrev, hbegin, hloD⟩ := h
obtain ⟨db, hcomp⟩ := hread
have hne : res.keys ≠ [] := RangeRead.compatible_ne_nil_of_more hcomp hmore
have hlo : r.begin.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) := by
simpa [leastReported, hrev] using hloD
have hcompiff : ∀ db, RangeRead.Compatible db r res ↔
RangeRead.Compatible db (nonposRevReduced r res) res :=
fun db => compatible_iff_nonposRevReduced hrev hmore hne hbegin hlo
have hread' : Readable (nonposRevReduced r res) res := ⟨db, (hcompiff db).mp hcomp⟩
have hmin' : Minimal (nonposRevReduced r res) res
(closedFormOffsetOneTotal (nonposRevReduced r res) res) :=
minimal_closedForm_of_offset_one_total hread' hne rfl
unfold closedFormNonposRevTrunc
exact (minimal_congr_of_compatible_iff (r := r) (r' := nonposRevReduced r res)
(res := res) (cr := closedFormOffsetOneTotal (nonposRevReduced r res) res) hcompiff).mpr hmin'
end FormalConflictRange