Documentation

Complexitylib.Algebraic.LowerBound.Cutwidth.Nondeterministic

The (4 - ε) n bound for nondeterministic circuits #

A nondeterministic circuit for f : {0,1}ⁿ → {0,1} is a circuit on n + m inputs whose accepted inputs x are exactly those with some witness y for which the output is 1. Witness inputs are read by the wiring graph but carry no port of the function computed, so the cut-counting lemma applies to the forgotten network (Network.forget) with the same multigraph. The excess of the wiring graph is the number of reachable gates minus the number of reachable inputs, ordinary and witness alike, which is at most the number of gates minus the number of ordinary inputs read. Hence the same bound holds: nondeterminism does not reduce the size below (4 - ε) n for any dense rectangle-free family with sublinear logarithmic threshold. The bound Wiring.card_vertex_le_two_mul_size makes the graph size independent of the number of declared inputs, so the witness count m is unrestricted. nondet_eventually_lt_size_of_rectangleFree instantiates the proved graph bounds and only needs log₂ K(n) = o(n), rectangle-freeness, and the accepting-input bound. The explicit family Extractor.sourceReductionHardFamily meets these hypotheses through balanced padding, but no nondeterministic corollary for it is stated; SourceReduction.Construction.Hardness states its deterministic bounds. The generic graph-ordering interfaces are retained; as in the deterministic case, an ordering coefficient A > 0 gives the circuit coefficient 1 + 1/A (nondet_eventually_lt_size_of_orderingBound), and a cubic cutwidth coefficient c gives 1 + 1/(2c).

The proof organization, the threshold-edge charging, the extractor application, and the graph restoration argument of the deterministic bound follow Ryan Williams's private working note (September 2026); this module only replaces the wiring network by its forgotten version.

noncomputable def Algebraic.Cutwidth.nondetFunction {n m : ℕ} (circuit : Circuit Binary.signature (n + m) 1) :

The Boolean function computed nondeterministically by a circuit on n + m inputs: x is accepted when some witness y makes the output 1.

Equations
Instances For

    A circuit on n + m inputs computes f nondeterministically when f x = 1 exactly when some witness makes the output 1.

    Equations
    Instances For
      noncomputable def Algebraic.Cutwidth.nondetGateFunction {n m s : ℕ} (p : Program Binary.signature (n + m) s) (out : Fin s) :

      The function computed nondeterministically by a program with m witness inputs and output gate out.

      Equations
      Instances For

        The forgotten wiring network computes the nondeterministic gate function.

        theorem Algebraic.Cutwidth.nondet_card_accepting_le_of_orderingBound {A η C : ℝ} (hAη : 0 ≤ A + η) (hC : 0 ≤ C) (order : Multigraph.OrderingBound A η C) {n m s : ℕ} (p : Program Binary.signature (n + m) s) (out : Fin s) {K : ℕ} (hK : 1 < K) (hrect : RectangleFree (nondetGateFunction p out) K) :
        (accepting (nondetGateFunction p out)).card < K * 2 ^ (n - (Wiring.network p out).forget.read.card) ∨ ↑(accepting (nondetGateFunction p out)).card ≤ (2 * ↑s + 1) * 2 ^ ((A + η) * max (↑s - ↑(Wiring.network p out).forget.read.card) 0 + 3 * Real.logb 2 (2 * ↑s + 1) + C + 3) * ↑K ^ 2

        The nondeterministic version of the circuit-level bound: the ordinary inputs read are those of the forgotten network, and the excess of the wiring graph is at most s minus their number.

        theorem Algebraic.Cutwidth.nondet_lt_size_of_orderingBound {A η θ C : ℝ} (hA : 0 < A) (hη : 0 ≤ η) (hηθ : η ≤ A ^ 2 * θ / 2) (hθA : θ ≤ 1 / A) (hC : 0 ≤ C) (order : Multigraph.OrderingBound A η C) {n : ℕ} (hn : 2 ≤ n) {f : Cslib.BooleanFunction n} {K : ℕ} (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hrect : RectangleFree f K) (hbig : 2 * K ^ 2 ≤ 2 ^ (n - 2)) (hlog : (A + η + 2) * Real.logb 2 ↑K + 4 * Real.logb 2 ↑n + (A + η + 4 * Real.logb 2 (4 + 3 / A) + C + 5) < A * θ / 2 * ↑n) {m : ℕ} (circuit : Circuit Binary.signature (n + m) 1) (computes : NondetComputes circuit f) :
        (1 + 1 / A - θ) * ↑n < ↑circuit.size

        The fixed-n nondeterministic core with a general ordering coefficient. The hypotheses are those of lt_size_of_orderingBound. The number of witness inputs is unrestricted: only the reachable graph, with at most 2 s + 1 vertices, enters the counting argument.

        theorem Algebraic.Cutwidth.nondet_lt_size_of_log_bounds {η C : ℝ} (hη : 0 < η) (hη1 : η ≤ 1 / 18) (hC : 0 ≤ C) (order : Multigraph.OrderingBound (1 / 3) η C) {n : ℕ} (hn : 2 ≤ n) {f : Cslib.BooleanFunction n} {K : ℕ} (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hrect : RectangleFree f K) (hbig : 2 * K ^ 2 ≤ 2 ^ (n - 2)) (hlog : 4 * Real.logb 2 ↑n + 3 * Real.logb 2 ↑K + (C + 22) < 3 * η * ↑n) {m : ℕ} (circuit : Circuit Binary.signature (n + m) 1) (computes : NondetComputes circuit f) :
        (4 - 18 * η) * ↑n < ↑circuit.size

        The fixed-n core for nondeterministic circuits. The logarithmic conditions are those of lt_size_of_log_bounds. The number of witness inputs is unrestricted: only the reachable graph, with at most 2 s + 1 vertices, enters the counting argument.

        theorem Algebraic.Cutwidth.nondet_lt_size_of_bounds {η C : ℝ} (hη : 0 < η) (hη1 : η ≤ 1 / 18) (hC : 0 ≤ C) (order : Multigraph.OrderingBound (1 / 3) η C) {n : ℕ} (hn : 2 ≤ n) {f : Cslib.BooleanFunction n} {K c : ℕ} (hK : K ≤ n ^ c) (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hrect : RectangleFree f K) (hpow : 8 * n ^ (2 * c) ≤ 2 ^ n) (hlog : (4 + 3 * ↑c) * Real.logb 2 ↑n + (C + 22) < 3 * η * ↑n) {m : ℕ} (circuit : Circuit Binary.signature (n + m) 1) (computes : NondetComputes circuit f) :
        (4 - 18 * η) * ↑n < ↑circuit.size

        The polynomial-threshold nondeterministic bound with an arbitrary number of witness inputs.

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size_of_orderingBound {A : ℝ} (hA : 0 < A) (order : ∀ (η : ℝ), 0 < η → ∃ (C : ℝ), Multigraph.OrderingBound A η C) (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (1 + 1 / A - ε) * ↑n < ↑circuit.size

        Nondeterministic circuits with a general ordering coefficient. Under the hypotheses of eventually_lt_size_of_orderingBound, for every ε > 0 and all sufficiently large n, every circuit on n + m inputs that computes f n nondeterministically has more than (1 + 1/A - ε) n gates, uniformly over every number m of witness inputs.

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size_of_cutwidthBound {c : ℝ} (hc : 0 < c) (cutwidth : ∀ (ξ : ℝ), 0 < ξ → ∃ (N₀ : ℕ), CutwidthBound c ξ N₀) (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (1 + 1 / (2 * c) - ε) * ↑n < ↑circuit.size

        Nondeterministic circuits from a cubic cutwidth bound. A cutwidth coefficient c > 0 at every positive slack gives the nondeterministic coefficient 1 + 1/(2c).

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size_of_pathwidthCoefficient {p : ℝ} (hp : 0 < p) (pathwidth : ∀ (ξ : ℝ), 0 < ξ → ∃ (N₀ : ℕ), PathwidthBound p ξ N₀) (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (1 + 1 / (2 * p) - ε) * ↑n < ↑circuit.size

        Nondeterministic circuits from a cubic pathwidth bound with coefficient p. A pathwidth coefficient p > 0 at every positive slack gives the nondeterministic coefficient 1 + 1/(2p).

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size_of_log_sublinear (order : ∀ (η : ℝ), 0 < η → ∃ (C : ℝ), Multigraph.OrderingBound (1 / 3) η C) (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (4 - ε) * ↑n < ↑circuit.size

        Sublinear source entropy suffices for the nondeterministic coefficient-four bound, uniformly over every number of witness inputs. This is nondet_eventually_lt_size_of_orderingBound at A = 1/3.

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size (order : ∀ (η : ℝ), 0 < η → ∃ (C : ℝ), Multigraph.OrderingBound (1 / 3) η C) (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (c : ℕ) (hK : ∀ᶠ (n : ℕ) in Filter.atTop, K n ≤ n ^ c) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (4 - ε) * ↑n < ↑circuit.size

        Nondeterministic circuits. Under the graph-ordering hypothesis and the hypotheses of eventually_lt_size on the family f n, for every ε > 0 and all sufficiently large n, every circuit on n + m inputs that computes f n nondeterministically has more than (4 - ε) n gates.

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size_of_pathwidthBound (pathwidth : ∀ (ξ : ℝ), 0 < ξ → ∃ (N₀ : ℕ), PathwidthBound (1 / 6) ξ N₀) (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (c : ℕ) (hK : ∀ᶠ (n : ℕ) in Filter.atTop, K n ≤ n ^ c) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (4 - ε) * ↑n < ↑circuit.size

        Nondeterministic circuits from the pathwidth hypothesis.

        theorem Algebraic.Cutwidth.nondet_eventually_lt_size_of_rectangleFree (f : (n : ℕ) → Cslib.BooleanFunction n) (K : ℕ → ℕ) (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) (hacc : ∀ᶠ (n : ℕ) in Filter.atTop, 2 ^ (n - 2) ≤ (accepting (f n)).card) (hrect : ∀ᶠ (n : ℕ) in Filter.atTop, RectangleFree (f n) (K n)) {ε : ℝ} (hε : 0 < ε) :
        ∀ᶠ (n : ℕ) in Filter.atTop, ∀ (m : ℕ) (circuit : Circuit Binary.signature (n + m) 1), NondetComputes circuit (f n) → (4 - ε) * ↑n < ↑circuit.size

        A dense rectangle-free family with sublinear logarithmic threshold requires more than (4 - ε) n gates even with arbitrarily many witness inputs. All graph bounds are instantiated by the proved cubic theorem.