On 1/3/22 6:08 PM, olcott wrote:
> 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 !!!

On 1/3/2022 5:29 PM, Richard Damon wrote:
>
> On 1/3/22 6:08 PM, olcott wrote:
>> 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 !!!
>
> Then SHOW it. I proved it doesn't. You just claim that it obviously
> does, and you track record isn't that good.
>
>>
>> Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>
> Right, we get a repeating pattern, but IF H aborts at some point, then
> goes to H.qn, then if we look at the UTM trace of the input, the next
> time through the cycle, the copy of H in the H^ we were simulating ALSO
> goes to H.qn and thus H^ goes to H^.qn and HALTS.
>

On 1/3/22 6:39 PM, olcott wrote:
> On 1/3/2022 5:29 PM, Richard Damon wrote:
>>
>> On 1/3/22 6:08 PM, olcott wrote:
>>> 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 !!!
>>
>> Then SHOW it. I proved it doesn't. You just claim that it obviously
>> does, and you track record isn't that good.
>>
>>>
>>> Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>
>> Right, we get a repeating pattern, but IF H aborts at some point, then
>> goes to H.qn, then if we look at the UTM trace of the input, the next
>> time through the cycle, the copy of H in the H^ we were simulating
>> ALSO goes to H.qn and thus H^ goes to H^.qn and HALTS.
>>
>
> That is not the way it works. It works like infinite recursion. If we
> abort infinite recursion at its first call or its 700th call it stops.
> If we never abort it, it never stops.

On 1/3/2022 6:03 PM, Richard Damon wrote:
> On 1/3/22 6:39 PM, olcott wrote:
>> On 1/3/2022 5:29 PM, Richard Damon wrote:
>>>
>>> On 1/3/22 6:08 PM, olcott wrote:
>>>> On 1/3/2022 5:03 PM, Richard Damon wrote:

>>>> Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>
>>> Right, we get a repeating pattern, but IF H aborts at some point,
>>> then goes to H.qn, then if we look at the UTM trace of the input, the
>>> next time through the cycle, the copy of H in the H^ we were
>>> simulating ALSO goes to H.qn and thus H^ goes to H^.qn and HALTS.
>>>
>>
>> That is not the way it works. It works like infinite recursion. If we
>> abort infinite recursion at its first call or its 700th call it stops.
>> If we never abort it, it never stops.
>
> Not quite, IF H aborts its simulation, it NEVER WAS actually an infinite
> recursion, AT ANY LEVEL, so H and H^ both end up a Qn and HALT.
>
> If H doesn't aborts its simulation, we do get the infinite simulation
> loop but H never return its answer and is wrong
>
> Since H MUST decide CONSISTENTLY to abort or not, whatever it does makes
> it wrong.
>
>>
>> Infinite recursion and infinitely nested simulation are infinite
>> patterns that can be recognized and reported.
>>
>
> NOPE. Please provide the pattern that you see in H^ that H can abort on
> and still leave H^ non-halting.
>

I have told you many hundreds of times that halting means that the
simulated input reaches its halt state.

--
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 7:16 PM, olcott wrote:
> On 1/3/2022 6:03 PM, Richard Damon wrote:
>> On 1/3/22 6:39 PM, olcott wrote:
>>> On 1/3/2022 5:29 PM, Richard Damon wrote:
>>>>
>>>> On 1/3/22 6:08 PM, olcott wrote:
>>>>> On 1/3/2022 5:03 PM, Richard Damon wrote:
>
>>>>> Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>
>>>> Right, we get a repeating pattern, but IF H aborts at some point,
>>>> then goes to H.qn, then if we look at the UTM trace of the input,
>>>> the next time through the cycle, the copy of H in the H^ we were
>>>> simulating ALSO goes to H.qn and thus H^ goes to H^.qn and HALTS.
>>>>
>>>
>>> That is not the way it works. It works like infinite recursion. If we
>>> abort infinite recursion at its first call or its 700th call it
>>> stops. If we never abort it, it never stops.
>>
>> Not quite, IF H aborts its simulation, it NEVER WAS actually an
>> infinite recursion, AT ANY LEVEL, so H and H^ both end up a Qn and HALT.
>>
>> If H doesn't aborts its simulation, we do get the infinite simulation
>> loop but H never return its answer and is wrong
>>
>> Since H MUST decide CONSISTENTLY to abort or not, whatever it does
>> makes it wrong.
>>
>>>
>>> Infinite recursion and infinitely nested simulation are infinite
>>> patterns that can be recognized and reported.
>>>
>>
>> NOPE. Please provide the pattern that you see in H^ that H can abort
>> on and still leave H^ non-halting.
>>
>
> I have told you many hundreds of times that halting means that the
> simulated input reaches its halt state.
>

It is the simulation done by putting the input into a real UTM that counts.

Since H is NOT a UTM the fact that H doesn't get to the halting state
doesn't matter.

You are just Lying about the definition of Halting.

If you change you mind AGAIN, to say if H doesn't abort then H^ doesn't
halt, then remember that when Hn doesn't abort its simulation, even
though Hn^(<Hn^) doesn't halt, you have the problem that then you have
that Hn(<Hn^,<Hn^>) never returns an answer, so it fails.

So your H that does abort Ha, which says that Ha(<Ha^>,<Ha^>) -> H.Qn
creates a Ha^ that Ha^(<Ha^>) -> H^.Qn and Halts.

Since Ha^ is NOT Hn^ (because Ha is not Hn), you can't use your logic
from Hn to 'prove' that Ha is right to abort its simulation.

FAIL.

On 1/3/2022 6:58 PM, Richard Damon wrote:
> On 1/3/22 7:16 PM, olcott wrote:
>> On 1/3/2022 6:03 PM, Richard Damon wrote:
>>> On 1/3/22 6:39 PM, olcott wrote:
>>>> On 1/3/2022 5:29 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/3/22 6:08 PM, olcott wrote:
>>>>>> On 1/3/2022 5:03 PM, Richard Damon wrote:
>>
>>>>>> Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>
>>>>> Right, we get a repeating pattern, but IF H aborts at some point,
>>>>> then goes to H.qn, then if we look at the UTM trace of the input,
>>>>> the next time through the cycle, the copy of H in the H^ we were
>>>>> simulating ALSO goes to H.qn and thus H^ goes to H^.qn and HALTS.
>>>>>
>>>>
>>>> That is not the way it works. It works like infinite recursion. If
>>>> we abort infinite recursion at its first call or its 700th call it
>>>> stops. If we never abort it, it never stops.
>>>
>>> Not quite, IF H aborts its simulation, it NEVER WAS actually an
>>> infinite recursion, AT ANY LEVEL, so H and H^ both end up a Qn and HALT.
>>>
>>> If H doesn't aborts its simulation, we do get the infinite simulation
>>> loop but H never return its answer and is wrong
>>>
>>> Since H MUST decide CONSISTENTLY to abort or not, whatever it does
>>> makes it wrong.
>>>
>>>>
>>>> Infinite recursion and infinitely nested simulation are infinite
>>>> patterns that can be recognized and reported.
>>>>
>>>
>>> NOPE. Please provide the pattern that you see in H^ that H can abort
>>> on and still leave H^ non-halting.
>>>
>>
>> I have told you many hundreds of times that halting means that the
>> simulated input reaches its halt state.
>>
>
> It is the simulation done by putting the input into a real UTM that counts.
>

Perhaps you are simply not bright enough to understand what I am saying.

> Since H is NOT a UTM the fact that H doesn't get to the halting state
> doesn't matter.
>

Yes it is either not you are not bright enough or are persistently
dishonest.

When embedded_H simulates N steps of its input this is computationally
equivalent to a UTM simulating N steps of its input.

That you disagree with this seems dishonest rather than stupid.

> You are just Lying about the definition of Halting.
>

computation that halts
…the Turing machine will halt whenever it enters a final state.
(Linz:1990:234)

> If you change you mind AGAIN, to say if H doesn't abort then H^ doesn't
> halt, then remember that when Hn doesn't abort its simulation, even
> though Hn^(<Hn^) doesn't halt, you have the problem that then you have
> that Hn(<Hn^,<Hn^>) never returns an answer, so it fails.
>
> So your H that does abort Ha, which says that Ha(<Ha^>,<Ha^>) -> H.Qn
> creates a Ha^ that Ha^(<Ha^>) -> H^.Qn and Halts.
>
> Since Ha^ is NOT Hn^ (because Ha is not Hn), you can't use your logic
> from Hn to 'prove' that Ha is right to abort its simulation.
>
>
> FAIL.
>

--
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 8:08 PM, olcott wrote:
> On 1/3/2022 6:58 PM, Richard Damon wrote:
>> On 1/3/22 7:16 PM, olcott wrote:
>>> On 1/3/2022 6:03 PM, Richard Damon wrote:
>>>> On 1/3/22 6:39 PM, olcott wrote:
>>>>> On 1/3/2022 5:29 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/3/22 6:08 PM, olcott wrote:
>>>>>>> On 1/3/2022 5:03 PM, Richard Damon wrote:
>>>
>>>>>>> Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>
>>>>>> Right, we get a repeating pattern, but IF H aborts at some point,
>>>>>> then goes to H.qn, then if we look at the UTM trace of the input,
>>>>>> the next time through the cycle, the copy of H in the H^ we were
>>>>>> simulating ALSO goes to H.qn and thus H^ goes to H^.qn and HALTS.
>>>>>>
>>>>>
>>>>> That is not the way it works. It works like infinite recursion. If
>>>>> we abort infinite recursion at its first call or its 700th call it
>>>>> stops. If we never abort it, it never stops.
>>>>
>>>> Not quite, IF H aborts its simulation, it NEVER WAS actually an
>>>> infinite recursion, AT ANY LEVEL, so H and H^ both end up a Qn and
>>>> HALT.
>>>>
>>>> If H doesn't aborts its simulation, we do get the infinite
>>>> simulation loop but H never return its answer and is wrong
>>>>
>>>> Since H MUST decide CONSISTENTLY to abort or not, whatever it does
>>>> makes it wrong.
>>>>
>>>>>
>>>>> Infinite recursion and infinitely nested simulation are infinite
>>>>> patterns that can be recognized and reported.
>>>>>
>>>>
>>>> NOPE. Please provide the pattern that you see in H^ that H can abort
>>>> on and still leave H^ non-halting.
>>>>
>>>
>>> I have told you many hundreds of times that halting means that the
>>> simulated input reaches its halt state.
>>>
>>
>> It is the simulation done by putting the input into a real UTM that
>> counts.
>>
>
> Perhaps you are simply not bright enough to understand what I am saying.
>
>> Since H is NOT a UTM the fact that H doesn't get to the halting state
>> doesn't matter.
>>
>
> Yes it is either not you are not bright enough or are persistently
> dishonest.
>
> When embedded_H simulates N steps of its input this is computationally
> equivalent to a UTM simulating N steps of its input.
>
> That you disagree with this seems dishonest rather than stupid.

But you are a Liar, as the test is the simulation by a UTM, not a UTM of
only N steps.

Since for any given H, you N is fixed, and NOT some arbitrary large
value, it just doesn't apply.

FAIL.

>
>> You are just Lying about the definition of Halting.
>>
>
> computation that halts
> …the Turing machine will halt whenever it enters a final state.
> (Linz:1990:234)
>

Right, and to be non-halting, it needs to never halt no matter how many
steps it is run.

You 'N-Step' isn't part of it.

FAIL.

>
>> If you change you mind AGAIN, to say if H doesn't abort then H^
>> doesn't halt, then remember that when Hn doesn't abort its simulation,
>> even though Hn^(<Hn^) doesn't halt, you have the problem that then you
>> have that Hn(<Hn^,<Hn^>) never returns an answer, so it fails.
>>
>> So your H that does abort Ha, which says that Ha(<Ha^>,<Ha^>) -> H.Qn
>> creates a Ha^ that Ha^(<Ha^>) -> H^.Qn and Halts.
>>
>> Since Ha^ is NOT Hn^ (because Ha is not Hn), you can't use your logic
>> from Hn to 'prove' that Ha is right to abort its simulation.
>>
>>
>> FAIL.
>>
>
>