Polynomial Acceptance Problem

• The Polynomial Acceptance Problem is a time-bounded variant of the classical acceptance problem, determining if a nondeterministic Turing machine accepts an input within a set polynomial number of steps.
• It underpins NP-completeness by enabling polynomial-time reductions to Circuit-SAT and 3-CNF-SAT, linking computation tableaux to Boolean satisfiability.
• Recent methodologies employ tape-consistent path constructions and linear programming formulations to deterministically solve PolyAcc in high-degree polynomial time, overcoming classical complexity barriers.

The polynomial acceptance problem is the canonical time-bounded analogue of the classical acceptance problem from computability theory, where one asks whether a nondeterministic Turing machine accepts a given input within a fixed polynomial number of steps. This problem, often denoted as $\mathrm{PolyAcc}$, plays a central role in the structure of $\mathrm{NP}$-completeness, the formalization of NP verification, and theoretical explorations of complexity class separations, particularly through the lens of diagonalization and its modern variants.

1. Formal Definition of the Polynomial Acceptance Problem

Let $p(n)$ be a fixed explicit polynomial, e.g., $p(n)=n^k$ for some $k\ge1$. The polynomial acceptance problem is defined as follows:

$$\mathrm{PolyAcc} = \left\{\langle M, x, 1^t \rangle \;\middle|\; \begin{array}{l} M\text{ is a nondeterministic Turing machine},\ t \le p(|x|),\ \text{and } M\text{ has an accepting path on }x\text{ of length} \le t \end{array}\right\}$$

where $M$ is encoded in the standard manner, $x\in\{0,1\}^*$, and $1^t$ is the unary encoding of time bound $t$. The restriction $t \le p(|x|)$ ensures polynomial encoding size.

The $\mathrm{PolyAcc}$ problem asks: Given $(M,x,1^t)$, does $M$ have at least one accepting computation on $x$ of length at most $t$? This refines the classical $A_{\mathrm{TM}}$ problem to polynomially-bounded resource regimes (Garcia, 14 Jan 2026, Yakhontov, 2012).

2. Reductions to Circuit-SAT and 3-CNF-SAT

$\mathrm{PolyAcc}$ is NP-complete via mapping reductions that structure the core of the Cook–Levin theorem and its variants.

2.1. $\mathrm{PolyAcc} \to \mathrm{CIRCUIT\mbox{-}SAT}$

For any instance $\alpha = \langle M, x, 1^t\rangle$, construct a Boolean circuit $C_\alpha$ such that $C_\alpha$ is satisfiable if and only if $M$ accepts $x$ within $t$ steps. The construction simulates a $t\times s$ computation tableau, with variables $v_{i,j,\sigma}$ (cell contents) and $h_{i,j,q}$ (head position and state), and enforces the initial configuration, valid transitions, and acceptance conditions through constant-size subcircuits.

2.2. $\mathrm{CIRCUIT\mbox{-}SAT} \to 3\text{-}\mathrm{CNF\mbox{-}SAT}$

Applying the Tseitin transformation, each gate is mapped to a bounded number of 3-CNF clauses, preserving satisfiability. The combined reduction $h = g \circ f$ satisfies

$\alpha\in\mathrm{PolyAcc} \iff h(\alpha)\in 3\text{-}\mathrm{CNF\mbox{-}SAT},$

with all mappings computable in polynomial time and the resulting formula of polynomial size (Garcia, 14 Jan 2026).

3. NP-Completeness and Recognition Properties

$\mathrm{PolyAcc}$ is NP-complete:

• Membership in NP: Given $\langle M, x, 1^t \rangle$, a nondeterministic verifier guesses an encoding of an accepting tableau or a satisfying assignment for $C_\alpha$ and checks validity in polynomial time over $|M|+|x|+t$.
• NP-hardness: The reduction above guarantees that any $3\text{-}\mathrm{CNF\mbox{-}SAT}$ instance can be mapped to a $\mathrm{PolyAcc}$ instance in polynomial time.

$\mathrm{PolyAcc}$ is thus “undecidable in polynomial time” (no deterministic poly-time algorithm unless $P=NP$) but “verifiable in polynomial time,” i.e., it is the archetypal NP-complete problem (Garcia, 14 Jan 2026).

4. Alternative Constructive and Linear Programming-Based Approaches

A constructive solution to $\mathrm{PolyAcc}$ is realized by reducing to the tape-consistent path existence problem (TCPE) and then formulating this as a linear program (LP):

1. TCPE Construction: For a given $(M_\mathrm{NP}, x, t(n))$, construct a directed acyclic graph $G$ and a tape-consistency pair set $TConsistPairSet$ such that every consistent $s$–$t$ path encodes a valid accepting computation.
2. LP Formulation: The decision problem is modeled as a multi-commodity flow LP whose feasibility corresponds to the existence of a tape-consistent accepting path.
3. Algorithmic Solution: The deterministic machine $M_{ExistsAcceptingPath}$ runs in $O(t(n)^{272})$ steps, building $G$, analyzing reachability, setting up, and solving the LP in polynomial time with respect to $t(n)$ (Yakhontov, 2012).

A bijection between accepting computation paths and tape-consistent $s$–$t$ paths, and between feasible LP solutions and those paths, yields exactness. The reduction and algorithm together show that the $\mathrm{PolyAcc}$ problem is both NP-complete and, in this constructive framework, deterministically solvable in high-degree polynomial time. This suggests a claimed equivalence $P=NP$ under this formalism (Yakhontov, 2012).

5. Semi-Relativization, Diagonalization, and Complexity Barriers

Traditional relativization methods fail to resolve $P$ vs $NP$ due to the existence of oracles $A$ and $B$ such that $P^A=NP^A$ but $P^B\neq NP^B$ (the Baker–Gill–Solovay theorem). Semi-relativization restricts attention to a specific oracle—the acceptance problem or its polynomial analogue $\mathrm{PolyAcc}$—and diagonalizes only against machines with query-access to this oracle.

Semi-relativized diagonalization lemma: Let $A=\mathrm{PolyAcc}$. There exists a language $D^A$ such that $D^A \notin P^A$ yet $D^A\in NP^A$, constructed by flipping the output of each $P^A$ machine on its own index (classical diagonalization). Verification remains in $NP^A$ while separation from $P^A$ follows by construction (Garcia, 14 Jan 2026).

This approach—using a fixed, natural oracle—contrasts with full relativization (all oracles), and hence circumvents the classical barrier, the algebrization barrier (since no algebraic oracles or arithmetization are invoked), and the natural proofs barrier (construction is nonconstructive and self-referential, not based on large, easily checkable combinatorial properties).

6. Implications for Complexity Class Separation

By “scaling down” the separation of $R$ vs $RE$ (decidable vs recursively enumerable languages in computability theory) to the polynomial setting, semi-relativized diagonalization establishes $P\subsetneq NP$ at the oracle level $A=\mathrm{PolyAcc}$, as $D^A$ is in $NP^A$ but not $P^A$ (Garcia, 14 Jan 2026). The argument depends on the nonconstructive nature of $D^A$ and the special properties of the $\mathrm{PolyAcc}$ oracle.

A plausible implication is that the separation $P\ne NP$ “semi-relativizes”: i.e., one can separate the classes using only the acceptance problem oracle, evading the relativization, algebrization, and natural proofs barriers. Whether this constitutes a resolution of the $P$ vs $NP$ question or only a demonstration of barrier circumvention depends on the acceptance of non-natural self-referential diagonal languages as sufficient evidence.

7. Summary Table: Main Aspects of the Polynomial Acceptance Problem

Property	Description	Reference
Definition	TM $M$ accepts $x$ in at most $t=p(|x|)$ steps	(Garcia, 14 Jan 2026)
NP-Completeness	$\mathrm{PolyAcc}$ is in NP and NP-hard (Cook–Levin, reductions to 3-CNF-SAT)	(Garcia, 14 Jan 2026)
Constructive Algorithm	Deterministic $O(t(n)^{272})$ algorithm via TCPE/LP formulation	(Yakhontov, 2012)
Diagonalization Technique	Semi-relativized diagonalization with $\mathrm{PolyAcc}$ oracle	(Garcia, 14 Jan 2026)
Barrier Circumvention	Evades relativization, algebrization, and natural proofs barriers	(Garcia, 14 Jan 2026)

The polynomial acceptance problem encapsulates the precise core of NP computation and verification, and serves as a locus for both traditional and barrier-evading approaches to central questions in computational complexity. Its reductions, completeness, and role in newly articulated diagonalization paradigms anchor ongoing developments in understanding the structure and separation of complexity classes.