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.

What would happen if THIS H was replaces by a UTM, i.e what happens if
we run a UTM on the same input. VALID.

The VALID case shows that H is wrong.

FAIL.

If you want to claim some other definition, provide a scolorly reference
to support it.