DeepAI

# A Stronger Foundation for Computer Science and P=NP

This article constructs a Turing Machine which can solve for β^' which is RE-complete. Such a machine is only possible if there is something wrong with the foundations of computer science and mathematics. We therefore check our work by looking very closely at Cantor's diagonalization and construct a novel formal language as an Abelian group which allows us, through equivalence relations, to provide a non-trivial counterexample to Cantor's argument. As if that wasn't enough, we then discover that the impredicative nature of Gödel's diagonalization lemma leads to logical tautology, invalidating any meaning behind the method, leaving no doubt that diagonalization is flawed. Our discovery in regards to these foundational arguments opens the door to solving the P vs NP problem.

02/07/2018

### Mathematical Logic in Computer Science

The article retraces major events and milestones in the mutual influence...
11/18/2020

### A Theoretical Computer Science Perspective on Consciousness

The quest to understand consciousness, once the purview of philosophers ...
05/29/2019

### Definitively Identifying an Inherent Limitation to Actual Cognition

A century ago, discoveries of a serious kind of logical error made separ...
07/05/2005

### Complexity Science for Simpletons

In this article, we shall describe some of the most interesting topics i...
06/22/2021

### Turing Award elites revisited: patterns of productivity, collaboration, authorship and impact

The Turing Award is recognized as the most influential and prestigious a...
04/04/2021

### What Kind of Person Wins the Turing Award?

Computer science has grown rapidly since its inception in the 1950s and ...
12/24/2009

### Similarité en intension vs en extension : à la croisée de l'informatique et du théâtre

Traditional staging is based on a formal approach of similarity leaning ...

## 1 A Counterexample to the Undecidability of the Halting Problem

### 1.1 Overview

#### 1.1.1 Context

Turing’s monumental 1936 paper “On Computable Numbers, with an Application to the Entscheidungsproblem” defined the mechanistic description of computation which directly lead to the development of programmable computers. His motivation was the logic problem known as the Entscheidungsproblem, which asks if there exists an algorithm which can determine if any input of first order logic is valid or invalid. After defining automated computing, he posited the possibility of a program called an Machine which can validate or invalidate its inputs based on reading a description number for some given program description. However, while he constructed a Universal Turing Machine, he did not provide an actual construction of his machine, only posited that one should exist. When he asked if this machine could decide for any input, he was able to show that in fact, it couldn’t. His proof specifically depends upon this Machine not being able to validate itself. He gives a detailed description as to why it can not, explained later in this article.

However, a close reading of his paper shows an added assumption by Turing when he constructs his machine. While this assumption does not affect the construction or effectiveness of a Universal Turing Machine, it does have an affect on the overall results regarding the Halting problem and its sister problem, the Entscheidungsproblem, as well as any related results having to do with computability.

In this article, we give a detailed description on how to construct a self-validating machine. The construction of a self-validating

machine may have application in fault-tolerance of run-time self-correcting code validation in artificial intelligence implementations. It may also lead to a better understanding of complexity relationships between complexity classes. It also expands our understanding of the theoretical limits of computation.

#### 1.1.2 Preliminary Considerations

The terms Circular Machine and Circle-free Machine are suitable for our description and we will use Turing’s own definition of a computing machine. A Circular Machine is deemed unsatisfactory due to forever looping, redundantly over a repeating pattern. Also, a Circle-free Machine is satisfactory because of its ability to continue deciding indefinitely, without entering an unbounded repeating loop. Turing’s description of the Halting problem is completely mechanical, while many modern descriptions rely on an oracle, reduction to Cantor’s Diagonalization or logical reduction similar to Gödel’s Diagonalization Lemma. Using his terminology helps the reader directly compare this article with the original proof without intermediary interpretations or simplifications. However, conventionally, a Circle-free Machine is considered to halt, while a Circular Machine does not halt. [5]

A Standard Description or S.D. is the rule set for any given Turing Machine in a standard form. By creating a standard, the rule sets themselves can be used to create a Description Number or D.N. which itself may be readable by a Universal Turing Machine, , as an instruction set. [5]

Remark. A Description Number arbitrarily represents a Standard Description. Thus, we can choose which D.N. is used to represent some specific S.D. to our liking, as long as our constructed machine can read the D.N. and interpret it as the corresponding S.D. Again, D.Ns. are arbitrary, thus, if the D.Ns. we receive do not fit our format, where the ordering is consequential to the functioning of , when developing , we can re-assign new D.Ns. (which are not fixed111The description numbers are only fixed relative the construction of ; we can always re-configure to change any given D.N. however we wish, as such we regard any D.N. as not fixed.) to the respective S.Ds. (which are fixed) such that reads the given D.Ns. in the proper order in relationship to c (c, a natural number of relative size defined in section 1.2.1).

From Turing’s paper: “Let be the Turing Machine which when supplied with the Standard Description (S.D.) of any computing machine will test this S.D. and if is circular will mark the S.D. with the symbol ‘u’ and if it is circle free, will mark it with ‘s’ for ‘unsatisfactory’ and ‘satisfactory’ respectively. By combining machines and , we could construct a machine to compute the sequence of [5]

#### 1.1.3 Turing’s Claim

Turing claims that while is circle free by construction, when is given the description number for it becomes circular. [5] In the eighth section of Turing’s paper on the Entscheidungsproblem, Turing claims that can not be determined because of the following reason:

“The instructions for calculating the R(K)-th [figure] would amount to ‘calculate the first R(K)-th figures computed by and write down the R(K)-th’. This R(K)-th would never be found. I.e. is circular…” [5]

This is because, since relies on certain subroutines to make its determination, when it reaches and tries to evaluate K, it must call itself, which provides instructions on reading inputs from 1 to K-1 in order to call the R(K)-th figure, but it can never get there, because it keeps repeating its own instruction loop. [5]

#### 1.1.4 Turing’s False Assumption

Turing assumed that his interpretation of , the one described just above, applies to all possible constructions of . Note that while he did formally define a Universal Turing machine, nowhere in Turing’s paper did he actually formally define the full construction of . He assumed that any program with the property to determine the halting problem for a given input, would also not have any property which could learn when it enters a repeating loop for any given S.D. However, this is not necessarily the case and if we can provide an example of a program which does recognize a repeating loop, arbitrarily, such that it can switch states and act accordingly, then we’ve discovered a means to write machine in such a way that it may solve for . It only takes one positive example to universalize the example to all Universal Turing Machines. A negative example, such as the machine assumed by Turing, is trivial upon the discovery of the existence of a positive example.

The problem reduces to describing a Turing Machine which can self-discover it’s running its own instructions arbitrarily222by self-discovering its own instructions arbitrarily, we mean that it can recognize it is evaluating its own S.D. from the given D.N. Additionally, we are not referring to the existence of an initializer that feeds a fixed K to be recognized by a single read instruction that skips K and just “rubber stamps” approval. Such “rubber stamping” is considered a trivial case and is not of any meaningful concern. when it reaches its Description Number (D.N.), such that some machine configuration prints .

Remark. Because the D.N. is arbitrary for any S.D., there is no restriction on which specific D.N. can be used to represent some S.D. Thus, we may choose whichever D.N. pleases us to represent any given S.D., provided can interpret the D.N. into the proper instructions.[3] While our proof depends on the ordering of D.Ns., this is not a problem for our results because it only takes one ordering of D.Ns., which are arbitrary representations of all S.Ds, and this ordering can be universalized to any order by reordering after solving. Solving for means solving the halting problem on arbitrary input for any given S.D. There is no restriction on the order of verification of any S.D.

We will, in the next subsection, construct a Supermachine that can recognize itself as its own input, from the S.D. simulation, which is then instructed to change to a circle-free state upon this recognition. Because such a construction exists, and because such a construction is arbitrary for any S.D. of this class of Turing Machines, we may solve for non-trivially.

### 1.2 The Existence of Self-validating Computers

#### 1.2.1 Supermachine

Let us consider that is a controller machine with a D.N. of . It controls two different machines: and . and each have the ability to determine “u” or “s” on a D.N. input, except tests as Turing describes, from D.N. 1 counting upwards (Each D.N. is a natural number) and tests from a certain twos complement of whatever number is being tested by as a simultaneous parallel input, such that its subsequent D.N. is one less than the previously tested D.N. Let us represent each D.N. by some integer . and have a unique D.N. of or respectively.333This can be determined through a unique identifier string, which does not affect the machine’s function or performance, but differentiates the two machines from each other giving them each a unique D.N.

Upon input of any to be read by , let store the value pair until is determined to be satisfactory or unsatisfactory. When the output is determined, let replace the with the respective or in the data store, such that there is no longer a data store of . Let the same process occur for any , such that also initially stores each D.N. input with and reads to determine satisfactory or unsatisfactory, subsequently replacing the initial value pair with the respective value pair or depending on the output of . A redundancy occurs when some .

Let have the ability to compare value pairs such that the machine may recognize a redundancy when it occurs, and may also recognize when a value pair contains a z value on the condition of such a redundancy. Let’s call this a z-check ability.

Let be the supermachine that is the configuration of all three Machines as described above and let be the D.N. for the supermachine.

Initialize the identifier strings such that .

Let the number of bits in . Let the twos complement of the first D.N. input to , which is 1, be determined by such that it satisfies the equation .

Lemma. proceeds circle free, until it reads .
If , then re-initialize the D.N.444one may re-initialize, if necessary, the D.N. by adding irrelevant description information into some S.D. yielding a different D.N. provided such information does not affect the integrity of the original S.D. for either or such that . This guarantees that will read before reads and also guarantees will read before reads . Let the controller contain a memory command which stores the decision value pairs given by and . The controller may routinely check for a redundancy on the next input.

Now consider when reads , and calls the D.N. for : will call , which will again call which will result in a z-check, recognizing that the value pair (, z) is already stored in memory, and therefore, since , we know that is the description number for itself, is impossible to call by construction without calling first, which means it must be checking the description number for a machine which calls itself, namely , which allows us to correctly store the value pair (, s). This same reasoning can be applied for when reads , correctly storing the value pair (, s).

If however, the machine has determined a redundancy occurred on a value pair where the value is either or (i.e., a negative evaluation on the z-check, but the redundancy check is positive), then we have already evaluated this D.N. from the other machine at the top level, and we no longer have to continue within the range 1 to , since they will all have been decided. The supermachine, at this point proceeds to utilize machine and proceeds from D.N. input value , and continues through the rest of all Description Numbers, , , etc… at least until it reaches its own D.N., , for no other D.N. should be problematic555We should note here the significant finding by Yedidia and Aaronson of the independence of calculating BB(7918) from ZFC which will only halt if and only if ZFC is inconsistent. In a later section of this paper, we prove ZFC is in fact, inconsistent, meaning that BB(7918) is expected to eventually halt. We could thus expect to determine that BB(7918) will halt. The unsolvability of the halting problem, as it is related to BB(7918) is contingent on ZFC being consistent, for BB(7918) will not halt if and only if ZFC is consistent. Forming such a Turing machine, which will halt if and only if the axiom set is inconsistent, using the proposed axiom in the later section of this article, is just not possible as the impredicative form of the machine will violate the proposed axiom. in determining the output decision. Thus, proceeds circle free, at least until it reaches which is easily constructed to be larger than .

#### 1.2.2 β′ is Decidable

###### Proof.

is Decidable. At the point is received as an input, it is determined satisfactory by either or . Neither nor are called during this phase of the process.

By lemma, is decided by , is decided by and continues indefinitely until we reach , which describes . is read by and as before, its Description Number is stored along with its temporary pair value of z until or returns a value for at that location. is sent to be verified by , which when calls for a second time, under the given recursive property of which will eventually call itself, the z-check for value pair is recognized as both redundant and with a z value, stored by in the data store, but because the associated value is z, the z-check ability tells us this process has already occurred, sends to , which self-verifies repeated z-check values. By construction, the only value which can provide this multiple z-check values where is , so now self-verifies the input as its own D.N., provides a value of “s” for satisfactory, and changes state to evaluate to continue indefinitely as a Circle-free Turing Machine.

Therefore, given some Universal Turing Machine which can emulate the Machine, is decidable over the set of given Description Numbers for all Standard Descriptions. ∎

### 1.3 Consequences

Solving for is RE-complete. If Turing’s final result were correct, it would be impossible to evaluate a value of or for any given . However, we have constructed a machine which does exactly what Turing assumed was impossible. Doing so implies that ZFC is inconsistent. To thoroughly prove ZFC is inconsistent, we must not only show that there is a counter-example to the Halting problem, but exactly where the incorrect assumption appears in a logical fashion. We will find, in the following section, that there is an implied axiom of incompleteness in current logical implementations of ZFC where ZFC is open to contradiction.

## 2 ZFC with Implied Axiom is Inconsistant

### 2.1 Incompleteness and Proof by Contradiction through Tautological Impredicatives

Gödel’s second incompleteness theorem tells us that any formal system with the expressive power strong enough to represent the proof of its own consistency is either inconsistent or incomplete. This implies that in order to prove the consistency of a formal system such as ZFC, which has the expressive power to represent the proof of its own consistency through the formulation of Peano Postulates together with the Axiom of Substitution, must be incomplete if it is consistent. [2]

We then assume that even though ZFC can express the proof of its own consistency, that it can not determine the proof of its own consistency, and as such, is incomplete, and we say such a proposition is independent of ZFC. However, while possibly true, this is not necessarily the case. Gödel’s second incompleteness theorem gives us a choice. It is possible that ZFC, and similarly expressive formal systems are in fact, inconsistent. [2]

In order to prove ZFC is inconsistent, we must find two of its theorems which contradict each other. As stated earlier in this article, a proof of the existence of a Turing machine which can solve over implies ZFC is inconsistent. This is because many theorems in ZFC contradict such a finding.666The list of proofs of this kind is inexhaustible, however they include diagonalization arguments, such as not being able to calculate Kolmogorov Complexity, forcing techniques, Rice’s Theorem, The Space-Hierarchy Theorem, et al. The proofs of such theorems all have certain material similarities, and can be defined as a certain class of proof. First, the conclusion generalizes the non-existence of some statement or structure, . Second, they are all proof by contradiction. Third, they all include an impredicative tautology. We can thus say that they are of the class of proof by contradiction through impredicative tautology. We will informally describe, then formally define an impredicative tautology below.

### 2.2 Impredicative Tautologies

An impredicative statement is defined as a statement with self-referencing. Intuitively, it is easy to see how we risk creating a tautological consequence by using such a tactic to define one’s terms: Self reference intrinsically eliminates the possibility for that variable to contradict itself, increasing the likelihood of tautology.

Intuitively, we can see that Russell’s paradox uses an impredicative definition that is itself also tautological. Russell’s paradox depends on the definition of S as the set of all sets that do not contain themselves. This is impredicative, and it is tautological, because there seems to be this infinite self-referencing that goes on when we apply S to itself. The paradox arises as soon as we ask the question whether or not S is a member of itself or not.

In Russell’s paradox, the property of being a set that does not contain itself, is a property applied to a dependent portion of the impredicative statement, that is, the property when applied to sets in general, also applies to the specific set we are defining. This dependence of the property of the set on the set, is the distinguishing factor. The point here being that paradoxes of this type can be resolved by removing the tautological impredicative. One way of removing the tautological impredicative, is by defining a class as a collection of sets, and thus, the class of all sets that do not contain themselves, can not contain itself, because classes, by definition cannot contain classes, only sets.

But I believe this heuristic falls short. It is not just this dependence that creates a tautological impredicative statement, it is also the nature of the property itself. We could easily define the set of all sets which contain the letter A. Such a definition has a dependence on impredicative portion of the statement, yet does not seem to create create a tautology or an infinite regression or anything of that sort. That is, in order to create a tautology, “A” itself would have to be defined, not only in terms of sets, but in terms of the class of sets in question. As such, in order for impredicatives to be a problem for logic, the property itself must point back to the impredicative dependence in a self referential way. Let’s call this

impredicative pointing.

So is there a more foundational way of removing tautological impredicatives?

Definition Let impredicative dependence be the condition of a statement S, whose property P depends on self-referencing.

Definition Let impredicative pointing be a condition of self-reference where a dependent property also references an impredicative dependence, i.e. the existence of S depends on S containing an impredicative dependence.

Definition Let a tautological impredicative be a statement which satisfies impredicative pointing.

Proposition Tautological impredicatives are logical tautologies.

Consider the following truth table, such that:

 S x P(x) x → P(x) {x → P(x)} → S P(S) P(S) ↔ {x → P(x)} → S T T T T T T T T T F F F F T T F T F F F T T F F T T T T F T T T F F T F F T F T T T F F F T F F T F T F F T T T

As is clear, is a tautology.
Proposition Attempting to disprove existence with a proof by contradiction through tautological impredicative implies disjoint results which may or may not be the desired result.

Also note in the truth table above that when we assume is true, and by substitution we allow, , creates a contradiction by construction when is false. This is because is true when is true and is false, but may or may not be false, setting up the contradiction is false when is false. The logical consequence of this contradiction is either .

Therefore, in an attempt to prove using a proof by contradiction that relies on tautological impredicatives:

Corollary A contradiction may be the result of impredicative pointing, rather than the non-existence of a given .

When substitution is used to form a tautological impredicative in order to prove through proof by contradiction, one must also prove . Current practice is to assume this does not exist without proof. However, if it can be shown that , then this is sufficient to prove the existence of , even if a contradiction still arises in the proof, as the contradiction does not arise if , the contradiction arises when . Firmly placing contradiction in the hands of impredicative pointing, and not the initial assumption of existence for proof by contradiction.

Corollary is false by contradiction only when we assume is false when is false.

I want to be completely clear here: a contradiction arises from the use of substitution of with to form an impredicative tautology whether or not . However, if , then we can not be certain is false, because in this case, both and can be true when both and , retaining contradiction for proof. This means that the truth value for is not determined through proof by contradiction; can be either true or false for any x. Therefore the conclusion that is false arises only when we must assume is false when is false.

Let’s call such an assumption that is false (or ) when , while also assuming is true (for proof that by contradiction), a hidden assumption.777As a corollary, S can also be the hidden assumption of a proof by contradiction through tautological impredicative when the proof openly assumes some property P(x) or x exists in order to disprove either P(x) or x.

Theorem Turing’s proof of the undecidability of the Halting Problem belongs to the class of proofs that are a proof by contradiction through impredicative tautology.

We may attempt to prove the undecidability of the Halting problem with the following simple version of a halting program:

def H():
if halts(h):
loop_forever()


As we can see, we can use this program to prove the undecidability of the Halting problem through a proof by contradiction: If the subroutine halts, will loop forever, in which case is false. Let be the instructions for . If halts, it will loop forever, which is a contradiction with , which must halt to be satisfactory, in which case, does not halt, which means it can not decide , therefore is undecidable.

To show this proof by contradiction uses an impredicative tautology, we can designate the function as the property . We can let the instructions for , which contains , be . We see that the proof defines . However, because is not fixed in all cases, we may designate as some arbitrary definition for , .

Proposition. The Halting problem proof contains an impredicative dependence.
We see this is true, because contains the instructions for , which is therefore .

Proposition. The Halting problem proof contains impredicative pointing.

We can see this is true, because first, . That is contains , so any property that applies to , must also apply to .

Second, when . That is, if only exists when there is impredicative dependence, then when exists in this manner, this implies when we substitute S with h, if , then .

Third, This is enough to derive that the Halting problem contains impredicative pointing, since
Proof. Finally, because the proof contains impredicative pointing, this means that the tautological impredicaive is a logical consequence of the assumptions and through the formulation of the proof by contradiction. Thus, Turing’s proof of the undecidability of the Halting problem belongs to the class of proofs that are a proof by contradiction through impredicative tautology.

Corollary. serves as a counterexample to the proof of the undecidability of the Halting problem.

Corollary. If there exists a counterexample to the Halting problem, there exists a counterexample to the SPACE hierarchy theorem. It is well known that the SPACE hierarchy theorem reduces to the Halting problem. It immediately follows that if a counterexample to the Halting problem exists, then a counterexample to the SPACE hierarchy theorem exists.

Proposition. A counterexample to the SPACE hierarchy theorem exists. This is an immediate consequence of the above corollary and the proof of the existence of a counterexample to the Halting problem in section 1.

Proof. ZFC is inconsistent.

Since all current implementations of ZFC accept hidden assumptions in proofs by contradiction through tautological impredicative, then the following Axiom is implied by ZFC, even if not explicitly stated, by ZFC.

Axiom

In other words, ZFC implies a particular incompleteness where acceptance of in the circumstance of a proof of the undecidability of by contradiction through impredicative tautology.888The axiom of incompleteness described here is in widespread use by any and all mathematicians and computer scientists today.

Accepting this axiom of incompleteness, as all logicians of note have since Post, Church and Turing, leads to contradiction when . By the existence of the counterexample to Turing’s proof in section 1, the direct implication is that , which is in direct contradiction with the above axiom. It immediately follows that ZFC, with the implied axiom above, is inconsistent.

#### 2.2.1 A New Foundational Axiom

We have demonstrated that substitution may lead to hidden assumptions in proof by contradiction. The need for a limit on how substitution is applied could help prevent such mistakes from occurring again. Perhaps we could just create a postulate or axiom which makes x a bounded variable after substitution. Such a postulate should allow some impredicative statements, all of which must avoid tautology, but through preventing certain re-substitutions on x, will prevent impredicative pointing, and thus prevent impredicative tautologies from forming. We can specify the limit of substitution over bounded x, not to substitution in general, but to statements from the free variable x. Thus, creating a much stronger foundation to our systems of logic and computability.

Axiom. For any formal system , with free variables [x; y] and a substitution operation, subst(), z is bounded by subst() such that

## 3 Conclusion, P=NP

In Section 1, we constructed a Supermachine which is able to solve for . In section 2, we tackled the dangers of impredicative tautologies when applied to proofs by contradiction and proved that ZFC, by accepting hidden assumptions, is inconsistent. In this section, we will expand upon our findings to prove .

When proofs by contradiction utilizing an impredicative tautology are not allowed, we are no longer restricted by them. Furthermore, finding that the halting problem can be solved for all S.D. is in direct contradiction with the SPACE hierarchy theorem, because it is RE-complete. However, the SPACE hierarchy theorem is a proof by contradiction which utilizes an impredicative tautology to form a hidden assumption, which also reduces to the Halting problem which has a counterexample. Thus, the theorem is invalid by our findings. Similarly, as with other complexity separation arguments, we find that the entire complexity hierarchy collapses, and we now have a foundation in computer science where there is enough information to solve the P vs. NP problem. Without proof by contradiction with impredicative tautology, our reasons for not using an oracle to solve P vs. NP vanish, as the contradictions which formally prevented the use of such oracle no longer exist.

Lemma. If , .
If the of a problem increases polynomially as with any -complete problem, this is comparable to the of a problem increasing polynomially, such that given an oracle, , which solves polynomial equivalence between SPACE and TIME, such that . Similarly, if the of a problem increases exponentially as with any -complete problem, this is comparable to NP which is at maximum, in exponential TIME, such that . If , then . Since , , which since P and NP are both in TIME, is the same as .

Solving for in Section 1 is RE-complete, and because the SPACE hierarchy theorem relies fully on the now defunct method of proof by contradiction utilizing an impredicative tautology, its results must be discarded.

And as such, with the Halting problem being RE-complete, and since we may solve for arbitrary using the Supermachine configuration, we may now conclude:

###### Proof.

Since by definition, , and
since any given Recursively Enumerable set is contained in PSPACE,
and solves for all Recursively Enumerable sets in PSPACE,
and since we can no longer accept the SPACE hierarchy theorem,

,
such that
and , implies
, proves through the above Lemma …

Mark Inman, Ph.D.

Saipan, Northern Mariana Islands, USA

## References

• [1] Aaronson, Scott Yedidia, Adam A Relatively Small Turing Machine Whose Behavior Is Independent of Set Theory 2016
• [2] Gödel, Kurt trans. by Meltzer, B. intro. by Fernau, Christopher On Formally Undecidable Propositions of Principia Mathematica and Related Systems 1962
• [3] Lewis, Harry Introduction to Formal Systems and Computation CS121 Harvard College December 2007 http://www.seas.harvard.edu/courses/cs121
• [4] Sipser, M.

Introduction to the Theory of Computation, 3rd ed.

, Cengage Learning, Boston 2013
• [5] Turing, Alan “On Computable Numbers, with an Application to the Entscheidungsproblem” 1936-1937: Proceedings of the London Mathematical Society, Series 2, 42, pp 230?265.