Title correction this post is the root post of my nearly complete work.

What has been mistaken as a contradiction consistently used as the basis
of rebuttals of my work is addressed in the last paragraph of this post.

Halting problem undecidability and infinitely nested simulation

When input P to simulating halt decider H has the pathological
self-reference error (PSRE) simulating halt decider H decides this input
P on the basis of proxy input P2 that has the pathological
self-reference error removed.

void H_Hat(u32 P)
{ u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
}

The pathological self-reference error arises in the halting theorem from
the fact that both return values: {0, 1} from Halts() to H_Hat() are
incorrect when H_Hat() is invoked with its own machine address as input.

When we define H_Hat2() by replacing the call to Halts() with a call to
Simulate()

u32 Simulate(u32 P, u32 I)
{ ((void(*)(int))P)(I);
return 1;
}

H_Hat2() never halts on its own machine address as input.
This key fact is leveraged to correctly decide halting:
Halts((u32)H_Hat, (u32)H_Hat);

We hypothesize that input P having the pathological self-reference error
(PSRE) can be substituted for equivalent proxy input P2 such that the
halting status of P2 derives the halting status of P. If this
hypothesis is correct it becomes the basis for refuting the halting
theorem.

To put this in concrete terms if Halts((u32)H_Hat2, (u32)H_Hat2);
provides the correct halting value for Halts((u32)H_Hat, (u32)H_Hat);
then H_Hat becomes a decidable input. The rest of the proof will attempt
to show this.

Generic halt deciding principle for inputs having the pathological
self-reference error

Whenever input P has the pathological self-reference error such that a
simulating halt decider H must decide halting on an input that invokes
itself we define proxy input P2 copy of P such that the embedded
simulating halt decider is replaced with a simulator.

(a) Simulating halt decider H and simulator S are equivalent
computations for all inputs P that halt. This means that H correctly
decides halting on P if and only if P2 halts.

(b) Simulating halt decider H and simulator S are equivalent
computations for all inputs P that do not halt up to the point where H
stops simulating P. This means that H correctly decides not halting on P
if and only if P2 does not halt.

In other words: Halts correctly decides not halting on H_Hat because
H_Hat2 does not halt.

Peter Linz Ĥ applied to the Turing machine description of itself: [Ĥ]

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn

The above is adapted from (Linz:1990:319).
It shows that Turing machine Ĥ copies its input at (q0) and begins
executing an embedded copy of the original halt decider with this input
at (qx).

The (qy) state indicates that the halt decider has determined that its
input would halt. The ((qn)) state indicates the input would not halt.
The appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
decider decides that its input would halt.

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company.

The above definition specifies this execution trace:
It can be understood from the above specification that when the embedded
halt decider at Ĥ.qx bases its halting decision on simulating its input,
and it has ([Ĥ],[Ĥ]) as its input that:
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
this copy then
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
this copy then
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
this copy...
unless and until the halt decider at Ĥ.qx stops simulating its input.

When we apply the Generic halt deciding principle to the embedded
simulating halt decider at state Ĥ.qx to its input ([Ĥ],[Ĥ]) we find
that the simulation of this input must be aborted.

Because the necessity to abort the simulation of an input is equated
with this input specifying an infinite computation the simulating halt
decider Ĥ.qx correctly transitions to its final Ĥ.qn state deciding not
halting on its input.

The computation Ĥ([Ĥ]) only halts because it contains an otherwise
infinitely nested simulation that has been aborted at state Ĥ.qx.
Because an aspect of the Ĥ([Ĥ]) computation has been aborted to force
the computation to halt we cannot count that fact that Ĥ([Ĥ]) halts
evidence that it is a halting computation.

http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/25/21 3:09 PM, olcott wrote:
> Title correction this post is the root post of my nearly complete work.
>
> What has been mistaken as a contradiction consistently used as the basis
> of rebuttals of my work is addressed in the last paragraph of this post.

As answer that shows why you are wrong at the end.
>
> Halting problem undecidability and infinitely nested simulation
>
> When input P to simulating halt decider H has the pathological
> self-reference error (PSRE) simulating halt decider H decides this input
> P on the basis of proxy input P2 that has the pathological
> self-reference error removed.
>
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = Halts(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> The pathological self-reference error arises in the halting theorem from
> the fact that both return values: {0, 1} from Halts() to H_Hat() are
> incorrect when H_Hat() is invoked with its own machine address as input.

That is NOT a problem with the Halting Theorem, but with the task to
design a Halting Decider.

Remember the order you must do things. FIRST you must define the
algroihm steps that H will preform to gets its answer. It can NOT just
be defined to get the right answer.

THEN we build H^.

The fact that there is no right answer for H is in fact the proof that
an H that gets all answers right does not exist.

>
> When we define H_Hat2() by replacing the call to Halts() with a call to
> Simulate()
>
> u32 Simulate(u32 P, u32 I)
> {
>   ((void(*)(int))P)(I);
>   return 1;
> }
>
> H_Hat2() never halts on its own machine address as input.
> This key fact is leveraged to correctly decide halting:
> Halts((u32)H_Hat, (u32)H_Hat);
>
> We hypothesize that input P having the pathological self-reference error
> (PSRE) can be substituted for equivalent proxy input P2 such that the
> halting status of P2 derives the halting status of P.  If this
> hypothesis  is correct it becomes the basis for refuting the halting
> theorem.

But it is IMPOSSIBLE to algorithmicly do this, so you hypothetical H is
a non-existent H.

>
> To put this in concrete terms if Halts((u32)H_Hat2, (u32)H_Hat2);
> provides the correct halting value for Halts((u32)H_Hat, (u32)H_Hat);
> then H_Hat becomes a decidable input. The rest of the proof will attempt
> to show this.
>
> Generic halt deciding principle for inputs having the pathological
> self-reference error

No. Once a machine has been defined (which was a prereqieste for
building H^), the Halting State of a given computation is firmly
established to be either Halting or Non-Halting. There is nt
self-reference error here, or even a self-reference.
>
> Whenever input P has the pathological self-reference error such that a
> simulating halt decider H must decide halting on an input that invokes
> itself we define proxy input P2 copy of P such that the embedded
> simulating halt decider is replaced with a simulator.

The is NO ground for making this claim. H is just now deciding on the
wrong machine, so can get the wrong answer.

>
> (a) Simulating halt decider H and simulator S are equivalent
> computations for all inputs P that halt. This means that H correctly
> decides halting on P if and only if P2 halts.
>
> (b) Simulating halt decider H and simulator S are equivalent
> computations for all inputs P that do not halt up to the point where H
> stops simulating P. This means that H correctly decides not halting on P
> if and only if P2 does not halt.
>
> In other words: Halts correctly decides not halting on H_Hat because
> H_Hat2 does not halt.
>
> Peter Linz Ĥ applied to the Turing machine description of itself: [Ĥ]
>
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>
> The above is adapted from (Linz:1990:319).
> It shows that Turing machine Ĥ copies its input at (q0) and begins
> executing an embedded copy of the original halt decider with this input
> at (qx).
>
> The (qy) state indicates that the halt decider has determined that its
> input would halt. The ((qn)) state indicates the input would not halt.
> The appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
> decider decides that its input would halt.
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company.
>
> The above definition specifies this execution trace:
> It can be understood from the above specification that when the embedded
> halt decider at Ĥ.qx bases its halting decision on simulating its input,
> and it has ([Ĥ],[Ĥ]) as its input that:
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy then
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy then
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy...
> unless and until the halt decider at Ĥ.qx stops simulating its input.
>
> When we apply the Generic halt deciding principle to the embedded
> simulating halt decider at state Ĥ.qx to its input ([Ĥ],[Ĥ]) we find
> that the simulation of this input must be aborted.
>
> Because the necessity to abort the simulation of an input is equated
> with this input specifying an infinite computation the simulating halt
> decider Ĥ.qx correctly transitions to its final Ĥ.qn state deciding not
> halting on its input.
>
> The computation Ĥ([Ĥ]) only halts because it contains an otherwise
> infinitely nested simulation that has been aborted at state Ĥ.qx.
> Because an aspect of the Ĥ([Ĥ]) computation has been aborted to force
> the computation to halt we cannot count that fact that Ĥ([Ĥ]) halts
> evidence that it is a halting computation.

But it does HALT, and by the definition of Halting, that makes it a
Halting Computation. YOU can't redefine it. H^ halted due to part of its
algorithm, so it does count. Your logic means that the following is a
non-halting computaiton:

for(int i=0; isLessThan(i, 5); i++) continue;

Also Your definition is inconsistent, and thus worthless.

Define two different halt deciders both based on this methon, H1, and H2.

Build H1^ on H1.

By your logic H1(H1^, H1^) is properly deciding H1^(H1^) as non-Halting.

But, if we run H2(H1^,H1^) then it won't see an infinite recursion of
itself, so will simulate the decider H1 inside H1^, and that decider
will decide that H1^ is non-Halting, return that answer to H1^ and H1^
will then Halt. This says that H2 will correctly decide that H1^ is Hating.

Thus we have shown that by two different 'correct' deciders, that H1^ is
both Halting and Non-Halting. This is impossible as the Halting Property
of a machine needs to be only a function of that machine and its input,
not which decider you use on it.

Also, to build such a decider, it will need to be able to recognize a
copy of itself inside the program P, which is an impossible task, as a
given Turing Machine has an infinite number of possible representations,
so it is impossible to try to match against all of them.
>
> http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
>