PreprintPDF Available

Halting problem undecidability and infinitely nested simulation (V4)

Authors:
  • Pixels2Words
Preprints and early-stage research may not have been peer reviewed yet.

Abstract

A Simulating Halt Decider (SHD) computes the mapping from its input to its own accept or reject state based on whether or not the input simulated by a UTM would reach its final state in a finite number of simulated steps. A halt decider (because it is a decider) must report on the behavior specified by its finite string input. This is its actual behavior when it is simulated by the UTM contained within its simulating halt decider while this SHD remains in UTM mode.
Halting problem undecidability and infinitely nested simulation (V4)
A Simulating Halt Decider (SHD) computes the mapping from its input to its own accept or
reject state based on whether or not the input simulated by a UTM would reach its final state
in a finite number of simulated steps.
A halt decider (because it is a decider) must report on the behavior specified by its finite
string input. This is its actual behavior when it is simulated by the UTM contained within its
simulating halt decider while this SHD remains in UTM mode.
It is self-evidently correct that when-so-ever a simulating halt decider must abort the
simulation of its input to prevent its infinite simulation that this input specifies an infinite
sequence of configurations.
Simulating halt decider H performs a pure simulation of its input as if it was a UTM unless
and until it detects an infinitely repeating pattern. Then it aborts the simulation of its input
and transitions to its final reject state. Otherwise H transitions to its accept state when its
simulation ends.
The following simplifies the syntax for the definition of the Linz Turing machine Ĥ, it is now a
single machine with a single start state. A copy of Linz H is embedded at Ĥ.qx
.qĤ0 ⟩ ⊢* .qĤ Ĥ x ⟩ ⟨ Ĥ Ĥ ⊢* .qĤy
If the pure simulation of ⟨ ⟩ ⟨ Ĥ Ĥ by embedded_H would reach its final state.
.qĤ0 ⟩ ⊢* .qĤ Ĥ x ⟩ ⟨ Ĥ Ĥ ⊢* .qĤn
If the pure simulation of ⟨ ⟩ ⟨ Ĥ Ĥ by embedded_H would never reach its final state.
Figure 12.3 Turing Machine Ĥ applied to Ĥ
When Ĥ is applied to ⟨ ⟩Ĥ
Ĥ copies its input Ĥ0 to Ĥ1 then embedded_H simulates Ĥ0 Ĥ1
Then these steps would keep repeating:
Ĥ0 copies its input Ĥ1 to Ĥ2 then embedded_H0 simulates Ĥ1 Ĥ2
Ĥ1 copies its input Ĥ2 to Ĥ3 then embedded_H1 simulates Ĥ2 Ĥ3
Ĥ2 copies its input Ĥ3 to Ĥ4 then embedded_H2 simulates Ĥ3 Ĥ4...
---1--- 2022-03-26 03:48 PM
The above shows that the simulated input to embedded_H never reaches its own final state
of ⟨ .qn⟩Ĥ whether or not its simulation is aborted.
(a) If the simulation is not aborted the above sequence never ends.
(b) If the simulation is aborted the entire chain of recursive simulations immediately stops.
In no case does the simulated input ⟨ ⟩Ĥ Ĥever reach its final state .qn⟩ Ĥthus never meets
the Linz definition of halting:
computation that halts … the Turing machine will halt whenever it enters a final state.
(Linz:1990:234) Thus if embedded_H rejects its input it is necessarily correct.
Because all halt deciders are deciders they compute the mapping from their input finite
strings to their own accept or reject state. Halt deciders (because they are deciders) do not
compute any mappings from non-finite string non-inputs.
No halt decider ever determines the halt status of the computation that contains its actual
self thus embedded_H does not compute the mapping from Ĥ Ĥ because it is neither an
input nor a finite string.
Even Linz was confused by this. embedded_H is not supposed to report on itself or the
computation that it is contained within.
In the conclusion of his proof Linz said that when the copy of Linz H embedded at Ĥ.qx
transitions to Ĥ.qn on the basis that its input: ⟩ ⟨ Ĥ Ĥ never halts that this forms a
contradiction with the fact that Ĥ ⟨ ⟩Ĥ halts. This assumes that a halt decider must compute
the halt status of the computation that contains itself.
As long as it is verified that the simulated input to embedded_H cannot reach its final state
then we know that this simulated input cannot meet the Linz definition of halting.
As long as we know that this simulated input cannot meet the Linz definition of halting we
know that this input specifies a non-halting sequence of configurations.
As long as we know that this input specifies a non-halting sequence of configurations then
we know that embedded_H would be correct to reject this input.
The behavior of ⟩ ⟨ Ĥ Ĥ simulated outside of Ĥmust be computationally equivalent to the
direct execution of Ĥapplied to Ĥyet not the same as ⟩ ⟨ Ĥ Ĥ simulated inside of .Ĥ
The directly executed Ĥ applied to ⟨ ⟩Ĥ is the first invocation of infinite recursion that only
terminates normally because of its one-way dependency relationship on embedded_H
aborting the second invocation of this otherwise infinite recursion.
When embedded_H simulates ⟩ ⟨ Ĥ Ĥ some steps of Ĥ have already been executed. This
shows that Ĥapplied to ⟨ ⟩Ĥ specifies a different sequence of configurations than ⟩ ⟨ Ĥ Ĥ
simulated by embedded_H.
---2--- 2022-03-26 03:48 PM
Appendix: Peter Linz Halting Problem Proof
Definition 12.1
Theorem 12.1
Let
WM
describe a Turing machine M = (Q,
I,
r, 8, qo,
D,
F),
and
let W be any element
of
I
+.
A solution
of
the halting problem is a Tur-
ing machine
H,
which for any W M and
w,
performs the computation
if
M applied to w halts, and
if
M applied to w does not halt.
Here
qy
and qn are both final states
of
H.
There
does not exist any Turing machine H that behaves as required by
Definition 12.1.
The
halting problem is therefore undecidable.
Proof: We assume the contrary, namely that there exists
an
algorithm,
and consequently some Turing machine
H,
that solves the halting problem.
The
input to H will be the description (encoded in some form)
of
M,
say
WM,
as well as the input w. The requirement is then that, given any
(WM'
w),
the Turing machine H will halt with either a yes or no answer. We achieve
this
by
asking that H halt in one
of
two corresponding final states, say, q y
or
qn'
The
situation can be visualized by a block diagram like Figure 12.1.
The
intent
of
this diagram is to indicate that, if M is started in state qo with input
(WM,
w), it will eventually halt in state
qy
or
qn' As required
by
Definition
12.1, we want H to operate according to the following rules:
if
M applied to W halts, and
if
M applied
to
W does not halt.
Figure
12.1
Figure
12.2
Next, we modify H to produce a Turing machine
H'
with the structure
shown in Figure 12.2. With the added states in Figure 12.2 we want to
convey that the transitions between state qy and the new states qa and qb are
to be made, regardless
of
the tape symbol, in such a way that the tape
remains unchanged. The way this is done is straightforward. Comparing H
and
H'
we see that, in situations where H reaches
qy
and halts, the modified
machine
H'
will enter an infinite loop. Formally, the action
of
H'
is de-
scribed by
if
M applied to w halts, and
if
M applied to w does not halt.
From
H'
we construct another Turing machine
Ii.
This new machine
takes as input
WM,
copies it, and then behaves exactly like
H'.
Then
the
action
of
Ii is such that
if
M applied to
WM
halts, and
if
M applied to
WM
does not halt.
Now
Ii is a Turing machine, so that it will have some description in
l*,
say
w.
This string, in addition to being the description
of
Ii can also
be
used
as input string. We can therefore legitimately ask what would happen
if
Ii is
applied
to
w.
From
the above, identifying M with
Ii,
we get
if
Ii applied to w halts,
and
A *
00
qow
~
if
'
if
Ii applied to w does not halt. This is clearly nonsense. The contradiction
tells us
that
our
assumption
of
the existence
of
H,
and hence the assump-
tion
of
the
decidability
of
the halting problem, must
be
false.
Linz, Peter 1990.
An
Introduction
to
Formal Languages and Automata.
LexingtonlToronto:
D.
C.
Heath and Company. (317-320)
ResearchGate has not been able to resolve any citations for this publication.
ResearchGate has not been able to resolve any references for this publication.