/- Released under Apache 2.0 license as described in the file LICENSE. -/ import FormalConflictRange.General import FormalConflictRange.Prototype import FormalConflictRange.Realization /-! # From databases to finite interval counts This file connects the database-realization theorem of `Realization.lean` to the difference-constraint systems of the prototype. A system is satisfiable by a database exactly when a finite list of interval counts fits the interval capacities and makes every constraint hold under the cumulative count environment. The remaining arithmetic is therefore entirely on natural-number interval counts, which is the shape an active-cell decider consumes. -/ namespace FormalConflictRange def EndpointCovered (e : WithTop Key) (bounds : List Key) : Prop := e = (([] : Key) : WithTop Key) ∨ e = ⊤ ∨ ∃ b ∈ bounds, e = (b : WithTop Key) /-- The count environment satisfies a constraint system when every difference constraint holds under `evalCount`. -/ def SystemHoldsWithCounts (S : ConstraintSystem) (bounds : List Key) (counts : List ℕ) (topCount : ℕ) : Prop := ∀ c ∈ S, evalCount bounds counts topCount c.hi - evalCount bounds counts topCount c.lo ≤ c.bound /-- `CountsFit` implies that the endpoint chain is nondecreasing. -/ theorem boundsLe_of_CountsFit {start : Key} {bounds : List Key} {counts : List ℕ} (h : CountsFit start bounds counts) : BoundsLe start bounds := by induction bounds generalizing start counts with | nil => trivial | cons b bs ih => cases counts with | nil => simp [CountsFit] at h | cons d ds => rcases h with ⟨hstartb, -, htail⟩ exact ⟨hstartb, ih htail⟩ /-- The count environment agrees with the database on every covered endpoint. -/ theorem evalCount_eq_cnt_of_covered {db : DB} {bounds : List Key} {counts : List ℕ} {topCount : ℕ} (h : CountsAt db 0 bounds counts) (htop : cnt db ⊤ = counts.sum + topCount) (hnoBot : ([] : Key) ∉ bounds) {e : WithTop Key} (he : EndpointCovered e bounds) : evalCount bounds counts topCount e = cnt db e := by rcases he with rfl | rfl | ⟨b, hb, rfl⟩ · exact evalCount_bot · exact evalCount_top htop · exact evalCount_coe_of_mem h hb (by intro hbBot exact hnoBot (hbBot ▸ hb)) /-- **Satisfiability bridge.** A constraint system is satisfied by some database exactly when its finite count relaxation is satisfiable: choose consecutive interval counts that fit the interval capacities and make every constraint hold under the cumulative count environment. This turns the existential over databases into a finite count problem. It is the bridge used by an active-cell decider; the remaining arithmetic is entirely on `ℕ`-valued interval counts. -/ theorem exists_db_systemHoldsAt_iff_counts (S : ConstraintSystem) (bounds : List Key) (hnoBot : ([] : Key) ∉ bounds) (hle : BoundsLe ([] : Key) bounds) (hcover : ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) : (∃ db : DB, SystemHoldsAt S db) ↔ ∃ counts : List ℕ, ∃ topCount : ℕ, CountsFit ([] : Key) bounds counts ∧ SystemHoldsWithCounts S bounds counts topCount := by constructor · rintro ⟨db, hS⟩ let counts : List ℕ := intervalCounts db ([] : Key) bounds have hfit : CountsFit ([] : Key) bounds counts := intervalCounts_fit db ([] : Key) bounds hle have hcounts : CountsAt db 0 bounds counts := countsAt_intervalCounts db ([] : Key) bounds hle 0 (by simp [cnt_nil]) have hsum : counts.sum ≤ cnt db ⊤ := intervalCounts_sum_le_top db bounds hle let topCount : ℕ := cnt db ⊤ - counts.sum have htop : cnt db ⊤ = counts.sum + topCount := by dsimp [topCount] omega refine ⟨counts, topCount, hfit, ?_⟩ intro c hc have hhi := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcover c hc).2 have hlo := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcover c hc).1 rw [hhi, hlo] exact hS c hc · rintro ⟨counts, topCount, hfit, hholds⟩ obtain ⟨db, hcounts, htop⟩ := exists_db_realizing_counts bounds counts topCount hfit refine ⟨db, ?_⟩ intro c hc have hhi := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcover c hc).2 have hlo := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcover c hc).1 change (cnt db c.hi : ℤ) - (cnt db c.lo : ℤ) ≤ c.bound rw [← hhi, ← hlo] exact hholds c hc /-! ## Toggling one key in the count environment -/ /-- The interval `[k, keyAfter k)` contains exactly `k` when it is stored and nothing otherwise. -/ theorem between_keyAfter_length (db : DB) (k : Key) : (between db (k : WithTop Key) ((keyAfter k : Key) : WithTop Key)).length = if k ∈ db.keys then 1 else 0 := by set l := between db (k : WithTop Key) ((keyAfter k : Key) : WithTop Key) with hl have hnodup : l.Nodup := db.nodup.filter _ have hsubset : l ⊆ [k] := by intro x hx simp only [hl, between, List.mem_filter, decide_eq_true_eq] at hx have hxk : x = k := eq_of_le_of_lt_keyAfter (WithTop.coe_le_coe.mp hx.2.1) (WithTop.coe_lt_coe.mp hx.2.2) simp [hxk] have hle : l.length ≤ 1 := by have := hnodup.length_le_of_subset hsubset simpa using this by_cases hk : k ∈ db.keys · have hmem : k ∈ l := by simp [hl, between, hk, keyAfter_self_lt] have hpos : 0 < l.length := List.length_pos_of_mem hmem rw [ite_eq_left hk] omega · have hnil : l = [] := by rw [hl, between, List.filter_eq_nil_iff] intro x hx hcon simp only [decide_eq_true_eq] at hcon have hxmem : x ∈ db.keys := by simpa using hx have hxk : x = k := eq_of_le_of_lt_keyAfter (WithTop.coe_le_coe.mp hcon.1) (WithTop.coe_lt_coe.mp hcon.2) exact hk (hxk ▸ hxmem) simp [hnil, hk] /-- The difference of the counts at `k` and `keyAfter k` is the indicator of `k` being stored. -/ theorem cnt_keyAfter_sub_cnt (db : DB) (k : Key) : (cnt db ((keyAfter k : Key) : WithTop Key) : ℤ) - cnt db (k : WithTop Key) = if k ∈ db.keys then 1 else 0 := by have hle : (k : WithTop Key) ≤ ((keyAfter k : Key) : WithTop Key) := WithTop.coe_le_coe.mpr (le_of_lt (keyAfter_self_lt k)) have hmono : cnt db (k : WithTop Key) ≤ cnt db ((keyAfter k : Key) : WithTop Key) := cnt_le_cnt_of_le db hle have hcnt := cnt_sub_eq_between_length (db := db) hle have hlen := between_keyAfter_length db k rw [← Nat.cast_sub hmono, hcnt, hlen] by_cases hk : k ∈ db.keys <;> simp [hk] /-- The additive change in a count when the membership of `k` is toggled. The variable `x` is the indicator that `k` is stored. -/ def toggleShift (bounds : List Key) (counts : List ℕ) (topCount : ℕ) (k : Key) (e : WithTop Key) : ℤ := let x : ℤ := evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) if (k : WithTop Key) < e then 1 - 2 * x else 0 /-- The count environment after toggling `k`. -/ def evalCountToggled (bounds : List Key) (counts : List ℕ) (topCount : ℕ) (k : Key) (e : WithTop Key) : ℤ := evalCount bounds counts topCount e + toggleShift bounds counts topCount k e /-- The toggled count environment agrees with the toggled database. -/ theorem evalCountToggled_eq_cnt_toggle {db : DB} {bounds : List Key} {counts : List ℕ} {topCount : ℕ} (hcounts : CountsAt db 0 bounds counts) (htop : cnt db ⊤ = counts.sum + topCount) (hnoBot : ([] : Key) ∉ bounds) {k : Key} (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) {e : WithTop Key} (he : EndpointCovered e bounds) : evalCountToggled bounds counts topCount k e = cnt (toggle db k) e := by have hka_bot : keyAfter k ≠ ([] : Key) := by intro h have : (keyAfter k).length = 0 := by simp [h] simp [keyAfter] at this have he_cnt := evalCount_eq_cnt_of_covered hcounts htop hnoBot he have hka_cnt : evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) = cnt db ((keyAfter k : Key) : WithTop Key) := evalCount_coe_of_mem hcounts hka hka_bot have hk_cnt : evalCount bounds counts topCount (k : WithTop Key) = cnt db (k : WithTop Key) := by rcases hk with rfl | hk · exact evalCount_bot · exact evalCount_coe_of_mem hcounts hk (by intro h exact hnoBot (h ▸ hk)) have hx : evalCount bounds counts topCount ((keyAfter k : Key) : WithTop Key) - evalCount bounds counts topCount (k : WithTop Key) = if k ∈ db.keys then 1 else 0 := by rw [hka_cnt, hk_cnt] exact cnt_keyAfter_sub_cnt db k unfold evalCountToggled toggleShift rw [he_cnt, hx] unfold toggle by_cases hmem : k ∈ db.keys · rw [dite_eq_left hmem, cnt_erase_eq db k hmem e] by_cases hlt : (k : WithTop Key) < e · simp [hlt, hmem] try ring · simp [hlt] · rw [dite_eq_right hmem, cnt_insert_eq db k hmem e] by_cases hlt : (k : WithTop Key) < e · simp [hlt, hmem] · simp [hlt] /-- **One toggle witness in finite count form.** A database satisfying a system `S` while violating every constraint in a chosen list `bad` after toggling `k` exists exactly when the finite count relaxation has a solution that satisfies `S` and makes every toggled constraint in `bad` fail. The list `bad` is the finite choice of one violated constraint per DNF alternative. -/ theorem exists_db_systemHoldsAt_and_violates_iff_counts (S : ConstraintSystem) (bad : List Constraint) (bounds : List Key) (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) {k : Key} (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) : (∃ db : DB, SystemHoldsAt S db ∧ ∀ c ∈ bad, ¬ c.HoldsAt (toggle db k)) ↔ ∃ 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 := by constructor · rintro ⟨db, hS, hbad⟩ let counts : List ℕ := intervalCounts db ([] : Key) bounds have hfit : CountsFit ([] : Key) bounds counts := intervalCounts_fit db ([] : Key) bounds hle have hcounts : CountsAt db 0 bounds counts := countsAt_intervalCounts db ([] : Key) bounds hle 0 (by simp [cnt_nil]) have hsum : counts.sum ≤ cnt db ⊤ := intervalCounts_sum_le_top db bounds hle let topCount : ℕ := cnt db ⊤ - counts.sum have htop : cnt db ⊤ = counts.sum + topCount := by dsimp [topCount] omega refine ⟨counts, topCount, hfit, ?_, ?_⟩ · intro c hc have hhi := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcoverS c hc).2 have hlo := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcoverS c hc).1 rw [hhi, hlo] exact hS c hc · intro c hc have hhi := evalCountToggled_eq_cnt_toggle hcounts htop hnoBot hk hka (hcoverBad c hc).2 have hlo := evalCountToggled_eq_cnt_toggle hcounts htop hnoBot hk hka (hcoverBad c hc).1 have hnc := hbad c hc change ¬ ((cnt (toggle db k) c.hi : ℤ) - (cnt (toggle db k) c.lo : ℤ) ≤ c.bound) at hnc rw [hhi, hlo] omega · rintro ⟨counts, topCount, hfit, hS, hbad⟩ obtain ⟨db, hcounts, htop⟩ := exists_db_realizing_counts bounds counts topCount hfit refine ⟨db, ?_, ?_⟩ · intro c hc have hhi := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcoverS c hc).2 have hlo := evalCount_eq_cnt_of_covered hcounts htop hnoBot (hcoverS c hc).1 change (cnt db c.hi : ℤ) - (cnt db c.lo : ℤ) ≤ c.bound rw [← hhi, ← hlo] exact hS c hc · intro c hc have hhi := evalCountToggled_eq_cnt_toggle hcounts htop hnoBot hk hka (hcoverBad c hc).2 have hlo := evalCountToggled_eq_cnt_toggle hcounts htop hnoBot hk hka (hcoverBad c hc).1 have hnc := hbad c hc change ¬ ((cnt (toggle db k) c.hi : ℤ) - (cnt (toggle db k) c.lo : ℤ) ≤ c.bound) rw [← hhi, ← hlo] omega /-- A finite choice of one violated constraint from each DNF alternative. -/ def ViolatesAll : List Constraint → ConstraintDNF → DB → Prop | [], [], _ => True | c :: cs, S :: Ss, db => c ∈ S ∧ ¬ c.HoldsAt db ∧ ViolatesAll cs Ss db | _, _, _ => False /-- A DNF fails exactly when one can choose a violated constraint from every alternative. This is the finite disjunction used by the count encoding. -/ theorem not_anyHolds_iff_exists_violating_choice {D : ConstraintDNF} {db : DB} : ¬ AnyHolds D db ↔ ∃ bad : List Constraint, ViolatesAll bad D db := by induction D with | nil => constructor · intro _ exact ⟨[], by trivial⟩ · intro _ h simp [AnyHolds] at h | cons S Ss ih => cases S with | nil => have hAny : AnyHolds ([] :: Ss) db := by refine ⟨[], by simp, ?_⟩ intro c hc simp at hc constructor · intro h exact absurd hAny h · rintro ⟨bad, hbad⟩ cases bad with | nil => unfold ViolatesAll at hbad exact False.elim hbad | cons b bs => unfold ViolatesAll at hbad exact False.elim (by simpa using hbad.1) | cons c cs => have hAny : AnyHolds ((c :: cs) :: Ss) db ↔ SystemHoldsAt (c :: cs) db ∨ AnyHolds Ss db := by simp [AnyHolds, exists_eq_or_imp] constructor · intro h rw [hAny] at h have hS : ¬ SystemHoldsAt (c :: cs) db := fun hh => h (Or.inl hh) have hTail : ¬ AnyHolds Ss db := fun hh => h (Or.inr hh) unfold SystemHoldsAt at hS push Not at hS rcases hS with ⟨c', hc', hnc'⟩ obtain ⟨bad, hbad⟩ := ih.mp hTail refine ⟨c' :: bad, ?_⟩ unfold ViolatesAll exact ⟨hc', hnc', hbad⟩ · rintro ⟨bad, hbad⟩ rw [hAny] intro h cases bad with | nil => unfold ViolatesAll at hbad exact False.elim hbad | cons b bs => unfold ViolatesAll at hbad rcases hbad with ⟨hb, hnb, htail⟩ rcases h with hS | hTail · exact hnb (hS b hb) · exact (ih.mpr ⟨bs, htail⟩) hTail /-- A finite choice of one constraint from each DNF alternative, independent of a database. -/ def ChoosesAll : List Constraint → ConstraintDNF → Prop | [], [] => True | c :: cs, S :: Ss => c ∈ S ∧ ChoosesAll cs Ss | _, _ => False /-- The database-dependent violation predicate is a choice of constraints plus their failure. -/ theorem violatesAll_iff_choosesAll {bad : List Constraint} {D : ConstraintDNF} {db : DB} : ViolatesAll bad D db ↔ ChoosesAll bad D ∧ ∀ c ∈ bad, ¬ c.HoldsAt db := by induction bad generalizing D with | nil => cases D with | nil => simp [ViolatesAll, ChoosesAll] | cons S Ss => simp [ViolatesAll, ChoosesAll] | cons c cs ih => cases D with | nil => simp [ViolatesAll, ChoosesAll] | cons S Ss => simp only [ViolatesAll, ChoosesAll, List.forall_mem_cons, ih, and_assoc] tauto /-- Every chosen constraint lies in one of the DNF alternatives. -/ theorem choosesAll_mem {bad : List Constraint} {D : ConstraintDNF} (h : ChoosesAll bad D) {c : Constraint} (hc : c ∈ bad) : ∃ S ∈ D, c ∈ S := by induction bad generalizing D with | nil => simp at hc | cons c' cs ih => cases D with | nil => simp [ChoosesAll] at h | cons S Ss => rcases h with ⟨hc', htail⟩ rcases List.mem_cons.mp hc with rfl | hcs · exact ⟨S, by simp, hc'⟩ · obtain ⟨S', hS', hcS'⟩ := ih htail hcs exact ⟨S', by simp [hS'], hcS'⟩ /-! ## Canonical finite endpoint lists for the count description -/ /-- The finite, nonempty part of a `WithTop Key` endpoint, as an option. -/ def finiteEndpointOption : WithTop Key → Option Key | some k => if k = ([] : Key) then none else some k | none => none theorem finiteEndpointOption_eq_some {e : WithTop Key} {k : Key} : finiteEndpointOption e = some k ↔ e = (k : WithTop Key) ∧ k ≠ ([] : Key) := by cases e with | top => simp [finiteEndpointOption] | coe a => by_cases ha : a = ([] : Key) · simp [finiteEndpointOption, ha] · simp only [finiteEndpointOption, ha, ↓reduceIte] constructor · intro h refine ⟨h, ?_⟩ intro hk exact ha (Option.some.inj h ▸ hk) · rintro ⟨h, _⟩ exact h theorem finiteEndpointOption_injective_on {a a' : WithTop Key} {b : Key} (ha : b ∈ finiteEndpointOption a) (ha' : b ∈ finiteEndpointOption a') : a = a' := by cases a with | top => simp [finiteEndpointOption] at ha | coe ka => cases a' with | top => simp [finiteEndpointOption] at ha' | coe ka' => by_cases hka : ka = ([] : Key) · simp [finiteEndpointOption, hka] at ha · by_cases hka' : ka' = ([] : Key) · simp [finiteEndpointOption, hka'] at ha' · simp only [finiteEndpointOption, hka, hka', ↓reduceIte] at ha ha' simp only [Option.mem_some] at ha ha' rw [ha, ha'] /-- All finite, nonempty endpoints occurring in a DNF. -/ def finiteKeyEndpoints (D : ConstraintDNF) : Finset Key := (cellEndpoints D).filterMap finiteEndpointOption (by intro a a' b ha ha' exact finiteEndpointOption_injective_on ha ha') theorem mem_finiteKeyEndpoints {D : ConstraintDNF} {k : Key} : k ∈ finiteKeyEndpoints D ↔ (k : WithTop Key) ∈ cellEndpoints D ∧ k ≠ ([] : Key) := by rw [finiteKeyEndpoints, Finset.mem_filterMap] constructor · rintro ⟨a, ha, hfa⟩ rw [finiteEndpointOption_eq_some] at hfa exact ⟨by simpa [hfa.1] using ha, hfa.2⟩ · rintro ⟨ha, hk⟩ exact ⟨(k : WithTop Key), ha, (finiteEndpointOption_eq_some).mpr ⟨rfl, hk⟩⟩ /-- The canonical finite endpoint list for the active-cell count description: all finite nonempty DNF endpoints, together with `k` (when nonempty) and `keyAfter k`, sorted increasingly. -/ def activeBounds (D : ConstraintDNF) (k : Key) : List Key := let s := insert (keyAfter k) (finiteKeyEndpoints D) (if k = ([] : Key) then s else insert k s).sort (· ≤ ·) theorem keyAfter_ne_nil (k : Key) : keyAfter k ≠ ([] : Key) := by intro h have : (keyAfter k).length = 0 := by simp [h] simp [keyAfter] at this theorem mem_activeBounds {D : ConstraintDNF} {k e : Key} : e ∈ activeBounds D k ↔ e = keyAfter k ∨ e ∈ finiteKeyEndpoints D ∨ (k ≠ ([] : Key) ∧ e = k) := by unfold activeBounds by_cases hk : k = ([] : Key) · simp [hk, Finset.mem_sort, or_comm] · simp [hk, Finset.mem_sort, or_left_comm, or_comm] theorem not_mem_activeBounds_bot (D : ConstraintDNF) (k : Key) : ([] : Key) ∉ activeBounds D k := by rw [mem_activeBounds] rintro (h | h | ⟨hk, hk'⟩) · exact keyAfter_ne_nil k h.symm · exact (mem_finiteKeyEndpoints.mp h).2 rfl · exact hk hk'.symm /-- A sorted list whose elements are all above `start` has nondecreasing bounds. -/ theorem boundsLe_of_sortedLE {start : Key} {l : List Key} (hs : l.SortedLE) (h : ∀ b ∈ l, start ≤ b) : BoundsLe start l := by induction l generalizing start with | nil => trivial | cons a t ih => change start ≤ a ∧ BoundsLe a t constructor · exact h a (by simp) · apply ih (start := a) · exact (List.sortedLE_cons.mp hs).2 · intro b hb exact (List.sortedLE_cons.mp hs).1 b hb theorem activeBounds_boundsLe (D : ConstraintDNF) (k : Key) : BoundsLe ([] : Key) (activeBounds D k) := by apply boundsLe_of_sortedLE · unfold activeBounds by_cases hk : k = ([] : Key) · simpa [hk] using (Finset.sortedLT_sort (insert (keyAfter k) (finiteKeyEndpoints D))).sortedLE · simpa [hk] using (Finset.sortedLT_sort (insert k (insert (keyAfter k) (finiteKeyEndpoints D)))).sortedLE · intro b hb exact nil_le_key b theorem endpointCovered_activeBounds {D : ConstraintDNF} {k : Key} {e : WithTop Key} (he : e ∈ cellEndpoints D) : EndpointCovered e (activeBounds D k) := by unfold EndpointCovered cases e with | top => exact Or.inr (Or.inl rfl) | coe a => by_cases ha : a = ([] : Key) · exact Or.inl (by simp [ha]) · refine Or.inr (Or.inr ⟨a, ?_, rfl⟩) rw [mem_activeBounds] exact Or.inr (Or.inl ((mem_finiteKeyEndpoints).mpr ⟨by simpa using he, ha⟩)) theorem dnfEndpointCovered_activeBounds {D : ConstraintDNF} {k : Key} {S : ConstraintSystem} {c : Constraint} (hS : S ∈ D) (hc : c ∈ S) : EndpointCovered c.lo (activeBounds D k) ∧ EndpointCovered c.hi (activeBounds D k) := ⟨endpointCovered_activeBounds (dnfEndpoints_subset_cellEndpoints D (mem_dnfEndpoints_lo hS hc)), endpointCovered_activeBounds (dnfEndpoints_subset_cellEndpoints D (mem_dnfEndpoints_hi hS hc))⟩ /-- **Flip witnesses as finite count disjunctions.** Under a characterizing DNF, a one-key toggle witness exists exactly when the limit is respected and there is an alternative `S` of the DNF, a finite choice `bad` of one constraint from every alternative, and a finite interval-count assignment that satisfies `S` while making every constraint in `bad` fail after toggling `k`. All quantifiers here are finite except the count feasibility, which is the remaining decision problem. -/ theorem flipWitness_iff_exists_counts {D : ConstraintDNF} {r : RangeRead} {res : Result} (hchar : CharacterizesDNF D r res) {k : Key} (bounds : List Key) (hnoBot : ([] : Key) ∉ bounds) (hle : BoundsLe ([] : Key) bounds) (hcoverD : ∀ S ∈ D, ∀ c ∈ S, EndpointCovered c.lo bounds ∧ EndpointCovered c.hi bounds) (hk : k = ([] : Key) ∨ k ∈ bounds) (hka : keyAfter k ∈ bounds) : FlipWitness r res k ↔ RangeRead.withinLimit r res.keys ∧ ∃ S ∈ D, ∃ bad : List Constraint, ChoosesAll bad D ∧ ∃ 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 := by rw [flipWitness_iff_exists_not_anyHolds hchar] constructor · rintro ⟨db, hcomp, hnot⟩ rcases (hchar db).mp hcomp with ⟨hwithin, hany⟩ obtain ⟨S, hS, hSholds⟩ := hany obtain ⟨bad, hbad⟩ := (not_anyHolds_iff_exists_violating_choice).mp hnot rcases (violatesAll_iff_choosesAll).mp hbad with ⟨hchooses, hviol⟩ 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' obtain ⟨counts, topCount, hfit, hScounts, hbadcounts⟩ := (exists_db_systemHoldsAt_and_violates_iff_counts S bad bounds hnoBot hle (hcoverD S hS) hcoverBad hk hka).mp ⟨db, hSholds, hviol⟩ exact ⟨hwithin, S, hS, bad, hchooses, counts, topCount, hfit, hScounts, hbadcounts⟩ · rintro ⟨hwithin, S, hS, bad, hchooses, counts, topCount, hfit, hScounts, hbadcounts⟩ 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' obtain ⟨db, hSholds, hviol⟩ := (exists_db_systemHoldsAt_and_violates_iff_counts S bad bounds hnoBot hle (hcoverD S hS) hcoverBad hk hka).mpr ⟨counts, topCount, hfit, hScounts, hbadcounts⟩ have hnot : ¬ AnyHolds D (toggle db k) := (not_anyHolds_iff_exists_violating_choice).mpr ⟨bad, (violatesAll_iff_choosesAll).mpr ⟨hchooses, hviol⟩⟩ exact ⟨db, (hchar db).mpr ⟨hwithin, ⟨S, hS, hSholds⟩⟩, hnot⟩ /-- **Canonical finite-count form of `FlipWitness`.** The endpoint list is computed from the DNF itself, so no coverage hypothesis remains. -/ theorem flipWitness_iff_exists_counts_canonical {D : ConstraintDNF} {r : RangeRead} {res : Result} (hchar : CharacterizesDNF D r res) {k : Key} : FlipWitness r res k ↔ RangeRead.withinLimit r res.keys ∧ ∃ S ∈ D, ∃ bad : List Constraint, ChoosesAll bad D ∧ ∃ counts : List ℕ, ∃ topCount : ℕ, CountsFit ([] : Key) (activeBounds D k) counts ∧ SystemHoldsWithCounts S (activeBounds D k) counts topCount ∧ ∀ c ∈ bad, c.bound < evalCountToggled (activeBounds D k) counts topCount k c.hi - evalCountToggled (activeBounds D k) counts topCount k c.lo := flipWitness_iff_exists_counts (D := D) hchar (bounds := activeBounds D k) (not_mem_activeBounds_bot D k) (activeBounds_boundsLe D k) (fun S hS c hc => dnfEndpointCovered_activeBounds hS hc) (by by_cases hk : k = ([] : Key) · exact Or.inl hk · exact Or.inr (by rw [mem_activeBounds] exact Or.inr (Or.inr ⟨hk, rfl⟩))) (by rw [mem_activeBounds] exact Or.inl rfl) /-! ## A total activity oracle and the unconditional cellwise algorithm -/ /-- The total classical activity oracle: decide `FlipWitness` by excluded middle. This closes the algebraic interface. Making it *computable* is exactly the finite count-feasibility decision problem isolated by `flipWitness_iff_exists_counts`. -/ noncomputable def activeClassical (r : RangeRead) (res : Result) : Key → Bool := fun k => @decide (FlipWitness r res k) (Classical.propDecidable _) /-- The classical oracle is exact. -/ theorem activeClassical_spec (r : RangeRead) (res : Result) : ActiveDecider r res (activeClassical r res) := by intro k simp [activeClassical] /-- With the classical total oracle, the cellwise algorithm is minimal on every readable pair. This is the unconditional form of `conflictRangeCellwise_minimal`; the only remaining *computability* obligation is the count-feasibility decider. -/ theorem conflictRangeCellwise_minimal_classical {r : RangeRead} {res : Result} (hread : Readable r res) : Minimal r res (conflictRangeCellwise r res (activeClassical r res)) := conflictRangeCellwise_minimal (activeClassical_spec r res) hread /-- The unconditional classical algorithm computes exactly the necessary set. -/ theorem conflictRangeCellwise_toSet_eq_necessarySet_classical {r : RangeRead} {res : Result} (hread : Readable r res) : (conflictRangeCellwise r res (activeClassical r res)).toSet = necessarySet r res := conflictRangeCellwise_toSet_eq_necessarySet (activeClassical_spec r res) hread end FormalConflictRange