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

+320
View File
@@ -0,0 +1,320 @@
/-
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.FiniteCountDecider
/-!
# A lazy activity oracle
The exact oracle `activeComputable` decides activity by enumerating, for every DNF
alternative, one violated constraint, and then testing the resulting finite count
system. That product is correct but needlessly large: for the characterizing DNF
the alternatives share almost all of their constraints.
This file replaces the eager product by a lazy search for a *hitting set* of
constraints: one constraint from every alternative, but without repeating a
constraint that has already been selected. A partial selection is tested for
count feasibility before it is extended; infeasible prefixes are discarded, since
adding more violated constraints can only make the count system harder.
-/
namespace FormalConflictRange
/-! ## Hitting sets versus choices -/
/-- A list of constraints hits an alternative when one of the alternative's
constraints occurs in the list. -/
def Hits (B : List Constraint) (S : ConstraintSystem) : Prop :=
∃ c ∈ S, c ∈ B
/-- A list of constraints hits every alternative of a DNF. -/
def HitsAll (B : List Constraint) (D : ConstraintDNF) : Prop :=
∀ S ∈ D, Hits B S
/-- Every `ChoosesAll` selection is a hitting set. -/
theorem hitsAll_of_choosesAll {bad : List Constraint} {D : ConstraintDNF}
(h : ChoosesAll bad D) : HitsAll bad D := by
induction D generalizing bad with
| nil => intro S hS; simp at hS
| cons S Ss ih =>
cases bad with
| nil => simp [ChoosesAll] at h
| cons c cs =>
rcases h with ⟨hcS, htail⟩
intro S' hS'
rcases List.mem_cons.mp hS' with rfl | hS'
· exact ⟨c, hcS, by simp⟩
· obtain ⟨c', hc'S', hc'bad⟩ := ih htail S' hS'
exact ⟨c', hc'S', by simp [hc'bad]⟩
/-- A hitting set contains a `ChoosesAll` selection: choose one hit from each
alternative, in order. -/
theorem exists_choices_subset {D : ConstraintDNF} {B : List Constraint}
(h : HitsAll B D) :
∃ bad : List Constraint, bad ∈ choices D ∧ ∀ c ∈ bad, c ∈ B := by
induction D with
| nil => exact ⟨[], by simp [choices], by simp⟩
| cons S Ss ih =>
obtain ⟨c, hcS, hcB⟩ := h S (by simp)
obtain ⟨bad, hbad, hsub⟩ := ih (fun S' hS' => h S' (by simp [hS']))
refine ⟨c :: bad, ?_, ?_⟩
· simp only [choices, List.mem_flatMap, List.mem_map]
exact ⟨c, hcS, bad, hbad, rfl⟩
· intro d hd
rcases List.mem_cons.mp hd with rfl | hd
· exact hcB
· exact hsub d hd
/-! ## Monotonicity of count feasibility -/
/-- Adding violated constraints cannot make a count system feasible. -/
theorem CountFeasible.mono {bounds : List Key} {k : Key} {S : ConstraintSystem}
{bad bad' : List Constraint} (hsub : ∀ c ∈ bad, c ∈ bad')
(h : CountFeasible bounds k S bad') : CountFeasible bounds k S bad := by
obtain ⟨counts, topCount, hfit, hS, hbad⟩ := h
exact ⟨counts, topCount, hfit, hS, fun c hc => hbad c (hsub c hc)⟩
/-! ## The lazy search -/
/-- Lazy search for a feasible hitting set. The accumulator `acc` already hits
the alternatives processed so far; a new constraint is added only when the
current alternative is not yet hit, and a prefix is abandoned as soon as its
count system is infeasible. -/
def searchBad (bounds : List Key) (k : Key) (S : ConstraintSystem) :
ConstraintDNF → List Constraint → Bool
| [], acc => countFeasibleBool bounds k S acc
| S' :: Ss, acc =>
if S'.any (fun c => decide (c ∈ acc)) then
searchBad bounds k S Ss acc
else
S'.any fun c =>
countFeasibleBool bounds k S (c :: acc) &&
searchBad bounds k S Ss (c :: acc)
/-- The search finds a feasible hitting set extending the accumulator. -/
theorem searchBad_spec (bounds : List Key) (k : Key) (S : ConstraintSystem)
(D : ConstraintDNF) (acc : List Constraint)
(hnoBot : ([] : Key) ∉ bounds) (hle : BoundsLe ([] : Key) bounds)
(hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds)
(hcoverS : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds)
(hcoverD : ∀ S' ∈ D, ∀ c ∈ S',
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds)
(hcoverAcc : ∀ c ∈ acc,
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) :
searchBad bounds k S D acc = true ↔
∃ B : List Constraint, (∀ c ∈ acc, c ∈ B) ∧ HitsAll B D ∧
CountFeasible bounds k S B := by
induction D generalizing acc with
| nil =>
constructor
· intro h
exact ⟨acc, fun _ hc => hc, by intro S' hS'; simp at hS',
(countFeasibleBool_spec bounds k S acc hnoBot hle hcoverS hcoverAcc hk hka).mp h⟩
· rintro ⟨B, haccB, -, hB⟩
exact (countFeasibleBool_spec bounds k S acc hnoBot hle hcoverS hcoverAcc hk hka).mpr
(CountFeasible.mono haccB hB)
| cons S' Ss ih =>
by_cases hcover : ∃ c ∈ S', c ∈ acc
· have hany : S'.any (fun c => decide (c ∈ acc)) = true := by
rw [List.any_eq_true]
obtain ⟨c, hcS', hcacc⟩ := hcover
exact ⟨c, hcS', by simp [hcacc]⟩
rw [searchBad, ite_eq_left hany]
obtain ⟨c, hcS', hcacc⟩ := hcover
have hcoverSs : ∀ S'' ∈ Ss, ∀ c ∈ S'',
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds :=
fun S'' hS'' c hc => hcoverD S'' (by simp [hS'']) c hc
have ih' := ih acc hcoverSs hcoverAcc
constructor
· intro hsearch
obtain ⟨B, haccB, hhits, hfeas⟩ := ih'.mp hsearch
exact ⟨B, haccB, fun S'' hS'' => by
rcases List.mem_cons.mp hS'' with hS | hS''
· subst S''
exact ⟨c, hcS', haccB c hcacc⟩
· exact hhits S'' hS'', hfeas⟩
· rintro ⟨B, haccB, hhits, hfeas⟩
exact ih'.mpr ⟨B, haccB,
fun S'' hS'' => hhits S'' (List.mem_cons_of_mem _ hS''), hfeas⟩
· have hany : S'.any (fun c => decide (c ∈ acc)) = false := by
rw [List.any_eq_false]
intro c hcS' hcacc
exact hcover ⟨c, hcS', by simpa using hcacc⟩
rw [searchBad, ite_eq_right (by simp [hany])]
constructor
· intro hsearch
rw [List.any_eq_true] at hsearch
obtain ⟨c, hcS', hboth⟩ := hsearch
rw [Bool.and_eq_true] at hboth
obtain ⟨hcfeas, htail⟩ := hboth
have hcoverAcc' : ∀ d ∈ c :: acc,
EndpointCovered d.lo bounds ∧ EndpointCovered d.hi bounds := by
intro d hd
rcases List.mem_cons.mp hd with hdc | hd
· rw [hdc]
exact hcoverD S' (by simp) c hcS'
· exact hcoverAcc d hd
have hfeasAcc : CountFeasible bounds k S (c :: acc) :=
(countFeasibleBool_spec bounds k S (c :: acc) hnoBot hle hcoverS
hcoverAcc' hk hka).mp hcfeas
have hcoverSs : ∀ S'' ∈ Ss, ∀ d ∈ S'',
EndpointCovered d.lo bounds ∧ EndpointCovered d.hi bounds :=
fun S'' hS'' d hd => hcoverD S'' (by simp [hS'']) d hd
obtain ⟨B, haccB, hhits, hfeas⟩ :=
(ih (c :: acc) hcoverSs hcoverAcc').mp htail
exact ⟨B, fun d hd => haccB d (List.mem_cons_of_mem _ hd),
fun S'' hS'' => by
rcases List.mem_cons.mp hS'' with hS | hS''
· subst S''
exact ⟨c, hcS', haccB c (by simp)⟩
· exact hhits S'' hS'', hfeas⟩
· rintro ⟨B, haccB, hhits, hfeas⟩
obtain ⟨c, hcS', hcB⟩ := hhits S' (by simp)
have hcacc : c ∉ acc := by
intro hcacc
exact hcover ⟨c, hcS', by simpa using hcacc⟩
have hsub : ∀ d ∈ c :: acc, d ∈ B := by
intro d hd
rcases List.mem_cons.mp hd with hdc | hd
· rw [hdc]
exact hcB
· exact haccB d hd
have hcoverAcc' : ∀ d ∈ c :: acc,
EndpointCovered d.lo bounds ∧ EndpointCovered d.hi bounds := by
intro d hd
rcases List.mem_cons.mp hd with hdc | hd
· rw [hdc]
exact hcoverD S' (by simp) c hcS'
· exact hcoverAcc d hd
have hcfeas : countFeasibleBool bounds k S (c :: acc) = true :=
(countFeasibleBool_spec bounds k S (c :: acc) hnoBot hle hcoverS
hcoverAcc' hk hka).mpr (CountFeasible.mono hsub hfeas)
have hcoverSs : ∀ S'' ∈ Ss, ∀ d ∈ S'',
EndpointCovered d.lo bounds ∧ EndpointCovered d.hi bounds :=
fun S'' hS'' d hd => hcoverD S'' (by simp [hS'']) d hd
have htail : searchBad bounds k S Ss (c :: acc) = true :=
(ih (c :: acc) hcoverSs hcoverAcc').mpr
⟨B, fun d hd => by
rcases List.mem_cons.mp hd with hdc | hd
· rw [hdc]
exact hcB
· exact haccB d hd,
fun S'' hS'' => hhits S'' (List.mem_cons_of_mem _ hS''), hfeas⟩
rw [List.any_eq_true]
exact ⟨c, hcS', by rw [Bool.and_eq_true]; exact ⟨hcfeas, htail⟩⟩
/-- On the canonical bounds, the lazy search is exactly the eager `choices`
enumeration. -/
theorem searchBad_choices (bounds : List Key) (k : Key) (S : ConstraintSystem)
(D : ConstraintDNF)
(hnoBot : ([] : Key) ∉ bounds) (hle : BoundsLe ([] : Key) bounds)
(hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds)
(hcoverS : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds)
(hcoverD : ∀ S' ∈ D, ∀ c ∈ S',
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) :
searchBad bounds k S D [] = true ↔
∃ bad : List Constraint, bad ∈ choices D ∧
countFeasibleBool bounds k S bad = true := by
constructor
· intro hsearch
obtain ⟨B, -, hhits, hfeas⟩ :=
(searchBad_spec bounds k S D [] hnoBot hle hk hka hcoverS hcoverD (by simp)).mp hsearch
obtain ⟨bad, hbad, hsub⟩ := exists_choices_subset hhits
have hcoverBad : ∀ c ∈ bad,
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds := by
intro c hc
obtain ⟨S', hS', hcS'⟩ := choosesAll_mem (mem_choices.mp hbad) hc
exact hcoverD S' hS' c hcS'
exact ⟨bad, hbad,
(countFeasibleBool_spec bounds k S bad hnoBot hle hcoverS hcoverBad hk hka).mpr
(CountFeasible.mono hsub hfeas)⟩
· rintro ⟨bad, hbad, hfeas⟩
have hchooses : ChoosesAll bad D := mem_choices.mp hbad
have hcoverBad : ∀ c ∈ bad,
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds := by
intro c hc
obtain ⟨S', hS', hcS'⟩ := choosesAll_mem hchooses hc
exact hcoverD S' hS' c hcS'
exact (searchBad_spec bounds k S D [] hnoBot hle hk hka hcoverS hcoverD (by simp)).mpr
⟨bad, by simp, hitsAll_of_choosesAll hchooses,
(countFeasibleBool_spec bounds k S bad hnoBot hle hcoverS hcoverBad hk hka).mp hfeas⟩
/-! ## The lazy oracle and the simple algorithm -/
/-- The lazy exact activity oracle. It has the same decision procedure as
`activeComputable`, but searches for a feasible hitting set instead of
enumerating the full product of one constraint per alternative. -/
def activeComputableFast (r : RangeRead) (res : Result) (k : Key) : Bool :=
let D := characterizingDNF r res
let bounds := activeBounds D k
withinLimitBool r res.keys &&
D.any fun S => searchBad bounds k S D []
/-- The lazy oracle is exact on every readable pair. -/
theorem activeComputableFast_spec {r : RangeRead} {res : Result}
(hread : Readable r res) :
ActiveDecider r res (activeComputableFast r res) := by
intro k
let D := characterizingDNF r res
let bounds := activeBounds D k
have hnoBot : ([] : Key) ∉ bounds := not_mem_activeBounds_bot D k
have hle : BoundsLe ([] : Key) bounds := activeBounds_boundsLe D k
have hcoverD : ∀ S' ∈ D, ∀ c ∈ S',
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds := by
intro S' hS' c hc
exact dnfEndpointCovered_activeBounds hS' hc
have hk : k = ([] : Key) ∨ k ∈ bounds := by
by_cases hkbot : k = ([] : Key)
· exact Or.inl hkbot
· exact Or.inr (by
rw [mem_activeBounds]
exact Or.inr (Or.inr ⟨hkbot, rfl⟩))
have hka : keyAfter k ∈ bounds := by
rw [mem_activeBounds]
exact Or.inl rfl
rw [activeComputableFast]
rw [Bool.and_eq_true, withinLimitBool_eq, List.any_eq_true]
constructor
· rintro ⟨hw, S, hS, hsearch⟩
obtain ⟨bad, hbad, hfeas⟩ :=
(searchBad_choices bounds k S D hnoBot hle hk hka (hcoverD S hS) hcoverD).mp hsearch
have hchooses : ChoosesAll bad D := mem_choices.mp hbad
have hcoverBad : ∀ c ∈ bad,
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds := by
intro c hc
obtain ⟨S', hS', hcS'⟩ := choosesAll_mem hchooses hc
exact hcoverD S' hS' c hcS'
have hcount : CountFeasible bounds k S bad :=
(countFeasibleBool_spec bounds k S bad hnoBot hle (hcoverD S hS) hcoverBad hk hka).mp
hfeas
exact (flipWitness_iff_exists_counts_canonical (D := D)
(characterizesDNF_characterizingDNF hread)).mpr
⟨hw, S, hS, bad, hchooses, hcount⟩
· intro hw
rcases (flipWitness_iff_exists_counts_canonical (D := D)
(characterizesDNF_characterizingDNF hread)).mp hw with
⟨hwithin, S, hS, bad, hchooses, hcount⟩
refine ⟨hwithin, ⟨S, hS, ?_⟩⟩
have hcoverBad : ∀ c ∈ bad,
EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds := by
intro c hc
obtain ⟨S', hS', hcS'⟩ := choosesAll_mem hchooses hc
exact hcoverD S' hS' c hcS'
have hfeas : countFeasibleBool bounds k S bad = true :=
(countFeasibleBool_spec bounds k S bad hnoBot hle (hcoverD S hS) hcoverBad hk hka).mpr
hcount
exact (searchBad_choices bounds k S D hnoBot hle hk hka (hcoverD S hS) hcoverD).mpr
⟨bad, mem_choices.mpr hchooses, hfeas⟩
/-- On a readable pair, the lazy oracle computes exactly the eager oracle's
answer. -/
theorem activeComputableFast_eq {r : RangeRead} {res : Result}
(hread : Readable r res) (k : Key) :
activeComputableFast r res k = activeComputable r res k := by
apply Bool.eq_iff_iff.mpr
rw [activeComputableFast_spec hread k, activeComputable_spec hread k]
end FormalConflictRange