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.

--
Copyright 2021 Pete Olcott

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