/- 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.CountBridge import FormalConflictRange.DiffFeasible /-! # Deciding the finite count relaxation We translate the finite count feasibility of `CountBridge.lean` into integer difference constraints on cumulative counts and decide the latter by variable elimination (`DiffFeasible.lean`). -/ namespace FormalConflictRange /-- Prefix sum of the first `i` interval counts. -/ def pref (counts : List ℕ) (i : ℕ) : ℕ := (counts.take i).sum /-- Cumulative counts extracted from a count assignment, with the last variable standing for the total count including the unbounded final interval. -/ def countsToX (n : ℕ) (counts : List ℕ) (topCount : ℕ) (i : ℕ) : ℤ := if i = n + 1 then (counts.sum + topCount : ℕ) else (pref counts i : ℕ) /-- The cumulative lookup in `countAtWith` is the prefix sum. -/ theorem countAtWith_eq_pref (base : ℕ) {bounds : List Key} {counts : List ℕ} (hlen : counts.length = bounds.length) {k : Key} (hk : k ∈ bounds) : countAtWith base bounds counts k = base + pref counts (bounds.idxOf k + 1) := by induction bounds generalizing base counts with | nil => simp at hk | cons b bs ih => cases counts with | nil => simp at hlen | cons d ds => have hlen' : ds.length = bs.length := by simpa using hlen by_cases hkb : k = b · subst k simp [countAtWith, pref, List.idxOf_cons_self] · have hkbs : k ∈ bs := by rcases List.mem_cons.mp hk with rfl | hkbs · exact absurd rfl hkb · exact hkbs rw [List.idxOf_cons_ne bs (fun h => hkb h.symm)] simp only [countAtWith, if_neg hkb] rw [ih (base := base + d) hlen' hkbs] simp [pref, List.take_succ_cons, List.sum_cons] omega /-- The variable index of an endpoint in the cumulative count vector. -/ def endpointIndex (bounds : List Key) : WithTop Key → ℕ | some k => if k = ([] : Key) then 0 else bounds.idxOf k + 1 | none => bounds.length + 1 /-- Capacity and nonnegativity edges for consecutive interval counts. -/ def capEdgesAux (start : Key) (bounds : List Key) (i : ℕ) : List DEdge := match bounds with | [] => [] | b :: bs => [⟨i + 1, i, 0⟩] ++ (if h : intervalCard (start : WithTop Key) (b : WithTop Key) = ⊤ then [] else [⟨i, i + 1, ((intervalCard (start : WithTop Key) (b : WithTop Key)).toNat : ℤ)⟩]) ++ capEdgesAux b bs (i + 1) /-- The full capacity/order system, including the nonnegativity of the final unbounded interval count. -/ def capEdges (bounds : List Key) : List DEdge := capEdgesAux ([] : Key) bounds 0 ++ [⟨bounds.length + 1, bounds.length, 0⟩] /-- The coefficient of the toggle shift on an endpoint. -/ def toggleCoeff (stored : Bool) (k : Key) (e : WithTop Key) : ℤ := if (k : WithTop Key) < e then (if stored then (-1 : ℤ) else 1) else 0 /-- An edge for a constraint `lo hi bound`. -/ def constraintEdge (bounds : List Key) (lo hi : WithTop Key) (w : ℤ) : DEdge := ⟨endpointIndex bounds lo, endpointIndex bounds hi, w⟩ /-- The edges encoding a whole constraint system. -/ def constraintEdges (bounds : List Key) (S : ConstraintSystem) : List DEdge := S.map fun c => constraintEdge bounds c.lo c.hi c.bound /-- The edges encoding the toggled failures of a chosen list of constraints. -/ def badEdges (bounds : List Key) (k : Key) (stored : Bool) (bad : List Constraint) : List DEdge := bad.map fun c => constraintEdge bounds c.hi c.lo (toggleCoeff stored k c.hi - toggleCoeff stored k c.lo - c.bound - 1) /-- The two edges forcing the toggle indicator to be `1` (stored) or `0` (absent). -/ def branchEqEdges (bounds : List Key) (k : Key) (stored : Bool) : List DEdge := let i := endpointIndex bounds (k : WithTop Key) let j := endpointIndex bounds ((keyAfter k : Key) : WithTop Key) if stored then [⟨i, j, 1⟩, ⟨j, i, -1⟩] else [⟨i, j, 0⟩, ⟨j, i, 0⟩] /-- The complete difference system for one branch of the finite count relaxation. -/ def countDiffEdges (bounds : List Key) (k : Key) (stored : Bool) (S : ConstraintSystem) (bad : List Constraint) : List DEdge := capEdges bounds ++ constraintEdges bounds S ++ badEdges bounds k stored bad ++ branchEqEdges bounds k stored /-- The finite-count feasibility predicate for one toggle-indicator branch. -/ def CountFeasibleBranch (bounds : List Key) (k : Key) (stored : Bool) (S : ConstraintSystem) (bad : List Constraint) : Prop := ∃ counts : List ℕ, ∃ topCount : ℕ, CountsFit ([] : Key) bounds counts ∧ SystemHoldsWithCounts S bounds counts topCount ∧ evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = (if stored then 1 else 0) ∧ ∀ c ∈ bad, c.bound < evalCountToggled bounds counts topCount k c.hi - evalCountToggled bounds counts topCount k c.lo /-- `x` has prefix sums given by `counts`, starting at index `i`. -/ def PrefixCum (x : ℕ → ℤ) (i : ℕ) (counts : List ℕ) : Prop := ∀ k ≤ counts.length, x (i + k) - x i = (pref counts k : ℤ) theorem pref_succ (counts : List ℕ) {i : ℕ} (hi : i < counts.length) : pref counts (i + 1) = pref counts i + counts[i] := by unfold pref rw [List.sum_take_succ counts i hi] theorem pref_zero (counts : List ℕ) : pref counts 0 = 0 := by simp [pref] theorem pref_cons_succ (d : ℕ) (ds : List ℕ) (k : ℕ) : pref (d :: ds) (k + 1) = d + pref ds k := by simp [pref, List.take_succ_cons, List.sum_cons] theorem prefixCum_cons_head {x : ℕ → ℤ} {i d} {ds : List ℕ} (h : PrefixCum x i (d :: ds)) : x (i + 1) - x i = (d : ℤ) := by have := h 1 (by simp) simpa [pref_cons_succ, pref_zero] using this theorem prefixCum_tail {x : ℕ → ℤ} {i d} {ds : List ℕ} (h : PrefixCum x i (d :: ds)) : PrefixCum x (i + 1) ds := by intro k hk have h1 := h (k + 1) (by simp [Nat.succ_le_succ_iff.mpr hk]) have h0 := h 1 (by simp) have : x (i + (k + 1)) - x i - (x (i + 1) - x i) = (pref (d :: ds) (k + 1) : ℤ) - (pref (d :: ds) 1 : ℤ) := by rw [h1, h0] rw [pref_cons_succ, pref_cons_succ, pref_zero] at this have harg : i + (k + 1) = i + 1 + k := by omega rw [harg] at this have hpref : ((d + pref ds k : ℕ) : ℤ) - ((d + 0 : ℕ) : ℤ) = (pref ds k : ℤ) := by push_cast ring linarith theorem prefixCum_countsToX (n : ℕ) (counts : List ℕ) (topCount : ℕ) (hlen : counts.length = n) : PrefixCum (countsToX n counts topCount) 0 counts := by intro k hk have hk' : k ≤ n := by omega have hne : k ≠ n + 1 := by omega simp [countsToX, hne, pref_zero] theorem length_eq_of_countsFit {start : Key} {bounds : List Key} {counts : List ℕ} (h : CountsFit start bounds counts) : counts.length = bounds.length := by induction bounds generalizing start counts with | nil => cases counts with | nil => rfl | cons d ds => simp [CountsFit] at h | cons b bs ih => cases counts with | nil => simp [CountsFit] at h | cons d ds => simp [CountsFit] at h; exact congrArg Nat.succ (ih h.2.2) /-- Capacity edges hold when the prefix-cumulative assignment comes from a capacity-fitting count list. -/ theorem capEdgesAux_holds_of_countsFit {start : Key} {bounds : List Key} {counts : List ℕ} {x : ℕ → ℤ} {i : ℕ} (hfit : CountsFit start bounds counts) (hlen : counts.length = bounds.length) (hx : PrefixCum x i counts) : HoldsAll x (capEdgesAux start bounds i) := by induction bounds generalizing start counts i with | nil => have : counts = [] := by cases counts with | nil => rfl | cons d ds => simp at hlen subst this simp [capEdgesAux, HoldsAll] | cons b bs ih => cases counts with | nil => simp [CountsFit] at hfit | cons d ds => rcases hfit with ⟨hstartb, hcap, hfitTail⟩ have hlen' : ds.length = bs.length := by simpa using hlen have hhead := prefixCum_cons_head hx have htail := prefixCum_tail hx have hnonneg : x i - x (i + 1) ≤ 0 := by linarith [hhead] have hcapEdge : HoldsAll x (if h : intervalCard (start : WithTop Key) (b : WithTop Key) = ⊤ then [] else [⟨i, i + 1, ((intervalCard (start : WithTop Key) (b : WithTop Key)).toNat : ℤ)⟩]) := by by_cases htop : intervalCard (start : WithTop Key) (b : WithTop Key) = ⊤ · simp [htop, HoldsAll] · intro e he simp only [htop, ↓reduceDIte, List.mem_singleton] at he subst he simp only [DEdge.Holds] have hcast : (d : ℕ∞) ≤ intervalCard (start : WithTop Key) (b : WithTop Key) := hcap have hnat : d ≤ (intervalCard (start : WithTop Key) (b : WithTop Key)).toNat := by have := ENat.natCast_toNat_eq_self.mpr htop rw [← this] at hcast exact_mod_cast hcast rw [hhead] exact_mod_cast hnat intro e he -- `capEdgesAux start (b :: bs) i` is `([nonneg] ++ caps) ++ tail` rcases List.mem_append.mp he with hheadList | htailList · rcases List.mem_append.mp hheadList with hnon | hcapMem · simp only [List.mem_singleton] at hnon rw [hnon] simpa [DEdge.Holds] using hnonneg · exact hcapEdge e hcapMem · exact ih hfitTail hlen' htail e htailList /-- Conversely, capacity edges produce a capacity-fitting count list. -/ theorem countsFit_of_capEdgesAux {start : Key} {bounds : List Key} {counts : List ℕ} {x : ℕ → ℤ} {i : ℕ} (hle : BoundsLe start bounds) (hlen : counts.length = bounds.length) (hx : PrefixCum x i counts) (h : HoldsAll x (capEdgesAux start bounds i)) : CountsFit start bounds counts := by induction bounds generalizing start counts i with | nil => cases counts with | nil => simp [CountsFit] | cons d ds => simp at hlen | cons b bs ih => cases counts with | nil => simp at hlen | cons d ds => rcases hle with ⟨hstartb, hleTail⟩ have hlen' : ds.length = bs.length := by simpa using hlen have hhead := prefixCum_cons_head hx have htail := prefixCum_tail hx have hnonnegEdge : (⟨i + 1, i, 0⟩ : DEdge) ∈ capEdgesAux start (b :: bs) i := by simp [capEdgesAux] have hnonneg := h _ hnonnegEdge simp only [DEdge.Holds] at hnonneg have hd_nonneg : (0 : ℤ) ≤ (d : ℤ) := by linarith [hhead] have hcap : (d : ℕ∞) ≤ intervalCard (start : WithTop Key) (b : WithTop Key) := by by_cases htop : intervalCard (start : WithTop Key) (b : WithTop Key) = ⊤ · rw [htop]; exact le_top · have hmem : (⟨i, i + 1, ((intervalCard (start : WithTop Key) (b : WithTop Key)).toNat : ℤ)⟩ : DEdge) ∈ capEdgesAux start (b :: bs) i := by simp [capEdgesAux, htop] have hcapInt := h _ hmem simp only [DEdge.Holds] at hcapInt rw [hhead] at hcapInt have hdNat : d ≤ (intervalCard (start : WithTop Key) (b : WithTop Key)).toNat := by exact_mod_cast hcapInt have hcast := ENat.natCast_toNat_eq_self.mpr htop rw [← hcast] exact_mod_cast hdNat refine ⟨hstartb, hcap, ?_⟩ apply ih hleTail hlen' htail intro e he exact h e (List.mem_append.mpr (Or.inr he)) /-- Evaluation of the count environment is the corresponding cumulative variable. -/ theorem evalCount_eq_countsToX {bounds : List Key} {counts : List ℕ} {topCount : ℕ} (hlen : counts.length = bounds.length) (hnoBot : ([] : Key) ∉ bounds) {e : WithTop Key} (he : EndpointCovered e bounds) : evalCount bounds counts topCount e = countsToX bounds.length counts topCount (endpointIndex bounds e) := by rcases he with rfl | rfl | ⟨k, hk, rfl⟩ · -- bottom simp [evalCount, countsToX, endpointIndex, pref] · -- top simp [evalCount, countsToX, endpointIndex] · -- finite nonempty endpoint by_cases hkbot : k = ([] : Key) · simp [evalCount, countsToX, endpointIndex, hkbot, pref] · have hidxlt : bounds.idxOf k < bounds.length := List.idxOf_lt_length_iff.mpr hk have hlen' : counts.length = bounds.length := hlen have hlook := countAtWith_eq_pref (base := 0) hlen' hk have hne : bounds.idxOf k ≠ bounds.length := by omega have hnot : k ≠ ([] : Key) := hkbot simp [evalCount, countsToX, endpointIndex, hkbot, hnot, hne, hlook] /-- The toggled count environment is the untoggled one plus the toggle coefficient, once the toggle indicator is pinned to the branch value. -/ theorem evalCountToggled_eq_add_toggleCoeff {bounds : List Key} {counts : List ℕ} {topCount : ℕ} {k : Key} {stored : Bool} (hxd : evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = (if stored then 1 else 0)) (e : WithTop Key) : evalCountToggled bounds counts topCount k e = evalCount bounds counts topCount e + toggleCoeff stored k e := by unfold evalCountToggled toggleShift toggleCoeff by_cases hlt : (k : WithTop Key) < e · cases stored <;> simp [hlt, hxd] · simp [hlt] /-- The constraint edges hold exactly when the count environment satisfies the constraint system. -/ theorem constraintEdges_holds_iff {bounds : List Key} {counts : List ℕ} {topCount : ℕ} {S : ConstraintSystem} (hlen : counts.length = bounds.length) {x : ℕ → ℤ} (hx : ∀ e : WithTop Key, EndpointCovered e bounds → x (endpointIndex bounds e) = evalCount bounds counts topCount e) (hcover : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) : HoldsAll x (constraintEdges bounds S) ↔ SystemHoldsWithCounts S bounds counts topCount := by unfold constraintEdges SystemHoldsWithCounts constructor · intro h c hc have hlo := hcover c hc have hedge := h (constraintEdge bounds c.lo c.hi c.bound) (List.mem_map.mpr ⟨c, hc, rfl⟩) simp only [constraintEdge, DEdge.Holds] at hedge rw [hx c.hi hlo.2, hx c.lo hlo.1] at hedge exact hedge · intro h e he rw [List.mem_map] at he obtain ⟨c, hc, rfl⟩ := he have hlo := hcover c hc simp only [constraintEdge, DEdge.Holds] rw [hx c.hi hlo.2, hx c.lo hlo.1] exact h c hc /-- The bad edges hold exactly when every chosen constraint fails after the toggle. -/ theorem badEdges_holds_iff {bounds : List Key} {counts : List ℕ} {topCount : ℕ} {k : Key} {stored : Bool} {bad : List Constraint} {x : ℕ → ℤ} (hxd : evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = (if stored then 1 else 0)) (hx : ∀ e : WithTop Key, EndpointCovered e bounds → x (endpointIndex bounds e) = evalCount bounds counts topCount e) (hcover : ∀ c ∈ bad, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) : HoldsAll x (badEdges bounds k stored bad) ↔ ∀ c ∈ bad, c.bound < evalCountToggled bounds counts topCount k c.hi - evalCountToggled bounds counts topCount k c.lo := by unfold badEdges constructor · intro h c hc have hlo := hcover c hc have hedge := h (constraintEdge bounds c.hi c.lo (toggleCoeff stored k c.hi - toggleCoeff stored k c.lo - c.bound - 1)) (List.mem_map.mpr ⟨c, hc, rfl⟩) simp only [constraintEdge, DEdge.Holds] at hedge rw [hx c.hi hlo.2, hx c.lo hlo.1] at hedge rw [evalCountToggled_eq_add_toggleCoeff hxd c.hi, evalCountToggled_eq_add_toggleCoeff hxd c.lo] omega · intro h e he rw [List.mem_map] at he obtain ⟨c, hc, rfl⟩ := he have hlo := hcover c hc have hbad := h c hc rw [evalCountToggled_eq_add_toggleCoeff hxd c.hi, evalCountToggled_eq_add_toggleCoeff hxd c.lo] at hbad simp only [constraintEdge, DEdge.Holds] rw [hx c.hi hlo.2, hx c.lo hlo.1] omega /-- The interval counts read off from a cumulative assignment. -/ def diffCounts (x : ℕ → ℤ) : ℕ → List ℕ | 0 => [] | n + 1 => diffCounts x n ++ [(x (n + 1) - x n).toNat] theorem diffCounts_length (x : ℕ → ℤ) (n : ℕ) : (diffCounts x n).length = n := by induction n with | zero => rfl | succ n ih => simp [diffCounts, ih] theorem pref_append_singleton_le {l : List ℕ} {d k : ℕ} (hk : k ≤ l.length) : pref (l ++ [d]) k = pref l k := by unfold pref rw [List.take_append_of_le_length hk] theorem pref_append_singleton_self (l : List ℕ) (d : ℕ) : pref (l ++ [d]) (l.length + 1) = pref l l.length + d := by unfold pref have hlen : l.length + 1 = (l ++ [d]).length := by simp rw [hlen, List.take_length] simp theorem pref_length (l : List ℕ) : pref l l.length = l.sum := by simp [pref] theorem pref_eq_sum_of_length_le {l : List ℕ} {n : ℕ} (h : l.length ≤ n) : pref l n = l.sum := by unfold pref rw [List.take_of_length_le h] /-- Differences read off from `x` telescope back to `x`. -/ theorem prefixCum_diffCounts {x : ℕ → ℤ} (h0 : x 0 = 0) (n : ℕ) (hnonneg : ∀ i < n, 0 ≤ x (i + 1) - x i) : PrefixCum x 0 (diffCounts x n) := by induction n with | zero => intro k hk have hk0 : k = 0 := by simpa [diffCounts] using hk subst k simp [PrefixCum, h0, pref] | succ n ih => intro k hk have hk' : k ≤ n + 1 := by simpa [diffCounts_length] using hk by_cases hkn : k ≤ n · have hklen : k ≤ (diffCounts x n).length := by simpa [diffCounts_length] using hkn rw [diffCounts, pref_append_singleton_le hklen] exact ih (fun i hi => hnonneg i (by omega)) k (by simpa [diffCounts_length] using hkn) · have hkeq : k = n + 1 := by omega subst k rw [diffCounts, show n + 1 = (diffCounts x n).length + 1 by rw [diffCounts_length]] rw [pref_append_singleton_self, pref_length, diffCounts_length] have hprev := ih (fun i hi => hnonneg i (by omega)) n (by simpa [diffCounts_length] using le_refl n) have hprefsum : pref (diffCounts x n) n = (diffCounts x n).sum := pref_eq_sum_of_length_le (by rw [diffCounts_length]) have hprev' : x n - x 0 = ((diffCounts x n).sum : ℤ) := by simpa only [Nat.zero_add, hprefsum] using hprev have hd : ((x (n + 1) - x n).toNat : ℤ) = x (n + 1) - x n := by rw [Int.toNat_of_nonneg (hnonneg n (by omega))] have hmap : (List.map Nat.cast (diffCounts x n)).sum = ((diffCounts x n).sum : ℤ) := (map_list_sum Int.ofNatHom (diffCounts x n)).symm push_cast rw [hmap, hd] simp only [Nat.zero_add] linarith /-- The cumulative assignment reconstructed from its differences agrees with `countsToX`. -/ theorem eq_countsToX_of_prefixCum {x : ℕ → ℤ} {counts : List ℕ} {n topCount : ℕ} (h0 : x 0 = 0) (hlen : counts.length = n) (hpref : PrefixCum x 0 counts) (htop : topCount = (x (n + 1) - x n).toNat) (hnonneg : 0 ≤ x (n + 1) - x n) : ∀ i ≤ n + 1, x i = countsToX n counts topCount i := by intro i hi by_cases hin : i = n + 1 · subst i simp only [countsToX, if_pos rfl] have hsum : x n = (pref counts n : ℤ) := by have := hpref n (by omega) simpa [h0] using this have hsum' : x n = (pref counts counts.length : ℤ) := by simpa [← hlen] using hsum have hsumsum : (counts.sum : ℤ) = x n := by rw [pref_length] at hsum' exact hsum'.symm have hd : ((x (n + 1) - x n).toNat : ℤ) = x (n + 1) - x n := Int.toNat_of_nonneg hnonneg have hmap : (List.map Nat.cast counts).sum = (counts.sum : ℤ) := (map_list_sum Int.ofNatHom counts).symm rw [htop] push_cast rw [hmap, hsumsum, hd] ring · have hi' : i ≤ n := by omega have hne : i ≠ n + 1 := hin simp only [countsToX, if_neg hne] have := hpref i (by omega) simpa [h0] using this /-- The branch equality edges say exactly that the toggle indicator is the chosen branch value. -/ theorem branchEqEdges_holds_iff {bounds : List Key} {counts : List ℕ} {topCount : ℕ} {k : Key} {stored : Bool} {x : ℕ → ℤ} (hx : ∀ e : WithTop Key, EndpointCovered e bounds → x (endpointIndex bounds e) = evalCount bounds counts topCount e) (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) : HoldsAll x (branchEqEdges bounds k stored) ↔ evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = (if stored then 1 else 0) := by have hcovK : EndpointCovered (k : WithTop Key) bounds := by rcases hk with rfl | hk · exact Or.inl rfl · exact Or.inr (Or.inr ⟨k, hk, rfl⟩) have hcovKa : EndpointCovered ((keyAfter k : Key) : WithTop Key) bounds := Or.inr (Or.inr ⟨keyAfter k, hka, rfl⟩) have hxi : x (endpointIndex bounds (k : WithTop Key)) = evalCount bounds counts topCount (k : WithTop Key) := hx _ hcovK have hxj : x (endpointIndex bounds ((keyAfter k : Key) : WithTop Key)) = evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) := hx _ hcovKa unfold branchEqEdges cases stored · change HoldsAll x [⟨endpointIndex bounds (k : WithTop Key), endpointIndex bounds ((keyAfter k : Key) : WithTop Key), 0⟩, ⟨endpointIndex bounds ((keyAfter k : Key) : WithTop Key), endpointIndex bounds (k : WithTop Key), 0⟩] ↔ evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = 0 constructor · intro h have h1 := h ⟨endpointIndex bounds (k : WithTop Key), endpointIndex bounds ((keyAfter k : Key) : WithTop Key), 0⟩ (by simp) have h2 := h ⟨endpointIndex bounds ((keyAfter k : Key) : WithTop Key), endpointIndex bounds (k : WithTop Key), 0⟩ (by simp) simp only [DEdge.Holds] at h1 h2 rw [hxi, hxj] at h1 h2 linarith · intro h intro e he simp only [List.mem_cons, List.not_mem_nil, or_false] at he rcases he with rfl | rfl · simp only [DEdge.Holds] rw [hxi, hxj] linarith · simp only [DEdge.Holds] rw [hxi, hxj] linarith · change HoldsAll x [⟨endpointIndex bounds (k : WithTop Key), endpointIndex bounds ((keyAfter k : Key) : WithTop Key), 1⟩, ⟨endpointIndex bounds ((keyAfter k : Key) : WithTop Key), endpointIndex bounds (k : WithTop Key), -1⟩] ↔ evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = 1 constructor · intro h have h1 := h ⟨endpointIndex bounds (k : WithTop Key), endpointIndex bounds ((keyAfter k : Key) : WithTop Key), 1⟩ (by simp) have h2 := h ⟨endpointIndex bounds ((keyAfter k : Key) : WithTop Key), endpointIndex bounds (k : WithTop Key), -1⟩ (by simp) simp only [DEdge.Holds] at h1 h2 rw [hxi, hxj] at h1 h2 linarith · intro h intro e he simp only [List.mem_cons, List.not_mem_nil, or_false] at he rcases he with rfl | rfl · simp only [DEdge.Holds] rw [hxi, hxj] linarith · simp only [DEdge.Holds] rw [hxi, hxj] linarith /-- Every nonnegativity edge of the capacity system is present. -/ theorem nonnegEdge_mem_capEdgesAux (start : Key) (bounds : List Key) (i j : ℕ) (hj : j < bounds.length) : (⟨i + j + 1, i + j, 0⟩ : DEdge) ∈ capEdgesAux start bounds i := by induction bounds generalizing start i j with | nil => simp at hj | cons b bs ih => cases j with | zero => simp [capEdgesAux] | succ j' => have hj' : j' < bs.length := by simpa using hj have hmem := ih b (i + 1) j' hj' simp only [capEdgesAux, List.mem_append] right have h1 : i + (j' + 1) = i + 1 + j' := by omega have h2 : i + (j' + 1) + 1 = i + 1 + j' + 1 := by omega simpa [h1, h2] using hmem /-- One branch of the finite count relaxation is feasible exactly when its difference system is. -/ theorem countFeasibleBranch_iff_diffFeasible (bounds : List Key) (k : Key) (stored : Bool) (S : ConstraintSystem) (bad : List Constraint) (hnoBot : ([] : Key) ∉ bounds) (hle : BoundsLe ([] : Key) bounds) (hcoverS : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hcoverBad : ∀ c ∈ bad, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) : CountFeasibleBranch bounds k stored S bad ↔ DiffFeasible [] (countDiffEdges bounds k stored S bad) := by classical constructor · rintro ⟨counts, topCount, hfit, hS, hxd, hbad⟩ have hlen : counts.length = bounds.length := length_eq_of_countsFit hfit let x : ℕ → ℤ := countsToX bounds.length counts topCount have hxEval : ∀ e : WithTop Key, EndpointCovered e bounds → x (endpointIndex bounds e) = evalCount bounds counts topCount e := by intro e he exact (evalCount_eq_countsToX hlen hnoBot he).symm have hpref : PrefixCum x 0 counts := prefixCum_countsToX bounds.length counts topCount hlen have hcapAux : HoldsAll x (capEdgesAux ([] : Key) bounds 0) := capEdgesAux_holds_of_countsFit hfit hlen hpref have htopEdge : HoldsAll x [⟨bounds.length + 1, bounds.length, 0⟩] := by intro e he simp only [List.mem_singleton] at he rw [he] simp only [DEdge.Holds] have hxn : x bounds.length = (counts.sum : ℤ) := by dsimp [x] rw [countsToX, if_neg (by omega)] rw [pref_eq_sum_of_length_le (l := counts) (n := bounds.length) (by omega)] have hxt : x (bounds.length + 1) = ((counts.sum + topCount : ℕ) : ℤ) := by dsimp [x] rw [countsToX, if_pos rfl] push_cast ring rw [hxn, hxt] push_cast omega have hcap : HoldsAll x (capEdges bounds) := by intro e he rw [capEdges, List.mem_append] at he rcases he with he | he · exact hcapAux e he · exact htopEdge e he have hcon : HoldsAll x (constraintEdges bounds S) := (constraintEdges_holds_iff hlen hxEval hcoverS).mpr hS have hbadH : HoldsAll x (badEdges bounds k stored bad) := (badEdges_holds_iff hxd hxEval hcoverBad).mpr hbad have hbr : HoldsAll x (branchEqEdges bounds k stored) := (branchEqEdges_holds_iff hxEval hk hka).mpr hxd refine ⟨x, by simp [HoldsConsts], ?_⟩ intro e he simp only [countDiffEdges, List.mem_append] at he rcases he with ((he | he) | he) | he · exact hcap e he · exact hcon e he · exact hbadH e he · exact hbr e he · rintro ⟨x, -, hx⟩ let y : ℕ → ℤ := fun i => x i - x 0 have hy : HoldsAll y (countDiffEdges bounds k stored S bad) := by intro e he have hx' := hx e he simp only [DEdge.Holds] at hx' ⊢ dsimp [y] linarith have hcap : HoldsAll y (capEdges bounds) := by intro e he apply hy e simp only [countDiffEdges, List.mem_append] exact Or.inl (Or.inl (Or.inl he)) have hcon : HoldsAll y (constraintEdges bounds S) := by intro e he apply hy e simp only [countDiffEdges, List.mem_append] exact Or.inl (Or.inl (Or.inr he)) have hbadH : HoldsAll y (badEdges bounds k stored bad) := by intro e he apply hy e simp only [countDiffEdges, List.mem_append] exact Or.inl (Or.inr he) have hbr : HoldsAll y (branchEqEdges bounds k stored) := by intro e he apply hy e simp only [countDiffEdges, List.mem_append] exact Or.inr he have hcapAux : HoldsAll y (capEdgesAux ([] : Key) bounds 0) := by intro e he exact hcap e (List.mem_append.mpr (Or.inl he)) have hnonneg : ∀ i < bounds.length, 0 ≤ y (i + 1) - y i := by intro i hi have hmem := nonnegEdge_mem_capEdgesAux ([] : Key) bounds 0 i hi have hmem' : (⟨i + 1, i, 0⟩ : DEdge) ∈ capEdges bounds := List.mem_append.mpr (Or.inl (by simpa using hmem)) have := hcap _ hmem' simpa [DEdge.Holds] using this have htopNonneg : 0 ≤ y (bounds.length + 1) - y bounds.length := by have hmem : (⟨bounds.length + 1, bounds.length, 0⟩ : DEdge) ∈ capEdges bounds := by simp [capEdges] have := hcap _ hmem simpa [DEdge.Holds] using this let counts : List ℕ := diffCounts y bounds.length let topCount : ℕ := (y (bounds.length + 1) - y bounds.length).toNat have hlen : counts.length = bounds.length := diffCounts_length y bounds.length have h0 : y 0 = 0 := by simp [y] have hpref : PrefixCum y 0 counts := prefixCum_diffCounts h0 bounds.length hnonneg have hfit : CountsFit ([] : Key) bounds counts := countsFit_of_capEdgesAux hle hlen hpref hcapAux have htopEq : topCount = (y (bounds.length + 1) - y bounds.length).toNat := rfl have hyAgree : ∀ i ≤ bounds.length + 1, y i = countsToX bounds.length counts topCount i := eq_countsToX_of_prefixCum h0 hlen hpref htopEq htopNonneg have hxEval : ∀ e : WithTop Key, EndpointCovered e bounds → y (endpointIndex bounds e) = evalCount bounds counts topCount e := by intro e he have hidx : endpointIndex bounds e ≤ bounds.length + 1 := by rcases he with rfl | rfl | ⟨a, ha, rfl⟩ · simp [endpointIndex] · simp [endpointIndex] · have ha' : a ≠ ([] : Key) := by intro hbot exact hnoBot (hbot ▸ ha) have hlt : bounds.idxOf a < bounds.length := List.idxOf_lt_length_iff.mpr ha simp only [endpointIndex, ha', if_false] omega rw [hyAgree _ hidx] exact (evalCount_eq_countsToX hlen hnoBot he).symm have hS : SystemHoldsWithCounts S bounds counts topCount := (constraintEdges_holds_iff hlen hxEval hcoverS).mp hcon have hxd : evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = (if stored then 1 else 0) := (branchEqEdges_holds_iff hxEval hk hka).mp hbr have hbad : ∀ c ∈ bad, c.bound < evalCountToggled bounds counts topCount k c.hi - evalCountToggled bounds counts topCount k c.lo := (badEdges_holds_iff hxd hxEval hcoverBad).mp hbadH exact ⟨counts, topCount, hfit, hS, hxd, hbad⟩ /-- The unbranched finite-count feasibility predicate appearing in `flipWitness_iff_exists_counts_canonical`. -/ def CountFeasible (bounds : List Key) (k : Key) (S : ConstraintSystem) (bad : List Constraint) : Prop := ∃ counts : List ℕ, ∃ topCount : ℕ, CountsFit ([] : Key) bounds counts ∧ SystemHoldsWithCounts S bounds counts topCount ∧ ∀ c ∈ bad, c.bound < evalCountToggled bounds counts topCount k c.hi - evalCountToggled bounds counts topCount k c.lo /-- The unbranched count predicate is the disjunction of the two toggle-indicator branches. -/ theorem countFeasible_iff_branch_or (bounds : List Key) (k : Key) (S : ConstraintSystem) (bad : List Constraint) (hnoBot : ([] : Key) ∉ bounds) (hcoverS : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hcoverBad : ∀ c ∈ bad, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) : CountFeasible bounds k S bad ↔ CountFeasibleBranch bounds k true S bad ∨ CountFeasibleBranch bounds k false S bad := by constructor · rintro ⟨counts, topCount, hfit, hS, hbad⟩ obtain ⟨db, hcountsAt, htop⟩ := exists_db_realizing_counts bounds counts topCount hfit have hcovK : EndpointCovered (k : WithTop Key) bounds := by rcases hk with rfl | hk · exact Or.inl rfl · exact Or.inr (Or.inr ⟨k, hk, rfl⟩) have hcovKa : EndpointCovered ((keyAfter k : Key) : WithTop Key) bounds := Or.inr (Or.inr ⟨keyAfter k, hka, rfl⟩) have hkEval : evalCount bounds counts topCount (k : WithTop Key) = cnt db (k : WithTop Key) := evalCount_eq_cnt_of_covered hcountsAt htop hnoBot hcovK have hkaEval : evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) = cnt db ((keyAfter k : Key) : WithTop Key) := evalCount_eq_cnt_of_covered hcountsAt htop hnoBot hcovKa by_cases hmem : k ∈ db.keys · refine Or.inl ⟨counts, topCount, hfit, hS, ?_, hbad⟩ rw [hkEval, hkaEval] simpa [hmem] using cnt_keyAfter_sub_cnt db k · refine Or.inr ⟨counts, topCount, hfit, hS, ?_, hbad⟩ rw [hkEval, hkaEval] simpa [hmem] using cnt_keyAfter_sub_cnt db k · rintro (⟨counts, topCount, hfit, hS, -, hbad⟩ | ⟨counts, topCount, hfit, hS, -, hbad⟩) · exact ⟨counts, topCount, hfit, hS, hbad⟩ · exact ⟨counts, topCount, hfit, hS, hbad⟩ /-- Computable decision of the unbranched finite-count feasibility. -/ def countFeasibleBool (bounds : List Key) (k : Key) (S : ConstraintSystem) (bad : List Constraint) : Bool := diffFeasibleBoolAuto (countDiffEdges bounds k false S bad) || diffFeasibleBoolAuto (countDiffEdges bounds k true S bad) theorem countFeasibleBool_spec (bounds : List Key) (k : Key) (S : ConstraintSystem) (bad : List Constraint) (hnoBot : ([] : Key) ∉ bounds) (hle : BoundsLe ([] : Key) bounds) (hcoverS : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hcoverBad : ∀ c ∈ bad, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) : countFeasibleBool bounds k S bad = true ↔ CountFeasible bounds k S bad := by have hfalse := countFeasibleBranch_iff_diffFeasible bounds k false S bad hnoBot hle hcoverS hcoverBad hk hka have htrue := countFeasibleBranch_iff_diffFeasible bounds k true S bad hnoBot hle hcoverS hcoverBad hk hka rw [countFeasibleBool, Bool.or_eq_true, diffFeasibleBoolAuto_spec, diffFeasibleBoolAuto_spec, ← hfalse, ← htrue] rw [countFeasible_iff_branch_or bounds k S bad hnoBot hcoverS hcoverBad hk hka] tauto /-- All finite choices of one constraint from each alternative of a DNF. -/ def choices : ConstraintDNF → List (List Constraint) | [] => [[]] | S :: Ss => S.flatMap fun c => (choices Ss).map fun bs => c :: bs theorem mem_choices {D : ConstraintDNF} {bad : List Constraint} : bad ∈ choices D ↔ ChoosesAll bad D := by induction D generalizing bad with | nil => cases bad <;> simp [choices, ChoosesAll] | cons S Ss ih => cases bad with | nil => simp [choices, ChoosesAll] | cons c cs => simp only [choices, List.mem_flatMap, List.mem_map, ChoosesAll, ih] constructor · rintro ⟨a, ha, bs, hbs, heq⟩ cases heq exact ⟨ha, hbs⟩ · rintro ⟨ha, hcs⟩ exact ⟨c, ha, cs, hcs, rfl⟩ /-- Computable version of `RangeRead.withinLimit`. -/ def withinLimitBool (r : RangeRead) (ks : List Key) : Bool := match r.limit with | none => true | some n => decide (ks.length ≤ (n : ℕ)) theorem withinLimitBool_eq (r : RangeRead) (ks : List Key) : withinLimitBool r ks = true ↔ RangeRead.withinLimit r ks := by cases h : r.limit with | none => simp [withinLimitBool, RangeRead.withinLimit, h] | some n => simp [withinLimitBool, RangeRead.withinLimit, h] /-- The computable activity oracle. It enumerates the DNF alternatives and the finite choices of one violated constraint per alternative, then invokes the difference-constraint decider for the canonical endpoint list `activeBounds`. -/ def activeComputable (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 => (choices D).any fun bad => countFeasibleBool bounds k S bad /-- The computable activity oracle is exact: it returns `true` exactly for the one-key flip witnesses. This closes the algorithmic interface left open in `General.lean`. -/ theorem activeComputable_spec {r : RangeRead} {res : Result} (hread : Readable r res) : ActiveDecider r res (activeComputable 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 [activeComputable] rw [Bool.and_eq_true, withinLimitBool_eq, List.any_eq_true] constructor · rintro ⟨hw, S, hS, hchoiceTrue⟩ rw [List.any_eq_true] at hchoiceTrue obtain ⟨bad, hbadMem, hfeas⟩ := hchoiceTrue have hchooses : ChoosesAll bad D := mem_choices.mp hbadMem 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, ?_⟩⟩ rw [List.any_eq_true] refine ⟨bad, mem_choices.mpr hchooses, ?_⟩ 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 (countFeasibleBool_spec bounds k S bad hnoBot hle (hcoverD S hS) hcoverBad hk hka).mpr hcount /-- The cellwise algorithm with the computable oracle is minimal on every readable pair. -/ theorem conflictRangeCellwise_minimal_computable {r : RangeRead} {res : Result} (hread : Readable r res) : Minimal r res (conflictRangeCellwise r res (activeComputable r res)) := conflictRangeCellwise_minimal (activeComputable_spec hread) hread /-- The computable-oracle cellwise algorithm computes exactly the necessary set. -/ theorem conflictRangeCellwise_toSet_eq_necessarySet_computable {r : RangeRead} {res : Result} (hread : Readable r res) : (conflictRangeCellwise r res (activeComputable r res)).toSet = necessarySet r res := conflictRangeCellwise_toSet_eq_necessarySet (activeComputable_spec hread) hread end FormalConflictRange