Documentation

Complexitylib.Algebraic.LowerBound.Cutwidth.FourN

The (4 - ε) n lower bound #

Assembling the cut-counting lemma, the wiring graph, and the proved cubic bisection and pathwidth bounds gives the circuit lower bound. A K-rectangle-free function with at least 2 ^ (n - 2) accepting inputs and log₂ K = o(n) needs more than (4 - ε) n gates over the full binary basis, for every ε > 0 and all sufficiently large n. Polynomial thresholds are a special case.

eventually_lt_size_of_rectangleFree has no graph hypothesis. Its remaining application obligation is a family f n with log₂ K(n) = o(n) satisfying RectangleFree and the accepting-input bound. The downstream module Extractor.SourceReduction.Construction.Hardness supplies a concrete uniform polynomial-time family and proves its unconditional coefficient-four lower bound.

The counting argument is generic in the graph-ordering coefficient: with Multigraph.OrderingBound A η C for every slack η > 0, where A > 0, the circuit coefficient is 1 + 1/A (eventually_lt_size_of_orderingBound, with fixed-n core lt_size_of_orderingBound and numeric core false_of_accepting_bound_of_log_coefficient). A cubic cutwidth or pathwidth bound with coefficient c gives A = 2 c and hence 1 + 1/(2c) (eventually_lt_size_of_cutwidthBound, eventually_lt_size_of_pathwidthCoefficient). The proved Monien–Preis and Fomin–Høie bounds give c = 1/6, A = 1/3, and the coefficient four.

The coefficient-four graph-ordering interface remains eventually_lt_size_of_log_sublinear, with fixed-n core lt_size_of_log_bounds. The original eventually_lt_size and lt_size_of_bounds specialize these to polynomial thresholds.

The proof organization, the threshold-edge charging, the application of a sumset extractor as the hard family, and the merge-tree restoration argument follow Ryan Williams's private working note A (4 − ε)n lower bound for Boolean circuits (September 2026), which uses the circuit-to-read-once compiler of the author's counting note. The formalization is the author's.

theorem Algebraic.Cutwidth.Multigraph.OrderingBound.mono {A η C A' η' C' : ℝ} (h : OrderingBound A η C) (hAη : A + η ≤ A' + η') (hC : C ≤ C') :
OrderingBound A' η' C'

Increasing the total coefficient A + η or the additive constant weakens the ordering hypothesis.

theorem Algebraic.Cutwidth.Multigraph.exists_orderingBound_one_third_of_pathwidthBound (pathwidth : ∀ (ξ : ℝ), 0 < ξ → ∃ (N₀ : ℕ), PathwidthBound (1 / 6) ξ N₀) (η : ℝ) :
0 < η → ∃ (C : ℝ), OrderingBound (1 / 3) η C

The coefficient-four ordering hypothesis from a cubic pathwidth bound with coefficient 1/6 at every positive slack.

The graph-ordering hypothesis with coefficient 1/3. It follows from the proved Fomin–Høie cubic pathwidth bound.

theorem Algebraic.Cutwidth.sub_card_lt_clog {n : ℕ} {f : Cslib.BooleanFunction n} {K : ℕ} (hK : 1 < K) (hrect : RectangleFree f K) (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hbig : 2 * K ^ 2 ≤ 2 ^ (n - 2)) {R : Finset (Fin n)} (hR : DependsOnlyOn f R) :
n - R.card < Nat.clog 2 K

A rectangle-free function with many accepting inputs cannot ignore ⌈log₂ K⌉ coordinates.

theorem Algebraic.Cutwidth.card_accepting_le_of_orderingBound {A η C : ℝ} (hAη : 0 ≤ A + η) (hC : 0 ≤ C) (order : Multigraph.OrderingBound A η C) {n s : ℕ} (p : Program Binary.signature n s) (out : Fin s) {K : ℕ} (hK : 1 < K) (hrect : RectangleFree (fun (x : Cslib.BitString n) => p.eval Binary.interpretation x out) K) :
(accepting fun (x : Cslib.BitString n) => p.eval Binary.interpretation x out).card < K * 2 ^ (n - (Wiring.read p out).card) ∨ ↑(accepting fun (x : Cslib.BitString n) => p.eval Binary.interpretation x out).card ≤ (↑n + 3 * ↑s) * 2 ^ ((A + η) * max (↑s - ↑(Wiring.read p out).card) 0 + 3 * Real.logb 2 (↑n + 3 * ↑s) + C + 3) * ↑K ^ 2

The circuit-level bound: for a circuit with output gate out, either the final past set is small, so that fewer than K · 2 ^ (n - n') inputs are accepted, or the accepted inputs are bounded through the ordering hypothesis. Here n' is the number of inputs with a path to the output.

theorem Algebraic.Cutwidth.circuit_slack_nonneg {A η θ : ℝ} (hA : 0 < A) (hη : 0 ≤ η) (hηθ : η ≤ A ^ 2 * θ / 2) :
0 ≤ θ

The slack conditions of the general cores force a nonnegative circuit slack: an ordering slack 0 ≤ η ≤ A² θ / 2 with A > 0 gives 0 ≤ θ.

theorem Algebraic.Cutwidth.false_of_accepting_bound_of_log_coefficient {A η θ C M : ℝ} (hA : 0 < A) (hη : 0 ≤ η) (hηθ : η ≤ A ^ 2 * θ / 2) (hθA : θ ≤ 1 / A) {n : ℕ} (hn : 2 ≤ n) {f : Cslib.BooleanFunction n} {K : ℕ} (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hK1 : 1 < 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 M + C + 5) < A * θ / 2 * ↑n) {s n' : ℕ} (hs : ↑s ≤ (1 + 1 / A - θ) * ↑n) (hn'le : n' ≤ n) (hread : n - n' < Nat.clog 2 K) {Vb : ℝ} (hVpos : 0 < Vb) (hVb : Vb ≤ M * ↑n) (bound : (accepting f).card < K * 2 ^ (n - n') ∨ ↑(accepting f).card ≤ Vb * 2 ^ ((A + η) * max (↑s - ↑n') 0 + 3 * Real.logb 2 Vb + C + 3) * ↑K ^ 2) :

The numeric core with a general ordering coefficient. Let A > 0 be the ordering coefficient, θ ≤ 1/A the circuit slack, and 0 ≤ η ≤ A² θ / 2 the ordering slack. A K-rectangle-free function with at least 2 ^ (n - 2) accepting inputs cannot satisfy the accepting-input bound of the cut-counting lemma for a circuit with s ≤ (1 + 1/A - θ) n gates reading n' inputs, when n - n' < ⌈log₂ K⌉, the wiring graph has at most M n vertices, and n is large enough. The bound is taken as a hypothesis so that the deterministic and nondeterministic assemblies share this argument.

theorem Algebraic.Cutwidth.false_of_accepting_bound_of_log {η C : ℝ} (hη : 0 < η) (hη1 : η ≤ 1 / 18) {n : ℕ} (hn : 2 ≤ n) {f : Cslib.BooleanFunction n} {K : ℕ} (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hK1 : 1 < K) (hbig : 2 * K ^ 2 ≤ 2 ^ (n - 2)) (hlog : 4 * Real.logb 2 ↑n + 3 * Real.logb 2 ↑K + (C + 22) < 3 * η * ↑n) {s n' : ℕ} (hs : ↑s ≤ (4 - 18 * η) * ↑n) (hn'le : n' ≤ n) (hread : n - n' < Nat.clog 2 K) {Vb : ℝ} (hVpos : 0 < Vb) (hVb : Vb ≤ 16 * ↑n) (bound : (accepting f).card < K * 2 ^ (n - n') ∨ ↑(accepting f).card ≤ Vb * 2 ^ ((1 / 3 + η) * max (↑s - ↑n') 0 + 3 * Real.logb 2 Vb + C + 3) * ↑K ^ 2) :

The numeric core. A K-rectangle-free function with at least 2 ^ (n - 2) accepting inputs cannot satisfy the accepting-input bound of the cut-counting lemma for a circuit with s ≤ (4 - 18 η) n gates reading n' inputs, when n - n' < ⌈log₂ K⌉ and n is large enough. This is the general core at coefficient A = 1/3 with θ = 18 η.

theorem Algebraic.Cutwidth.false_of_accepting_bound {η C : ℝ} (hη : 0 < η) (hη1 : η ≤ 1 / 18) {n : ℕ} (hn : 2 ≤ n) {f : Cslib.BooleanFunction n} {K c : ℕ} (hK : K ≤ n ^ c) (hacc : 2 ^ (n - 2) ≤ (accepting f).card) (hK1 : 1 < K) (hpow : 8 * n ^ (2 * c) ≤ 2 ^ n) (hlog : (4 + 3 * ↑c) * Real.logb 2 ↑n + (C + 22) < 3 * η * ↑n) {s n' : ℕ} (hs : ↑s ≤ (4 - 18 * η) * ↑n) (hn'le : n' ≤ n) (hread : n - n' < Nat.clog 2 K) {Vb : ℝ} (hVpos : 0 < Vb) (hVb : Vb ≤ 16 * ↑n) (bound : (accepting f).card < K * 2 ^ (n - n') ∨ ↑(accepting f).card ≤ Vb * 2 ^ ((1 / 3 + η) * max (↑s - ↑n') 0 + 3 * Real.logb 2 Vb + C + 3) * ↑K ^ 2) :

The polynomial-threshold numeric core follows from the logarithmic core; this preserves the original deterministic and nondeterministic interface.

theorem Algebraic.Cutwidth.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) (circuit : Circuit Binary.signature n 1) (computes : circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f x) :
(1 + 1 / A - θ) * ↑n < ↑circuit.size

The fixed-n core with a general ordering coefficient. With the graph-ordering hypothesis for coefficient A > 0 and slack 0 ≤ η ≤ A² θ / 2, where θ ≤ 1/A, a K-rectangle-free function with at least 2 ^ (n - 2) accepting inputs needs more than (1 + 1/A - θ) n binary gates, provided its threshold and the logarithmic overhead satisfy the stated numeric conditions.

theorem Algebraic.Cutwidth.log_condition_one_third {η C : ℝ} (hη1 : η ≤ 1 / 18) {n K : ℝ} (hlogK : 0 ≤ Real.logb 2 K) (hlog : 4 * Real.logb 2 n + 3 * Real.logb 2 K + (C + 22) < 3 * η * n) :
(1 / 3 + η + 2) * Real.logb 2 K + 4 * Real.logb 2 n + (1 / 3 + η + 4 * Real.logb 2 (4 + 3 / (1 / 3)) + C + 5) < 1 / 3 * (18 * η) / 2 * n

The coefficient-four logarithmic condition implies the condition of the general cores at A = 1/3 and θ = 18 η.

theorem Algebraic.Cutwidth.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) (circuit : Circuit Binary.signature n 1) (computes : circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f x) :
(4 - 18 * η) * ↑n < ↑circuit.size

The fixed-n core of the lower bound. With the graph-ordering hypothesis for slack η ≤ 1/18, a K-rectangle-free function with at least 2 ^ (n - 2) accepting inputs needs more than (4 - 18 η) n binary gates, provided its threshold and the logarithmic overhead satisfy the stated numeric conditions. No polynomial-threshold assumption is needed.

theorem Algebraic.Cutwidth.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) (circuit : Circuit Binary.signature n 1) (computes : circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f x) :
(4 - 18 * η) * ↑n < ↑circuit.size

The original polynomial-threshold circuit bound, obtained by bounding the logarithm of the threshold in lt_size_of_log_bounds.

theorem Algebraic.Cutwidth.eventually_two_mul_sq_le_pow_of_log {K : ℕ → ℕ} (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) :
∀ᶠ (n : ℕ) in Filter.atTop, 2 * K n ^ 2 ≤ 2 ^ (n - 2)

A sublinear logarithmic threshold eventually satisfies the finite square bound needed to recover almost all input coordinates.

theorem Algebraic.Cutwidth.eventually_le_pow_half_of_log {K : ℕ → ℕ} (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) :
∀ᶠ (n : ℕ) in Filter.atTop, K n ≤ 2 ^ (n / 2)

A subexponential threshold fits in either half of the input cube for all sufficiently large input lengths.

theorem Algebraic.Cutwidth.exists_slack_eventually_log_condition {A : ℝ} (hA : 0 < A) (order : ∀ (η : ℝ), 0 < η → ∃ (C : ℝ), Multigraph.OrderingBound A η C) (K : ℕ → ℕ) (hK : (fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n) {ε : ℝ} (hε : 0 < ε) :
∃ (θ : ℝ) (η : ℝ) (C : ℝ), 0 ≤ η ∧ η ≤ A ^ 2 * θ / 2 ∧ θ ≤ 1 / A ∧ θ ≤ ε ∧ 0 ≤ C ∧ Multigraph.OrderingBound A η C ∧ ∀ᶠ (n : ℕ) in Filter.atTop, (A + η + 2) * Real.logb 2 ↑(K n) + 4 * Real.logb 2 ↑n + (A + η + 4 * Real.logb 2 (4 + 3 / A) + C + 5) < A * θ / 2 * ↑n

Slack selection for the general asymptotic bounds. Given the graph-ordering hypothesis with coefficient A > 0 at every positive slack, a threshold with log₂ K(n) = o(n), and ε > 0, some circuit slack θ ≤ min(ε, 1/A), ordering slack η, and constant C ≥ 0 satisfy the hypotheses of the general fixed-n cores, and their logarithmic condition holds for all sufficiently large n.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (1 + 1 / A - ε) * ↑n < ↑circuit.size

The circuit bound with a general ordering coefficient. Assume the graph-ordering hypothesis with coefficient A > 0 for every slack η > 0, and a family f n that is K n-rectangle-free with log₂ K(n) = o(n) and has at least 2 ^ (n - 2) accepting inputs for all large n. Then for every ε > 0 and all sufficiently large n, every binary circuit computing f n has more than (1 + 1/A - ε) n gates.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (1 + 1 / (2 * c) - ε) * ↑n < ↑circuit.size

The circuit bound from a cubic cutwidth bound. If for every slack ξ > 0 all sufficiently large simple cubic graphs on h vertices have orderings whose prefix cuts have at most (c + ξ) h edges, then the hypotheses of eventually_lt_size_of_orderingBound give more than (1 + 1/(2c) - ε) n gates.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (1 + 1 / (2 * p) - ε) * ↑n < ↑circuit.size

The circuit bound from a cubic pathwidth bound with coefficient p. If for every slack ξ > 0 all sufficiently large simple cubic graphs on h vertices have path decompositions of width at most (p + ξ) h, then the hypotheses of eventually_lt_size_of_orderingBound give more than (1 + 1/(2p) - ε) n gates.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (4 - ε) * ↑n < ↑circuit.size

Subexponential-threshold circuit bound. The coefficient four only needs log₂ K(n) = o(n); the threshold itself need not be polynomial. The graph-ordering theorem and the hard-family properties are still explicit hypotheses. This is eventually_lt_size_of_orderingBound at A = 1/3.

theorem Algebraic.Cutwidth.logb_isLittleO_of_eventually_le_pow {K : ℕ → ℕ} {c : ℕ} (hK : ∀ᶠ (n : ℕ) in Filter.atTop, K n ≤ n ^ c) :
(fun (n : ℕ) => Real.logb 2 ↑(K n)) =o[Filter.atTop] fun (n : ℕ) => ↑n

Polynomial thresholds have sublinear binary logarithms. This includes the value zero, whose real logarithm is defined to be zero.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (4 - ε) * ↑n < ↑circuit.size

Theorem 1. Assume the graph-ordering lemma for every slack η > 0 and a family of functions f n that is K n-rectangle-free with K n ≤ n ^ c and at least 2 ^ (n - 2) accepting inputs, for all large n. Then for every ε > 0 and all sufficiently large n, every binary circuit computing f n has more than (4 - ε) n gates.

theorem Algebraic.Cutwidth.eventually_lt_size_of_pathwidthBound_of_log_sublinear (pathwidth : ∀ (ξ : ℝ), 0 < ξ → ∃ (N₀ : ℕ), PathwidthBound (1 / 6) ξ 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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (4 - ε) * ↑n < ↑circuit.size

The subexponential-threshold lower bound from the cubic pathwidth theorem.

theorem Algebraic.Cutwidth.eventually_lt_size_of_bisectionBound_of_log_sublinear (bisection : ∀ (ξ : ℝ), 0 < ξ → ∃ (N₀ : ℕ), BisectionBound ξ 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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (4 - ε) * ↑n < ↑circuit.size

The coefficient-four lower bound with only the cubic bisection theorem and the hard-family properties as hypotheses. The pathwidth reduction is proved.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (4 - ε) * ↑n < ↑circuit.size

Theorem 1 from the pathwidth hypothesis. The graph-ordering hypothesis is replaced by the pathwidth bound for simple cubic graphs: for every ξ > 0 there is a threshold beyond which every simple 3-regular graph on h vertices has a path decomposition of width at most (1/6 + ξ) h.

theorem Algebraic.Cutwidth.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, ∀ (circuit : Circuit Binary.signature n 1), (circuit.Computes Binary.interpretation fun (x : Fin n → Bool) (x_1 : Fin 1) => f n x) → (4 - ε) * ↑n < ↑circuit.size

A dense rectangle-free family with sublinear logarithmic threshold has the coefficient-four circuit lower bound. The graph bounds are proved; only the stated hard-family properties remain to be supplied.