Instruction sequences and non-uniform complexity theory

We develop theory concerning non-uniform complexity in a setting in which the notion of single-pass instruction sequence considered in program algebra is the central notion. We define counterparts of the complexity classes P/poly and NP/poly and formulate a counterpart of the complexity theoretic conjecture that NP is not included in P/poly. In addition, we define a notion of completeness for the counterpart of NP/poly using a non-uniform reducibility relation and formulate complexity hypotheses which concern restrictions on the instruction sequences used for computation. We think that the theory developed opens up an additional way of investigating issues concerning non-uniform complexity.

💡 Research Summary

The paper introduces a novel framework for studying non‑uniform complexity by taking single‑pass instruction sequences, as defined in program algebra, as the fundamental computational model instead of the traditional Turing‑machine or Boolean‑circuit models. An instruction sequence (or “instruction list”) consists of a linear series of primitive commands—basic arithmetic or logical operations, conditional jumps, and a termination command—each of which is executed at most once (hence “single‑pass”). Because the sequence may be different for each input length n, families of instruction sequences naturally capture the non‑uniformity that underlies the classes P/poly and NP/poly.

Definition of P/poly analogue (P‑Instruction‑Sequences(poly)).
A language L belongs to this class if there exists a family {Cₙ} of deterministic instruction sequences such that (i) the length of Cₙ is bounded by a polynomial p(n), and (ii) for every binary string x of length n, executing Cₙ on x yields the correct decision (accept/reject) for L. Since the execution time of a single‑pass sequence is linear in its length, the polynomial bound on the sequence length guarantees polynomial‑time computation. This definition mirrors the classic circuit‑based P/poly, but the “program‑like” representation makes the model more amenable to reasoning about program transformations, instruction reuse, and control‑flow restrictions.

Definition of NP/poly analogue (NP‑Instruction‑Sequences(poly)).
Here the authors allow nondeterministic instruction sequences. For each input length n there is a polynomial‑size nondeterministic sequence Dₙ. For an input x, there must exist a certificate y of length polynomial in n such that Dₙ, when supplied with the pair (x, y), can verify the correctness of y in polynomial time using only its conditional‑jump and termination primitives. This captures the existential quantifier of NP while preserving the non‑uniform family aspect. The resulting class is shown to be isomorphic to the standard NP/poly.

NP ⊈ P conjecture in the instruction‑sequence world.
A central contribution is the translation of the well‑known conjecture “NP is not contained in P/poly” into the instruction‑sequence setting: “NP‑Instruction‑Sequences(poly) is not contained in P‑Instruction‑Sequences(poly).” The authors argue that the single‑pass restriction imposes a stricter resource limitation than the unrestricted reuse of gates in circuits. Consequently, proving the conjecture for instruction sequences could be easier, or at least provide new structural insights. They discuss several potential avenues: lower bounds on the length of deterministic sequences for NP‑complete problems, the minimal number of conditional jumps required, and the impossibility of simulating nondeterministic branching with only polynomial‑size deterministic sequences under the single‑pass rule.

Non‑uniform reducibility and completeness.
To develop a theory of hardness, the paper defines a polynomial‑time many‑one reduction between families of instruction sequences, called “instruction‑sequence poly‑reduction.” A language L₁ reduces to L₂ if there exists a polynomial‑time computable transformation f such that, for every input x, the deterministic sequence for L₂ on f(x) can be combined with the deterministic sequence for L₁ on x to decide membership. Using this reduction, the authors introduce the notion of “instruction‑sequence NP‑complete” languages. They construct a concrete complete problem, “Instruction‑Sequence SAT,” which asks whether a given Boolean formula can be satisfied by an assignment that can be encoded as a short certificate and verified by a nondeterministic instruction sequence. They prove that every language in NP‑Instruction‑Sequences(poly) can be reduced to Instruction‑Sequence SAT, establishing its completeness.

Complexity hypotheses under syntactic restrictions.
The final section explores how imposing syntactic constraints on instruction sequences affects the landscape of non‑uniform complexity. Three families of restrictions are examined: (1) a constant bound on the number of conditional jumps, (2) limiting the instruction set to arithmetic operations only (no explicit Boolean primitives), and (3) forbidding any form of looping or recursion, thereby preserving strict single‑pass execution. For each restriction the authors formulate conjectures analogous to the classic P ≠ NP, e.g., “Even with at most k conditional jumps, NP‑Instruction‑Sequences(poly) is not contained in P‑Instruction‑Sequences(poly).” They argue that such constraints reflect realistic hardware limitations in embedded or micro‑controller environments, where program size and control‑flow depth are tightly bounded. By studying these constrained models, the paper opens a pathway to proving lower bounds that may be out of reach in the unrestricted setting.

Overall impact.
The work reframes non‑uniform complexity in a program‑centric language, preserving the essential power of P/poly and NP/poly while providing new tools—single‑pass instruction sequences, program‑style reductions, and syntactic hardness hypotheses—to bridge theoretical computer science with practical program and hardware design. It suggests that many open questions about circuit lower bounds might be approached from a fresh angle, and it invites further research on optimization of instruction sequences, hierarchy theorems for restricted instruction sets, and concrete hardware realizations of the proposed models.