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.

--
Copyright 2021 Pete Olcott

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