Ĥ.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 decides 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.

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

*Three irrefutable truisms lead to one conclusion*

Truism(1a)
The simulation of [Ĥ] by its simulating halt decider Ĥ would never halt
unless this simulation is aborted.

Truism(1b)
(1a) is another way of saying that when the copy of H at Ĥ.qx only
simulates its input [Ĥ] its input never halts.

Any input running under a simulating halt decider that never aborts its
input will have the same behavior as an input run under a simulator.

This [simulating halt decider] is not decider in the technical sense,
because it never halts. The fact that it never halts proves that its
input is not halting.

Truism(2)
Every simulation of input P that would never halt unless simulating halt
decider H stopped simulating it <is> a non-halting computation. This
remains true even after H stops simulating P.

I am merely generalizing the the halt deciding principle that overcomes
the pathological self-reference error of the halting theorem.

Truism(3)
Ĥ([Ĥ]) Halts because it aborted the simulation of its input.

Conclusion:
Ĥ is a halting computation and its input is not a halting computation
therefore Ĥ decides its input [Ĥ] as non-halting correctly.

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

["Followup-To:" header set to comp.theory.]
On 2021-05-20, olcott <NoOne@NoWhere.com> wrote:
> Ĥ.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 decides 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.
>
> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>
>
>
> *Three irrefutable truisms lead to one conclusion*
>
> Truism(1a)
> The simulation of [Ĥ] by its simulating halt decider Ĥ would never halt
> unless this simulation is aborted.

Corrections.

Firstly, you made a typo: the halt decider is H, not H-hat.

Secondly, the truth is more general:

"The simulation of [Ĥ] by *ANY* simulating halt decider would never
halt unless this simulation is aborted."

When the simulating decider is H, then ... the simulation is NOT
aborted. So this truism specifically does not apply to H in any useful
way.

When we apply the truism specifically to H, we get a VACUOUS TRUTH.

> Truism(1b)
> (1a) is another way of saying that when the copy of H at Ĥ.qx only
> simulates its input [Ĥ] its input never halts.

That "when" is always. H only simulates its input.

If you want to talk about some other thing that simulates its input
with abort checks ... you must not call it H.

> This [simulating halt decider] is not decider in the technical sense,
> because it never halts. The fact that it never halts proves that its
> input is not halting.

(Not really; a really broken decider could fail to halt on a halting
input.)

> Truism(3)
> Ĥ([Ĥ]) Halts because it aborted the simulation of its input.

False; Ĥ([Ĥ]) does not halt. Ĥ embeds H, and H is a non-aborting,
simulate-only, run-to-completion machine.

olcott <NoOne@NoWhere.com> writes:

> Ĥ.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 decides that its input
> would halt. The ((qn)) state indicates the input would not halt.

The only qy and qn you show are in H^. They do not indicate what you
say. They can't since qy is not even a final state! You need to learn
what a decider is and you need to learn what a Turing machine is.

> *Three irrefutable truisms lead to one conclusion*
>
> Truism(1a)
> The simulation of [Ĥ] by its simulating halt decider Ĥ would never
> halt unless this simulation is aborted.

Ĥ is not a halt decider. It is not even a partial halt decider. Years
down the line and you can't even write a simple sentence using core
technical terms correctly.

There is no need to mis-use the name H^. There is no need (other than
to prime linguistic trick you plan to pull later) to use silly terms
like "its", and if you must use operational language, computation "do".
There is no point in saying what they would do if there were not the
computation that they are.

Here are the facts that I think you are deliberately trying to make
obscure by misusing names and terms:

(a) UTM^([UTM^]) is not a finite computation. The "hat" construction
means that a pure simulator will not halt on it's "hat" version.

(b) Your partial decider D is a UTM that also scans for the
silly-non-halting pattern.

(c) D^([D^]) is a finite computation.

(d) D(<[D^], [D^]>) gives the wrong result for the halting problem but,
according to you, the correct result or the silly-non-halting
problem.

Now, do you agree with these facts? An actual answer would be appreciated.

> Truism(1b)
> (1a) is another way of saying that when the copy of H at Ĥ.qx only
> simulates its input [Ĥ] its input never halts.

Just say that UTM^([UTM^]) is not a finite computation. No need to
abuse the name H to refer to a UTM as well.

> Truism(2)
> Every simulation of input P that would never halt unless simulating
> halt decider H stopped simulating it <is> a non-halting
> computation. This remains true even after H stops simulating P.

Try writing this is English. Better yet, try writing it formally.

A halting problem instance, P, is a non-halting computation if the
sequence of configurations it defines is not finite.

Any statement about what "remains true" when something changes is just
part of your plan to define the silly-non-halting result for one
computation as the halting status of another.

> Truism(3)
> Ĥ([Ĥ]) Halts because it aborted the simulation of its input.

Much better to call it D and say that D^([D^]) halts.

> Conclusion:
> Ĥ is a halting computation

No. So many years down the line and you still don't even know what a
computation is.

> and its input is not a halting computation

You show no input. Any string can be presented to any TM so "its input"
is just meaningless.

> therefore Ĥ decides its input [Ĥ] as non-halting correctly.

[H^] is not a computation. It is neither halting nor non halting.

The actual facts of the matter:

(a) UTM^([UTM^]) is not a finite computation. The "hat" construction
means that a pure simulator will not halt on it's "hat" version.

(b) Your partial decider D is a UTM that also scans for the
silly-non-halting pattern.

(c) D^([D^]) is a finite computation.

(d) D(<[D^], [D^]>) gives the wrong result for the halting problem but,
according to you, the correct result or the silly-non-halting
problem.

--
Ben.

On 5/20/2021 6:35 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> Ĥ.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 decides that its input

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 only qy and qn you show are in H^. They do not indicate what you
> say. They can't since qy is not even a final state! You need to learn
> what a decider is and you need to learn what a Turing machine is.
>

corrected.

>> *Three irrefutable truisms lead to one conclusion*
>>
>> Truism(1a)
>> The simulation of [Ĥ] by its simulating halt decider Ĥ would never
>> halt unless this simulation is aborted.
>
> Ĥ is not a halt decider. It is not even a partial halt decider. Years
> down the line and you can't even write a simple sentence using core
> technical terms correctly.
>

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

Ĥ contains a halt decider @ Ĥ.qx

Truism(1a)
The simulation of: ([Ĥ][Ĥ]) by the simulating halt decider @ Ĥ.qx would
never halt unless Ĥ.qx aborts this simulation.

Truism(1b)
(1a) is another way of saying that the simulation of: ([Ĥ][Ĥ]) by a UTM
@ Ĥ.qx would never halt.

Unless and until people understand that (1a) is a paraphrase of (1b) we
cannot move to truism(2).

> There is no need to mis-use the name H^. There is no need (other than
> to prime linguistic trick you plan to pull later) to use silly terms
> like "its", and if you must use operational language, computation "do".
> There is no point in saying what they would do if there were not the
> computation that they are.
>
> Here are the facts that I think you are deliberately trying to make
> obscure by misusing names and terms:
>
> (a) UTM^([UTM^]) is not a finite computation. The "hat" construction
> means that a pure simulator will not halt on it's "hat" version.
>

All that I am referring to is that when the simulating halt decider @
Ĥ.qx has been replaced by a UTM then Ĥ([Ĥ]) never halts.

> (b) Your partial decider D is a UTM that also scans for the
> silly-non-halting pattern.
>
> (c) D^([D^]) is a finite computation.
>
> (d) D(<[D^], [D^]>) gives the wrong result for the halting problem but,
> according to you, the correct result or the silly-non-halting
> problem.
>
> Now, do you agree with these facts? An actual answer would be appreciated.
>

After (a) I have no idea what D refers to.

>> Truism(1b)
>> (1a) is another way of saying that when the copy of H at Ĥ.qx only
>> simulates its input [Ĥ] its input never halts.
>
> Just say that UTM^([UTM^]) is not a finite computation. No need to
> abuse the name H to refer to a UTM as well.
>

Understanding that the paraphrase is correct is a mandatory prerequisite
to Truism(2)

>> Truism(2)
>> Every simulation of input P that would never halt unless simulating
>> halt decider H stopped simulating it <is> a non-halting
>> computation. This remains true even after H stops simulating P.
>
> Try writing this is English. Better yet, try writing it formally.
>
> A halting problem instance, P, is a non-halting computation if the
> sequence of configurations it defines is not finite.
>

That one allows the pathological self-reference error to prevent a
correct halt decider from being defined on some inputs. That one would
decide that an infinite loop is a halting computation when this infinite
loop is analyzed by a simulating halt decider.

void Infinite_Loop()
{ HERE: goto HERE;
}

_Infinite_Loop()
[00000aaf](01) 55 push ebp
[00000ab0](02) 8bec mov ebp,esp
[00000ab2](02) ebfe jmp 00000ab2
[00000ab4](01) 5d pop ebp
[00000ab5](01) c3 ret
Size in bytes:(0007) [00000ab5]

[infinite_loop] non-halting behavior pattern
(a) The instruction is a JMP instruction.
(b) It is jumping upward or to its own address.
(c) There are no conditional branch instructions in-between.
(d) There are no other JMP instructions in-between (André G. Isaak)

We can verify that _Infinite_Loop() <is> a non halting computation, this
is quite obvious.

Architectural design of simulating halt decider H
When the behavior of the input P to H
(a) Correctly matches
(b) A correct non-halting behavior pattern
Then H decides non-halting on P correctly.

We can also verify that when the above Architectural design is applied
to _Infinite_Loop() that it does decide not halting on _Infinite_Loop()
correctly. This fact validates the following statement:

>> Every simulation of input P that would never halt unless simulating
>> halt decider H stopped simulating it <is> a non-halting
>> computation. This remains true even after H stops simulating

Truism(1a)
The simulation of: ([Ĥ][Ĥ]) by the simulating halt decider @ Ĥ.qx would
never halt unless Ĥ.qx aborts this simulation.

Truism(1b)
(1a) is another way of saying that the simulation of: ([Ĥ][Ĥ]) by a UTM
@ Ĥ.qx would never halt.

Unless and until people understand that (1a) is a correct paraphrase of
(1b) we cannot move to truism(2).

We cannot proceed to any other points until we have some mutually agreed
wording of the above three lines. I cannot agree to any wording of
(1a) that reinserts the pathological self-reference error.

> Any statement about what "remains true" when something changes is just
> part of your plan to define the silly-non-halting result for one
> computation as the halting status of another.
>
>> Truism(3)
>> Ĥ([Ĥ]) Halts because it aborted the simulation of its input.
>
> Much better to call it D and say that D^([D^]) halts.
>
>> Conclusion:
>> Ĥ is a halting computation
>
> No. So many years down the line and you still don't even know what a
> computation is.
>
>> and its input is not a halting computation
>
> You show no input. Any string can be presented to any TM so "its input"
> is just meaningless.
>
>> therefore Ĥ decides its input [Ĥ] as non-halting correctly.
>
> [H^] is not a computation. It is neither halting nor non halting.
>
> The actual facts of the matter:
>
> (a) UTM^([UTM^]) is not a finite computation. The "hat" construction
> means that a pure simulator will not halt on it's "hat" version.
>
> (b) Your partial decider D is a UTM that also scans for the
> silly-non-halting pattern.
>
> (c) D^([D^]) is a finite computation.
>
> (d) D(<[D^], [D^]>) gives the wrong result for the halting problem but,
> according to you, the correct result or the silly-non-halting
> problem.
>

--
Copyright 2021 Pete Olcott

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

On 5/20/2021 1:16 AM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-05-20, olcott <NoOne@NoWhere.com> wrote:
>> Ĥ.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 decides 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.
>>
>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>
>>
>>
>> *Three irrefutable truisms lead to one conclusion*
>>
>> Truism(1a)
>> The simulation of [Ĥ] by its simulating halt decider Ĥ would never halt
>> unless this simulation is aborted.
>
> Corrections.
>
> Firstly, you made a typo: the halt decider is H, not H-hat.
>

This is a {clarification, correction and simplification} of the Peter
Linz text:
(a) Clarification all states are labeled with the machine name
(b) Correction the second q0 start state has been renamed qx
(c) Simplification tape states do not provide any useful information and
have been removed.

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

I am only referring to this computation Ĥ([Ĥ]) on the basis of the
actions of the simulating halt decider @ Ĥ.qx

> Secondly, the truth is more general:
>
> "The simulation of [Ĥ] by *ANY* simulating halt decider would never
> halt unless this simulation is aborted."
>

Full analysis of the that requires more that the minimum inference steps
necessary to prove my point.

> When the simulating decider is H, then ... the simulation is NOT
> aborted. So this truism specifically does not apply to H in any useful
> way.
>

You changed the subject on the basis that you mistook what I am saying
for a typo. We cannot proceed on the basis of a false assumption, I am
stopping here.

> When we apply the truism specifically to H, we get a VACUOUS TRUTH.
>
>> Truism(1b)
>> (1a) is another way of saying that when the copy of H at Ĥ.qx only
>> simulates its input [Ĥ] its input never halts.
>
> That "when" is always. H only simulates its input.
>
> If you want to talk about some other thing that simulates its input
> with abort checks ... you must not call it H.
>
>> This [simulating halt decider] is not decider in the technical sense,
>> because it never halts. The fact that it never halts proves that its
>> input is not halting.
>
> (Not really; a really broken decider could fail to halt on a halting
> input.)
>
>> Truism(3)
>> Ĥ([Ĥ]) Halts because it aborted the simulation of its input.
>
> False; Ĥ([Ĥ]) does not halt. Ĥ embeds H, and H is a non-aborting,
> simulate-only, run-to-completion machine.
>

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 5/20/2021 6:35 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Ĥ.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 decides that its input
>
> The (qy) state indicates...

I'm going to concentrate on one significant reply a day so see
Message-ID: <87h7ixrn18.fsf@bsb.me.uk>

--
Ben.

On 5/20/2021 6:44 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/20/2021 6:35 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Ĥ.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 decides that its input
>>
>> The (qy) state indicates...
>
> I'm going to concentrate on one significant reply a day so see
> Message-ID: <87h7ixrn18.fsf@bsb.me.uk>
>

Message IDs are totally useless to me I need time and date stamps.

--
Copyright 2021 Pete Olcott

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

On 5/20/21 8:08 PM, olcott wrote:
> On 5/20/2021 6:44 PM, Ben Bacarisse wrote:

>> I'm going to concentrate on one significant reply a day so see
>> Message-ID: <87h7ixrn18.fsf@bsb.me.uk>
>>
>
> Message IDs are totally useless to me I need time and date stamps.
>

They shouldn't be. I use the same newsreader as you do and I can look up
messages by Message-ID.

olcott <NoOne@NoWhere.com> writes:

> On 5/20/2021 6:44 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/20/2021 6:35 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> Ĥ.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 decides that its input
>>>
>>> The (qy) state indicates...
>>
>> I'm going to concentrate on one significant reply a day so see
>> Message-ID: <87h7ixrn18.fsf@bsb.me.uk>
>
> Message IDs are totally useless to me I need time and date stamps.

I'm sorry to hear that.

--
Ben.