Content uploaded by PL Olcott

Author content

All content in this area was uploaded by PL Olcott on Mar 26, 2022

Content may be subject to copyright.

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)