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:
andrew committed 2026-11-16 21:53:59 -05:00
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