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

We can see that the pattern exists GOOFUS !!!

Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...

--
Copyright 2021 Pete Olcott

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