Revised Linz H halt deciding criteria (My criteria Ben's notation)
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

The above means that the simulating halt decider H bases its halt status
decision on the behavior of the pure UTM simulation of its input.

H examines this behavior looking for infinite behavior patterns. When H
detects an infinite behavior pattern it aborts the simulation of its
input and transitions to H.qn.

Infinite behavior patterns are cases where the the pure UTM simulation
of the input would never reach the final state of this input.

For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.

Simplified syntax adapted from bottom of page 319:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach its
final state thus conclusively proving that this input never halts.
This enables embedded_H to correctly transition to Ĥ.qn.

All deciders are only accountable for mapping their input to an accept /
reject state.

As long as the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ could never reach
its final state then the transition to Ĥ.qn is necessarily correct.

Peter Linz HP Proof
https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/3/22 9:25 AM, olcott wrote:
> Revised Linz H halt deciding criteria (My criteria Ben's notation)
> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>
> The above means that the simulating halt decider H bases its halt status
> decision on the behavior of the pure UTM simulation of its input.
>
> H examines this behavior looking for infinite behavior patterns. When H
> detects an infinite behavior pattern it aborts the simulation of its
> input and transitions to H.qn.

This pattern does not exist as a finite pattern.

Proved, and accepted by failure to rebut.

Mesage ID <FOnzJ.162569$np6.119786@fx46.iad>
Date: 2021-12-30 19:31:49 GMT
Subject: Re: Concise refutation of halting problem proofs V42 [compute
the mapping]

FAIL.

>
> Infinite behavior patterns are cases where the the pure UTM simulation
> of the input would never reach the final state of this input.
>
> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>
> Simplified syntax adapted from bottom of page 319:
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach its
> final state thus conclusively proving that this input never halts.
> This enables embedded_H to correctly transition to Ĥ.qn.
>

WRONG.

> All deciders are only accountable for mapping their input to an accept /
> reject state.
>

And they must do so CORRECTLY.

Remember Requirements on H

H wM w -> Qy if M w Halts
H wm w -> Qn if M w Never Halts.

Thus, even though H only gets mW as its actual input, it is
'Accountable' for the behavior of M

Since if H -> Qn, we also have H^ -> Qn and Halt, H <H^> <H^> is WRONG
about H^ <H^>

> As long as the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ could never reach
> its final state then the transition to Ĥ.qn is necessarily correct.

And if H <H^> <H^> -> Qn then UTM <H^> <H^> Halts as shown above
>
>
> Peter Linz HP Proof
> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>

FAIL.

On 1/3/2022 9:18 AM, Richard Damon wrote:
>
> On 1/3/22 9:25 AM, olcott wrote:
>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>
>> The above means that the simulating halt decider H bases its halt
>> status decision on the behavior of the pure UTM simulation of its input.
>>
>> H examines this behavior looking for infinite behavior patterns. When
>> H detects an infinite behavior pattern it aborts the simulation of its
>> input and transitions to H.qn.
>
> This pattern does not exist as a finite pattern.
>
> Proved, and accepted by failure to rebut.
>
> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
> Date: 2021-12-30 19:31:49 GMT
> Subject: Re: Concise refutation of halting problem proofs V42 [compute
> the mapping]
>
> FAIL.
>
>>
>> Infinite behavior patterns are cases where the the pure UTM simulation
>> of the input would never reach the final state of this input.
>>
>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>
>> Simplified syntax adapted from bottom of page 319:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach its
>> final state thus conclusively proving that this input never halts.
>> This enables embedded_H to correctly transition to Ĥ.qn.
>>
>
> WRONG.
LIAR !!!

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/3/22 10:24 AM, olcott wrote:
> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>
>> On 1/3/22 9:25 AM, olcott wrote:
>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>
>>> The above means that the simulating halt decider H bases its halt
>>> status decision on the behavior of the pure UTM simulation of its input.
>>>
>>> H examines this behavior looking for infinite behavior patterns. When
>>> H detects an infinite behavior pattern it aborts the simulation of
>>> its input and transitions to H.qn.
>>
>> This pattern does not exist as a finite pattern.
>>
>> Proved, and accepted by failure to rebut.
>>
>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>> Date: 2021-12-30 19:31:49 GMT
>> Subject: Re: Concise refutation of halting problem proofs V42 [compute
>> the mapping]
>>
>> FAIL.
>>
>>>
>>> Infinite behavior patterns are cases where the the pure UTM
>>> simulation of the input would never reach the final state of this input.
>>>
>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>
>>> Simplified syntax adapted from bottom of page 319:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach its
>>> final state thus conclusively proving that this input never halts.
>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>
>>
>> WRONG.
> LIAR !!!
>

PROVE IT, or YOUR the LIAR.

I have shown my proof, which you have failed to give a rebuttal that
actually tries to rebut it.

IF embedded_H doesn't abort, then H never gets to Qn as claimed

If embedded_H does abort and go to Qn, then H^ also goes to Qn and Halts.

H and embedded_H must be the same algorithm with the same input so must
behave the same.

WHAT IS THE ERROR?, speak now with REAL proof or admit you are the LIAR.

On 1/3/2022 9:28 AM, Richard Damon wrote:
>
> On 1/3/22 10:24 AM, olcott wrote:
>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>
>>> On 1/3/22 9:25 AM, olcott wrote:
>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>
>>>> The above means that the simulating halt decider H bases its halt
>>>> status decision on the behavior of the pure UTM simulation of its
>>>> input.
>>>>
>>>> H examines this behavior looking for infinite behavior patterns.
>>>> When H detects an infinite behavior pattern it aborts the simulation
>>>> of its input and transitions to H.qn.
>>>
>>> This pattern does not exist as a finite pattern.
>>>
>>> Proved, and accepted by failure to rebut.
>>>
>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>> Date: 2021-12-30 19:31:49 GMT
>>> Subject: Re: Concise refutation of halting problem proofs V42
>>> [compute the mapping]
>>>
>>> FAIL.
>>>
>>>>
>>>> Infinite behavior patterns are cases where the the pure UTM
>>>> simulation of the input would never reach the final state of this
>>>> input.
>>>>
>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>>
>>>> Simplified syntax adapted from bottom of page 319:
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
>>>> its final state thus conclusively proving that this input never halts.
>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>
>>>
>>> WRONG.
>> LIAR !!!
>>
>
> PROVE IT, or YOUR the LIAR.
>
> I have shown my proof, which you have failed to give a rebuttal that
> actually tries to rebut it.
>
> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>
> If embedded_H does abort and go to Qn, then H^ also goes to Qn and Halts.

embedded_H is only accountable for mapping the behavior of the pure
simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.

Because the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach
the final state of this input embedded_H computes the mapping of ⟨Ĥ⟩ ⟨Ĥ⟩
to Ĥ.qn correctly.

If an animal is a cat then this animal is not a dog even if it barks and
gives birth to puppies.

>
> H and embedded_H must be the same algorithm with the same input so must
> behave the same.
>
>
> WHAT IS THE ERROR?, speak now with REAL proof or admit you are the LIAR.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/3/22 11:34 AM, olcott wrote:
> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>
>> On 1/3/22 10:24 AM, olcott wrote:
>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>
>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>
>>>>> The above means that the simulating halt decider H bases its halt
>>>>> status decision on the behavior of the pure UTM simulation of its
>>>>> input.
>>>>>
>>>>> H examines this behavior looking for infinite behavior patterns.
>>>>> When H detects an infinite behavior pattern it aborts the
>>>>> simulation of its input and transitions to H.qn.
>>>>
>>>> This pattern does not exist as a finite pattern.
>>>>
>>>> Proved, and accepted by failure to rebut.
>>>>
>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>> Date: 2021-12-30 19:31:49 GMT
>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>> [compute the mapping]
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>> simulation of the input would never reach the final state of this
>>>>> input.
>>>>>
>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>>>
>>>>> Simplified syntax adapted from bottom of page 319:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
>>>>> its final state thus conclusively proving that this input never halts.
>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>
>>>>
>>>> WRONG.
>>> LIAR !!!
>>>
>>
>> PROVE IT, or YOUR the LIAR.
>>
>> I have shown my proof, which you have failed to give a rebuttal that
>> actually tries to rebut it.
>>
>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>
>> If embedded_H does abort and go to Qn, then H^ also goes to Qn and Halts.
>
> embedded_H is only accountable for mapping the behavior of the pure
> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.

Right, and to correctly answer the input <H^> <H^> then H/embedded_H
must go to the state that matches the behavior of the Computation of H^
applied to <H^>.

Are you forgetting again that the input <H^> INCLUDES its own copy of H
that exactly matches the H that is claimed to be able to give the right
answer, so H IS accountable for THAT copy of itself?

>
> Because the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach
> the final state of this input embedded_H computes the mapping of ⟨Ĥ⟩ ⟨Ĥ⟩
> to Ĥ.qn correctly.

Why can't it? If embedded_H DOES go to H.qn then the pure simulation of
that input also goes to H^.qn and Halts.

>
> If an animal is a cat then this animal is not a dog even if it barks and
> gives birth to puppies.

RED HERRING.

What is the analogy to the cat and the dog.

It seems that YOU are the one making this sort of claim.

H^ is a Turing Machine, as is H, which means they have definite behavior
for any given input.

If H goes to H.qn, then H^ goes to H^.qn and halts so H <H^> <H^> going
to H.qn is WRONG as that input represents H^ <H^> which we just saw halts.

TRY AGAIN.

YOU CLAIM you have a correct halt decider, (your cat?) but it gives the
wrong answer (a dog?) which is shown by the wrong answer it gives (the
puppies?). Why do you think it is a cat?

>
>>
>> H and embedded_H must be the same algorithm with the same input so
>> must behave the same.
>>
>>
>> WHAT IS THE ERROR?, speak now with REAL proof or admit you are the LIAR.
>
>

On 1/3/2022 10:43 AM, Richard Damon wrote:
> On 1/3/22 11:34 AM, olcott wrote:
>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>
>>> On 1/3/22 10:24 AM, olcott wrote:
>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>
>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>
>>>>>> The above means that the simulating halt decider H bases its halt
>>>>>> status decision on the behavior of the pure UTM simulation of its
>>>>>> input.
>>>>>>
>>>>>> H examines this behavior looking for infinite behavior patterns.
>>>>>> When H detects an infinite behavior pattern it aborts the
>>>>>> simulation of its input and transitions to H.qn.
>>>>>
>>>>> This pattern does not exist as a finite pattern.
>>>>>
>>>>> Proved, and accepted by failure to rebut.
>>>>>
>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>> [compute the mapping]
>>>>>
>>>>> FAIL.
>>>>>
>>>>>>
>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>> simulation of the input would never reach the final state of this
>>>>>> input.
>>>>>>
>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>> embedded_H.
>>>>>>
>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
>>>>>> its final state thus conclusively proving that this input never
>>>>>> halts.
>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>
>>>>>
>>>>> WRONG.
>>>> LIAR !!!
>>>>
>>>
>>> PROVE IT, or YOUR the LIAR.
>>>
>>> I have shown my proof, which you have failed to give a rebuttal that
>>> actually tries to rebut it.
>>>
>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>
>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn and
>>> Halts.
>>
>> embedded_H is only accountable for mapping the behavior of the pure
>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>
> Right, and to correctly answer the input <H^> <H^> then H/embedded_H
> must go to the state that matches the behavior of the Computation of H^
> applied to <H^>.
>

WRONG:
embedded_H must go to the state that correctly describes the behavior of
the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩

these steps would keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/3/22 11:53 AM, olcott wrote:
> On 1/3/2022 10:43 AM, Richard Damon wrote:
>> On 1/3/22 11:34 AM, olcott wrote:
>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>
>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>
>>>>>>> The above means that the simulating halt decider H bases its halt
>>>>>>> status decision on the behavior of the pure UTM simulation of its
>>>>>>> input.
>>>>>>>
>>>>>>> H examines this behavior looking for infinite behavior patterns.
>>>>>>> When H detects an infinite behavior pattern it aborts the
>>>>>>> simulation of its input and transitions to H.qn.
>>>>>>
>>>>>> This pattern does not exist as a finite pattern.
>>>>>>
>>>>>> Proved, and accepted by failure to rebut.
>>>>>>
>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>>> [compute the mapping]
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>>
>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>> simulation of the input would never reach the final state of this
>>>>>>> input.
>>>>>>>
>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>> embedded_H.
>>>>>>>
>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
>>>>>>> its final state thus conclusively proving that this input never
>>>>>>> halts.
>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>
>>>>>>
>>>>>> WRONG.
>>>>> LIAR !!!
>>>>>
>>>>
>>>> PROVE IT, or YOUR the LIAR.
>>>>
>>>> I have shown my proof, which you have failed to give a rebuttal that
>>>> actually tries to rebut it.
>>>>
>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>
>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn and
>>>> Halts.
>>>
>>> embedded_H is only accountable for mapping the behavior of the pure
>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>
>> Right, and to correctly answer the input <H^> <H^> then H/embedded_H
>> must go to the state that matches the behavior of the Computation of
>> H^ applied to <H^>.
>>
>
> WRONG:
> embedded_H must go to the state that correctly describes the behavior of
> the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> these steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>

That only happens if embedded_H never aborts its simulation of its input.

And if that happens, it can never then abort and go to Qn to be 'right',
as all copies of an algorithm when given the same input behave the same.

The problem is that since its input includes a copy of it, there is no
right answer it can give.

This is what proves that embedded_H can't exist.

We KNOW that if we actually have some H (which we will try to be
correct, but don't force that, so we know that some H will exist) then

If H decides that <H^> <H^> represents a non-halting pattern, and thus
goes to H.qn, then the H^ this represents will also go to H^.qn and
Halt, and thus that H is by necessity wrong.

If H decides that <H^> <H^> represents a Halting Pattern, and thus goes
to H.qy, then the H^ this represents will also go to H^.qy and from
there to an infinite loop and never halt, and thus that H is by
necessity wrong.

The only other option of H is to not go to Qy or Qn in finite time, at
which point it fails to be a decider.

Thus the only way that H can exist is for it to be WRONG.

FAIL.

You are only restating your (false) position and not actually pointing
out errors.

This is really a concession that you understand you are wrong, but just
refuse to actually say it, so you are still shown to be the LIAR.

ALL you claims revolve around contradictory behavior, which we know can
not happen.

On 1/3/2022 11:10 AM, Richard Damon wrote:
> On 1/3/22 11:53 AM, olcott wrote:
>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>> On 1/3/22 11:34 AM, olcott wrote:
>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>
>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>
>>>>>>>> The above means that the simulating halt decider H bases its
>>>>>>>> halt status decision on the behavior of the pure UTM simulation
>>>>>>>> of its input.
>>>>>>>>
>>>>>>>> H examines this behavior looking for infinite behavior patterns.
>>>>>>>> When H detects an infinite behavior pattern it aborts the
>>>>>>>> simulation of its input and transitions to H.qn.
>>>>>>>
>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>
>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>
>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>>>> [compute the mapping]
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>>>
>>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>>> simulation of the input would never reach the final state of
>>>>>>>> this input.
>>>>>>>>
>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>> embedded_H.
>>>>>>>>
>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>>>>>>> reach its final state thus conclusively proving that this input
>>>>>>>> never halts.
>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG.
>>>>>> LIAR !!!
>>>>>>
>>>>>
>>>>> PROVE IT, or YOUR the LIAR.
>>>>>
>>>>> I have shown my proof, which you have failed to give a rebuttal
>>>>> that actually tries to rebut it.
>>>>>
>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>
>>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn and
>>>>> Halts.
>>>>
>>>> embedded_H is only accountable for mapping the behavior of the pure
>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>
>>> Right, and to correctly answer the input <H^> <H^> then H/embedded_H
>>> must go to the state that matches the behavior of the Computation of
>>> H^ applied to <H^>.
>>>
>>
>> WRONG:
>> embedded_H must go to the state that correctly describes the behavior
>> of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> these steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>
> That only happens if embedded_H never aborts its simulation of its input.
>
> And if that happens, it can never then abort and go to Qn to be 'right',
> as all copies of an algorithm when given the same input behave the same.
>
The criteria that H uses is what the behavior would be if H never
aborted the simulation of its input.

You seem to be confused into believing that when H aborts the simulation
of its input that this causes the input to halt. This is not true. An
input only halts when it reaches its final state.

As long as the input would never reach its final state if H did not
abort the simulation of its input then H is ALWAYS free to abort its
simulation and correctly transition to H.qn.

Simulating halt deciders must always abort the simulation of inputs that
cannot possibly ever reach their final state and every input that cannot
possibly ever reach its final state is an input that never halts.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/3/22 12:37 PM, olcott wrote:
> On 1/3/2022 11:10 AM, Richard Damon wrote:
>> On 1/3/22 11:53 AM, olcott wrote:
>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>
>>>>>>>>> The above means that the simulating halt decider H bases its
>>>>>>>>> halt status decision on the behavior of the pure UTM simulation
>>>>>>>>> of its input.
>>>>>>>>>
>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>> patterns. When H detects an infinite behavior pattern it aborts
>>>>>>>>> the simulation of its input and transitions to H.qn.
>>>>>>>>
>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>
>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>
>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>>>>> [compute the mapping]
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>>>> simulation of the input would never reach the final state of
>>>>>>>>> this input.
>>>>>>>>>
>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>> repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>>>>>>>> reach its final state thus conclusively proving that this input
>>>>>>>>> never halts.
>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG.
>>>>>>> LIAR !!!
>>>>>>>
>>>>>>
>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>
>>>>>> I have shown my proof, which you have failed to give a rebuttal
>>>>>> that actually tries to rebut it.
>>>>>>
>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>
>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn and
>>>>>> Halts.
>>>>>
>>>>> embedded_H is only accountable for mapping the behavior of the pure
>>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>>
>>>> Right, and to correctly answer the input <H^> <H^> then H/embedded_H
>>>> must go to the state that matches the behavior of the Computation of
>>>> H^ applied to <H^>.
>>>>
>>>
>>> WRONG:
>>> embedded_H must go to the state that correctly describes the behavior
>>> of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>
>>> these steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>
>> That only happens if embedded_H never aborts its simulation of its input.
>>
>> And if that happens, it can never then abort and go to Qn to be
>> 'right', as all copies of an algorithm when given the same input
>> behave the same.
>>
> The criteria that H uses is what the behavior would be if H never
> aborted the simulation of its input.
>

Which is gthe WRONG criteria!!!!

THe criteria NEEDS to be what is the behavior of the machine the input
represents, or of a REAL UTM given that same input.

So, THERE'S YOUR PROBLEM!

> You seem to be confused into believing that when H aborts the simulation
> of its input that this causes the input to halt. This is not true. An
> input only halts when it reaches its final state.
>

But it isn't the 'input' that matters, but the computation that the
input represents, and since that computation uses a copy of H, the
behavior of the computation is depencent on what H does, and if H goes
to Qn then it Halts. PERIOD.

This is one of your old errors that shows that you don't understand what
you are talking about.

> As long as the input would never reach its final state if H did not
> abort the simulation of its input then H is ALWAYS free to abort its
> simulation and correctly transition to H.qn.

By THAT definitions, ANY input could be correctly decided non-halting by
a 'simulating decider that just immediately aborts its simulation',
which is non-sense.

Note the REAL definition is that H needs to decide on what the input
REPERESENTS, what that COMPUTATION does.

>
> Simulating halt deciders must always abort the simulation of inputs that
> cannot possibly ever reach their final state and every input that cannot
> possibly ever reach its final state is an input that never halts.
>

Except your H doesn't do that. When we correct your definition (since
inputs never have 'behavior' only the computation they represent or that
of the UTM simulating them), we see that if H -> Qn then H^ -> Qn and
Halts, thus for ANY input H <H^> x that H answers by going to Qn it will
be wrong, so it applies for H <H^> <H^>.

You can't just 'define' your decider to be right, you have to show that
you can actually build such a thing. You have NEVER even attempted an
existence proof. You did start out previously trying to make an example,
but you found that all your examples failed because it was clear they
were wrong. If you aren't going to present an example to show that one
exists, you need to some how PROVE that one can exist, which considering
you lack of ability to actually prove anything is probably out of your
reach,

FAIL.

On 1/3/2022 12:18 PM, Richard Damon wrote:
>
> On 1/3/22 12:37 PM, olcott wrote:
>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>> On 1/3/22 11:53 AM, olcott wrote:
>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>> notation)
>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>
>>>>>>>>>> The above means that the simulating halt decider H bases its
>>>>>>>>>> halt status decision on the behavior of the pure UTM
>>>>>>>>>> simulation of its input.
>>>>>>>>>>
>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>
>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>
>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>
>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>>>>>> [compute the mapping]
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>>>>> simulation of the input would never reach the final state of
>>>>>>>>>> this input.
>>>>>>>>>>
>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>> embedded_H.
>>>>>>>>>>
>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>> repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>>>>>>>>> reach its final state thus conclusively proving that this
>>>>>>>>>> input never halts.
>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>> LIAR !!!
>>>>>>>>
>>>>>>>
>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>
>>>>>>> I have shown my proof, which you have failed to give a rebuttal
>>>>>>> that actually tries to rebut it.
>>>>>>>
>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>>
>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn
>>>>>>> and Halts.
>>>>>>
>>>>>> embedded_H is only accountable for mapping the behavior of the
>>>>>> pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>>>
>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>> H/embedded_H must go to the state that matches the behavior of the
>>>>> Computation of H^ applied to <H^>.
>>>>>
>>>>
>>>> WRONG:
>>>> embedded_H must go to the state that correctly describes the
>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>
>>>> these steps would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>
>>> That only happens if embedded_H never aborts its simulation of its
>>> input.
>>>
>>> And if that happens, it can never then abort and go to Qn to be
>>> 'right', as all copies of an algorithm when given the same input
>>> behave the same.
>>>
>> The criteria that H uses is what the behavior would be if H never
>> aborted the simulation of its input.
>>
>
> Which is gthe WRONG criteria!!!!
>
> THe criteria NEEDS to be what is the behavior of the machine the input
> represents, or of a REAL UTM given that same input.
>
> So, THERE'S YOUR PROBLEM!

The criteria of H is whether or not the pure simulation of its input
would ever reach its final state. The pure simulation of the input to
embedded_H would never reach its final state.

>> You seem to be confused into believing that when H aborts the
>> simulation of its input that this causes the input to halt. This is
>> not true. An input only halts when it reaches its final state.
>>
>
> But it isn't the 'input' that matters, but the computation that the
> input represents, and since that computation uses a copy of H, the
> behavior of the computation is depencent on what H does, and if H goes
> to Qn then it Halts. PERIOD.
>
> This is one of your old errors that shows that you don't understand what
> you are talking about.
>
>> As long as the input would never reach its final state if H did not
>> abort the simulation of its input then H is ALWAYS free to abort its
>> simulation and correctly transition to H.qn.
>
> By THAT definitions, ANY input could be correctly decided non-halting by
> a 'simulating decider that just immediately aborts its simulation',
> which is non-sense.

NO STUPID THAT IS NOT WHAT THIS MEANS:
As long as the input would never reach its final state if H did not
abort the simulation of its input

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/3/22 1:26 PM, olcott wrote:
> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>
>> On 1/3/22 12:37 PM, olcott wrote:
>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>> notation)
>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>
>>>>>>>>>>> The above means that the simulating halt decider H bases its
>>>>>>>>>>> halt status decision on the behavior of the pure UTM
>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>>
>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>
>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>
>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>>>>>>> [compute the mapping]
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>>>>>> simulation of the input would never reach the final state of
>>>>>>>>>>> this input.
>>>>>>>>>>>
>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>> embedded_H.
>>>>>>>>>>>
>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>> repeating:
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>>>>>>>>>> reach its final state thus conclusively proving that this
>>>>>>>>>>> input never halts.
>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WRONG.
>>>>>>>>> LIAR !!!
>>>>>>>>>
>>>>>>>>
>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>
>>>>>>>> I have shown my proof, which you have failed to give a rebuttal
>>>>>>>> that actually tries to rebut it.
>>>>>>>>
>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>>>
>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn
>>>>>>>> and Halts.
>>>>>>>
>>>>>>> embedded_H is only accountable for mapping the behavior of the
>>>>>>> pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>>>>
>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>> H/embedded_H must go to the state that matches the behavior of the
>>>>>> Computation of H^ applied to <H^>.
>>>>>>
>>>>>
>>>>> WRONG:
>>>>> embedded_H must go to the state that correctly describes the
>>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>
>>>>> these steps would keep repeating:
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>
>>>> That only happens if embedded_H never aborts its simulation of its
>>>> input.
>>>>
>>>> And if that happens, it can never then abort and go to Qn to be
>>>> 'right', as all copies of an algorithm when given the same input
>>>> behave the same.
>>>>
>>> The criteria that H uses is what the behavior would be if H never
>>> aborted the simulation of its input.
>>>
>>
>> Which is gthe WRONG criteria!!!!
>>
>> THe criteria NEEDS to be what is the behavior of the machine the input
>> represents, or of a REAL UTM given that same input.
>>
>> So, THERE'S YOUR PROBLEM!
>
> The criteria of H is whether or not the pure simulation of its input
> would ever reach its final state. The pure simulation of the input to
> embedded_H would never reach its final state.

This was just explained to you.

IF you actually mean this, then that means that H has to be defined as
never going to H.qn, as if it does, then the pure simulation of it input
will end up stopping in H^.qn

FAIL.

>
>>> You seem to be confused into believing that when H aborts the
>>> simulation of its input that this causes the input to halt. This is
>>> not true. An input only halts when it reaches its final state.
>>>
>>
>> But it isn't the 'input' that matters, but the computation that the
>> input represents, and since that computation uses a copy of H, the
>> behavior of the computation is depencent on what H does, and if H goes
>> to Qn then it Halts. PERIOD.
>>
>> This is one of your old errors that shows that you don't understand
>> what you are talking about.
>>
>>> As long as the input would never reach its final state if H did not
>>> abort the simulation of its input then H is ALWAYS free to abort its
>>> simulation and correctly transition to H.qn.
>>
>> By THAT definitions, ANY input could be correctly decided non-halting
>> by a 'simulating decider that just immediately aborts its simulation',
>> which is non-sense.
>
> NO STUPID THAT IS NOT WHAT THIS MEANS:
> As long as the input would never reach its final state if H did not
> abort the simulation of its input
>

WRONG. You are using the wrong definition AGAIN.

Show me where the definition for the Halting Decider says 'if H did not
abort its simulation of its input'.

THAT IS A BLATANT DAMNED LIE.

The definition (the version you are using) is if a UTM would not Halt.
IF H -> Qn then the UTM WILL Halt when its simulation goes to H^.Qn.

You need to be consistent with your behavior of H.

You are conditioning your proof on contraditions, so it is BY DEFINITION
unsound.

FAIL.

On 1/3/2022 12:59 PM, Richard Damon wrote:
>
> On 1/3/22 1:26 PM, olcott wrote:
>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>
>>> On 1/3/22 12:37 PM, olcott wrote:
>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>> notation)
>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> The above means that the simulating halt decider H bases its
>>>>>>>>>>>> halt status decision on the behavior of the pure UTM
>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>>>
>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>
>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>
>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs V42
>>>>>>>>>>> [compute the mapping]
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>>>>>>> simulation of the input would never reach the final state of
>>>>>>>>>>>> this input.
>>>>>>>>>>>>
>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>> repeating:
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>>>>>>>>>>> reach its final state thus conclusively proving that this
>>>>>>>>>>>> input never halts.
>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WRONG.
>>>>>>>>>> LIAR !!!
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>
>>>>>>>>> I have shown my proof, which you have failed to give a rebuttal
>>>>>>>>> that actually tries to rebut it.
>>>>>>>>>
>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>>>>
>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn
>>>>>>>>> and Halts.
>>>>>>>>
>>>>>>>> embedded_H is only accountable for mapping the behavior of the
>>>>>>>> pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>>>>>
>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>> H/embedded_H must go to the state that matches the behavior of
>>>>>>> the Computation of H^ applied to <H^>.
>>>>>>>
>>>>>>
>>>>>> WRONG:
>>>>>> embedded_H must go to the state that correctly describes the
>>>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>
>>>>>> these steps would keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>
>>>>> That only happens if embedded_H never aborts its simulation of its
>>>>> input.
>>>>>
>>>>> And if that happens, it can never then abort and go to Qn to be
>>>>> 'right', as all copies of an algorithm when given the same input
>>>>> behave the same.
>>>>>
>>>> The criteria that H uses is what the behavior would be if H never
>>>> aborted the simulation of its input.
>>>>
>>>
>>> Which is gthe WRONG criteria!!!!
>>>
>>> THe criteria NEEDS to be what is the behavior of the machine the
>>> input represents, or of a REAL UTM given that same input.
>>>
>>> So, THERE'S YOUR PROBLEM!
>>
>> The criteria of H is whether or not the pure simulation of its input
>> would ever reach its final state. The pure simulation of the input to
>> embedded_H would never reach its final state.
>
> This was just explained to you.
>
> IF you actually mean this, then that means that H has to be defined as
> never going to H.qn, as if it does, then the pure simulation of it input
> will end up stopping in H^.qn
>

As I keep telling you and you keep stupidly ignoring the fact that the
input stops running because its simulation was aborted is no indication
what-so-ever that this simulated input halts. HALTING IS ONLY REACHING A
FINAL STATE.

You also stupidly ignore that the halt decider is only accountable for
what the behavior of its actual input would be. It is not responsible
for the behavior of any non-inputs.

> FAIL.
>
>>
>>>> You seem to be confused into believing that when H aborts the
>>>> simulation of its input that this causes the input to halt. This is
>>>> not true. An input only halts when it reaches its final state.
>>>>
>>>
>>> But it isn't the 'input' that matters, but the computation that the
>>> input represents, and since that computation uses a copy of H, the
>>> behavior of the computation is depencent on what H does, and if H
>>> goes to Qn then it Halts. PERIOD.
>>>
>>> This is one of your old errors that shows that you don't understand
>>> what you are talking about.
>>>
>>>> As long as the input would never reach its final state if H did not
>>>> abort the simulation of its input then H is ALWAYS free to abort its
>>>> simulation and correctly transition to H.qn.
>>>
>>> By THAT definitions, ANY input could be correctly decided non-halting
>>> by a 'simulating decider that just immediately aborts its
>>> simulation', which is non-sense.
>>
>> NO STUPID THAT IS NOT WHAT THIS MEANS:
>> As long as the input would never reach its final state if H did not
>> abort the simulation of its input
>>
>
> WRONG. You are using the wrong definition AGAIN.
>
> Show me where the definition for the Halting Decider says 'if H did not
> abort its simulation of its input'.
>

On 1/3/22 2:32 PM, olcott wrote:
> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>
>> On 1/3/22 1:26 PM, olcott wrote:
>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>
>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>> notation)
>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above means that the simulating halt decider H bases
>>>>>>>>>>>>> its halt status decision on the behavior of the pure UTM
>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>>>>
>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>
>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>
>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs
>>>>>>>>>>>> V42 [compute the mapping]
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Infinite behavior patterns are cases where the the pure UTM
>>>>>>>>>>>>> simulation of the input would never reach the final state
>>>>>>>>>>>>> of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>>>>>>>>>>>> reach its final state thus conclusively proving that this
>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG.
>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>
>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>
>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>>>>>
>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to Qn
>>>>>>>>>> and Halts.
>>>>>>>>>
>>>>>>>>> embedded_H is only accountable for mapping the behavior of the
>>>>>>>>> pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>>>>>>
>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>> H/embedded_H must go to the state that matches the behavior of
>>>>>>>> the Computation of H^ applied to <H^>.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG:
>>>>>>> embedded_H must go to the state that correctly describes the
>>>>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>
>>>>>>> these steps would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>
>>>>>> That only happens if embedded_H never aborts its simulation of its
>>>>>> input.
>>>>>>
>>>>>> And if that happens, it can never then abort and go to Qn to be
>>>>>> 'right', as all copies of an algorithm when given the same input
>>>>>> behave the same.
>>>>>>
>>>>> The criteria that H uses is what the behavior would be if H never
>>>>> aborted the simulation of its input.
>>>>>
>>>>
>>>> Which is gthe WRONG criteria!!!!
>>>>
>>>> THe criteria NEEDS to be what is the behavior of the machine the
>>>> input represents, or of a REAL UTM given that same input.
>>>>
>>>> So, THERE'S YOUR PROBLEM!
>>>
>>> The criteria of H is whether or not the pure simulation of its input
>>> would ever reach its final state. The pure simulation of the input to
>>> embedded_H would never reach its final state.
>>
>> This was just explained to you.
>>
>> IF you actually mean this, then that means that H has to be defined as
>> never going to H.qn, as if it does, then the pure simulation of it
>> input will end up stopping in H^.qn
>>
>
> As I keep telling you and you keep stupidly ignoring the fact that the
> input stops running because its simulation was aborted is no indication
> what-so-ever that this simulated input halts. HALTING IS ONLY REACHING A
> FINAL STATE.
>

No, YOU are stupidly ignoring that it is only the simulation done by a
UTM, or the direct execution of the computation that shows halting.

The behavior of its input is UTM(<H^>,<H^>) which WILL halt and reach
its final state if H aborts its simulation and goes to H.qn

It absolutely doesn't matter what H's simulation does, since by aborting
its simulation it makes itself NOT a UTM, and thus its opinion on the
matter becomes irrelevant.

FAIL.

> You also stupidly ignore that the halt decider is only accountable for
> what the behavior of its actual input would be. It is not responsible
> for the behavior of any non-inputs.

And the behavior of its actual input is UTM(<H^>,<H^>) which will HALT
if H goes to H.qn.

FAIL.

Your STUPIDITY is exposed.

On 1/3/2022 1:48 PM, Richard Damon wrote:
> On 1/3/22 2:32 PM, olcott wrote:
>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>
>>> On 1/3/22 1:26 PM, olcott wrote:
>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>>> notation)
>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above means that the simulating halt decider H bases
>>>>>>>>>>>>>> its halt status decision on the behavior of the pure UTM
>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs
>>>>>>>>>>>>> V42 [compute the mapping]
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the pure
>>>>>>>>>>>>>> UTM simulation of the input would never reach the final
>>>>>>>>>>>>>> state of this input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>> never reach its final state thus conclusively proving that
>>>>>>>>>>>>>> this input never halts.
>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>
>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>
>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>>>>>>
>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to
>>>>>>>>>>> Qn and Halts.
>>>>>>>>>>
>>>>>>>>>> embedded_H is only accountable for mapping the behavior of the
>>>>>>>>>> pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
>>>>>>>>>
>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>> H/embedded_H must go to the state that matches the behavior of
>>>>>>>>> the Computation of H^ applied to <H^>.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG:
>>>>>>>> embedded_H must go to the state that correctly describes the
>>>>>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>
>>>>>>>> these steps would keep repeating:
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>
>>>>>>> That only happens if embedded_H never aborts its simulation of
>>>>>>> its input.
>>>>>>>
>>>>>>> And if that happens, it can never then abort and go to Qn to be
>>>>>>> 'right', as all copies of an algorithm when given the same input
>>>>>>> behave the same.
>>>>>>>
>>>>>> The criteria that H uses is what the behavior would be if H never
>>>>>> aborted the simulation of its input.
>>>>>>
>>>>>
>>>>> Which is gthe WRONG criteria!!!!
>>>>>
>>>>> THe criteria NEEDS to be what is the behavior of the machine the
>>>>> input represents, or of a REAL UTM given that same input.
>>>>>
>>>>> So, THERE'S YOUR PROBLEM!
>>>>
>>>> The criteria of H is whether or not the pure simulation of its input
>>>> would ever reach its final state. The pure simulation of the input
>>>> to embedded_H would never reach its final state.
>>>
>>> This was just explained to you.
>>>
>>> IF you actually mean this, then that means that H has to be defined
>>> as never going to H.qn, as if it does, then the pure simulation of it
>>> input will end up stopping in H^.qn
>>>
>>
>> As I keep telling you and you keep stupidly ignoring the fact that the
>> input stops running because its simulation was aborted is no
>> indication what-so-ever that this simulated input halts. HALTING IS
>> ONLY REACHING A FINAL STATE.
>>
>
> No, YOU are stupidly ignoring that it is only the simulation done by a
> UTM, or the direct execution of the computation that shows halting.
>
> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and reach
> its final state if H aborts its simulation and goes to H.qn
>

On 1/3/22 2:59 PM, olcott wrote:
> On 1/3/2022 1:48 PM, Richard Damon wrote:
>> On 1/3/22 2:32 PM, olcott wrote:
>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>
>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>>>> notation)
>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The above means that the simulating halt decider H bases
>>>>>>>>>>>>>>> its halt status decision on the behavior of the pure UTM
>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs
>>>>>>>>>>>>>> V42 [compute the mapping]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the pure
>>>>>>>>>>>>>>> UTM simulation of the input would never reach the final
>>>>>>>>>>>>>>> state of this input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>> never reach its final state thus conclusively proving
>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>
>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>
>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as claimed
>>>>>>>>>>>>
>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to
>>>>>>>>>>>> Qn and Halts.
>>>>>>>>>>>
>>>>>>>>>>> embedded_H is only accountable for mapping the behavior of
>>>>>>>>>>> the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept /
>>>>>>>>>>> reject state.
>>>>>>>>>>
>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>> H/embedded_H must go to the state that matches the behavior of
>>>>>>>>>> the Computation of H^ applied to <H^>.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG:
>>>>>>>>> embedded_H must go to the state that correctly describes the
>>>>>>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>
>>>>>>>>> these steps would keep repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>
>>>>>>>> That only happens if embedded_H never aborts its simulation of
>>>>>>>> its input.
>>>>>>>>
>>>>>>>> And if that happens, it can never then abort and go to Qn to be
>>>>>>>> 'right', as all copies of an algorithm when given the same input
>>>>>>>> behave the same.
>>>>>>>>
>>>>>>> The criteria that H uses is what the behavior would be if H never
>>>>>>> aborted the simulation of its input.
>>>>>>>
>>>>>>
>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>
>>>>>> THe criteria NEEDS to be what is the behavior of the machine the
>>>>>> input represents, or of a REAL UTM given that same input.
>>>>>>
>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>
>>>>> The criteria of H is whether or not the pure simulation of its
>>>>> input would ever reach its final state. The pure simulation of the
>>>>> input to embedded_H would never reach its final state.
>>>>
>>>> This was just explained to you.
>>>>
>>>> IF you actually mean this, then that means that H has to be defined
>>>> as never going to H.qn, as if it does, then the pure simulation of
>>>> it input will end up stopping in H^.qn
>>>>
>>>
>>> As I keep telling you and you keep stupidly ignoring the fact that
>>> the input stops running because its simulation was aborted is no
>>> indication what-so-ever that this simulated input halts. HALTING IS
>>> ONLY REACHING A FINAL STATE.
>>>
>>
>> No, YOU are stupidly ignoring that it is only the simulation done by a
>> UTM, or the direct execution of the computation that shows halting.
>>
>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and reach
>> its final state if H aborts its simulation and goes to H.qn
>>
>
> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H is
> not enough to ever reach the halting state of this input and infinity is
> the maximum now that you say that this input will reach its final state
> can only be a lie.
>
> Or are you so stupid that you believe an aborted simulation magically
> reaches the final state of this aborted simulated input?
>

On 1/3/2022 2:20 PM, Richard Damon wrote:
> On 1/3/22 2:59 PM, olcott wrote:
>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>> On 1/3/22 2:32 PM, olcott wrote:
>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>>>>> notation)
>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above means that the simulating halt decider H bases
>>>>>>>>>>>>>>>> its halt status decision on the behavior of the pure UTM
>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern it
>>>>>>>>>>>>>>>> aborts the simulation of its input and transitions to H.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem proofs
>>>>>>>>>>>>>>> V42 [compute the mapping]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the pure
>>>>>>>>>>>>>>>> UTM simulation of the input would never reach the final
>>>>>>>>>>>>>>>> state of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>> never reach its final state thus conclusively proving
>>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as
>>>>>>>>>>>>> claimed
>>>>>>>>>>>>>
>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes to
>>>>>>>>>>>>> Qn and Halts.
>>>>>>>>>>>>
>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior of
>>>>>>>>>>>> the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept /
>>>>>>>>>>>> reject state.
>>>>>>>>>>>
>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>> H/embedded_H must go to the state that matches the behavior
>>>>>>>>>>> of the Computation of H^ applied to <H^>.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WRONG:
>>>>>>>>>> embedded_H must go to the state that correctly describes the
>>>>>>>>>> behavior of the pure simulation of the input to embedded_H ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩
>>>>>>>>>>
>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That only happens if embedded_H never aborts its simulation of
>>>>>>>>> its input.
>>>>>>>>>
>>>>>>>>> And if that happens, it can never then abort and go to Qn to be
>>>>>>>>> 'right', as all copies of an algorithm when given the same
>>>>>>>>> input behave the same.
>>>>>>>>>
>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>> never aborted the simulation of its input.
>>>>>>>>
>>>>>>>
>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>
>>>>>>> THe criteria NEEDS to be what is the behavior of the machine the
>>>>>>> input represents, or of a REAL UTM given that same input.
>>>>>>>
>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>
>>>>>> The criteria of H is whether or not the pure simulation of its
>>>>>> input would ever reach its final state. The pure simulation of the
>>>>>> input to embedded_H would never reach its final state.
>>>>>
>>>>> This was just explained to you.
>>>>>
>>>>> IF you actually mean this, then that means that H has to be defined
>>>>> as never going to H.qn, as if it does, then the pure simulation of
>>>>> it input will end up stopping in H^.qn
>>>>>
>>>>
>>>> As I keep telling you and you keep stupidly ignoring the fact that
>>>> the input stops running because its simulation was aborted is no
>>>> indication what-so-ever that this simulated input halts. HALTING IS
>>>> ONLY REACHING A FINAL STATE.
>>>>
>>>
>>> No, YOU are stupidly ignoring that it is only the simulation done by
>>> a UTM, or the direct execution of the computation that shows halting.
>>>
>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and reach
>>> its final state if H aborts its simulation and goes to H.qn
>>>
>>
>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>> is not enough to ever reach the halting state of this input and
>> infinity is the maximum now that you say that this input will reach
>> its final state can only be a lie.
>>
>> Or are you so stupid that you believe an aborted simulation magically
>> reaches the final state of this aborted simulated input?
>>
>
> You Lie with Double Speak.
>
> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
> actually exist. Some times you say it will simulate forever, other times
> you say it will abort its simulation and go to H.qn. Since it can't do
> both for the same machine, it just doesn't exist. PERIDD
>

On 1/3/22 3:30 PM, olcott wrote:
> On 1/3/2022 2:20 PM, Richard Damon wrote:
>> On 1/3/22 2:59 PM, olcott wrote:
>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of the
>>>>>>>>>>>>>>>>> pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern
>>>>>>>>>>>>>>>>> it aborts the simulation of its input and transitions
>>>>>>>>>>>>>>>>> to H.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the pure
>>>>>>>>>>>>>>>>> UTM simulation of the input would never reach the final
>>>>>>>>>>>>>>>>> state of this input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>> never reach its final state thus conclusively proving
>>>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as
>>>>>>>>>>>>>> claimed
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes
>>>>>>>>>>>>>> to Qn and Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior of
>>>>>>>>>>>>> the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept /
>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>> H/embedded_H must go to the state that matches the behavior
>>>>>>>>>>>> of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WRONG:
>>>>>>>>>>> embedded_H must go to the state that correctly describes the
>>>>>>>>>>> behavior of the pure simulation of the input to embedded_H
>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>
>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That only happens if embedded_H never aborts its simulation of
>>>>>>>>>> its input.
>>>>>>>>>>
>>>>>>>>>> And if that happens, it can never then abort and go to Qn to
>>>>>>>>>> be 'right', as all copies of an algorithm when given the same
>>>>>>>>>> input behave the same.
>>>>>>>>>>
>>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>
>>>>>>>> THe criteria NEEDS to be what is the behavior of the machine the
>>>>>>>> input represents, or of a REAL UTM given that same input.
>>>>>>>>
>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>
>>>>>>> The criteria of H is whether or not the pure simulation of its
>>>>>>> input would ever reach its final state. The pure simulation of
>>>>>>> the input to embedded_H would never reach its final state.
>>>>>>
>>>>>> This was just explained to you.
>>>>>>
>>>>>> IF you actually mean this, then that means that H has to be
>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>
>>>>>
>>>>> As I keep telling you and you keep stupidly ignoring the fact that
>>>>> the input stops running because its simulation was aborted is no
>>>>> indication what-so-ever that this simulated input halts. HALTING IS
>>>>> ONLY REACHING A FINAL STATE.
>>>>>
>>>>
>>>> No, YOU are stupidly ignoring that it is only the simulation done by
>>>> a UTM, or the direct execution of the computation that shows halting.
>>>>
>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>
>>>
>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>> is not enough to ever reach the halting state of this input and
>>> infinity is the maximum now that you say that this input will reach
>>> its final state can only be a lie.
>>>
>>> Or are you so stupid that you believe an aborted simulation magically
>>> reaches the final state of this aborted simulated input?
>>>
>>
>> You Lie with Double Speak.
>>
>> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
>> actually exist. Some times you say it will simulate forever, other
>> times you say it will abort its simulation and go to H.qn. Since it
>> can't do both for the same machine, it just doesn't exist. PERIDD
>>
>
> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING KNUCKLEHEAD
>
> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS SIMULATION
> AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN IF EMBEDDED_H
> SIMULATED ITS INPUT FOREVER.
>
>

On 1/3/2022 2:54 PM, Richard Damon wrote:
> On 1/3/22 3:30 PM, olcott wrote:
>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>> On 1/3/22 2:59 PM, olcott wrote:
>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of the
>>>>>>>>>>>>>>>>>> pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite behavior
>>>>>>>>>>>>>>>>>> patterns. When H detects an infinite behavior pattern
>>>>>>>>>>>>>>>>>> it aborts the simulation of its input and transitions
>>>>>>>>>>>>>>>>>> to H.qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the
>>>>>>>>>>>>>>>>>> pure UTM simulation of the input would never reach the
>>>>>>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>> never reach its final state thus conclusively proving
>>>>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as
>>>>>>>>>>>>>>> claimed
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes
>>>>>>>>>>>>>>> to Qn and Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior of
>>>>>>>>>>>>>> the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept /
>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>>> H/embedded_H must go to the state that matches the behavior
>>>>>>>>>>>>> of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG:
>>>>>>>>>>>> embedded_H must go to the state that correctly describes the
>>>>>>>>>>>> behavior of the pure simulation of the input to embedded_H
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>
>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That only happens if embedded_H never aborts its simulation
>>>>>>>>>>> of its input.
>>>>>>>>>>>
>>>>>>>>>>> And if that happens, it can never then abort and go to Qn to
>>>>>>>>>>> be 'right', as all copies of an algorithm when given the same
>>>>>>>>>>> input behave the same.
>>>>>>>>>>>
>>>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>
>>>>>>>>> THe criteria NEEDS to be what is the behavior of the machine
>>>>>>>>> the input represents, or of a REAL UTM given that same input.
>>>>>>>>>
>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>
>>>>>>>> The criteria of H is whether or not the pure simulation of its
>>>>>>>> input would ever reach its final state. The pure simulation of
>>>>>>>> the input to embedded_H would never reach its final state.
>>>>>>>
>>>>>>> This was just explained to you.
>>>>>>>
>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>
>>>>>>
>>>>>> As I keep telling you and you keep stupidly ignoring the fact that
>>>>>> the input stops running because its simulation was aborted is no
>>>>>> indication what-so-ever that this simulated input halts. HALTING
>>>>>> IS ONLY REACHING A FINAL STATE.
>>>>>>
>>>>>
>>>>> No, YOU are stupidly ignoring that it is only the simulation done
>>>>> by a UTM, or the direct execution of the computation that shows
>>>>> halting.
>>>>>
>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>>
>>>>
>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>> is not enough to ever reach the halting state of this input and
>>>> infinity is the maximum now that you say that this input will reach
>>>> its final state can only be a lie.
>>>>
>>>> Or are you so stupid that you believe an aborted simulation
>>>> magically reaches the final state of this aborted simulated input?
>>>>
>>>
>>> You Lie with Double Speak.
>>>
>>> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
>>> actually exist. Some times you say it will simulate forever, other
>>> times you say it will abort its simulation and go to H.qn. Since it
>>> can't do both for the same machine, it just doesn't exist. PERIDD
>>>
>>
>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>> KNUCKLEHEAD
>>
>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN IF
>> EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>
>>
>
> Since H/embedded_H WON'T simulate forever (by your criteria) you can't
> just imagine that it does, as that is a false premise.
>
> That would be like saying that since if your cat was a dog, it could
> bark, that means that cats can bark.
>
> This applies since you are claiming GLOBAL change of the definition of
> H, to the point of changing the representation of H^ to include that
> 'hypothetical H'.
>
> You COULD say, "if I changed THIS COPY of H/embedded_H to not abort",
> but kept all the copies in the input as there original aborting version.
> We can do this, because that is just asking what would a UTM do on the
> same input, by replacing THIS copy with a UTM to check the answer.
>
> Summary:
>
> What would happen if H never aborted it simulation, NOT VALID, as H
> doesn't behave that way so this is a contradiction, so do this you need
> to change the input.
>

On 1/3/22 4:04 PM, olcott wrote:
> On 1/3/2022 2:54 PM, Richard Damon wrote:
>> On 1/3/22 3:30 PM, olcott wrote:
>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of the
>>>>>>>>>>>>>>>>>>> pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the
>>>>>>>>>>>>>>>>>>> pure UTM simulation of the input would never reach
>>>>>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>>> never reach its final state thus conclusively proving
>>>>>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as
>>>>>>>>>>>>>>>> claimed
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes
>>>>>>>>>>>>>>>> to Qn and Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior
>>>>>>>>>>>>>>> of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept
>>>>>>>>>>>>>>> / reject state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>>>> H/embedded_H must go to the state that matches the
>>>>>>>>>>>>>> behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>> embedded_H must go to the state that correctly describes
>>>>>>>>>>>>> the behavior of the pure simulation of the input to
>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>
>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That only happens if embedded_H never aborts its simulation
>>>>>>>>>>>> of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> And if that happens, it can never then abort and go to Qn to
>>>>>>>>>>>> be 'right', as all copies of an algorithm when given the
>>>>>>>>>>>> same input behave the same.
>>>>>>>>>>>>
>>>>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>
>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the machine
>>>>>>>>>> the input represents, or of a REAL UTM given that same input.
>>>>>>>>>>
>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>
>>>>>>>>> The criteria of H is whether or not the pure simulation of its
>>>>>>>>> input would ever reach its final state. The pure simulation of
>>>>>>>>> the input to embedded_H would never reach its final state.
>>>>>>>>
>>>>>>>> This was just explained to you.
>>>>>>>>
>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>>
>>>>>>>
>>>>>>> As I keep telling you and you keep stupidly ignoring the fact
>>>>>>> that the input stops running because its simulation was aborted
>>>>>>> is no indication what-so-ever that this simulated input halts.
>>>>>>> HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>
>>>>>>
>>>>>> No, YOU are stupidly ignoring that it is only the simulation done
>>>>>> by a UTM, or the direct execution of the computation that shows
>>>>>> halting.
>>>>>>
>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>>>
>>>>>
>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>> embedded_H is not enough to ever reach the halting state of this
>>>>> input and infinity is the maximum now that you say that this input
>>>>> will reach its final state can only be a lie.
>>>>>
>>>>> Or are you so stupid that you believe an aborted simulation
>>>>> magically reaches the final state of this aborted simulated input?
>>>>>
>>>>
>>>> You Lie with Double Speak.
>>>>
>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
>>>> actually exist. Some times you say it will simulate forever, other
>>>> times you say it will abort its simulation and go to H.qn. Since it
>>>> can't do both for the same machine, it just doesn't exist. PERIDD
>>>>
>>>
>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>> KNUCKLEHEAD
>>>
>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN IF
>>> EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>
>>>
>>
>> Since H/embedded_H WON'T simulate forever (by your criteria) you can't
>> just imagine that it does, as that is a false premise.
>>
>> That would be like saying that since if your cat was a dog, it could
>> bark, that means that cats can bark.
>>
>> This applies since you are claiming GLOBAL change of the definition of
>> H, to the point of changing the representation of H^ to include that
>> 'hypothetical H'.
>>
>> You COULD say, "if I changed THIS COPY of H/embedded_H to not abort",
>> but kept all the copies in the input as there original aborting
>> version. We can do this, because that is just asking what would a UTM
>> do on the same input, by replacing THIS copy with a UTM to check the
>> answer.
>>
>> Summary:
>>
>> What would happen if H never aborted it simulation, NOT VALID, as H
>> doesn't behave that way so this is a contradiction, so do this you
>> need to change the input.
>>
>
> void Infinite_Loop(int N)
> {
>   HERE: goto HERE;
> }
>  _Infinite_Loop()
> [00000cb5](01)  55              push ebp
> [00000cb6](02)  8bec            mov ebp,esp
> [00000cb8](02)  ebfe            jmp 00000cb8
> [00000cba](01)  5d              pop ebp
> [00000cbb](01)  c3              ret
> Size in bytes:(0007) [00000cbb]
>
> H can see what the behavior of the above would be if H never aborted the
> simulation of this input.
>
> That you say that H can not do his has to be dishonest because you are
> not that stupid.
>

On 1/3/2022 3:29 PM, Richard Damon wrote:
> On 1/3/22 4:04 PM, olcott wrote:
>> On 1/3/2022 2:54 PM, Richard Damon wrote:
>>> On 1/3/22 3:30 PM, olcott wrote:
>>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of
>>>>>>>>>>>>>>>>>>>> the pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the
>>>>>>>>>>>>>>>>>>>> pure UTM simulation of the input would never reach
>>>>>>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H
>>>>>>>>>>>>>>>>>>>> at Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> would never reach its final state thus conclusively
>>>>>>>>>>>>>>>>>>>> proving that this input never halts.
>>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to
>>>>>>>>>>>>>>>>>>>> Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as
>>>>>>>>>>>>>>>>> claimed
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also
>>>>>>>>>>>>>>>>> goes to Qn and Halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior
>>>>>>>>>>>>>>>> of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept
>>>>>>>>>>>>>>>> / reject state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>>>>> H/embedded_H must go to the state that matches the
>>>>>>>>>>>>>>> behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>>> embedded_H must go to the state that correctly describes
>>>>>>>>>>>>>> the behavior of the pure simulation of the input to
>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That only happens if embedded_H never aborts its simulation
>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And if that happens, it can never then abort and go to Qn
>>>>>>>>>>>>> to be 'right', as all copies of an algorithm when given the
>>>>>>>>>>>>> same input behave the same.
>>>>>>>>>>>>>
>>>>>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>>
>>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the machine
>>>>>>>>>>> the input represents, or of a REAL UTM given that same input.
>>>>>>>>>>>
>>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>>
>>>>>>>>>> The criteria of H is whether or not the pure simulation of its
>>>>>>>>>> input would ever reach its final state. The pure simulation of
>>>>>>>>>> the input to embedded_H would never reach its final state.
>>>>>>>>>
>>>>>>>>> This was just explained to you.
>>>>>>>>>
>>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>>>
>>>>>>>>
>>>>>>>> As I keep telling you and you keep stupidly ignoring the fact
>>>>>>>> that the input stops running because its simulation was aborted
>>>>>>>> is no indication what-so-ever that this simulated input halts.
>>>>>>>> HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>>
>>>>>>>
>>>>>>> No, YOU are stupidly ignoring that it is only the simulation done
>>>>>>> by a UTM, or the direct execution of the computation that shows
>>>>>>> halting.
>>>>>>>
>>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>>>>
>>>>>>
>>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>> embedded_H is not enough to ever reach the halting state of this
>>>>>> input and infinity is the maximum now that you say that this input
>>>>>> will reach its final state can only be a lie.
>>>>>>
>>>>>> Or are you so stupid that you believe an aborted simulation
>>>>>> magically reaches the final state of this aborted simulated input?
>>>>>>
>>>>>
>>>>> You Lie with Double Speak.
>>>>>
>>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
>>>>> actually exist. Some times you say it will simulate forever, other
>>>>> times you say it will abort its simulation and go to H.qn. Since it
>>>>> can't do both for the same machine, it just doesn't exist. PERIDD
>>>>>
>>>>
>>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>>> KNUCKLEHEAD
>>>>
>>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN
>>>> IF EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>>
>>>>
>>>
>>> Since H/embedded_H WON'T simulate forever (by your criteria) you
>>> can't just imagine that it does, as that is a false premise.
>>>
>>> That would be like saying that since if your cat was a dog, it could
>>> bark, that means that cats can bark.
>>>
>>> This applies since you are claiming GLOBAL change of the definition
>>> of H, to the point of changing the representation of H^ to include
>>> that 'hypothetical H'.
>>>
>>> You COULD say, "if I changed THIS COPY of H/embedded_H to not abort",
>>> but kept all the copies in the input as there original aborting
>>> version. We can do this, because that is just asking what would a UTM
>>> do on the same input, by replacing THIS copy with a UTM to check the
>>> answer.
>>>
>>> Summary:
>>>
>>> What would happen if H never aborted it simulation, NOT VALID, as H
>>> doesn't behave that way so this is a contradiction, so do this you
>>> need to change the input.
>>>
>>
>> void Infinite_Loop(int N)
>> {
>>    HERE: goto HERE;
>> }
>>   _Infinite_Loop()
>> [00000cb5](01)  55              push ebp
>> [00000cb6](02)  8bec            mov ebp,esp
>> [00000cb8](02)  ebfe            jmp 00000cb8
>> [00000cba](01)  5d              pop ebp
>> [00000cbb](01)  c3              ret
>> Size in bytes:(0007) [00000cbb]
>>
>> H can see what the behavior of the above would be if H never aborted
>> the simulation of this input.
>>
>> That you say that H can not do his has to be dishonest because you are
>> not that stupid.
>>
>
> RED HERRING.
>
> H can correctly determine SOME machines, but NOT H^, so it FAILS.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

On 1/3/22 4:43 PM, olcott wrote:
> On 1/3/2022 3:29 PM, Richard Damon wrote:
>> On 1/3/22 4:04 PM, olcott wrote:
>>> On 1/3/2022 2:54 PM, Richard Damon wrote:
>>>> On 1/3/22 3:30 PM, olcott wrote:
>>>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of
>>>>>>>>>>>>>>>>>>>>> the pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the
>>>>>>>>>>>>>>>>>>>>> pure UTM simulation of the input would never reach
>>>>>>>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H
>>>>>>>>>>>>>>>>>>>>> at Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> would never reach its final state thus conclusively
>>>>>>>>>>>>>>>>>>>>> proving that this input never halts.
>>>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to
>>>>>>>>>>>>>>>>>>>>> Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn
>>>>>>>>>>>>>>>>>> as claimed
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also
>>>>>>>>>>>>>>>>>> goes to Qn and Halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior
>>>>>>>>>>>>>>>>> of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an
>>>>>>>>>>>>>>>>> accept / reject state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>>>>>> H/embedded_H must go to the state that matches the
>>>>>>>>>>>>>>>> behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>>>> embedded_H must go to the state that correctly describes
>>>>>>>>>>>>>>> the behavior of the pure simulation of the input to
>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That only happens if embedded_H never aborts its
>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And if that happens, it can never then abort and go to Qn
>>>>>>>>>>>>>> to be 'right', as all copies of an algorithm when given
>>>>>>>>>>>>>> the same input behave the same.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>>>
>>>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the machine
>>>>>>>>>>>> the input represents, or of a REAL UTM given that same input.
>>>>>>>>>>>>
>>>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>>>
>>>>>>>>>>> The criteria of H is whether or not the pure simulation of
>>>>>>>>>>> its input would ever reach its final state. The pure
>>>>>>>>>>> simulation of the input to embedded_H would never reach its
>>>>>>>>>>> final state.
>>>>>>>>>>
>>>>>>>>>> This was just explained to you.
>>>>>>>>>>
>>>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> As I keep telling you and you keep stupidly ignoring the fact
>>>>>>>>> that the input stops running because its simulation was aborted
>>>>>>>>> is no indication what-so-ever that this simulated input halts.
>>>>>>>>> HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, YOU are stupidly ignoring that it is only the simulation
>>>>>>>> done by a UTM, or the direct execution of the computation that
>>>>>>>> shows halting.
>>>>>>>>
>>>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>>>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>>>>>
>>>>>>>
>>>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>> embedded_H is not enough to ever reach the halting state of this
>>>>>>> input and infinity is the maximum now that you say that this
>>>>>>> input will reach its final state can only be a lie.
>>>>>>>
>>>>>>> Or are you so stupid that you believe an aborted simulation
>>>>>>> magically reaches the final state of this aborted simulated input?
>>>>>>>
>>>>>>
>>>>>> You Lie with Double Speak.
>>>>>>
>>>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
>>>>>> actually exist. Some times you say it will simulate forever, other
>>>>>> times you say it will abort its simulation and go to H.qn. Since
>>>>>> it can't do both for the same machine, it just doesn't exist. PERIDD
>>>>>>
>>>>>
>>>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>>>> KNUCKLEHEAD
>>>>>
>>>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN
>>>>> IF EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>>>
>>>>>
>>>>
>>>> Since H/embedded_H WON'T simulate forever (by your criteria) you
>>>> can't just imagine that it does, as that is a false premise.
>>>>
>>>> That would be like saying that since if your cat was a dog, it could
>>>> bark, that means that cats can bark.
>>>>
>>>> This applies since you are claiming GLOBAL change of the definition
>>>> of H, to the point of changing the representation of H^ to include
>>>> that 'hypothetical H'.
>>>>
>>>> You COULD say, "if I changed THIS COPY of H/embedded_H to not
>>>> abort", but kept all the copies in the input as there original
>>>> aborting version. We can do this, because that is just asking what
>>>> would a UTM do on the same input, by replacing THIS copy with a UTM
>>>> to check the answer.
>>>>
>>>> Summary:
>>>>
>>>> What would happen if H never aborted it simulation, NOT VALID, as H
>>>> doesn't behave that way so this is a contradiction, so do this you
>>>> need to change the input.
>>>>
>>>
>>> void Infinite_Loop(int N)
>>> {
>>>    HERE: goto HERE;
>>> }
>>>   _Infinite_Loop()
>>> [00000cb5](01)  55              push ebp
>>> [00000cb6](02)  8bec            mov ebp,esp
>>> [00000cb8](02)  ebfe            jmp 00000cb8
>>> [00000cba](01)  5d              pop ebp
>>> [00000cbb](01)  c3              ret
>>> Size in bytes:(0007) [00000cbb]
>>>
>>> H can see what the behavior of the above would be if H never aborted
>>> the simulation of this input.
>>>
>>> That you say that H can not do his has to be dishonest because you
>>> are not that stupid.
>>>
>>
>> RED HERRING.
>>
>> H can correctly determine SOME machines, but NOT H^, so it FAILS.
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
> this input would never reach a final state and stop running.
>
> These steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> Since humans can see the above infinitely repeating pattern this is
> complete proof that recognizing this infinitely repeating pattern is not
> impossible, thus when you say it is impossible you lie.
>

On 1/3/2022 3:59 PM, Richard Damon wrote:
> On 1/3/22 4:43 PM, olcott wrote:
>> On 1/3/2022 3:29 PM, Richard Damon wrote:
>>> On 1/3/22 4:04 PM, olcott wrote:
>>>> On 1/3/2022 2:54 PM, Richard Damon wrote:
>>>>> On 1/3/22 3:30 PM, olcott wrote:
>>>>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of
>>>>>>>>>>>>>>>>>>>>>> the pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the
>>>>>>>>>>>>>>>>>>>>>> pure UTM simulation of the input would never reach
>>>>>>>>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H
>>>>>>>>>>>>>>>>>>>>>> at Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>>>>>>>>>>>>>>>>>> would keep repeating:
>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> would never reach its final state thus
>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to
>>>>>>>>>>>>>>>>>>>>>> Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give
>>>>>>>>>>>>>>>>>>> a rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn
>>>>>>>>>>>>>>>>>>> as claimed
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also
>>>>>>>>>>>>>>>>>>> goes to Qn and Halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the
>>>>>>>>>>>>>>>>>> behavior of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> to an accept / reject state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>>>>>>> H/embedded_H must go to the state that matches the
>>>>>>>>>>>>>>>>> behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>>>>> embedded_H must go to the state that correctly describes
>>>>>>>>>>>>>>>> the behavior of the pure simulation of the input to
>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That only happens if embedded_H never aborts its
>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And if that happens, it can never then abort and go to Qn
>>>>>>>>>>>>>>> to be 'right', as all copies of an algorithm when given
>>>>>>>>>>>>>>> the same input behave the same.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The criteria that H uses is what the behavior would be if
>>>>>>>>>>>>>> H never aborted the simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>>>>
>>>>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the
>>>>>>>>>>>>> machine the input represents, or of a REAL UTM given that
>>>>>>>>>>>>> same input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>>>>
>>>>>>>>>>>> The criteria of H is whether or not the pure simulation of
>>>>>>>>>>>> its input would ever reach its final state. The pure
>>>>>>>>>>>> simulation of the input to embedded_H would never reach its
>>>>>>>>>>>> final state.
>>>>>>>>>>>
>>>>>>>>>>> This was just explained to you.
>>>>>>>>>>>
>>>>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> As I keep telling you and you keep stupidly ignoring the fact
>>>>>>>>>> that the input stops running because its simulation was
>>>>>>>>>> aborted is no indication what-so-ever that this simulated
>>>>>>>>>> input halts. HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, YOU are stupidly ignoring that it is only the simulation
>>>>>>>>> done by a UTM, or the direct execution of the computation that
>>>>>>>>> shows halting.
>>>>>>>>>
>>>>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>>>>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>>>>>>
>>>>>>>>
>>>>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>> embedded_H is not enough to ever reach the halting state of this
>>>>>>>> input and infinity is the maximum now that you say that this
>>>>>>>> input will reach its final state can only be a lie.
>>>>>>>>
>>>>>>>> Or are you so stupid that you believe an aborted simulation
>>>>>>>> magically reaches the final state of this aborted simulated input?
>>>>>>>>
>>>>>>>
>>>>>>> You Lie with Double Speak.
>>>>>>>
>>>>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which
>>>>>>> doesn't actually exist. Some times you say it will simulate
>>>>>>> forever, other times you say it will abort its simulation and go
>>>>>>> to H.qn. Since it can't do both for the same machine, it just
>>>>>>> doesn't exist. PERIDD
>>>>>>>
>>>>>>
>>>>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>>>>> KNUCKLEHEAD
>>>>>>
>>>>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>>>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN
>>>>>> IF EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>>>>
>>>>>>
>>>>>
>>>>> Since H/embedded_H WON'T simulate forever (by your criteria) you
>>>>> can't just imagine that it does, as that is a false premise.
>>>>>
>>>>> That would be like saying that since if your cat was a dog, it
>>>>> could bark, that means that cats can bark.
>>>>>
>>>>> This applies since you are claiming GLOBAL change of the definition
>>>>> of H, to the point of changing the representation of H^ to include
>>>>> that 'hypothetical H'.
>>>>>
>>>>> You COULD say, "if I changed THIS COPY of H/embedded_H to not
>>>>> abort", but kept all the copies in the input as there original
>>>>> aborting version. We can do this, because that is just asking what
>>>>> would a UTM do on the same input, by replacing THIS copy with a UTM
>>>>> to check the answer.
>>>>>
>>>>> Summary:
>>>>>
>>>>> What would happen if H never aborted it simulation, NOT VALID, as H
>>>>> doesn't behave that way so this is a contradiction, so do this you
>>>>> need to change the input.
>>>>>
>>>>
>>>> void Infinite_Loop(int N)
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>>   _Infinite_Loop()
>>>> [00000cb5](01)  55              push ebp
>>>> [00000cb6](02)  8bec            mov ebp,esp
>>>> [00000cb8](02)  ebfe            jmp 00000cb8
>>>> [00000cba](01)  5d              pop ebp
>>>> [00000cbb](01)  c3              ret
>>>> Size in bytes:(0007) [00000cbb]
>>>>
>>>> H can see what the behavior of the above would be if H never aborted
>>>> the simulation of this input.
>>>>
>>>> That you say that H can not do his has to be dishonest because you
>>>> are not that stupid.
>>>>
>>>
>>> RED HERRING.
>>>
>>> H can correctly determine SOME machines, but NOT H^, so it FAILS.
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>> this input would never reach a final state and stop running.
>>
>> These steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> Since humans can see the above infinitely repeating pattern this is
>> complete proof that recognizing this infinitely repeating pattern is
>> not impossible, thus when you say it is impossible you lie.
>>
>
> You keep getting stuck in your Schrodinger Turing Machine.
>
> Yes, IF H is DEFINED in a way that doesn't abort its simulation, (give
> this H the name Hn), then the H^ derived from it (call it Hn^) will not
> halt, but H never gives an answer to question Hn <Hn^> <Hn^> so it fails
> to be the needed decider.
Every simulating halt decider must recognize infinite behavior patterns.

On 1/3/22 5:20 PM, olcott wrote:
> On 1/3/2022 3:59 PM, Richard Damon wrote:
>> On 1/3/22 4:43 PM, olcott wrote:
>>> On 1/3/2022 3:29 PM, Richard Damon wrote:
>>>> On 1/3/22 4:04 PM, olcott wrote:
>>>>> On 1/3/2022 2:54 PM, Richard Damon wrote:
>>>>>> On 1/3/22 3:30 PM, olcott wrote:
>>>>>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>>>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My
>>>>>>>>>>>>>>>>>>>>>>> criteria Ben's notation)
>>>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>> H bases its halt status decision on the behavior
>>>>>>>>>>>>>>>>>>>>>>> of the pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the
>>>>>>>>>>>>>>>>>>>>>>> the pure UTM simulation of the input would never
>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz
>>>>>>>>>>>>>>>>>>>>>>> H at Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>>>>>>>>>>>>>>>>>>> would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> would never reach its final state thus
>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition
>>>>>>>>>>>>>>>>>>>>>>> to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give
>>>>>>>>>>>>>>>>>>>> a rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn
>>>>>>>>>>>>>>>>>>>> as claimed
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also
>>>>>>>>>>>>>>>>>>>> goes to Qn and Halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the
>>>>>>>>>>>>>>>>>>> behavior of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> to an accept / reject state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^>
>>>>>>>>>>>>>>>>>> then H/embedded_H must go to the state that matches
>>>>>>>>>>>>>>>>>> the behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>>>>>> embedded_H must go to the state that correctly
>>>>>>>>>>>>>>>>> describes the behavior of the pure simulation of the
>>>>>>>>>>>>>>>>> input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That only happens if embedded_H never aborts its
>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And if that happens, it can never then abort and go to
>>>>>>>>>>>>>>>> Qn to be 'right', as all copies of an algorithm when
>>>>>>>>>>>>>>>> given the same input behave the same.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The criteria that H uses is what the behavior would be if
>>>>>>>>>>>>>>> H never aborted the simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the
>>>>>>>>>>>>>> machine the input represents, or of a REAL UTM given that
>>>>>>>>>>>>>> same input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>>>>>
>>>>>>>>>>>>> The criteria of H is whether or not the pure simulation of
>>>>>>>>>>>>> its input would ever reach its final state. The pure
>>>>>>>>>>>>> simulation of the input to embedded_H would never reach its
>>>>>>>>>>>>> final state.
>>>>>>>>>>>>
>>>>>>>>>>>> This was just explained to you.
>>>>>>>>>>>>
>>>>>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> As I keep telling you and you keep stupidly ignoring the fact
>>>>>>>>>>> that the input stops running because its simulation was
>>>>>>>>>>> aborted is no indication what-so-ever that this simulated
>>>>>>>>>>> input halts. HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, YOU are stupidly ignoring that it is only the simulation
>>>>>>>>>> done by a UTM, or the direct execution of the computation that
>>>>>>>>>> shows halting.
>>>>>>>>>>
>>>>>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt
>>>>>>>>>> and reach its final state if H aborts its simulation and goes
>>>>>>>>>> to H.qn
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>> embedded_H is not enough to ever reach the halting state of
>>>>>>>>> this input and infinity is the maximum now that you say that
>>>>>>>>> this input will reach its final state can only be a lie.
>>>>>>>>>
>>>>>>>>> Or are you so stupid that you believe an aborted simulation
>>>>>>>>> magically reaches the final state of this aborted simulated input?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You Lie with Double Speak.
>>>>>>>>
>>>>>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which
>>>>>>>> doesn't actually exist. Some times you say it will simulate
>>>>>>>> forever, other times you say it will abort its simulation and go
>>>>>>>> to H.qn. Since it can't do both for the same machine, it just
>>>>>>>> doesn't exist. PERIDD
>>>>>>>>
>>>>>>>
>>>>>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>>>>>> KNUCKLEHEAD
>>>>>>>
>>>>>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>>>>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD
>>>>>>> HAPPEN IF EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Since H/embedded_H WON'T simulate forever (by your criteria) you
>>>>>> can't just imagine that it does, as that is a false premise.
>>>>>>
>>>>>> That would be like saying that since if your cat was a dog, it
>>>>>> could bark, that means that cats can bark.
>>>>>>
>>>>>> This applies since you are claiming GLOBAL change of the
>>>>>> definition of H, to the point of changing the representation of H^
>>>>>> to include that 'hypothetical H'.
>>>>>>
>>>>>> You COULD say, "if I changed THIS COPY of H/embedded_H to not
>>>>>> abort", but kept all the copies in the input as there original
>>>>>> aborting version. We can do this, because that is just asking what
>>>>>> would a UTM do on the same input, by replacing THIS copy with a
>>>>>> UTM to check the answer.
>>>>>>
>>>>>> Summary:
>>>>>>
>>>>>> What would happen if H never aborted it simulation, NOT VALID, as
>>>>>> H doesn't behave that way so this is a contradiction, so do this
>>>>>> you need to change the input.
>>>>>>
>>>>>
>>>>> void Infinite_Loop(int N)
>>>>> {
>>>>>    HERE: goto HERE;
>>>>> }
>>>>>   _Infinite_Loop()
>>>>> [00000cb5](01)  55              push ebp
>>>>> [00000cb6](02)  8bec            mov ebp,esp
>>>>> [00000cb8](02)  ebfe            jmp 00000cb8
>>>>> [00000cba](01)  5d              pop ebp
>>>>> [00000cbb](01)  c3              ret
>>>>> Size in bytes:(0007) [00000cbb]
>>>>>
>>>>> H can see what the behavior of the above would be if H never
>>>>> aborted the simulation of this input.
>>>>>
>>>>> That you say that H can not do his has to be dishonest because you
>>>>> are not that stupid.
>>>>>
>>>>
>>>> RED HERRING.
>>>>
>>>> H can correctly determine SOME machines, but NOT H^, so it FAILS.
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>> this input would never reach a final state and stop running.
>>>
>>> These steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> Since humans can see the above infinitely repeating pattern this is
>>> complete proof that recognizing this infinitely repeating pattern is
>>> not impossible, thus when you say it is impossible you lie.
>>>
>>
>> You keep getting stuck in your Schrodinger Turing Machine.
>>
>> Yes, IF H is DEFINED in a way that doesn't abort its simulation, (give
>> this H the name Hn), then the H^ derived from it (call it Hn^) will
>> not halt, but H never gives an answer to question Hn <Hn^> <Hn^> so it
>> fails to be the needed decider.
> Every simulating halt decider must recognize infinite behavior patterns.
>
> All of these patterns have the same thing in common the simulated input
> would never reach is final state even if infinitely simulated.
>
> As I have told you at least fifty times (and you make sure to keep
> forgetting) this does not mean that H simulates its input forever.
>
> H merely recognizes that if it would simulate its input forever that
> this input would never reach its final state.
>
> Since aborting the simulation of an input that would never reach its
> final state does not cause an input to reach its final state all of
> these aborted simulations remain computations that never halt even after
> they have been aborted.
>
> This works the same way for infinite loops infinite recursion and
> infinitely nested simulation.
>

On 1/3/2022 5:03 PM, Richard Damon wrote:
> On 1/3/22 5:20 PM, olcott wrote:
>> On 1/3/2022 3:59 PM, Richard Damon wrote:
>>> On 1/3/22 4:43 PM, olcott wrote:
>>>> On 1/3/2022 3:29 PM, Richard Damon wrote:
>>>>> On 1/3/22 4:04 PM, olcott wrote:
>>>>>> On 1/3/2022 2:54 PM, Richard Damon wrote:
>>>>>>> On 1/3/22 3:30 PM, olcott wrote:
>>>>>>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>>>>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>>>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My
>>>>>>>>>>>>>>>>>>>>>>>> criteria Ben's notation)
>>>>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>> H bases its halt status decision on the behavior
>>>>>>>>>>>>>>>>>>>>>>>> of the pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting
>>>>>>>>>>>>>>>>>>>>>>> problem proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the
>>>>>>>>>>>>>>>>>>>>>>>> the pure UTM simulation of the input would never
>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz
>>>>>>>>>>>>>>>>>>>>>>>> H at Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>>>>>>>>>>>>>>>>>>>> would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final state thus
>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition
>>>>>>>>>>>>>>>>>>>>>>>> to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to
>>>>>>>>>>>>>>>>>>>>> give a rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to
>>>>>>>>>>>>>>>>>>>>> Qn as claimed
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also
>>>>>>>>>>>>>>>>>>>>> goes to Qn and Halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the
>>>>>>>>>>>>>>>>>>>> behavior of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> to an accept / reject state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^>
>>>>>>>>>>>>>>>>>>> then H/embedded_H must go to the state that matches
>>>>>>>>>>>>>>>>>>> the behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>>>>>>> embedded_H must go to the state that correctly
>>>>>>>>>>>>>>>>>> describes the behavior of the pure simulation of the
>>>>>>>>>>>>>>>>>> input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That only happens if embedded_H never aborts its
>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And if that happens, it can never then abort and go to
>>>>>>>>>>>>>>>>> Qn to be 'right', as all copies of an algorithm when
>>>>>>>>>>>>>>>>> given the same input behave the same.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The criteria that H uses is what the behavior would be
>>>>>>>>>>>>>>>> if H never aborted the simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the
>>>>>>>>>>>>>>> machine the input represents, or of a REAL UTM given that
>>>>>>>>>>>>>>> same input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The criteria of H is whether or not the pure simulation of
>>>>>>>>>>>>>> its input would ever reach its final state. The pure
>>>>>>>>>>>>>> simulation of the input to embedded_H would never reach
>>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This was just explained to you.
>>>>>>>>>>>>>
>>>>>>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>>>>>>> defined as never going to H.qn, as if it does, then the
>>>>>>>>>>>>> pure simulation of it input will end up stopping in H^.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> As I keep telling you and you keep stupidly ignoring the
>>>>>>>>>>>> fact that the input stops running because its simulation was
>>>>>>>>>>>> aborted is no indication what-so-ever that this simulated
>>>>>>>>>>>> input halts. HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, YOU are stupidly ignoring that it is only the simulation
>>>>>>>>>>> done by a UTM, or the direct execution of the computation
>>>>>>>>>>> that shows halting.
>>>>>>>>>>>
>>>>>>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt
>>>>>>>>>>> and reach its final state if H aborts its simulation and goes
>>>>>>>>>>> to H.qn
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>> embedded_H is not enough to ever reach the halting state of
>>>>>>>>>> this input and infinity is the maximum now that you say that
>>>>>>>>>> this input will reach its final state can only be a lie.
>>>>>>>>>>
>>>>>>>>>> Or are you so stupid that you believe an aborted simulation
>>>>>>>>>> magically reaches the final state of this aborted simulated
>>>>>>>>>> input?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You Lie with Double Speak.
>>>>>>>>>
>>>>>>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which
>>>>>>>>> doesn't actually exist. Some times you say it will simulate
>>>>>>>>> forever, other times you say it will abort its simulation and
>>>>>>>>> go to H.qn. Since it can't do both for the same machine, it
>>>>>>>>> just doesn't exist. PERIDD
>>>>>>>>>
>>>>>>>>
>>>>>>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>>>>>>> KNUCKLEHEAD
>>>>>>>>
>>>>>>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>>>>>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD
>>>>>>>> HAPPEN IF EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Since H/embedded_H WON'T simulate forever (by your criteria) you
>>>>>>> can't just imagine that it does, as that is a false premise.
>>>>>>>
>>>>>>> That would be like saying that since if your cat was a dog, it
>>>>>>> could bark, that means that cats can bark.
>>>>>>>
>>>>>>> This applies since you are claiming GLOBAL change of the
>>>>>>> definition of H, to the point of changing the representation of
>>>>>>> H^ to include that 'hypothetical H'.
>>>>>>>
>>>>>>> You COULD say, "if I changed THIS COPY of H/embedded_H to not
>>>>>>> abort", but kept all the copies in the input as there original
>>>>>>> aborting version. We can do this, because that is just asking
>>>>>>> what would a UTM do on the same input, by replacing THIS copy
>>>>>>> with a UTM to check the answer.
>>>>>>>
>>>>>>> Summary:
>>>>>>>
>>>>>>> What would happen if H never aborted it simulation, NOT VALID, as
>>>>>>> H doesn't behave that way so this is a contradiction, so do this
>>>>>>> you need to change the input.
>>>>>>>
>>>>>>
>>>>>> void Infinite_Loop(int N)
>>>>>> {
>>>>>>    HERE: goto HERE;
>>>>>> }
>>>>>>   _Infinite_Loop()
>>>>>> [00000cb5](01)  55              push ebp
>>>>>> [00000cb6](02)  8bec            mov ebp,esp
>>>>>> [00000cb8](02)  ebfe            jmp 00000cb8
>>>>>> [00000cba](01)  5d              pop ebp
>>>>>> [00000cbb](01)  c3              ret
>>>>>> Size in bytes:(0007) [00000cbb]
>>>>>>
>>>>>> H can see what the behavior of the above would be if H never
>>>>>> aborted the simulation of this input.
>>>>>>
>>>>>> That you say that H can not do his has to be dishonest because you
>>>>>> are not that stupid.
>>>>>>
>>>>>
>>>>> RED HERRING.
>>>>>
>>>>> H can correctly determine SOME machines, but NOT H^, so it FAILS.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> this input would never reach a final state and stop running.
>>>>
>>>> These steps would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> Since humans can see the above infinitely repeating pattern this is
>>>> complete proof that recognizing this infinitely repeating pattern is
>>>> not impossible, thus when you say it is impossible you lie.
>>>>
>>>
>>> You keep getting stuck in your Schrodinger Turing Machine.
>>>
>>> Yes, IF H is DEFINED in a way that doesn't abort its simulation,
>>> (give this H the name Hn), then the H^ derived from it (call it Hn^)
>>> will not halt, but H never gives an answer to question Hn <Hn^> <Hn^>
>>> so it fails to be the needed decider.
>> Every simulating halt decider must recognize infinite behavior patterns.
>>
>> All of these patterns have the same thing in common the simulated
>> input would never reach is final state even if infinitely simulated.
>>
>> As I have told you at least fifty times (and you make sure to keep
>> forgetting) this does not mean that H simulates its input forever.
>>
>> H merely recognizes that if it would simulate its input forever that
>> this input would never reach its final state.
>>
>> Since aborting the simulation of an input that would never reach its
>> final state does not cause an input to reach its final state all of
>> these aborted simulations remain computations that never halt even
>> after they have been aborted.
>>
>> This works the same way for infinite loops infinite recursion and
>> infinitely nested simulation.
>>
>
> And it was proved that there is no finite pattern that H can recognize
> in H^ to correctly decide that it is non-halting:
>
> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
> Date: 2021-12-30 19:31:49 GMT
> Subject: Re: Concise refutation of halting problem proofs V42 [compute
> the mapping]
>
> You can't just ASSUME that a pattern exists for H to use.
>