474 lines
26 KiB
Lean4
474 lines
26 KiB
Lean4
/-
|
||
Released under Apache 2.0 license as described in the file LICENSE.
|
||
-/
|
||
import FormalConflictRange.NegCrossComplete
|
||
import FormalConflictRange.NegCrossClosedForm
|
||
import FormalConflictRange.NonposRevClosedForm
|
||
|
||
/-!
|
||
# The crossed negative-begin complete non-overshoot residual
|
||
|
||
This module closes the remaining crossed negative-begin complete cells: those with
|
||
`2 ≤ end.offset`, `begin.key` strictly above the reported head, and at least one
|
||
reported key at or above `end.key`.
|
||
|
||
The key observation is that the end selector can be shifted to the immediate successor
|
||
of the last reported key without changing any compatible database. If `L` is the last
|
||
reported key and `t` is the number of reported keys at or above `end.key`, then the
|
||
original end anchor is `cnt end.key + end.offset - 1`, while the anchor of
|
||
`⟨keyAfter L, end.offset - t⟩` is `cnt (keyAfter L) + end.offset - t - 1`. Because the
|
||
half-open gap `[end.key, keyAfter L)` contains only reported keys in every compatible
|
||
database, `cnt (keyAfter L) = cnt end.key + t`, so the two anchors agree. The reduced
|
||
read has all reported keys strictly below its end key; it is therefore a complete
|
||
overshoot (`2 ≤ end.offset - t`) or an offset-one cell. Minimality transfers between
|
||
the two reads directly, since their compatible database sets coincide.
|
||
-/
|
||
|
||
namespace FormalConflictRange
|
||
|
||
/-- The number of reported keys at or above the end selector key. -/
|
||
def reportedAtOrAboveEnd (r : RangeRead) (res : Result) : ℕ :=
|
||
res.keys.countP (fun k : Key => decide (r.end_.key ≤ ((k : Key) : WithTop Key)))
|
||
|
||
/-- The read whose end selector is shifted to the successor of the last reported key.
|
||
The offset is reduced by the number of reported keys at or above `end.key`, so the end
|
||
anchor (and hence every resolution) is unchanged on compatible databases. -/
|
||
noncomputable def completeResidualReduced (r : RangeRead) (res : Result) : RangeRead :=
|
||
{ r with
|
||
end_ :=
|
||
{ key := ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)
|
||
offset := r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) } }
|
||
|
||
/-- **The gap `[end.key, keyAfter L)` contains exactly the reported keys at or above
|
||
`end.key`.** The result keys are the stored keys of the half-open window, `L` is the
|
||
last reported key, and `end.key` lies between the window's lower bound and `L`. Any
|
||
stored key strictly above `L` but below the window's upper bound would be reported and
|
||
contradict `L` being last. -/
|
||
theorem between_end_keyAfter_length_eq_reportedAtOrAboveEnd
|
||
{db : DB} {res : Result} {lo hi : WithTop Key} {E : WithTop Key}
|
||
(hne : res.keys ≠ [])
|
||
(hkeys : res.keys = RangeRead.inRange db.keys lo hi)
|
||
(hloE : lo ≤ E)
|
||
(_hEL : E ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||
(_hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) :
|
||
(between db E ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key)).length =
|
||
res.keys.countP (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key))) := by
|
||
set L : Key := res.keys.getLastD ([] : Key) with hL
|
||
have hLget : L = res.keys.getLast hne := by
|
||
rw [hL]
|
||
exact getLastD_eq_getLast_of_ne hne
|
||
have hLmem : L ∈ res.keys := by rw [hLget]; exact List.getLast_mem hne
|
||
have hpair : res.keys.Pairwise (· < ·) := hkeys.symm ▸ RangeRead.inRange_pairwise db lo hi
|
||
have hmax : ∀ x ∈ res.keys, x ≤ L := fun x hx => le_getLastD_of_pairwise hpair hx
|
||
have hLin : L ∈ RangeRead.inRange db.keys lo hi := hkeys.symm ▸ hLmem
|
||
have hLin' : L ∈ db.keys ∧ lo ≤ (L : WithTop Key) ∧ (L : WithTop Key) < hi := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin
|
||
have hLstored : L ∈ db.keys := hLin'.1
|
||
-- No stored key lies strictly between `L` and the window's upper bound.
|
||
have hno_above : ∀ x ∈ db.keys, L < x → hi ≤ (x : WithTop Key) := by
|
||
intro x hxdb hxL
|
||
by_contra hxhi
|
||
have hxhi' : (x : WithTop Key) < hi := lt_of_not_ge hxhi
|
||
have hxin : x ∈ RangeRead.inRange db.keys lo hi := by
|
||
simp only [RangeRead.inRange, List.mem_filter, decide_eq_true_eq]
|
||
exact ⟨hxdb, le_trans hLin'.2.1 (WithTop.coe_le_coe.mpr (le_of_lt hxL)), hxhi'⟩
|
||
have hxmem : x ∈ res.keys := hkeys.symm ▸ hxin
|
||
exact absurd (hmax x hxmem) (not_le.mpr hxL)
|
||
-- The two filters agree: both select the stored keys in `[E, L]`.
|
||
have hflt : (db.keys.filter (fun k : Key =>
|
||
decide (E ≤ ((k : Key) : WithTop Key) ∧
|
||
((k : Key) : WithTop Key) < ((keyAfter L : Key) : WithTop Key)))) =
|
||
(db.keys.filter (fun k : Key =>
|
||
decide (E ≤ ((k : Key) : WithTop Key) ∧ ((k : Key) : WithTop Key) < hi))) := by
|
||
apply List.filter_congr
|
||
intro x hxdb
|
||
rw [decide_eq_decide]
|
||
constructor
|
||
· rintro ⟨hEx, hxka⟩
|
||
refine ⟨hEx, lt_of_le_of_lt ?_ hLin'.2.2⟩
|
||
exact WithTop.coe_le_coe.mpr ((lt_keyAfter_iff x L).mp (WithTop.coe_lt_coe.mp hxka))
|
||
· rintro ⟨hEx, hxhi⟩
|
||
refine ⟨hEx, ?_⟩
|
||
by_contra hcon
|
||
have hxge : ((keyAfter L : Key) : WithTop Key) ≤ ((x : Key) : WithTop Key) :=
|
||
le_of_not_gt hcon
|
||
have hxL : L < x :=
|
||
lt_of_lt_of_le (keyAfter_self_lt L) (WithTop.coe_le_coe.mp hxge)
|
||
exact absurd hxhi (not_lt.mpr (hno_above x hxdb hxL))
|
||
-- Convert to the reported-key count.
|
||
rw [show (between db E ((keyAfter L : Key) : WithTop Key)) =
|
||
db.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key) ∧
|
||
((k : Key) : WithTop Key) < ((keyAfter L : Key) : WithTop Key))) by
|
||
rfl]
|
||
rw [hflt]
|
||
-- The reported keys at or above `E` are exactly the stored keys in `[E, hi)`.
|
||
have hreported : res.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key))) =
|
||
RangeRead.inRange db.keys E hi := by
|
||
rw [hkeys]
|
||
unfold RangeRead.inRange
|
||
rw [List.filter_filter]
|
||
apply List.filter_congr
|
||
intro x _
|
||
by_cases hE : E ≤ ((x : Key) : WithTop Key)
|
||
· by_cases hhi : ((x : Key) : WithTop Key) < hi
|
||
· have hlo : lo ≤ ((x : Key) : WithTop Key) := le_trans hloE hE
|
||
simp [hE, hhi, hlo]
|
||
· simp [hE, hhi]
|
||
· simp [hE]
|
||
have hlen : (db.keys.filter (fun k : Key => decide (E ≤ ((k : Key) : WithTop Key) ∧
|
||
((k : Key) : WithTop Key) < hi))) =
|
||
RangeRead.inRange db.keys E hi := rfl
|
||
rw [hlen, ← hreported, List.countP_eq_length_filter]
|
||
|
||
/-- The count identity behind the reduction: the number of stored keys below the
|
||
successor of the last reported key is the count below `end.key` plus the number of
|
||
reported keys at or above `end.key`. -/
|
||
theorem cnt_keyAfter_eq_cnt_end_add
|
||
{db : DB} {r : RangeRead} {res : Result} {lo hi : WithTop Key}
|
||
(hne : res.keys ≠ [])
|
||
(hkeys : res.keys = RangeRead.inRange db.keys lo hi)
|
||
(hloE : lo ≤ r.end_.key)
|
||
(hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||
(hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) :
|
||
cnt db ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) =
|
||
cnt db r.end_.key + reportedAtOrAboveEnd r res := by
|
||
have hEL' : r.end_.key ≤ ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) :=
|
||
le_trans hEL (WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt _)))
|
||
rw [cnt_eq_add_between db hEL',
|
||
between_end_keyAfter_length_eq_reportedAtOrAboveEnd hne hkeys hloE hEL hLhi]
|
||
rfl
|
||
|
||
/-- The shifted end selector has the same anchor as the original on any compatible
|
||
complete result. -/
|
||
theorem reduced_end_anchor_eq
|
||
{db : DB} {r : RangeRead} {res : Result} {lo hi : WithTop Key}
|
||
(hne : res.keys ≠ [])
|
||
(hkeys : res.keys = RangeRead.inRange db.keys lo hi)
|
||
(hloE : lo ≤ r.end_.key)
|
||
(hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||
(hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi) :
|
||
(completeResidualReduced r res).end_.anchor db = r.end_.anchor db := by
|
||
have hcnt := cnt_keyAfter_eq_cnt_end_add hne hkeys hloE hEL hLhi
|
||
change (cnt db ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) : ℤ) +
|
||
(r.end_.offset - (reportedAtOrAboveEnd r res : ℤ)) - 1 =
|
||
(cnt db r.end_.key : ℤ) + r.end_.offset - 1
|
||
rw [hcnt]
|
||
push_cast
|
||
ring
|
||
|
||
/-- The complete keys of a forward read are the stored keys in the resolved window. -/
|
||
theorem completeKeys_eq_inRange_of_not_rev {db : DB} {r : RangeRead}
|
||
(hrev : r.reverse = false) :
|
||
RangeRead.completeKeys db r =
|
||
RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by
|
||
unfold RangeRead.completeKeys
|
||
rw [ite_eq_right (by simp [hrev])]
|
||
|
||
/-- **The reduction preserves compatible databases.** Under the complete-result
|
||
hypotheses and the cell condition that the resolved begin is at or below `end.key`
|
||
(which follows from `head ≤ end.key`), shifting the end selector to
|
||
`⟨keyAfter (last reported), end.offset - t⟩` leaves the set of compatible databases
|
||
unchanged. -/
|
||
theorem compatible_reduced_iff
|
||
{db : DB} {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ [])
|
||
(hheadE : ((res.keys.headD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key)
|
||
(hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)) :
|
||
RangeRead.Compatible db r res ↔
|
||
RangeRead.Compatible db (completeResidualReduced r res) res := by
|
||
have hwithin : RangeRead.withinLimit r res.keys ↔
|
||
RangeRead.withinLimit (completeResidualReduced r res) res.keys := by
|
||
simp [RangeRead.withinLimit, completeResidualReduced]
|
||
have hrev' : (completeResidualReduced r res).reverse = false := hrev
|
||
constructor
|
||
· intro h
|
||
have heq : res.keys = RangeRead.completeKeys db r := by
|
||
rcases h.2 with ⟨hm, -, -⟩ | ⟨-, he⟩
|
||
· simp [hmore] at hm
|
||
· exact he
|
||
have hkeys : res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) :=
|
||
heq.trans (completeKeys_eq_inRange_of_not_rev hrev)
|
||
have hloE : resolve db r.begin ≤ r.end_.key := by
|
||
have hheadmem : res.keys.headD ([] : Key) ∈ res.keys := headD_mem hne
|
||
have hheadin : res.keys.headD ([] : Key) ∈
|
||
RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by
|
||
rw [← hkeys]; exact hheadmem
|
||
have hheadin' : (res.keys.headD ([] : Key)) ∈ db.keys ∧
|
||
resolve db r.begin ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧
|
||
((res.keys.headD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hheadin
|
||
exact le_trans hheadin'.2.1 hheadE
|
||
have hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) <
|
||
resolve db r.end_ := by
|
||
have hLin : (res.keys.getLastD ([] : Key)) ∈
|
||
RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by
|
||
rw [← hkeys]; exact getLastD_mem hne
|
||
have hLin' : (res.keys.getLastD ([] : Key)) ∈ db.keys ∧
|
||
resolve db r.begin ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin
|
||
exact hLin'.2.2
|
||
have hanc := reduced_end_anchor_eq (db := db) (r := r) (res := res)
|
||
(lo := resolve db r.begin) (hi := resolve db r.end_) hne hkeys hloE hEL hLhi
|
||
have hres_eq : resolve db (completeResidualReduced r res).end_ = resolve db r.end_ := by
|
||
unfold resolve
|
||
rw [hanc]
|
||
refine ⟨hwithin.mp h.1, Or.inr ⟨hmore, ?_⟩⟩
|
||
rw [heq, completeKeys_eq_inRange_of_not_rev hrev,
|
||
completeKeys_eq_inRange_of_not_rev hrev', hres_eq]
|
||
simp only [completeResidualReduced]
|
||
· intro h
|
||
have heq : res.keys = RangeRead.completeKeys db (completeResidualReduced r res) := by
|
||
rcases h.2 with ⟨hm, -, -⟩ | ⟨-, he⟩
|
||
· simp [hmore] at hm
|
||
· exact he
|
||
have hkeys : res.keys = RangeRead.inRange db.keys (resolve db r.begin)
|
||
(resolve db (completeResidualReduced r res).end_) :=
|
||
heq.trans (completeKeys_eq_inRange_of_not_rev hrev')
|
||
have hloE : resolve db r.begin ≤ r.end_.key := by
|
||
have hheadmem : res.keys.headD ([] : Key) ∈ res.keys := headD_mem hne
|
||
have hheadin : res.keys.headD ([] : Key) ∈
|
||
RangeRead.inRange db.keys (resolve db r.begin)
|
||
(resolve db (completeResidualReduced r res).end_) := by
|
||
rw [← hkeys]; exact hheadmem
|
||
have hheadin' : (res.keys.headD ([] : Key)) ∈ db.keys ∧
|
||
resolve db r.begin ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧
|
||
((res.keys.headD ([] : Key) : Key) : WithTop Key) <
|
||
resolve db (completeResidualReduced r res).end_ := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hheadin
|
||
exact le_trans hheadin'.2.1 hheadE
|
||
have hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) <
|
||
resolve db (completeResidualReduced r res).end_ := by
|
||
have hLin : (res.keys.getLastD ([] : Key)) ∈
|
||
RangeRead.inRange db.keys (resolve db r.begin)
|
||
(resolve db (completeResidualReduced r res).end_) := by
|
||
rw [← hkeys]; exact getLastD_mem hne
|
||
have hLin' : (res.keys.getLastD ([] : Key)) ∈ db.keys ∧
|
||
resolve db r.begin ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) <
|
||
resolve db (completeResidualReduced r res).end_ := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin
|
||
exact hLin'.2.2
|
||
have hanc := reduced_end_anchor_eq (db := db) (r := r) (res := res)
|
||
(lo := resolve db r.begin) (hi := resolve db (completeResidualReduced r res).end_)
|
||
hne hkeys hloE hEL hLhi
|
||
have hres_eq : resolve db r.end_ = resolve db (completeResidualReduced r res).end_ := by
|
||
unfold resolve
|
||
rw [hanc]
|
||
refine ⟨hwithin.mpr h.1, Or.inr ⟨hmore, ?_⟩⟩
|
||
rw [heq, completeKeys_eq_inRange_of_not_rev hrev',
|
||
completeKeys_eq_inRange_of_not_rev hrev, hres_eq]
|
||
simp only [completeResidualReduced]
|
||
|
||
/-- The number of stored keys below a resolution is at most its clamped anchor index. -/
|
||
theorem cnt_resolve_le_anchor_toNat {db : DB} {s : Selector} (h0 : 0 ≤ s.anchor db) :
|
||
cnt db (resolve db s) ≤ (s.anchor db).toNat := by
|
||
rcases resolve_eq_nil_or_eq_top_or_mem (db := db) (s := s) with hnil | htop | ⟨k, hkdb, hkeq⟩
|
||
· rw [hnil, cnt_nil]; omega
|
||
· rw [htop, cnt_top]
|
||
have hlen : db.keys.length ≤ (s.anchor db).toNat := by
|
||
by_contra hcon
|
||
have hlt : (s.anchor db).toNat < db.keys.length := lt_of_not_ge hcon
|
||
rw [resolve_eq_getElem h0 hlt] at htop
|
||
exact absurd htop (by simp)
|
||
exact hlen
|
||
· rw [hkeq]
|
||
have hlt : (s.anchor db).toNat < db.keys.length := by
|
||
by_contra hcon
|
||
exact absurd (resolve_eq_top h0 (le_of_not_gt hcon) ▸ hkeq : (⊤ : WithTop Key) = ↑k) (by simp)
|
||
have hget : db.keys[(s.anchor db).toNat] = k := by
|
||
have := resolve_eq_getElem (db := db) (s := s) h0 hlt
|
||
rw [hkeq] at this
|
||
exact WithTop.coe_inj.mp this.symm
|
||
rw [cnt_coe, countP_lt_eq_of_getElem db.sorted hlt hget]
|
||
|
||
/-- **The reduced end offset is positive.** The last reported key lies strictly below
|
||
the resolved end, so the successor of the last reported key is at most the resolved
|
||
end; hence the number of stored keys below the successor is at most the end anchor,
|
||
which is `cnt end.key + end.offset - 1`. The count identity then gives
|
||
`end.offset - t ≥ 1`. -/
|
||
theorem endOffset_sub_reportedAtOrAboveEnd_ge_one
|
||
{db : DB} {r : RangeRead} {res : Result} {lo hi : WithTop Key}
|
||
(hne : res.keys ≠ [])
|
||
(hkeys : res.keys = RangeRead.inRange db.keys lo hi)
|
||
(hloE : lo ≤ r.end_.key)
|
||
(hEL : r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key))
|
||
(hLhi : ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < hi)
|
||
(hhi : hi = resolve db r.end_)
|
||
(heo : 1 ≤ r.end_.offset) :
|
||
1 ≤ r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) := by
|
||
have hcnt := cnt_keyAfter_eq_cnt_end_add hne hkeys hloE hEL hLhi
|
||
have hkeyle : ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) ≤
|
||
resolve db r.end_ := by
|
||
rw [← hhi]
|
||
exact keyAfter_le_of_lt hLhi
|
||
have hle1 : cnt db ((keyAfter (res.keys.getLastD ([] : Key)) : Key) : WithTop Key) ≤
|
||
cnt db (resolve db r.end_) := cnt_le_cnt_of_le db hkeyle
|
||
have h0 : 0 ≤ r.end_.anchor db := by
|
||
unfold Selector.anchor
|
||
have : (0 : ℤ) ≤ (db.keys.countP (fun k : Key =>
|
||
decide ((↑k : WithTop Key) < r.end_.key)) : ℤ) := Int.natCast_nonneg _
|
||
omega
|
||
have hle2 : cnt db (resolve db r.end_) ≤ (r.end_.anchor db).toNat :=
|
||
cnt_resolve_le_anchor_toNat h0
|
||
have hanc : (r.end_.anchor db).toNat =
|
||
cnt db r.end_.key + (r.end_.offset - 1).toNat :=
|
||
anchor_toNat_eq (s := r.end_) heo
|
||
have hcntle : reportedAtOrAboveEnd r res ≤ (r.end_.offset - 1).toNat := by
|
||
rw [hcnt] at hle1
|
||
omega
|
||
have hcast : ((reportedAtOrAboveEnd r res : ℕ) : ℤ) ≤ r.end_.offset - 1 := by
|
||
have hd0 : 0 ≤ r.end_.offset - 1 := by omega
|
||
have h2 : ((r.end_.offset - 1).toNat : ℤ) = r.end_.offset - 1 :=
|
||
Int.toNat_of_nonneg hd0
|
||
exact le_trans (by exact_mod_cast hcntle) (le_of_eq h2)
|
||
omega
|
||
|
||
/-- The forward crossed negative-begin complete residual non-overshoot cell: at least one
|
||
reported key is at or above `end.key`, but the reported head is at or below `end.key` and
|
||
the reported last is at or above it. -/
|
||
abbrev negCrossCompleteResidual (r : RangeRead) (res : Result) : Prop :=
|
||
r.reverse = false ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
|
||
2 ≤ r.end_.offset ∧
|
||
((res.keys.headD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
||
((res.keys.headD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key ∧
|
||
r.end_.key ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key)
|
||
|
||
/-- The closed form for the residual: shift the end selector to the successor of the last
|
||
reported key, then read off the overshoot or offset-one rule of the shifted read. -/
|
||
noncomputable def closedFormNegCrossCompleteResidual (r : RangeRead) (res : Result) :
|
||
ConflictRange :=
|
||
let r' := completeResidualReduced r res
|
||
if 2 ≤ r'.end_.offset then closedFormNegCrossOvershoot r' res
|
||
else if reportedBelowBegin r' res ≤ beginSlack r' then closedFormNegCrossClampEndOne r' res
|
||
else if r.begin.key ≤ r'.end_.key then closedFormNegCrossEndOne r' res
|
||
else closedFormNegCrossEndOneLong r' res
|
||
|
||
/-- The last reported key lies strictly below the resolved end of any compatible complete
|
||
forward database, and every reported key is at or below it. -/
|
||
theorem complete_residual_last_facts {db : DB} {r : RangeRead} {res : Result}
|
||
(hrev : r.reverse = false) (hmore : res.more = false) (hne : res.keys ≠ [])
|
||
(hcomp : RangeRead.Compatible db r res) :
|
||
res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ ∧
|
||
List.Pairwise (· < ·) res.keys := by
|
||
have heq : res.keys = RangeRead.completeKeys db r := by
|
||
rcases hcomp.2 with ⟨hm, -, -⟩ | ⟨-, he⟩
|
||
· simp [hmore] at hm
|
||
· exact he
|
||
have hkeys : res.keys = RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) :=
|
||
heq.trans (completeKeys_eq_inRange_of_not_rev hrev)
|
||
refine ⟨hkeys, ?_, ?_⟩
|
||
· have hLin : (res.keys.getLastD ([] : Key)) ∈
|
||
RangeRead.inRange db.keys (resolve db r.begin) (resolve db r.end_) := by
|
||
rw [← hkeys]; exact getLastD_mem hne
|
||
have hLin' : (res.keys.getLastD ([] : Key)) ∈ db.keys ∧
|
||
resolve db r.begin ≤ ((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < resolve db r.end_ := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hLin
|
||
exact hLin'.2.2
|
||
· exact hkeys.symm ▸ RangeRead.inRange_pairwise db _ _
|
||
|
||
/-- **The crossed negative-begin complete residual non-overshoot cell is minimal.** -/
|
||
theorem minimal_closedForm_of_negCross_complete_residual {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hcell : negCrossCompleteResidual r res) :
|
||
Minimal r res (closedFormNegCrossCompleteResidual r res) := by
|
||
obtain ⟨hrev, hbegin, hmore, hne, hend2, hcrossD, hheadE, hEL⟩ := hcell
|
||
obtain ⟨db₀, hcomp₀⟩ := hread
|
||
obtain ⟨hkeys₀, hlast_lt, hpair₀⟩ := complete_residual_last_facts hrev hmore hne hcomp₀
|
||
have hheadmem : res.keys.headD ([] : Key) ∈ res.keys := headD_mem hne
|
||
have hheadin : res.keys.headD ([] : Key) ∈
|
||
RangeRead.inRange db₀.keys (resolve db₀ r.begin) (resolve db₀ r.end_) := by
|
||
rw [← hkeys₀]; exact hheadmem
|
||
have hheadin' : (res.keys.headD ([] : Key)) ∈ db₀.keys ∧
|
||
resolve db₀ r.begin ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key) ∧
|
||
((res.keys.headD ([] : Key) : Key) : WithTop Key) < resolve db₀ r.end_ := by
|
||
simpa [RangeRead.inRange, List.mem_filter, decide_eq_true_eq] using hheadin
|
||
have hloE₀ : resolve db₀ r.begin ≤ r.end_.key := le_trans hheadin'.2.1 hheadE
|
||
have hpos : 1 ≤ r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) :=
|
||
endOffset_sub_reportedAtOrAboveEnd_ge_one hne hkeys₀ hloE₀ hEL hlast_lt rfl (by omega)
|
||
have hcompat : ∀ db, RangeRead.Compatible db r res ↔
|
||
RangeRead.Compatible db (completeResidualReduced r res) res :=
|
||
fun db => compatible_reduced_iff hrev hmore hne hheadE hEL
|
||
have hread' : Readable (completeResidualReduced r res) res := ⟨db₀, (hcompat db₀).mp hcomp₀⟩
|
||
have hrev' : (completeResidualReduced r res).reverse = false := hrev
|
||
have hhi : ∀ k ∈ res.keys, ((k : Key) : WithTop Key) <
|
||
(completeResidualReduced r res).end_.key := by
|
||
intro k hk
|
||
have hkle : k ≤ res.keys.getLastD ([] : Key) := le_getLastD_of_pairwise hpair₀ hk
|
||
exact lt_of_le_of_lt (WithTop.coe_le_coe.mpr hkle)
|
||
(WithTop.coe_lt_coe.mpr (keyAfter_self_lt _))
|
||
have hcross : ((res.keys.head hne : Key) : WithTop Key) < r.begin.key := by
|
||
rw [← headD_eq_head_of_ne hne]; exact hcrossD
|
||
rw [minimal_congr_of_compatible_iff hcompat]
|
||
unfold closedFormNegCrossCompleteResidual
|
||
have hred : (completeResidualReduced r res).end_.offset =
|
||
r.end_.offset - (reportedAtOrAboveEnd r res : ℤ) := rfl
|
||
by_cases hbig : 2 ≤ (completeResidualReduced r res).end_.offset
|
||
· rw [ite_eq_left hbig]
|
||
exact minimal_closedForm_of_negCross_overshoot hread' hrev' hbegin hmore hne hbig hhi hcross
|
||
· rw [ite_eq_right hbig]
|
||
have hoff1 : (completeResidualReduced r res).end_.offset = 1 := by omega
|
||
by_cases hclamp : reportedBelowBegin (completeResidualReduced r res) res ≤
|
||
beginSlack (completeResidualReduced r res)
|
||
· rw [ite_eq_left hclamp]
|
||
exact minimal_closedForm_of_negCross_clampEndOne hread'
|
||
⟨hrev', hbegin, hmore, hne, hoff1, hcrossD, hclamp⟩
|
||
· rw [ite_eq_right hclamp]
|
||
have hnc : beginSlack (completeResidualReduced r res) <
|
||
reportedBelowBegin (completeResidualReduced r res) res := not_le.mp hclamp
|
||
by_cases hB : r.begin.key ≤ (completeResidualReduced r res).end_.key
|
||
· rw [ite_eq_left hB]
|
||
exact minimal_closedForm_of_negCross_endOne hread'
|
||
⟨hrev', hbegin, hmore, hne, hoff1, hcrossD, hnc, hB⟩
|
||
· rw [ite_eq_right hB]
|
||
exact minimal_closedForm_of_negCross_endOne_long hread'
|
||
⟨hrev', hbegin, hmore, hne, hoff1, hcrossD, hnc, not_le.mp hB⟩
|
||
|
||
/-- The reversed crossed negative-begin complete residual non-overshoot cell. -/
|
||
abbrev negCrossCompleteResidualRev (r : RangeRead) (res : Result) : Prop :=
|
||
r.reverse = true ∧ r.begin.offset < 0 ∧ res.more = false ∧ res.keys ≠ [] ∧
|
||
2 ≤ r.end_.offset ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) < r.begin.key ∧
|
||
((res.keys.getLastD ([] : Key) : Key) : WithTop Key) ≤ r.end_.key ∧
|
||
r.end_.key ≤ ((res.keys.headD ([] : Key) : Key) : WithTop Key)
|
||
|
||
/-- The reversed closed form, expressed through the forward rule on the flipped read. -/
|
||
noncomputable def closedFormNegCrossCompleteResidualRev (r : RangeRead) (res : Result) :
|
||
ConflictRange :=
|
||
closedFormNegCrossCompleteResidual { r with reverse := false }
|
||
{ keys := res.keys.reverse, more := false }
|
||
|
||
/-- **The reversed crossed negative-begin complete residual non-overshoot cell is
|
||
minimal**, by flipping the traversal. -/
|
||
theorem minimal_closedForm_of_negCross_complete_residual_rev {r : RangeRead} {res : Result}
|
||
(hread : Readable r res) (hcell : negCrossCompleteResidualRev r res) :
|
||
Minimal r res (closedFormNegCrossCompleteResidualRev r res) := by
|
||
obtain ⟨hrev, hbegin, hmore, hne, hend2, hcrossD, hheadE, hEL⟩ := hcell
|
||
have hne' : res.keys.reverse ≠ [] := by simpa using hne
|
||
have hheadD : res.keys.reverse.headD ([] : Key) = res.keys.getLastD ([] : Key) := by
|
||
rw [List.headD_eq_head?, List.getLastD_eq_getLast?, List.head?_reverse]
|
||
have hlastD : res.keys.reverse.getLastD ([] : Key) = res.keys.headD ([] : Key) := by
|
||
rw [List.getLastD_eq_getLast?, List.headD_eq_head?, List.getLast?_reverse]
|
||
have hpair : List.Pairwise (· < ·) res.keys.reverse := by
|
||
obtain ⟨db, hcompd⟩ := hread
|
||
simpa using ((RangeRead.compatible_pairwise hcompd).2 hrev).reverse
|
||
have hcell' : negCrossCompleteResidual { r with reverse := false }
|
||
{ keys := res.keys.reverse, more := false } := by
|
||
refine ⟨rfl, hbegin, rfl, hne', hend2, ?_, ?_, ?_⟩
|
||
· rw [hheadD]; exact hcrossD
|
||
· rw [hheadD]; exact hheadE
|
||
· rw [hlastD]; exact hEL
|
||
have hread' : Readable { r with reverse := false }
|
||
{ keys := res.keys.reverse, more := false } := by
|
||
obtain ⟨db, hcomp⟩ := hread
|
||
exact ⟨db, (compatible_flip (db := db) (b := true) hrev hmore).mpr hcomp⟩
|
||
have hmin := minimal_closedForm_of_negCross_complete_residual hread' hcell'
|
||
exact (minimal_flip (b := true) hrev hmore).mp (by
|
||
change Minimal { r with reverse := false } { keys := res.keys.reverse, more := false }
|
||
(closedFormNegCrossCompleteResidual { r with reverse := false }
|
||
{ keys := res.keys.reverse, more := false })
|
||
exact hmin)
|
||
|
||
end FormalConflictRange
|