Prove conflict-range closed-form minimality
- Vendor the FormalConflictRange reference library needed by the proof - Add Bridge.lean with simp lemmas connecting the Statement definitions to the reference library - Prove Statement.closedFormMinimal in Proof.lean - Register the new libraries in the Lake config
This commit is contained in:
1 parent
7a0826e873
commit
a54a5f82f8
78 files changed
+91636
-2
No files matched your search
@@ -0,0 +1,185 @@
|
||||
/-
|
||||
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.NegCrossLongNonpos
|
||||
|
||||
/-!
|
||||
# The truncated negative-begin anchor bound
|
||||
|
||||
The complete negative-begin cells show that a negative begin anchor forces the capacity
|
||||
bound `clampNonposBottom` (`clampNonposBottom_of_anchor_neg`,
|
||||
`clampNonposBottom_of_anchor_neg_long`). This module proves the truncated analogue: for a
|
||||
forward result reporting `more`, a negative begin offset and a nonpositive end offset, a
|
||||
negative begin anchor still forces `clampNonposBottom`.
|
||||
|
||||
The only difference from the complete case is that the reported keys are a prefix of the
|
||||
complete window rather than the whole window. The reported keys below `begin.key` are
|
||||
therefore a *sub*-count of the complete keys, which is enough: the complete window has
|
||||
`clampNonposD + 1` keys in `[resolve end, end.key)`, so the count below `begin.key` still
|
||||
forces the capacity inequality.
|
||||
-/
|
||||
|
||||
open FormalConflictRange
|
||||
|
||||
namespace FormalConflictRange
|
||||
|
||||
/-- In a compatible forward truncated nonpositive-end read, the reported keys below
|
||||
`begin.key` are no more numerous than the complete window, i.e. the stored keys below
|
||||
`resolve end`. -/
|
||||
theorem reportedBelowBegin_le_cnt_resolve_end {db : DB} {r : RangeRead} {res : Result}
|
||||
(hcomp : RangeRead.Compatible db r res) (hrev : r.reverse = false) :
|
||||
reportedBelowBegin r res ≤ cnt db (resolve db r.end_) := by
|
||||
have htlen : reportedBelowBegin r res ≤ res.keys.length :=
|
||||
List.countP_le_length
|
||||
have hpre := RangeRead.compatible_keys_prefix hcomp
|
||||
have hlenle : res.keys.length ≤ (RangeRead.completeKeys db r).length :=
|
||||
hpre.length_le
|
||||
have hck : (RangeRead.completeKeys db r).length ≤ cnt db (resolve db r.end_) := by
|
||||
rw [RangeRead.completeKeys, if_neg (by simp [hrev]), RangeRead.inRange]
|
||||
calc (db.keys.filter
|
||||
(fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧
|
||||
(k : WithTop Key) < resolve db r.end_))).length
|
||||
= db.keys.countP
|
||||
(fun k : Key => decide (resolve db r.begin ≤ (k : WithTop Key) ∧
|
||||
(k : WithTop Key) < resolve db r.end_)) := by
|
||||
rw [List.countP_eq_length_filter]
|
||||
_ ≤ db.keys.countP
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < resolve db r.end_)) := by
|
||||
apply countP_le_countP_of_imp
|
||||
intro k _ hk
|
||||
rw [decide_eq_true_eq] at hk ⊢
|
||||
exact hk.2
|
||||
_ = cnt db (resolve db r.end_) := by rw [cnt]
|
||||
omega
|
||||
|
||||
/-- If the begin key lies at or below the end resolution in a nonpositive-end read, the
|
||||
capacity of `[begin.key, end.key)` already contains the `clampNonposD + 1` stored keys in
|
||||
`[resolve end, end.key)`. Hence the clamping capacity test `clampNonposBottom` holds
|
||||
whenever the reported keys below the begin key fit in the begin slack. -/
|
||||
theorem clampNonposBottom_of_le_resolve_end {r : RangeRead} {res : Result} {db : DB}
|
||||
(hend : r.end_.offset ≤ 0)
|
||||
(hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key))
|
||||
(hB_le_R : r.begin.key ≤ resolve db r.end_)
|
||||
(hmq : reportedBelowBegin r res ≤ beginSlack r) :
|
||||
clampNonposBottom r res := by
|
||||
have hRE : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
|
||||
have hlen : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 :=
|
||||
between_resolve_end_length hend hRne
|
||||
have hbetween_le : ((between db (resolve db r.end_) r.end_.key).length : ℕ∞) ≤
|
||||
intervalCard (resolve db r.end_) r.end_.key :=
|
||||
between_length_le_intervalCard hRE
|
||||
have hmono : intervalCard (resolve db r.end_) r.end_.key ≤
|
||||
intervalCard r.begin.key r.end_.key := by
|
||||
rw [intervalCard_eq_encard_keysIn, intervalCard_eq_encard_keysIn]
|
||||
apply Set.encard_le_encard
|
||||
intro k hk
|
||||
exact ⟨le_trans hB_le_R hk.1, hk.2⟩
|
||||
have hcap : (((clampNonposD r + 1 : ℕ)) : ℕ∞) ≤ intervalCard r.begin.key r.end_.key := by
|
||||
rw [← hlen]
|
||||
exact le_trans hbetween_le hmono
|
||||
have hsub : (((clampNonposD r + 1 : ℕ)) : ℕ∞) -
|
||||
intervalCard r.begin.key r.end_.key = 0 := by
|
||||
rw [tsub_eq_zero_iff_le]
|
||||
exact hcap
|
||||
unfold clampNonposBottom
|
||||
rw [hsub, add_zero]
|
||||
exact Nat.cast_le.mpr hmq
|
||||
|
||||
/-- **The truncated negative-begin anchor bound.** In a compatible forward truncated
|
||||
result with a negative begin offset, a nonpositive end offset, and reported keys below the
|
||||
begin key within the begin slack, a negative begin anchor forces `clampNonposBottom`. -/
|
||||
theorem clampNonposBottom_of_anchor_neg_trunc {r : RangeRead} {res : Result} {db : DB}
|
||||
(hcomp : RangeRead.Compatible db r res)
|
||||
(hrev : r.reverse = false) (_hmore : res.more = true)
|
||||
(hne : res.keys ≠ []) (hbegin : r.begin.offset < 0) (hend : r.end_.offset ≤ 0)
|
||||
(hmq : reportedBelowBegin r res ≤ beginSlack r)
|
||||
(hanchor : r.begin.anchor db < 0) :
|
||||
clampNonposBottom r res := by
|
||||
have hL : resolve db r.begin = (([] : Key) : WithTop Key) := resolve_eq_nil hanchor
|
||||
have hck : RangeRead.completeKeys db r =
|
||||
db.keys.filter (fun k : Key => decide (((k : Key) : WithTop Key) < resolve db r.end_)) := by
|
||||
rw [RangeRead.completeKeys, if_neg (by simp [hrev])]
|
||||
unfold RangeRead.inRange
|
||||
rw [hL]
|
||||
apply List.filter_congr
|
||||
intro k _
|
||||
rw [decide_eq_decide]
|
||||
exact ⟨fun h => h.2, fun h => ⟨coe_nil_le_key_withTop _, h⟩⟩
|
||||
have hRne : resolve db r.end_ ≠ (([] : Key) : WithTop Key) := by
|
||||
intro hR
|
||||
have hpre := RangeRead.compatible_keys_prefix (db := db) (r := r) (res := res) hcomp
|
||||
rw [hck, hR] at hpre
|
||||
have hempty : db.keys.filter
|
||||
(fun k : Key => decide (((k : Key) : WithTop Key) < (([] : Key) : WithTop Key))) = [] := by
|
||||
rw [List.filter_eq_nil_iff]
|
||||
intro k _
|
||||
simp only [decide_eq_true_eq, not_lt]
|
||||
exact coe_nil_le_key_withTop _
|
||||
rw [hempty] at hpre
|
||||
exact hne (List.prefix_nil.mp hpre)
|
||||
have hRE : resolve db r.end_ ≤ r.end_.key := resolve_le_key_of_offset_nonpos hend
|
||||
have hlen : (between db (resolve db r.end_) r.end_.key).length = clampNonposD r + 1 :=
|
||||
between_resolve_end_length hend hRne
|
||||
have htR : reportedBelowBegin r res ≤ cnt db (resolve db r.end_) :=
|
||||
reportedBelowBegin_le_cnt_resolve_end hcomp hrev
|
||||
have hcB : cnt db r.begin.key ≤ beginSlack r := by
|
||||
have h := hanchor
|
||||
rw [anchor_eq_count_sub_slack db r (le_of_lt hbegin)] at h
|
||||
unfold cnt
|
||||
omega
|
||||
have hcntE : cnt db r.end_.key =
|
||||
cnt db (resolve db r.end_) + (clampNonposD r + 1) := by
|
||||
rw [cnt_eq_add_between db hRE, hlen]
|
||||
by_cases hB_le_E : r.begin.key ≤ r.end_.key
|
||||
· have hcntEB : cnt db r.end_.key =
|
||||
cnt db r.begin.key + (between db r.begin.key r.end_.key).length :=
|
||||
cnt_eq_add_between db hB_le_E
|
||||
have hdnat : clampNonposD r + 1 ≤
|
||||
(between db r.begin.key r.end_.key).length +
|
||||
(beginSlack r - reportedBelowBegin r res) := by
|
||||
omega
|
||||
have hcast : (((clampNonposD r + 1 : ℕ)) : ℕ∞) ≤
|
||||
((between db r.begin.key r.end_.key).length : ℕ∞) +
|
||||
((beginSlack r - reportedBelowBegin r res : ℕ) : ℕ∞) := by
|
||||
exact_mod_cast hdnat
|
||||
have hg' : ((between db r.begin.key r.end_.key).length : ℕ∞) ≤
|
||||
intervalCard r.begin.key r.end_.key :=
|
||||
between_length_le_intervalCard hB_le_E
|
||||
have hmain : (((clampNonposD r + 1 : ℕ)) : ℕ∞) ≤
|
||||
intervalCard r.begin.key r.end_.key +
|
||||
((beginSlack r - reportedBelowBegin r res : ℕ) : ℕ∞) :=
|
||||
le_trans hcast (add_le_add hg' le_rfl)
|
||||
have htsub : (((clampNonposD r + 1 : ℕ)) : ℕ∞) - intervalCard r.begin.key r.end_.key ≤
|
||||
((beginSlack r - reportedBelowBegin r res : ℕ) : ℕ∞) := by
|
||||
rw [tsub_le_iff_left]
|
||||
exact hmain
|
||||
unfold clampNonposBottom
|
||||
calc (reportedBelowBegin r res : ℕ∞) +
|
||||
((((clampNonposD r + 1 : ℕ)) : ℕ∞) - intervalCard r.begin.key r.end_.key)
|
||||
≤ (reportedBelowBegin r res : ℕ∞) +
|
||||
((beginSlack r - reportedBelowBegin r res : ℕ) : ℕ∞) :=
|
||||
add_le_add le_rfl htsub
|
||||
_ = (beginSlack r : ℕ∞) := by
|
||||
rw [← ENat.natCast_add]
|
||||
congr 1
|
||||
omega
|
||||
· have hEB : r.end_.key < r.begin.key := lt_of_not_ge hB_le_E
|
||||
have hEBle : r.end_.key ≤ r.begin.key := le_of_lt hEB
|
||||
have hcntB : cnt db r.begin.key =
|
||||
cnt db r.end_.key + (between db r.end_.key r.begin.key).length :=
|
||||
cnt_eq_add_between db hEBle
|
||||
have hnat : reportedBelowBegin r res + (clampNonposD r + 1) ≤ beginSlack r := by
|
||||
omega
|
||||
have hcap0 : intervalCard r.begin.key r.end_.key = 0 :=
|
||||
intervalCard_eq_zero_of_le hEBle
|
||||
unfold clampNonposBottom
|
||||
rw [hcap0]
|
||||
have hcast : (((reportedBelowBegin r res + (clampNonposD r + 1) : ℕ)) : ℕ∞) ≤
|
||||
(beginSlack r : ℕ∞) :=
|
||||
Nat.cast_le.mpr hnat
|
||||
simpa [ENat.natCast_add, add_comm, add_left_comm, add_assoc] using hcast
|
||||
|
||||
end FormalConflictRange
|
||||
Reference in new issue
Block a user