Logical Marker Algebra: The Inconsistency of the Classical Turing Machine in the Formal System of Information Science

 Abstract

The classical Turing machine is the foundational model of computation in information science. It is defined by six finite components: a state set, a tape alphabet, a transition function, an initial state, accepting states, and a tape convention. These components are stipulated as given. For the study of computation-as-execution, this convention is entirely legitimate and has proven enormously fruitful.

This paper argues, however, that a fundamental inconsistency arises when the classical Turing machine is treated as a complete formal system for information science rather than as an execution model. The inconsistency is as follows:

1. Every component of a Turing machine is a finite, structured, non-random information object. Collectively, they constitute ordered information.

2. Ordered information cannot arise from disordered information without a source process. This is the conservation of ordered information—a principle logically prior to any computational model.

3. The classical definition stipulates these ordered components without accounting for their origin. It treats them as "free" information, available at zero cost and with no source explanation.

4. A formal system that uses ordered information but does not account for its origin is informationally incomplete. It relies on an external, unexamined input to supply the very structure that defines its operation.

5. Therefore, the classical Turing machine, when treated as a complete formal system for information science, is inconsistent with the conservation of ordered information. It presupposes a source of information that it does not include, explain, or charge.

This is not a technical flaw in the Turing machine as a device for defining computability. It is a category error in the use of that device as a foundation for information-theoretic questions. The P versus NP problem, as classically formulated, inherits this inconsistency: it asks about the cost of ordered information during computation while treating the ordered information of the machine description itself as free.

We argue that this inconsistency is not repairable by a local modification. Any attempt to explain the origin of the machine description merely shifts the origin question to a higher level, generating an infinite regress unless the regress is terminated by an unexamined assumption. The only coherent response is to recognize that the classical problem is not a mathematical conjecture awaiting proof, but a formal system awaiting completion. In a complete information-accounting framework, the distinction between "algorithm" and "enumeration" dissolves: both are candidates generated by an origin process and selected by a verifier. The classical P vs NP distinction, which implicitly relies on this dissolved distinction, is therefore not well-formed as an objective question.

Within an objective formal system, certain enumerations of symbols are selected and designated as "structures"—associativity, commutativity, group axioms, and so forth. This selection is not dictated by logic. It is arbitrary in the sense that the system itself provides no criterion for why these particular symbol strings are privileged over others. The designation of a symbol combination as a "structure" is a human act of naming, not a logical discovery. Consequently, mathematical objects are treated unequally: some are elevated to the status of "structures" or "theories," while others remain "mere enumerations." This inequality is not grounded in the formal properties of the objects themselves, but in human selection, historical contingency, and aesthetic judgment. In a formal system, all symbol combinations are equally valid candidates until subjected to verification; the distinction between "structure" and "non-structure" is not a logical distinction. It is a social and psychological one, imposed from outside the formal system. Therefore, any mathematical classification—including the classical distinction between algorithms and brute-force search—that depends on the presence or absence of "structure" imports a non-logical, arbitrary preference into the heart of formal reasoning. The P versus NP problem, which implicitly relies on such a preference, is not a well-formed question about formal systems; it is a question about human naming conventions disguised as a question about computation.

The selection of logical and mathematical axioms is not dictated by logic itself. Axioms are chosen because they align with human intuition—they appear simple, concise, or useful. But this is a psychological and historical fact, not a logical necessity. Other symbol combinations could have been selected as axioms; different selections generate different mathematical worlds, each internally consistent and equally valid from a formal perspective. That a particular axiom system corresponds to human intuition is a contingent fact about human cognition, not a theorem about formal systems. Logic does not privilege one axiom system over another; it merely derives consequences from whichever system is given. The designation of certain symbol combinations as "foundational" or "structured" is therefore not a logical distinction but a human preference, imposed from outside the formal system. A complete accounting of mathematical reasoning must recognize this arbitrariness at its base.

**Keywords:** Turing machine, formal inconsistency, information conservation, ordered information, P versus NP, category error, free-method convention, logical marker algebra, origin accounting, computational foundations

---

Extended Abstract

1. The Classical Turing Machine

The classical Turing machine is specified by a finite tuple:

$$M = (Q, \Gamma, \delta, q_0, F, \Theta)$$

where:
- $Q$ is a finite set of states,
- $\Gamma$ is a finite tape alphabet,
- $\delta: Q \times \Gamma \to Q \times \Gamma \times \{L, R\}$ is a transition function,
- $q_0 \in Q$ is the initial state,
- $F \subseteq Q$ is the set of accepting states,
- $\Theta$ is a tape convention (boundary conditions, blank symbol, etc.)

Each of these components is a finite, structured information object. Together, they constitute a finite amount of ordered information. The ordered information content of a Turing machine description is bounded by:

$$H(M) = O\left(|Q|\,|\Gamma|\log(2|Q||\Gamma|) + |Q| + \log|Q| + \dots\right)$$

bits, under a fixed coding convention. This is a finite, positive quantity.

2. The Conservation of Ordered Information

The conservation of ordered information is the principle that a finite, structured information object cannot emerge from a disordered, unstructured environment without a source process that supplies the order. This is not an additional assumption imposed by this paper; it is a necessary condition for any formal theory of information. Without it, information would be created ex nihilo, violating the foundational intuition that information is a conserved quantity in symbolic systems.

Formally, for any ordered information object $I$ and any source environment $E$, the emergence of $I$ from $E$ requires a process $P$ such that:

$$I = P(E)$$

where $P$ is an information-transformation process. If no such $P$ is specified, the origin of $I$ is unaccounted for.

 3. The Inconsistency

The inconsistency is now direct. The classical Turing machine definition provides $M$ as a stipulated object. It does not provide $P$. It does not explain how the ordered information in $Q, \Gamma, \delta, q_0, F, \Theta$ came into existence. It treats these objects as if they were free—available without source, selection, or cost.

A formal system that:
1. Uses ordered information to define its operation,
2. Does not account for the origin of that ordered information,

is informationally incomplete. It is not inconsistent in the sense of containing a contradiction, but it is inconsistent in the sense that its stated assumptions do not include all the information it requires to be self-contained. It is an open system pretending to be closed.

This is precisely the situation of the classical Turing machine when used as a foundation for information science. It is a closed system for execution (given the machine, it produces a unique computation), but it is an open system for information accounting (the machine itself must come from somewhere).

4. Consequences for P vs NP

The P versus NP problem, as classically formulated, inherits this inconsistency. It asks:

> Given a problem instance of size $n$, and given a fixed machine $M$ (whose description is free), what is the asymptotic cost of finding a solution?

It charges the cost of searching for a certificate during execution, but it does not charge the cost of selecting the machine $M$ itself. This asymmetry is not a bug in the execution model; it is a deliberate choice to separate "algorithm design" from "algorithm execution." However, this separation is not a logical necessity; it is a convention. The classical formulation assumes that one can ask meaningful questions about the cost of computation without asking about the origin of the machine that performs it.

Once the origin question is admitted, the distinction dissolves. The machine $M$ itself is an ordered information object. In a complete information-accounting framework, $M$ must be generated by an origin process—which, in the absence of prior structure, can only be a form of enumeration with verification. Thus the "algorithm" is a candidate that passed verification at an earlier stage, while the "search" is a candidate that is being verified at the current stage. The difference is temporal, not essential.

The classical P vs NP distinction implicitly relies on an essential distinction between "structured methods" (algorithms) and "unstructured search" (enumeration). This distinction is not a logical category; it is a psychological label assigned by human observers to candidates that have passed verification. Since subjective labels cannot serve as objective mathematical predicates, the P vs NP problem is not well-formed as a question about mathematical reality.

5. Conclusion

The classical Turing machine, when treated as a complete formal system for information science, is inconsistent with the conservation of ordered information. It uses ordered information without accounting for its origin. The P versus NP problem, which inherits this inconsistency, is therefore not a mathematical conjecture awaiting solution; it is a formal system awaiting recognition of its own incompleteness.

The appropriate response is not to prove P = NP or P ≠ NP, but to dissolve the question and replace it with a complete information-accounting framework in which the origin of all ordered information—including machine descriptions—is explicitly accounted for. In such a framework, the distinction between "algorithm" and "enumeration" is replaced by a uniform treatment of all candidates that pass verification, and the classical problem is seen for what it is: a category error arising from a hidden assumption about free information.

---

The Equivalence of Algorithm Discovery and Pre-Enumeration in Complexity

A fundamental point must be made explicit: for an external human Turing machine—the designer operating outside the formal execution layer—there is no asymptotic complexity difference between discovering a polynomial-time algorithm and performing a complete pre-enumeration of all possible solutions.

This equivalence is not intuitive, because classical complexity theory conditions us to think of algorithms as "given." We imagine that the algorithm already exists, sitting on a shelf, and the only question is how fast it runs. But this framing silently excludes the most expensive part of the enterprise: the act of finding the algorithm itself.

Consider the task from the perspective of an external selector—a human mathematician, or any outer-layer process, operating before the inner machine begins its execution. This selector faces the following problem: given a problem instance, find a method that produces the correct answer. The selector may search through the space of all possible algorithms. This space is vast. It is at least as large as the space of possible solutions to the original problem, and in many cases substantially larger. To find a correct polynomial-time algorithm, the selector must examine candidates, test them against correctness conditions, and verify their behavior across all relevant inputs. This is a form of search—a search through the space of methods rather than the space of solutions.

Now compare this to the alternative: the selector may instead choose to pre-enumerate all possible solutions to the original problem. The selector generates candidates from the solution space, tests each against the verification condition, and records all valid answers in a table. Once this table is constructed, it can be passed to the inner machine, which performs a polynomial-time lookup.

From the perspective of the outer selector, the two tasks are structurally identical. Both are searches through a candidate space—one through the space of methods, the other through the space of solutions. Both require generating candidates and verifying them against a correctness predicate. Both require the selector to invest time before the inner machine can execute. In both cases, the selector is performing an enumeration and filtering process.

Crucially, there is no general reason to believe that searching through the algorithm space is asymptotically cheaper than searching through the solution space. The algorithm space, after all, contains all possible descriptions of Turing machines—a set whose size is at least exponential in the description length, and often vastly larger than the original solution space. To find a polynomial-time algorithm, the selector must navigate this enormous space without any guarantee of success. This is, in the worst case, at least as hard as enumerating the solution space.

The classical definition of P assumes that the algorithm discovery phase has already been completed, and that its cost is zero. This assumption is not derived from the problem's structure; it is imposed by the definition. It is a convention that treats the outer design layer as invisible to complexity accounting. But once we recognize that the outer selector's search is a real computational process with real time costs, the asymmetry between "finding an algorithm" and "pre-enumerating solutions" dissolves. Both are forms of preparatory enumeration. Both require comparable work. The only difference is where the work is performed—in the outer design layer or the inner execution layer—and when it is performed—before the machine starts or after it receives input.

Therefore, from the standpoint of the complete symbolic accounting framework, there is no complexity-theoretic distinction between being given a polynomial-time algorithm and being given a pre-enumerated table of verified solutions. The distinction is not formal. It is temporal and sociological. It reflects a choice about which part of the total information-processing effort to count, not a property of the mathematical problem being solved.

---

Formal Summary

Let:

· $A$ = the class of polynomial-time algorithms for a problem
· $S$ = the solution space of the problem
· $$T_{\text{find}}(n)$$ = the time required by an outer selector to find a correct algorithm in $A$
· $$T_{\text{enum}}(n)$$ = the time required by an outer selector to pre-enumerate all solutions in $S$

Claim: There is no asymptotic guarantee that $T_{\text{find}}(n)$ is smaller than $T_{\text{enum}}(n)$. In fact, since $A$ is a class of descriptions of arbitrary Turing machines, its size is generally larger than $S$, and the verification condition for an algorithm—correctness on all inputs—is at least as demanding as verification of a single solution.

Therefore:

$T_{\text{find}}(n) = \Omega(T_{\text{enum}}(n))$

for the worst case, and in all cases the cost of algorithm discovery is of the same order as the cost of solution enumeration.

---

Concluding Statement

The classical P vs NP question, in claiming that "if an efficient algorithm exists, the problem is easy," ignores the fact that the algorithm itself must be discovered. The discovery process is a search through the algorithm space—a search that is at least as expensive as searching through the solution space. When this discovery cost is included in the total complexity ledger, the distinction between "algorithm" and "pre-enumeration" disappears. Both are enumeration products that passed the outer selector's verification. Both are paid for at design time. The only question that remains is a question of accounting convention, not a question of mathematical essence.

Keywords (English)

Turing machine; formal inconsistency; information conservation; ordered information; P versus NP; category error; free-method convention; logical marker algebra; origin accounting; computational foundations; information science; Millennium Prize Problems; proof theory; complexity theory foundations

---

Suggested Citation

Wang, J. (2026). *Logical Marker Algebra: The Inconsistency of the Classical Turing Machine in the Formal System of Information Science*. [Manuscript submitted for publication]