Circuit Satisfiability Problem for circuits of small complexity

The following problem is considered. A Turing machine $M$, that accepts a string of fixed length $t$ as input, runs for a time not exceeding a fixed value $n$ and is guaranteed to produce a binary output, is given. It’s required to find a string $X$ such that $M(X) = 1$ effectively in terms of $t$, $n$, the size of the alphabet of $M$ and the number of states of $M$. The problem is close to the well-known Circuit Satisfiability Problem. The difference from Circuit Satisfiability Problem is that when reduced to Circuit Satisfiability Problem, we get circuits with a rich internal structure (in particular, these are circuits of small Kolmogorov complexity). The proof system, operating with potential proofs of the fact that, for a given machine $M$, the string $X$ does not exist, is provided, its completeness is proved and the algorithm guaranteed to find a proof of the absence of the string $X$ in the case of its actual absence is presented (in the worst case, the algorithm is exponential, but in a wide class of interesting cases it works in polynomial time). We present an algorithm searching for the string $X$, for which its efficiency was neither tested, nor proven, and it may require serious improvement in the future, so it can be regarded as an idea. We also discuss first steps towards solving a more complex problem similar to this one: a Turing machine $M$, that accepts two strings $X$ and $Y$ of fixed length and running for a time that does not exceed a fixed value, is given; it is required to build an algorithm $N$ that builds a string $Y = N(X)$ for any string $X$, such that $M(X, Y) = 1$ (details in the introduction).

💡 Research Summary

The paper investigates a decision problem that lies at the intersection of Turing‑machine computation and Boolean‑circuit satisfiability. A deterministic Turing machine M is given with two fixed parameters: the length t of its input string and an upper bound n on its running time. M always halts within n steps and produces a single binary output (0 or 1). The central task is to find, efficiently in terms of t, n, the size of M’s alphabet, and the number of its states, an input string X such that M(X)=1, or to prove that no such X exists.

The authors first show how to translate the bounded‑time execution of M into a Boolean circuit of size polynomial in n and t. They construct a rectangular space‑time diagram of dimensions (2n+1) × n, where each cell (x, y) records the tape symbol at position x at time y, whether the head is present, and the machine’s internal state. The transition rule of M depends only on the three cells directly below (x‑1, y‑1), (x, y‑1), (x+1, y‑1); consequently each cell’s next‑step value can be expressed as a Boolean gate whose inputs are those three cells. The output of the whole circuit is the value of a distinguished gate on the top row, which equals the final output of M. Because the machine runs for at most n steps, the head never moves farther than n cells from the start, guaranteeing the bounded rectangle.

What makes this setting distinct from the classic Circuit‑SAT problem is that the resulting circuit has very low Kolmogorov complexity: it can be described succinctly by the description of M and the bound n. The authors argue that this structural restriction may allow algorithms that are more efficient than the generic exponential‑time SAT solvers.

To certify that a given circuit never outputs 1, the paper introduces a proof system called a “cage”. A cage consists of a collection of constant‑size neighborhoods of gates (each neighborhood contains a bounded number of gates) together with a set of rational‑coefficient functions defined on the Boolean assignments of those gates. Two local conditions must hold:

1. Positivity of the sum – For any assignment to the gates in a neighborhood, the sum of the values of all functions that depend on that neighborhood is a positive rational number, independent of the global assignment. This condition can be checked locally because each function depends only on a constant‑size set of gates.

2. Existence of an unsatisfied gate – Whenever a function evaluates to a positive value on a particular local assignment, there must exist at least one gate within the same neighborhood whose actual Boolean value does not match the value prescribed by the circuit’s logical constraints. In other words, the local assignment cannot be globally consistent.

If both conditions are satisfied for every neighborhood, the cage constitutes a proof that the circuit cannot output 1: assuming the contrary would lead to a contradiction between the positivity of the sum (which would be non‑positive for a globally satisfying assignment) and the existence of an unsatisfied gate (which would force the sum to be positive).

The authors claim completeness of this system: whenever a circuit truly never outputs 1, a cage can be constructed that fulfills the two conditions. They present an algorithm that searches for such a cage. In the worst case the algorithm is exponential, but because the circuit’s description is of low Kolmogorov complexity, many practical instances admit a polynomial‑time construction of a cage. The algorithm proceeds by enumerating constant‑size neighborhoods, generating candidate functions, and checking the two local conditions; if a violation is found, additional functions or constraints are added until the cage is complete.

When a circuit does have a satisfying input, the paper sketches an “idea” algorithm to actually find an input X with output 1. No implementation or empirical evaluation is provided. The approach relies on exploiting the structural regularities of the low‑complexity circuit. Two mathematical techniques are mentioned:

• Half‑space method – Interpreting certain gate constraints as linear inequalities and intersecting the corresponding half‑spaces to narrow down the feasible region of inputs.
• Quadratic‑function optimization – Approximating Boolean constraints by quadratic polynomials and applying quadratic programming to locate a satisfying assignment.

Both methods are described at a high level; detailed complexity analysis, correctness proofs, or experimental results are absent.

The paper then extends the setting to a “big string writing problem”. Here a Turing machine M takes two fixed‑length strings X and Y as input and outputs a binary value. The goal is to construct an algorithm N such that for every X, the string Y = N(X) satisfies M(X, Y)=1, or to output a special symbol if no such Y exists. This problem is related to reinforcement‑learning models, specifically Marcus Hutter’s “Cybernetic Agent Model”, where an agent (the algorithm N) interacts with an environment (the machine M) in alternating moves and receives a reward (the output 1). The authors argue that the big‑string problem can be viewed as a special case of this interaction: the environment makes a deterministic move (producing a reward 1) after the agent’s move, and the agent must choose a response that guarantees the reward.

To handle the two‑input scenario, the authors generalize the cage concept to a “generalized cage” and introduce the notion of a d‑constant generalized circuit. In addition to the original gates, new auxiliary gates and constraints are added. Each new constraint forces a new gate’s value to be a deterministic function of a bounded set of earlier gates, preserving the property that any satisfying assignment for the original circuit can be extended to satisfy the new constraints. The generalized circuit is no longer a pure Boolean circuit but a set of clauses with a metric structure that still admits local verification of the two cage conditions.

The paper concludes with a discussion of future work: improving the practical efficiency of the search algorithm for satisfying inputs, applying the framework to concrete problems (e.g., graph‑labeling tasks), and deepening the connection with reinforcement‑learning agents. The authors acknowledge that the current results are largely theoretical; no experimental validation, no concrete complexity bounds beyond the worst‑case exponential, and no implementation of the proposed algorithms are provided.

In summary, the contribution of the paper is threefold:

1. A formal reduction of bounded‑time Turing‑machine computation to a Boolean circuit with provably low Kolmogorov complexity.
2. A novel local‑proof system (cage) that can certify unsatisfiability of such circuits, together with a completeness argument and an algorithm that is polynomial‑time on many low‑complexity instances.
3. An outline of algorithms for actually finding satisfying inputs and for handling the two‑input “big string” variant, together with a conceptual link to reinforcement‑learning models.

While the theoretical ideas are intriguing, the lack of concrete algorithmic analysis, implementation, and empirical evaluation leaves the practical impact of the work open for future investigation.