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

+344
View File
@@ -0,0 +1,344 @@
/-
Copyright (c) 2026 FormalConflictRange contributors. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: FormalConflictRange contributors
-/
import Mathlib
/-!
# A computable decision procedure for difference constraints
-/
namespace FormalConflictRange
/-- A difference constraint `x v - x u ≤ w`. -/
structure DEdge where
u : ℕ
v : ℕ
w : ℤ
namespace DEdge
/-- The constraint holds at the assignment `x`. -/
def Holds (x : ℕ → ℤ) (e : DEdge) : Prop := x e.v - x e.u ≤ e.w
end DEdge
/-- All constraints hold at `x`. -/
def HoldsAll (x : ℕ → ℤ) (es : List DEdge) : Prop := ∀ e ∈ es, e.Holds x
/-- All collected constant constraints `0 ≤ w` hold. -/
def HoldsConsts (cs : List ℤ) : Prop := ∀ w ∈ cs, 0 ≤ w
/-- A state is feasible when it has an assignment satisfying all constants and edges. -/
def DiffFeasible (cs : List ℤ) (es : List DEdge) : Prop :=
∃ x : ℕ → ℤ, HoldsConsts cs ∧ HoldsAll x es
/-- Eliminate variable `k` from a difference-constraint state. -/
def eliminate (k : ℕ) (cs : List ℤ) (es : List DEdge) : List ℤ × List DEdge :=
let selfs0 := es.filter (fun e => decide (e.u = e.v))
let inc := es.filter (fun e => decide (e.u ≠ e.v ∧ e.v = k))
let out := es.filter (fun e => decide (e.u ≠ e.v ∧ e.u = k))
let keep := es.filter (fun e => decide (e.u ≠ e.v ∧ e.u ≠ k ∧ e.v ≠ k))
let comb := inc.flatMap fun a => out.map fun b => (⟨a.u, b.v, a.w + b.w⟩ : DEdge)
let all := keep ++ comb
let selfs := all.filter (fun e => decide (e.u = e.v))
let rest := all.filter (fun e => decide (e.u ≠ e.v))
(cs ++ selfs0.map (fun e => e.w) ++ selfs.map (fun e => e.w), rest)
/-- Eliminate variables `0, …, n-1`, highest first. -/
def elimAll : ℕ → List ℤ → List DEdge → List ℤ × List DEdge
| 0, cs, es => (cs, es)
| n + 1, cs, es =>
let p := eliminate n cs es
elimAll n p.1 p.2
/-- The decision procedure: eliminate all variables, then check the constants. -/
def diffFeasibleBool (n : ℕ) (cs : List ℤ) (es : List DEdge) : Bool :=
let p := elimAll n cs es
p.1.all (fun w => decide (0 ≤ w))
/-- A finite separation lemma for integers. -/
theorem exists_between_finset (L U : Finset ℤ)
(h : ∀ l ∈ L, ∀ u ∈ U, l ≤ u) :
∃ x : ℤ, (∀ l ∈ L, l ≤ x) ∧ (∀ u ∈ U, x ≤ u) := by
by_cases hL : L.Nonempty
· by_cases hU : U.Nonempty
· refine ⟨L.max' hL, ?_, ?_⟩
· intro l hl
exact Finset.le_max' L l hl
· intro u hu
exact h _ (Finset.max'_mem L hL) u hu
· refine ⟨L.max' hL, ?_, ?_⟩
· intro l hl
exact Finset.le_max' L l hl
· intro u hu
exact absurd ⟨u, hu⟩ hU
· by_cases hU : U.Nonempty
· refine ⟨U.min' hU, ?_, ?_⟩
· intro l hl
exact absurd ⟨l, hl⟩ hL
· intro u hu
exact Finset.min'_le U u hu
· refine ⟨0, ?_, ?_⟩
· intro l hl
exact absurd ⟨l, hl⟩ hL
· intro u hu
exact absurd ⟨u, hu⟩ hU
theorem self_holds_iff {x : ℕ → ℤ} {e : DEdge} (h : e.u = e.v) :
e.Holds x ↔ 0 ≤ e.w := by
simp [DEdge.Holds, h]
/-- Eliminating one variable preserves feasibility. -/
theorem diffFeasible_eliminate (k : ℕ) (cs : List ℤ) (es : List DEdge) :
DiffFeasible cs es ↔ DiffFeasible (eliminate k cs es).1 (eliminate k cs es).2 := by
classical
unfold DiffFeasible
constructor
· rintro ⟨x, hcs, hes⟩
have hself0 : ∀ e ∈ es, e.u = e.v → 0 ≤ e.w := by
intro e he huv
have := hes e he
rwa [self_holds_iff huv] at this
have hkeep : HoldsAll x
(es.filter (fun e => decide (e.u ≠ e.v ∧ e.u ≠ k ∧ e.v ≠ k))) := by
intro e he
simp only [List.mem_filter, decide_eq_true_eq] at he
exact hes e he.1
have hcomb : HoldsAll x
((es.filter (fun e => decide (e.u ≠ e.v ∧ e.v = k))).flatMap fun a =>
(es.filter (fun e => decide (e.u ≠ e.v ∧ e.u = k))).map fun b =>
(⟨a.u, b.v, a.w + b.w⟩ : DEdge)) := by
intro e he
rw [List.mem_flatMap] at he
obtain ⟨a, ha, he⟩ := he
rw [List.mem_map] at he
obtain ⟨b, hb, rfl⟩ := he
simp only [List.mem_filter, decide_eq_true_eq] at ha hb
have hae := hes a ha.1
have hbe := hes b hb.1
simp only [DEdge.Holds] at hae hbe ⊢
rw [ha.2.2] at hae
rw [hb.2.2] at hbe
linarith
refine ⟨x, ?_, ?_⟩
· intro w hw
simp only [eliminate, List.mem_append, List.mem_map, List.mem_filter,
decide_eq_true_eq] at hw
rcases hw with (hw | hw) | hw
· exact hcs w hw
· obtain ⟨e, he, rfl⟩ := hw
exact hself0 e he.1 he.2
· obtain ⟨e, he, rfl⟩ := hw
rcases he.1 with hek | hec
· exact hself0 e hek.1 he.2
· rw [List.mem_flatMap] at hec
obtain ⟨a, ha, hec⟩ := hec
rw [List.mem_map] at hec
obtain ⟨b, hb, rfl⟩ := hec
simp only [List.mem_filter, decide_eq_true_eq] at ha hb
have hae := hes a ha.1
have hbe := hes b hb.1
simp only [DEdge.Holds] at hae hbe ⊢
rw [ha.2.2] at hae
rw [hb.2.2] at hbe
-- self means `a.u = b.v`, so the left side is zero
have hab : a.u = b.v := he.2
have hzero : x b.v - x a.u = 0 := by rw [← hab]; ring
linarith
· intro e he
simp only [eliminate, List.mem_append, List.mem_filter, decide_eq_true_eq] at he
rcases he.1 with hek | hec
· exact hkeep e (by simpa only [List.mem_filter, decide_eq_true_eq] using hek)
· exact hcomb e hec
· rintro ⟨y, hcs, hes⟩
let selfs0 := es.filter (fun e => decide (e.u = e.v))
let inc := es.filter (fun e => decide (e.u ≠ e.v ∧ e.v = k))
let out := es.filter (fun e => decide (e.u ≠ e.v ∧ e.u = k))
let keep := es.filter (fun e => decide (e.u ≠ e.v ∧ e.u ≠ k ∧ e.v ≠ k))
let comb := inc.flatMap fun a => out.map fun b => (⟨a.u, b.v, a.w + b.w⟩ : DEdge)
let all := keep ++ comb
let selfs := all.filter (fun e => decide (e.u = e.v))
have hcs' : HoldsConsts (cs ++ selfs0.map (fun e => e.w) ++
selfs.map (fun e => e.w)) := by
simpa only [eliminate, selfs0, inc, out, keep, comb, all, selfs] using hcs
have hes' : HoldsAll y (all.filter (fun e => decide (e.u ≠ e.v))) := by
simpa only [eliminate, selfs0, inc, out, keep, comb, all, selfs] using hes
have hkeep : HoldsAll y keep := by
intro e he
have hek : e ∈ es ∧ e.u ≠ e.v ∧ e.u ≠ k ∧ e.v ≠ k := by
simpa [keep] using he
apply hes' e
simp only [List.mem_filter, decide_eq_true_eq]
exact ⟨List.mem_append.mpr (Or.inl he), hek.2.1⟩
have hcomb : HoldsAll y comb := by
intro e he
by_cases hself : e.u = e.v
· have hw : e.w ∈ cs ++ selfs0.map (fun e => e.w) ++ selfs.map (fun e => e.w) := by
simp only [List.mem_append, List.mem_map]
exact Or.inr ⟨e, by
change e ∈ all.filter (fun e => decide (e.u = e.v))
simp only [List.mem_filter, decide_eq_true_eq]
exact ⟨List.mem_append.mpr (Or.inr he), hself⟩, rfl⟩
have := hcs' e.w hw
simpa [DEdge.Holds, hself] using this
· apply hes' e
simp only [List.mem_filter, decide_eq_true_eq]
exact ⟨List.mem_append.mpr (Or.inr he), hself⟩
let L : Finset ℤ := (out.map fun b => y b.v - b.w).toFinset
let U : Finset ℤ := (inc.map fun a => y a.u + a.w).toFinset
have hsep : ∀ l ∈ L, ∀ u ∈ U, l ≤ u := by
intro l hl u hu
rw [show L = (out.map fun b => y b.v - b.w).toFinset by rfl] at hl
rw [show U = (inc.map fun a => y a.u + a.w).toFinset by rfl] at hu
rw [List.mem_toFinset] at hl hu
obtain ⟨b, hb, rfl⟩ := List.mem_map.mp hl
obtain ⟨a, ha, rfl⟩ := List.mem_map.mp hu
have hcombEdge : (⟨a.u, b.v, a.w + b.w⟩ : DEdge) ∈ comb := by
unfold comb
rw [List.mem_flatMap]
exact ⟨a, ha, List.mem_map.mpr ⟨b, hb, rfl⟩⟩
have hh := hcomb _ hcombEdge
simp only [DEdge.Holds] at hh
linarith
obtain ⟨xk, hxkL, hxkU⟩ := exists_between_finset L U hsep
let x : ℕ → ℤ := Function.update y k xk
have hx_eq : ∀ i, i ≠ k → x i = y i := by
intro i hi
simp [x, Function.update_of_ne hi]
have hx_self : x k = xk := by simp [x]
refine ⟨x, ?_, ?_⟩
· intro w hw
have hw' : w ∈ (cs ++ selfs0.map (fun e => e.w)) ++ selfs.map (fun e => e.w) :=
List.mem_append.mpr (Or.inl (List.mem_append.mpr (Or.inl hw)))
exact hcs' w hw'
· intro e he
by_cases huv : e.u = e.v
· have hw : e.w ∈ cs ++ selfs0.map (fun e => e.w) ++ selfs.map (fun e => e.w) := by
simp only [List.mem_append, List.mem_map]
exact Or.inl (Or.inr ⟨e, by
simp only [selfs0, List.mem_filter, decide_eq_true_eq]
exact ⟨he, huv⟩, rfl⟩)
exact (self_holds_iff huv).mpr (hcs' e.w hw)
· by_cases huk : e.u = k
· have hmem : e ∈ out := by
simp only [out, List.mem_filter, decide_eq_true_eq]
exact ⟨he, huv, huk⟩
have hlow : y e.v - e.w ≤ xk := hxkL _ (by
rw [show L = (out.map fun b => y b.v - b.w).toFinset by rfl]
exact List.mem_toFinset.mpr (List.mem_map.mpr ⟨e, hmem, rfl⟩))
have hve : e.v ≠ k := by
intro h; exact huv (huk.trans h.symm)
simp only [DEdge.Holds]
rw [show e.u = k from huk, hx_self, hx_eq e.v hve]
linarith
· by_cases hvk : e.v = k
· have hmem : e ∈ inc := by
simp only [inc, List.mem_filter, decide_eq_true_eq]
exact ⟨he, huv, hvk⟩
have hup : xk ≤ y e.u + e.w := hxkU _ (by
rw [show U = (inc.map fun a => y a.u + a.w).toFinset by rfl]
exact List.mem_toFinset.mpr (List.mem_map.mpr ⟨e, hmem, rfl⟩))
have hue : e.u ≠ k := by
intro h; exact huv (h.trans hvk.symm)
simp only [DEdge.Holds]
rw [show e.v = k from hvk, hx_self, hx_eq e.u hue]
linarith
· have hmem : e ∈ keep := by
simp only [keep, List.mem_filter, decide_eq_true_eq]
exact ⟨he, huv, huk, hvk⟩
have hh := hkeep e hmem
simpa only [DEdge.Holds, hx_eq e.u huk, hx_eq e.v hvk] using hh
/-- Eliminating all variables preserves feasibility. -/
theorem diffFeasible_elimAll (n : ℕ) (cs : List ℤ) (es : List DEdge) :
DiffFeasible cs es ↔ DiffFeasible (elimAll n cs es).1 (elimAll n cs es).2 := by
induction n generalizing cs es with
| zero => simp [elimAll]
| succ n ih =>
rw [elimAll, diffFeasible_eliminate]
exact ih _ _
/-- After eliminating `0, …, n-1`, no nonself edge with endpoints below `n`
remains. -/
theorem elimAll_snd_eq_nil_of_endpoints_lt {n : ℕ} {cs : List ℤ} {es : List DEdge}
(h : ∀ e ∈ es, e.u < n ∧ e.v < n) : (elimAll n cs es).2 = [] := by
induction n generalizing cs es with
| zero =>
have hes : es = [] := by
rw [List.eq_nil_iff_forall_not_mem]
intro e he
have := h e he
omega
simp [elimAll, hes]
| succ n ih =>
let p := eliminate n cs es
have hp : ∀ e ∈ p.2, e.u < n ∧ e.v < n := by
intro e he
dsimp [p] at he
simp only [eliminate, List.mem_filter, decide_eq_true_eq, List.mem_append] at he
rcases he with ⟨hek | hec, hne⟩
· have hb := h e hek.1
exact ⟨by omega, by omega⟩
· rw [List.mem_flatMap] at hec
obtain ⟨a, ha, hec⟩ := hec
rw [List.mem_map] at hec
obtain ⟨b, hb, rfl⟩ := hec
simp only [List.mem_filter, decide_eq_true_eq] at ha hb
have hua := h a ha.1
have hvb := h b hb.1
change a.u < n ∧ b.v < n
exact ⟨by omega, by omega⟩
have := ih (cs := p.1) (es := p.2) hp
simpa [elimAll, p] using this
/-- The Boolean elimination procedure is correct for edge lists whose endpoints
all lie below `n`. -/
theorem diffFeasibleBool_spec (n : ℕ) (cs : List ℤ) (es : List DEdge)
(h : ∀ e ∈ es, e.u < n ∧ e.v < n) :
diffFeasibleBool n cs es = true ↔ DiffFeasible cs es := by
have hnil := elimAll_snd_eq_nil_of_endpoints_lt (cs := cs) (es := es) h
have hconst : HoldsConsts (elimAll n cs es).1 ↔
DiffFeasible (elimAll n cs es).1 (elimAll n cs es).2 := by
constructor
· intro hc
exact ⟨fun _ => 0, hc, by simp [HoldsAll, hnil]⟩
· rintro ⟨x, hc, -⟩
exact hc
rw [diffFeasibleBool, List.all_eq_true, diffFeasible_elimAll]
constructor
· intro hall
exact hconst.mp fun w hw => of_decide_eq_true (hall w hw)
· intro hf w hw
exact decide_eq_true_eq.mpr (hconst.mpr hf w hw)
/-- A safe upper bound on all variable indices occurring in an edge list. -/
def edgeBound : List DEdge → ℕ
| [] => 0
| e :: es => max (max e.u e.v + 1) (edgeBound es)
theorem edgeBound_spec (es : List DEdge) :
∀ e ∈ es, e.u < edgeBound es ∧ e.v < edgeBound es := by
induction es with
| nil => intro e he; simp at he
| cons d ds ih =>
intro e he
simp only [edgeBound]
rw [List.mem_cons] at he
rcases he with rfl | he
· omega
· have := ih e he
omega
/-- Feasibility of an arbitrary edge list, using its own index bound. -/
def diffFeasibleBoolAuto (es : List DEdge) : Bool :=
diffFeasibleBool (edgeBound es) [] es
theorem diffFeasibleBoolAuto_spec (es : List DEdge) :
diffFeasibleBoolAuto es = true ↔ DiffFeasible [] es :=
diffFeasibleBool_spec (edgeBound es) [] es (edgeBound_spec es)
end FormalConflictRange