On 1/22/22 6:03 PM, olcott wrote:
> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>
>> On 1/22/22 5:32 PM, olcott wrote:
>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision
>>>>>>>>>>>>>>>>>>>>>>> on the behavior of its pure simulation of N steps
>>>>>>>>>>>>>>>>>>>>>>> of its input. N is either the number of steps
>>>>>>>>>>>>>>>>>>>>>>> that it takes for its simulated input to reach
>>>>>>>>>>>>>>>>>>>>>>> its final state or the number of steps required
>>>>>>>>>>>>>>>>>>>>>>> for H to match an infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>> proving that the simulated input would never
>>>>>>>>>>>>>>>>>>>>>>> reach its own final state. In this case H aborts
>>>>>>>>>>>>>>>>>>>>>>> the simulation of this input and transitions to
>>>>>>>>>>>>>>>>>>>>>>> H.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter
>>>>>>>>>>>>>>>>>>>>>> for the proof.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you
>>>>>>>>>>>>>>>>>>>>>> MUST provide it or accept that your logic is just
>>>>>>>>>>>>>>>>>>>>>> plain flawed as you are claiming the existance of
>>>>>>>>>>>>>>>>>>>>>> something that is impossible.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write
>>>>>>>>>>>>>>>>>>>>>> a halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is
>>>>>>>>>>>>>>>>>>>>>>> now a single machine with a single start state. A
>>>>>>>>>>>>>>>>>>>>>>> copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation of a
>>>>>>>>>>>>>>>>>>>>>>> machine is computationally equivalent to the
>>>>>>>>>>>>>>>>>>>>>>> direct execution of this same machine H can
>>>>>>>>>>>>>>>>>>>>>>> always form its halt status decision on the basis
>>>>>>>>>>>>>>>>>>>>>>> of what the behavior of the UTM simulation of its
>>>>>>>>>>>>>>>>>>>>>>> inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then
>>>>>>>>>>>>>>>>>>>>>> the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps
>>>>>>>>>>>>>>>>>>>>> that the simulated input to embedded_H would ever
>>>>>>>>>>>>>>>>>>>>> reach its final state conclusively proves that
>>>>>>>>>>>>>>>>>>>>> embedded_H is correct to abort its simulation of
>>>>>>>>>>>>>>>>>>>>> this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>>>>>>>> number of steps, gives the wrong answer because it
>>>>>>>>>>>>>>>>>>>> only looked to see if the input doesn't halt at some
>>>>>>>>>>>>>>>>>>>> specific finite number.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated
>>>>>>>>>>>>>>>>>>> input to embedded_H reaches its final state then we
>>>>>>>>>>>>>>>>>>> know that this simulated input does not halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And the only case when that happens is when H does not
>>>>>>>>>>>>>>>>>> abort its simulation,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever
>>>>>>>>>>>>>>>>> reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM any
>>>>>>>>>>>>>>>> longer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>>>>>>> matter what embedded_H does, thus conclusively proving
>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^> will
>>>>>>>>>>>>>>>> go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>>>> Ĥ.qy or Ĥ.qn on the basis of the behavior specified by
>>>>>>>>>>>>>>> these inputs. embedded_H is not accountable for the
>>>>>>>>>>>>>>> behavior of the computation that it is contained within:
>>>>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ because this is not an actual input to
>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show
>>>>>>>>>>>>>> that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach its
>>>>>>>>>>>>> final state NO MATTER WHAT.
>>>>>>>>>>>>
>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>
>>>>>>>>>>> If the simulated input cannot possibly every reach its final
>>>>>>>>>>> state no matter what embedded_H does then this simulated
>>>>>>>>>>> input is correctly determined to meet the Linz definition of
>>>>>>>>>>> never halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except that the simulated input DOES reach its final state if
>>>>>>>>>> H/embeded_H goes to H.Qn.
>>>>>>>>>
>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted
>>>>>>>>> its simulated input making it utterly impossible for any aspect
>>>>>>>>> of this simulated input to do anything at all.
>>>>>>>>
>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>
>>>>>>>
>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>
>>>>>>> This is true for infinite loops, infinite recursion, infinitely
>>>>>>> nested simulation and all other non halting inputs:
>>>>>>>
>>>>>>> When-so-ever any simulated input to any simulating halt decider
>>>>>>> would never reach the final state of this simulated input in any
>>>>>>> finite number of steps it is always correct for the simulating
>>>>>>> halt decider to abort its simulation and transition to its reject
>>>>>>> state.
>>>>>>>
>>>>>>
>>>>>> Can you PROVE that statement, or is this just one of your false
>>>>>> 'self evident truth'. Does the proof include the posibility that
>>>>>> the input includes a copy of the decider?
>>>>>>
>>>>>> The problem is that IF the simulating halt decider does abort its
>>>>>> input based on some condition, then it is no longer a source of
>>>>>> truth for the halting status of that input.
>>>>>>
>>>>>> It turns out that for H^, if H does abort its simulation, then it
>>>>>> turns out that an actual simulation of the input proves that it
>>>>>> will halt.
>>>>>>
>>>>>
>>>>> You really must have actual brain damage. That would not be your fault
>>>>> I have told you the Linz definintion of halting many dozens of times:
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>
>>>> And stopping simulating doesn't mean non-halt.
>>>>
>>>
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>> Matching the infinite behavior pattern means not halt.
>>>
>>
>>
>> WRONG. UTM never halting means does not Halt, use the right definitons.
>>
>
> I give up on you again.
> You can't understand that infinite behavior patterns can be recognized.

On 1/22/2022 5:18 PM, Richard Damon wrote:
> On 1/22/22 6:03 PM, olcott wrote:
>> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>>
>>> On 1/22/22 5:32 PM, olcott wrote:
>>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure simulation
>>>>>>>>>>>>>>>>>>>>>>>> of N steps of its input. N is either the number
>>>>>>>>>>>>>>>>>>>>>>>> of steps that it takes for its simulated input
>>>>>>>>>>>>>>>>>>>>>>>> to reach its final state or the number of steps
>>>>>>>>>>>>>>>>>>>>>>>> required for H to match an infinite behavior
>>>>>>>>>>>>>>>>>>>>>>>> pattern proving that the simulated input would
>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state. In this case H
>>>>>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input and
>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a
>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter
>>>>>>>>>>>>>>>>>>>>>>> for the proof.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you
>>>>>>>>>>>>>>>>>>>>>>> MUST provide it or accept that your logic is just
>>>>>>>>>>>>>>>>>>>>>>> plain flawed as you are claiming the existance of
>>>>>>>>>>>>>>>>>>>>>>> something that is impossible.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can
>>>>>>>>>>>>>>>>>>>>>>> write a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is
>>>>>>>>>>>>>>>>>>>>>>>> now a single machine with a single start state.
>>>>>>>>>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation of a
>>>>>>>>>>>>>>>>>>>>>>>> machine is computationally equivalent to the
>>>>>>>>>>>>>>>>>>>>>>>> direct execution of this same machine H can
>>>>>>>>>>>>>>>>>>>>>>>> always form its halt status decision on the
>>>>>>>>>>>>>>>>>>>>>>>> basis of what the behavior of the UTM simulation
>>>>>>>>>>>>>>>>>>>>>>>> of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate
>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then
>>>>>>>>>>>>>>>>>>>>>>> the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps
>>>>>>>>>>>>>>>>>>>>>> that the simulated input to embedded_H would ever
>>>>>>>>>>>>>>>>>>>>>> reach its final state conclusively proves that
>>>>>>>>>>>>>>>>>>>>>> embedded_H is correct to abort its simulation of
>>>>>>>>>>>>>>>>>>>>>> this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a
>>>>>>>>>>>>>>>>>>>>> finite number of steps, gives the wrong answer
>>>>>>>>>>>>>>>>>>>>> because it only looked to see if the input doesn't
>>>>>>>>>>>>>>>>>>>>> halt at some specific finite number.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated
>>>>>>>>>>>>>>>>>>>> input to embedded_H reaches its final state then we
>>>>>>>>>>>>>>>>>>>> know that this simulated input does not halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And the only case when that happens is when H does
>>>>>>>>>>>>>>>>>>> not abort its simulation,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever
>>>>>>>>>>>>>>>>>> reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM any
>>>>>>>>>>>>>>>>> longer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>>>>>>>> matter what embedded_H does, thus conclusively proving
>>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^>
>>>>>>>>>>>>>>>>> will go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>>>>> Ĥ.qy or Ĥ.qn on the basis of the behavior specified by
>>>>>>>>>>>>>>>> these inputs. embedded_H is not accountable for the
>>>>>>>>>>>>>>>> behavior of the computation that it is contained within:
>>>>>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ because this is not an actual input to
>>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show
>>>>>>>>>>>>>>> that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach its
>>>>>>>>>>>>>> final state NO MATTER WHAT.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>>
>>>>>>>>>>>> If the simulated input cannot possibly every reach its final
>>>>>>>>>>>> state no matter what embedded_H does then this simulated
>>>>>>>>>>>> input is correctly determined to meet the Linz definition of
>>>>>>>>>>>> never halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except that the simulated input DOES reach its final state if
>>>>>>>>>>> H/embeded_H goes to H.Qn.
>>>>>>>>>>
>>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted
>>>>>>>>>> its simulated input making it utterly impossible for any
>>>>>>>>>> aspect of this simulated input to do anything at all.
>>>>>>>>>
>>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>>
>>>>>>>> This is true for infinite loops, infinite recursion, infinitely
>>>>>>>> nested simulation and all other non halting inputs:
>>>>>>>>
>>>>>>>> When-so-ever any simulated input to any simulating halt decider
>>>>>>>> would never reach the final state of this simulated input in any
>>>>>>>> finite number of steps it is always correct for the simulating
>>>>>>>> halt decider to abort its simulation and transition to its
>>>>>>>> reject state.
>>>>>>>>
>>>>>>>
>>>>>>> Can you PROVE that statement, or is this just one of your false
>>>>>>> 'self evident truth'. Does the proof include the posibility that
>>>>>>> the input includes a copy of the decider?
>>>>>>>
>>>>>>> The problem is that IF the simulating halt decider does abort its
>>>>>>> input based on some condition, then it is no longer a source of
>>>>>>> truth for the halting status of that input.
>>>>>>>
>>>>>>> It turns out that for H^, if H does abort its simulation, then it
>>>>>>> turns out that an actual simulation of the input proves that it
>>>>>>> will halt.
>>>>>>>
>>>>>>
>>>>>> You really must have actual brain damage. That would not be your
>>>>>> fault
>>>>>> I have told you the Linz definintion of halting many dozens of times:
>>>>>>
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters a final state. (Linz:1990:234)
>>>>>>
>>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>
>>>>>
>>>>> And stopping simulating doesn't mean non-halt.
>>>>>
>>>>
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>> Matching the infinite behavior pattern means not halt.
>>>>
>>>
>>>
>>> WRONG. UTM never halting means does not Halt, use the right definitons.
>>>
>>
>> I give up on you again.
>> You can't understand that infinite behavior patterns can be recognized.
>
> Prove it!!!
>
> Show the actual pattern.
>
> Note, it can't be the H sees the machine it is simulating 'calling' H
> with the same inputs it is simulating, as we can show that if H uses
> this then H^ will halt,
OK SO YOU ARE A LIAR, THAT MAKES THINKS SIMPLE.

On 1/22/22 6:22 PM, olcott wrote:
> On 1/22/2022 5:18 PM, Richard Damon wrote:
>> On 1/22/22 6:03 PM, olcott wrote:
>>> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>>>
>>>> On 1/22/22 5:32 PM, olcott wrote:
>>>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of its input. N is either the number
>>>>>>>>>>>>>>>>>>>>>>>>> of steps that it takes for its simulated input
>>>>>>>>>>>>>>>>>>>>>>>>> to reach its final state or the number of steps
>>>>>>>>>>>>>>>>>>>>>>>>> required for H to match an infinite behavior
>>>>>>>>>>>>>>>>>>>>>>>>> pattern proving that the simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state. In this case H
>>>>>>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input and
>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a
>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter
>>>>>>>>>>>>>>>>>>>>>>>> for the proof.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you
>>>>>>>>>>>>>>>>>>>>>>>> MUST provide it or accept that your logic is
>>>>>>>>>>>>>>>>>>>>>>>> just plain flawed as you are claiming the
>>>>>>>>>>>>>>>>>>>>>>>> existance of something that is impossible.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a
>>>>>>>>>>>>>>>>>>>>>>>> halt decider for you halt decider to use, you
>>>>>>>>>>>>>>>>>>>>>>>> can write a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is
>>>>>>>>>>>>>>>>>>>>>>>>> now a single machine with a single start state.
>>>>>>>>>>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation of
>>>>>>>>>>>>>>>>>>>>>>>>> a machine is computationally equivalent to the
>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of this same machine H can
>>>>>>>>>>>>>>>>>>>>>>>>> always form its halt status decision on the
>>>>>>>>>>>>>>>>>>>>>>>>> basis of what the behavior of the UTM
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate
>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort,
>>>>>>>>>>>>>>>>>>>>>>>> then the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps
>>>>>>>>>>>>>>>>>>>>>>> that the simulated input to embedded_H would ever
>>>>>>>>>>>>>>>>>>>>>>> reach its final state conclusively proves that
>>>>>>>>>>>>>>>>>>>>>>> embedded_H is correct to abort its simulation of
>>>>>>>>>>>>>>>>>>>>>>> this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a
>>>>>>>>>>>>>>>>>>>>>> finite number of steps, gives the wrong answer
>>>>>>>>>>>>>>>>>>>>>> because it only looked to see if the input doesn't
>>>>>>>>>>>>>>>>>>>>>> halt at some specific finite number.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated
>>>>>>>>>>>>>>>>>>>>> input to embedded_H reaches its final state then we
>>>>>>>>>>>>>>>>>>>>> know that this simulated input does not halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And the only case when that happens is when H does
>>>>>>>>>>>>>>>>>>>> not abort its simulation,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever
>>>>>>>>>>>>>>>>>>> reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM
>>>>>>>>>>>>>>>>>> any longer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final state
>>>>>>>>>>>>>>>>> no matter what embedded_H does, thus conclusively
>>>>>>>>>>>>>>>>> proving that this input never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^>
>>>>>>>>>>>>>>>>>> will go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>>>>>> Ĥ.qy or Ĥ.qn on the basis of the behavior specified by
>>>>>>>>>>>>>>>>> these inputs. embedded_H is not accountable for the
>>>>>>>>>>>>>>>>> behavior of the computation that it is contained
>>>>>>>>>>>>>>>>> within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual
>>>>>>>>>>>>>>>>> input to embedded_H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show
>>>>>>>>>>>>>>>> that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach its
>>>>>>>>>>>>>>> final state NO MATTER WHAT.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the simulated input cannot possibly every reach its
>>>>>>>>>>>>> final state no matter what embedded_H does then this
>>>>>>>>>>>>> simulated input is correctly determined to meet the Linz
>>>>>>>>>>>>> definition of never halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that the simulated input DOES reach its final state
>>>>>>>>>>>> if H/embeded_H goes to H.Qn.
>>>>>>>>>>>
>>>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted
>>>>>>>>>>> its simulated input making it utterly impossible for any
>>>>>>>>>>> aspect of this simulated input to do anything at all.
>>>>>>>>>>
>>>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>>>
>>>>>>>>> This is true for infinite loops, infinite recursion, infinitely
>>>>>>>>> nested simulation and all other non halting inputs:
>>>>>>>>>
>>>>>>>>> When-so-ever any simulated input to any simulating halt decider
>>>>>>>>> would never reach the final state of this simulated input in
>>>>>>>>> any finite number of steps it is always correct for the
>>>>>>>>> simulating halt decider to abort its simulation and transition
>>>>>>>>> to its reject state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Can you PROVE that statement, or is this just one of your false
>>>>>>>> 'self evident truth'. Does the proof include the posibility that
>>>>>>>> the input includes a copy of the decider?
>>>>>>>>
>>>>>>>> The problem is that IF the simulating halt decider does abort
>>>>>>>> its input based on some condition, then it is no longer a source
>>>>>>>> of truth for the halting status of that input.
>>>>>>>>
>>>>>>>> It turns out that for H^, if H does abort its simulation, then
>>>>>>>> it turns out that an actual simulation of the input proves that
>>>>>>>> it will halt.
>>>>>>>>
>>>>>>>
>>>>>>> You really must have actual brain damage. That would not be your
>>>>>>> fault
>>>>>>> I have told you the Linz definintion of halting many dozens of
>>>>>>> times:
>>>>>>>
>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>
>>>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>
>>>>>>
>>>>>> And stopping simulating doesn't mean non-halt.
>>>>>>
>>>>>
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>> Matching the infinite behavior pattern means not halt.
>>>>>
>>>>
>>>>
>>>> WRONG. UTM never halting means does not Halt, use the right definitons.
>>>>
>>>
>>> I give up on you again.
>>> You can't understand that infinite behavior patterns can be recognized.
>>
>> Prove it!!!
>>
>> Show the actual pattern.
>>
>> Note, it can't be the H sees the machine it is simulating 'calling' H
>> with the same inputs it is simulating, as we can show that if H uses
>> this then H^ will halt,
> OK SO YOU ARE A LIAR, THAT MAKES THINKS SIMPLE.
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>

On 1/22/2022 5:54 PM, Richard Damon wrote:
>
> On 1/22/22 6:22 PM, olcott wrote:
>> On 1/22/2022 5:18 PM, Richard Damon wrote:
>>> On 1/22/22 6:03 PM, olcott wrote:
>>>> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/22/22 5:32 PM, olcott wrote:
>>>>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes for
>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required for H to match
>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite behavior pattern proving that the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>> final state. In this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a
>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter
>>>>>>>>>>>>>>>>>>>>>>>>> for the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you
>>>>>>>>>>>>>>>>>>>>>>>>> MUST provide it or accept that your logic is
>>>>>>>>>>>>>>>>>>>>>>>>> just plain flawed as you are claiming the
>>>>>>>>>>>>>>>>>>>>>>>>> existance of something that is impossible.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a
>>>>>>>>>>>>>>>>>>>>>>>>> halt decider for you halt decider to use, you
>>>>>>>>>>>>>>>>>>>>>>>>> can write a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is
>>>>>>>>>>>>>>>>>>>>>>>>>> now a single machine with a single start
>>>>>>>>>>>>>>>>>>>>>>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>> a machine is computationally equivalent to the
>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of this same machine H can
>>>>>>>>>>>>>>>>>>>>>>>>>> always form its halt status decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>> basis of what the behavior of the UTM
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate
>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort,
>>>>>>>>>>>>>>>>>>>>>>>>> then the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of
>>>>>>>>>>>>>>>>>>>>>>>> steps that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> would ever reach its final state conclusively
>>>>>>>>>>>>>>>>>>>>>>>> proves that embedded_H is correct to abort its
>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a
>>>>>>>>>>>>>>>>>>>>>>> finite number of steps, gives the wrong answer
>>>>>>>>>>>>>>>>>>>>>>> because it only looked to see if the input
>>>>>>>>>>>>>>>>>>>>>>> doesn't halt at some specific finite number.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated
>>>>>>>>>>>>>>>>>>>>>> input to embedded_H reaches its final state then
>>>>>>>>>>>>>>>>>>>>>> we know that this simulated input does not halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And the only case when that happens is when H does
>>>>>>>>>>>>>>>>>>>>> not abort its simulation,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever
>>>>>>>>>>>>>>>>>>>> reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM
>>>>>>>>>>>>>>>>>>> any longer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It remains true (invariant) that the simulated input
>>>>>>>>>>>>>>>>>> to embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>> state no matter what embedded_H does, thus
>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^>
>>>>>>>>>>>>>>>>>>> will go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>>>>>>> Ĥ.qy or Ĥ.qn on the basis of the behavior specified by
>>>>>>>>>>>>>>>>>> these inputs. embedded_H is not accountable for the
>>>>>>>>>>>>>>>>>> behavior of the computation that it is contained
>>>>>>>>>>>>>>>>>> within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual
>>>>>>>>>>>>>>>>>> input to embedded_H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show
>>>>>>>>>>>>>>>>> that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach its
>>>>>>>>>>>>>>>> final state NO MATTER WHAT.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the simulated input cannot possibly every reach its
>>>>>>>>>>>>>> final state no matter what embedded_H does then this
>>>>>>>>>>>>>> simulated input is correctly determined to meet the Linz
>>>>>>>>>>>>>> definition of never halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that the simulated input DOES reach its final state
>>>>>>>>>>>>> if H/embeded_H goes to H.Qn.
>>>>>>>>>>>>
>>>>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted
>>>>>>>>>>>> its simulated input making it utterly impossible for any
>>>>>>>>>>>> aspect of this simulated input to do anything at all.
>>>>>>>>>>>
>>>>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>>>>
>>>>>>>>>> This is true for infinite loops, infinite recursion,
>>>>>>>>>> infinitely nested simulation and all other non halting inputs:
>>>>>>>>>>
>>>>>>>>>> When-so-ever any simulated input to any simulating halt
>>>>>>>>>> decider would never reach the final state of this simulated
>>>>>>>>>> input in any finite number of steps it is always correct for
>>>>>>>>>> the simulating halt decider to abort its simulation and
>>>>>>>>>> transition to its reject state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Can you PROVE that statement, or is this just one of your false
>>>>>>>>> 'self evident truth'. Does the proof include the posibility
>>>>>>>>> that the input includes a copy of the decider?
>>>>>>>>>
>>>>>>>>> The problem is that IF the simulating halt decider does abort
>>>>>>>>> its input based on some condition, then it is no longer a
>>>>>>>>> source of truth for the halting status of that input.
>>>>>>>>>
>>>>>>>>> It turns out that for H^, if H does abort its simulation, then
>>>>>>>>> it turns out that an actual simulation of the input proves that
>>>>>>>>> it will halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You really must have actual brain damage. That would not be your
>>>>>>>> fault
>>>>>>>> I have told you the Linz definintion of halting many dozens of
>>>>>>>> times:
>>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>
>>>>>>>
>>>>>>> And stopping simulating doesn't mean non-halt.
>>>>>>>
>>>>>>
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>
>>>>>
>>>>>
>>>>> WRONG. UTM never halting means does not Halt, use the right
>>>>> definitons.
>>>>>
>>>>
>>>> I give up on you again.
>>>> You can't understand that infinite behavior patterns can be recognized.
>>>
>>> Prove it!!!
>>>
>>> Show the actual pattern.
>>>
>>> Note, it can't be the H sees the machine it is simulating 'calling' H
>>> with the same inputs it is simulating, as we can show that if H uses
>>> this then H^ will halt,
>> OK SO YOU ARE A LIAR, THAT MAKES THINKS SIMPLE.
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>
> Halting means it DOES NOT reach the final state.
>
> Halting requires having an actual machine defined.
>
> You keep on talking about H as if it is actually an amagamation of a
> family of machines, THAT is not allowed. H needs to be a SPECIFIC
> example of one.
>
> Yes, you can make a proof to show that NO machine in a class can do
> something, but that proof needs to look at each machine as a specific
> machine.
>
> You claimed 'Proof of non-halting' just shows that No H which aborts a
> simulation can ever simulate long enough to see the Halt state, which

On 1/22/22 7:12 PM, olcott wrote:
> On 1/22/2022 5:54 PM, Richard Damon wrote:
>>
>> On 1/22/22 6:22 PM, olcott wrote:
>>> On 1/22/2022 5:18 PM, Richard Damon wrote:
>>>> On 1/22/22 6:03 PM, olcott wrote:
>>>>> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/22/22 5:32 PM, olcott wrote:
>>>>>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>>>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes for
>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>> match an infinite behavior pattern proving
>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulated input would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state. In this case H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of this input and transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a
>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no
>>>>>>>>>>>>>>>>>>>>>>>>>> counter for the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists,
>>>>>>>>>>>>>>>>>>>>>>>>>> you MUST provide it or accept that your logic
>>>>>>>>>>>>>>>>>>>>>>>>>> is just plain flawed as you are claiming the
>>>>>>>>>>>>>>>>>>>>>>>>>> existance of something that is impossible.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a
>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider for you halt decider to use, you
>>>>>>>>>>>>>>>>>>>>>>>>>> can write a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it
>>>>>>>>>>>>>>>>>>>>>>>>>>> is now a single machine with a single start
>>>>>>>>>>>>>>>>>>>>>>>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine is computationally equivalent to
>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of this same machine H
>>>>>>>>>>>>>>>>>>>>>>>>>>> can always form its halt status decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of what the behavior of the UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort,
>>>>>>>>>>>>>>>>>>>>>>>>>> then the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of
>>>>>>>>>>>>>>>>>>>>>>>>> steps that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> would ever reach its final state conclusively
>>>>>>>>>>>>>>>>>>>>>>>>> proves that embedded_H is correct to abort its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a
>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps, gives the wrong answer
>>>>>>>>>>>>>>>>>>>>>>>> because it only looked to see if the input
>>>>>>>>>>>>>>>>>>>>>>>> doesn't halt at some specific finite number.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite
>>>>>>>>>>>>>>>>>>>>>>> (or infinite) number of steps such that the
>>>>>>>>>>>>>>>>>>>>>>> simulated input to embedded_H reaches its final
>>>>>>>>>>>>>>>>>>>>>>> state then we know that this simulated input does
>>>>>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And the only case when that happens is when H does
>>>>>>>>>>>>>>>>>>>>>> not abort its simulation,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever
>>>>>>>>>>>>>>>>>>>>> reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it
>>>>>>>>>>>>>>>>>>>> doesn't matter if IT sees it or not, as it isn't
>>>>>>>>>>>>>>>>>>>> then a UTM any longer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It remains true (invariant) that the simulated input
>>>>>>>>>>>>>>>>>>> to embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>> state no matter what embedded_H does, thus
>>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^>
>>>>>>>>>>>>>>>>>>>> will go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is
>>>>>>>>>>>>>>>>>>> only accountable for computing the mapping from ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the behavior
>>>>>>>>>>>>>>>>>>> specified by these inputs. embedded_H is not
>>>>>>>>>>>>>>>>>>> accountable for the behavior of the computation that
>>>>>>>>>>>>>>>>>>> it is contained within: Ĥ applied to ⟨Ĥ⟩ because this
>>>>>>>>>>>>>>>>>>> is not an actual input to embedded_H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show
>>>>>>>>>>>>>>>>>> that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach its
>>>>>>>>>>>>>>>>> final state NO MATTER WHAT.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If the simulated input cannot possibly every reach its
>>>>>>>>>>>>>>> final state no matter what embedded_H does then this
>>>>>>>>>>>>>>> simulated input is correctly determined to meet the Linz
>>>>>>>>>>>>>>> definition of never halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that the simulated input DOES reach its final state
>>>>>>>>>>>>>> if H/embeded_H goes to H.Qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already
>>>>>>>>>>>>> aborted its simulated input making it utterly impossible
>>>>>>>>>>>>> for any aspect of this simulated input to do anything at all.
>>>>>>>>>>>>
>>>>>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>>>>>
>>>>>>>>>>> This is true for infinite loops, infinite recursion,
>>>>>>>>>>> infinitely nested simulation and all other non halting inputs:
>>>>>>>>>>>
>>>>>>>>>>> When-so-ever any simulated input to any simulating halt
>>>>>>>>>>> decider would never reach the final state of this simulated
>>>>>>>>>>> input in any finite number of steps it is always correct for
>>>>>>>>>>> the simulating halt decider to abort its simulation and
>>>>>>>>>>> transition to its reject state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Can you PROVE that statement, or is this just one of your
>>>>>>>>>> false 'self evident truth'. Does the proof include the
>>>>>>>>>> posibility that the input includes a copy of the decider?
>>>>>>>>>>
>>>>>>>>>> The problem is that IF the simulating halt decider does abort
>>>>>>>>>> its input based on some condition, then it is no longer a
>>>>>>>>>> source of truth for the halting status of that input.
>>>>>>>>>>
>>>>>>>>>> It turns out that for H^, if H does abort its simulation, then
>>>>>>>>>> it turns out that an actual simulation of the input proves
>>>>>>>>>> that it will halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You really must have actual brain damage. That would not be
>>>>>>>>> your fault
>>>>>>>>> I have told you the Linz definintion of halting many dozens of
>>>>>>>>> times:
>>>>>>>>>
>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>
>>>>>>>>
>>>>>>>> And stopping simulating doesn't mean non-halt.
>>>>>>>>
>>>>>>>
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> WRONG. UTM never halting means does not Halt, use the right
>>>>>> definitons.
>>>>>>
>>>>>
>>>>> I give up on you again.
>>>>> You can't understand that infinite behavior patterns can be
>>>>> recognized.
>>>>
>>>> Prove it!!!
>>>>
>>>> Show the actual pattern.
>>>>
>>>> Note, it can't be the H sees the machine it is simulating 'calling'
>>>> H with the same inputs it is simulating, as we can show that if H
>>>> uses this then H^ will halt,
>>> OK SO YOU ARE A LIAR, THAT MAKES THINKS SIMPLE.
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>
>> Halting means it DOES NOT reach the final state.
>>
>> Halting requires having an actual machine defined.
>>
>> You keep on talking about H as if it is actually an amagamation of a
>> family of machines, THAT is not allowed. H needs to be a SPECIFIC
>> example of one.
>>
>> Yes, you can make a proof to show that NO machine in a class can do
>> something, but that proof needs to look at each machine as a specific
>> machine.
>>
>> You claimed 'Proof of non-halting' just shows that No H which aborts a
>> simulation can ever simulate long enough to see the Halt state, which
>
> In exactly the same way that no H can simulate an infinite loop long
> enough to see this infinite loop stop running.
>
> I take it back that you are a liar, you just aren't very bright.
>
>

On 1/22/2022 6:34 PM, Richard Damon wrote:
> On 1/22/22 7:12 PM, olcott wrote:
>> On 1/22/2022 5:54 PM, Richard Damon wrote:
>>>
>>> On 1/22/22 6:22 PM, olcott wrote:
>>>> On 1/22/2022 5:18 PM, Richard Damon wrote:
>>>>> On 1/22/22 6:03 PM, olcott wrote:
>>>>>> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/22/22 5:32 PM, olcott wrote:
>>>>>>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes for
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> match an infinite behavior pattern proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulated input would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state. In this case H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of this input and transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> and becomes non-answering and thus FAILS to
>>>>>>>>>>>>>>>>>>>>>>>>>>> be a decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you
>>>>>>>>>>>>>>>>>>>>>>>>>>> have ignored that proof, showing you have no
>>>>>>>>>>>>>>>>>>>>>>>>>>> counter for the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists,
>>>>>>>>>>>>>>>>>>>>>>>>>>> you MUST provide it or accept that your logic
>>>>>>>>>>>>>>>>>>>>>>>>>>> is just plain flawed as you are claiming the
>>>>>>>>>>>>>>>>>>>>>>>>>>> existance of something that is impossible.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a
>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider for you halt decider to use, you
>>>>>>>>>>>>>>>>>>>>>>>>>>> can write a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is now a single machine with a single start
>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine is computationally equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the direct execution of this same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can always form its halt status decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of what the behavior of the UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>> then the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>> steps that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> would ever reach its final state conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>> proves that embedded_H is correct to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a
>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps, gives the wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>> because it only looked to see if the input
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't halt at some specific finite number.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite
>>>>>>>>>>>>>>>>>>>>>>>> (or infinite) number of steps such that the
>>>>>>>>>>>>>>>>>>>>>>>> simulated input to embedded_H reaches its final
>>>>>>>>>>>>>>>>>>>>>>>> state then we know that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And the only case when that happens is when H
>>>>>>>>>>>>>>>>>>>>>>> does not abort its simulation,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case.
>>>>>>>>>>>>>>>>>>>>>> The simulated input to embedded_H cannot possibly
>>>>>>>>>>>>>>>>>>>>>> ever reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it
>>>>>>>>>>>>>>>>>>>>> doesn't matter if IT sees it or not, as it isn't
>>>>>>>>>>>>>>>>>>>>> then a UTM any longer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It remains true (invariant) that the simulated input
>>>>>>>>>>>>>>>>>>>> to embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>>> state no matter what embedded_H does, thus
>>>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^>
>>>>>>>>>>>>>>>>>>>>> will go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is
>>>>>>>>>>>>>>>>>>>> only accountable for computing the mapping from ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the behavior
>>>>>>>>>>>>>>>>>>>> specified by these inputs. embedded_H is not
>>>>>>>>>>>>>>>>>>>> accountable for the behavior of the computation that
>>>>>>>>>>>>>>>>>>>> it is contained within: Ĥ applied to ⟨Ĥ⟩ because
>>>>>>>>>>>>>>>>>>>> this is not an actual input to embedded_H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will
>>>>>>>>>>>>>>>>>>> show that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach
>>>>>>>>>>>>>>>>>> its final state NO MATTER WHAT.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the simulated input cannot possibly every reach its
>>>>>>>>>>>>>>>> final state no matter what embedded_H does then this
>>>>>>>>>>>>>>>> simulated input is correctly determined to meet the Linz
>>>>>>>>>>>>>>>> definition of never halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that the simulated input DOES reach its final
>>>>>>>>>>>>>>> state if H/embeded_H goes to H.Qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already
>>>>>>>>>>>>>> aborted its simulated input making it utterly impossible
>>>>>>>>>>>>>> for any aspect of this simulated input to do anything at all.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>>>>>>
>>>>>>>>>>>> This is true for infinite loops, infinite recursion,
>>>>>>>>>>>> infinitely nested simulation and all other non halting inputs:
>>>>>>>>>>>>
>>>>>>>>>>>> When-so-ever any simulated input to any simulating halt
>>>>>>>>>>>> decider would never reach the final state of this simulated
>>>>>>>>>>>> input in any finite number of steps it is always correct for
>>>>>>>>>>>> the simulating halt decider to abort its simulation and
>>>>>>>>>>>> transition to its reject state.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Can you PROVE that statement, or is this just one of your
>>>>>>>>>>> false 'self evident truth'. Does the proof include the
>>>>>>>>>>> posibility that the input includes a copy of the decider?
>>>>>>>>>>>
>>>>>>>>>>> The problem is that IF the simulating halt decider does abort
>>>>>>>>>>> its input based on some condition, then it is no longer a
>>>>>>>>>>> source of truth for the halting status of that input.
>>>>>>>>>>>
>>>>>>>>>>> It turns out that for H^, if H does abort its simulation,
>>>>>>>>>>> then it turns out that an actual simulation of the input
>>>>>>>>>>> proves that it will halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You really must have actual brain damage. That would not be
>>>>>>>>>> your fault
>>>>>>>>>> I have told you the Linz definintion of halting many dozens of
>>>>>>>>>> times:
>>>>>>>>>>
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And stopping simulating doesn't mean non-halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> WRONG. UTM never halting means does not Halt, use the right
>>>>>>> definitons.
>>>>>>>
>>>>>>
>>>>>> I give up on you again.
>>>>>> You can't understand that infinite behavior patterns can be
>>>>>> recognized.
>>>>>
>>>>> Prove it!!!
>>>>>
>>>>> Show the actual pattern.
>>>>>
>>>>> Note, it can't be the H sees the machine it is simulating 'calling'
>>>>> H with the same inputs it is simulating, as we can show that if H
>>>>> uses this then H^ will halt,
>>>> OK SO YOU ARE A LIAR, THAT MAKES THINKS SIMPLE.
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>
>>> Halting means it DOES NOT reach the final state.
>>>
>>> Halting requires having an actual machine defined.
>>>
>>> You keep on talking about H as if it is actually an amagamation of a
>>> family of machines, THAT is not allowed. H needs to be a SPECIFIC
>>> example of one.
>>>
>>> Yes, you can make a proof to show that NO machine in a class can do
>>> something, but that proof needs to look at each machine as a specific
>>> machine.
>>>
>>> You claimed 'Proof of non-halting' just shows that No H which aborts
>>> a simulation can ever simulate long enough to see the Halt state, which
>>
>> In exactly the same way that no H can simulate an infinite loop long
>> enough to see this infinite loop stop running.
>>
>> I take it back that you are a liar, you just aren't very bright.
>>
>>
>
>
> No, because there ARE patterns that do reliably detect that, as can
> actually be proven. There ARE Theorems that have been proven that you
> can use to prove that case. You just can't find one that works for the
> H^ / H interaction, because it turns out that there really isn't one.
>
> If H answers about H^ <H^>, by construction H^ will make the answer
> wrong. This is possible, and H^ does it.
>

On 1/22/22 8:07 PM, olcott wrote:
> On 1/22/2022 6:34 PM, Richard Damon wrote:
>> On 1/22/22 7:12 PM, olcott wrote:
>>> On 1/22/2022 5:54 PM, Richard Damon wrote:
>>>>
>>>> On 1/22/22 6:22 PM, olcott wrote:
>>>>> On 1/22/2022 5:18 PM, Richard Damon wrote:
>>>>>> On 1/22/22 6:03 PM, olcott wrote:
>>>>>>> On 1/22/2022 4:45 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/22/22 5:32 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 4:45 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for its simulated input to reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state or the number of steps required for H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to match an infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proving that the simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state. In this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case H aborts the simulation of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> pattern, thus your H can't correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort and becomes non-answering and thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAILS to be a decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ignored that proof, showing you have no
>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter for the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you MUST provide it or accept that your
>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic is just plain flawed as you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming the existance of something that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider for you halt decider to use,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can write a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is now a single machine with a single start
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine is computationally equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the direct execution of this same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine H can always form its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the basis of what the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would keep
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>> steps that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>> would ever reach its final state conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that embedded_H is correct to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of this input and transition
>>>>>>>>>>>>>>>>>>>>>>>>>>> to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a
>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps, gives the wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>>> because it only looked to see if the input
>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't halt at some specific finite number.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite
>>>>>>>>>>>>>>>>>>>>>>>>> (or infinite) number of steps such that the
>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to embedded_H reaches its final
>>>>>>>>>>>>>>>>>>>>>>>>> state then we know that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And the only case when that happens is when H
>>>>>>>>>>>>>>>>>>>>>>>> does not abort its simulation,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case.
>>>>>>>>>>>>>>>>>>>>>>> The simulated input to embedded_H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it
>>>>>>>>>>>>>>>>>>>>>> doesn't matter if IT sees it or not, as it isn't
>>>>>>>>>>>>>>>>>>>>>> then a UTM any longer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It remains true (invariant) that the simulated
>>>>>>>>>>>>>>>>>>>>> input to embedded_H cannot possibly ever reach its
>>>>>>>>>>>>>>>>>>>>> final state no matter what embedded_H does, thus
>>>>>>>>>>>>>>>>>>>>> conclusively proving that this input never halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then
>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^> and the UTM Simulation of <H^>
>>>>>>>>>>>>>>>>>>>>>> <H^> will go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is
>>>>>>>>>>>>>>>>>>>>> only accountable for computing the mapping from ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the behavior
>>>>>>>>>>>>>>>>>>>>> specified by these inputs. embedded_H is not
>>>>>>>>>>>>>>>>>>>>> accountable for the behavior of the computation
>>>>>>>>>>>>>>>>>>>>> that it is contained within: Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> because this is not an actual input to embedded_H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will
>>>>>>>>>>>>>>>>>>>> show that H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You can define that a cat is a dog, yet the actual
>>>>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly reach
>>>>>>>>>>>>>>>>>>> its final state NO MATTER WHAT.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the simulated input cannot possibly every reach its
>>>>>>>>>>>>>>>>> final state no matter what embedded_H does then this
>>>>>>>>>>>>>>>>> simulated input is correctly determined to meet the
>>>>>>>>>>>>>>>>> Linz definition of never halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that the simulated input DOES reach its final
>>>>>>>>>>>>>>>> state if H/embeded_H goes to H.Qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already
>>>>>>>>>>>>>>> aborted its simulated input making it utterly impossible
>>>>>>>>>>>>>>> for any aspect of this simulated input to do anything at
>>>>>>>>>>>>>>> all.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is simply beyond your intellectual capacity:
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is true for infinite loops, infinite recursion,
>>>>>>>>>>>>> infinitely nested simulation and all other non halting inputs:
>>>>>>>>>>>>>
>>>>>>>>>>>>> When-so-ever any simulated input to any simulating halt
>>>>>>>>>>>>> decider would never reach the final state of this simulated
>>>>>>>>>>>>> input in any finite number of steps it is always correct
>>>>>>>>>>>>> for the simulating halt decider to abort its simulation and
>>>>>>>>>>>>> transition to its reject state.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Can you PROVE that statement, or is this just one of your
>>>>>>>>>>>> false 'self evident truth'. Does the proof include the
>>>>>>>>>>>> posibility that the input includes a copy of the decider?
>>>>>>>>>>>>
>>>>>>>>>>>> The problem is that IF the simulating halt decider does
>>>>>>>>>>>> abort its input based on some condition, then it is no
>>>>>>>>>>>> longer a source of truth for the halting status of that input.
>>>>>>>>>>>>
>>>>>>>>>>>> It turns out that for H^, if H does abort its simulation,
>>>>>>>>>>>> then it turns out that an actual simulation of the input
>>>>>>>>>>>> proves that it will halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You really must have actual brain damage. That would not be
>>>>>>>>>>> your fault
>>>>>>>>>>> I have told you the Linz definintion of halting many dozens
>>>>>>>>>>> of times:
>>>>>>>>>>>
>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> Any you can't seem to rememeber that I ever said it once.
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>>>>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And stopping simulating doesn't mean non-halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>> Matching the infinite behavior pattern means not halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG. UTM never halting means does not Halt, use the right
>>>>>>>> definitons.
>>>>>>>>
>>>>>>>
>>>>>>> I give up on you again.
>>>>>>> You can't understand that infinite behavior patterns can be
>>>>>>> recognized.
>>>>>>
>>>>>> Prove it!!!
>>>>>>
>>>>>> Show the actual pattern.
>>>>>>
>>>>>> Note, it can't be the H sees the machine it is simulating
>>>>>> 'calling' H with the same inputs it is simulating, as we can show
>>>>>> that if H uses this then H^ will halt,
>>>>> OK SO YOU ARE A LIAR, THAT MAKES THINKS SIMPLE.
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>>
>>>>
>>>> Halting means it DOES NOT reach the final state.
>>>>
>>>> Halting requires having an actual machine defined.
>>>>
>>>> You keep on talking about H as if it is actually an amagamation of a
>>>> family of machines, THAT is not allowed. H needs to be a SPECIFIC
>>>> example of one.
>>>>
>>>> Yes, you can make a proof to show that NO machine in a class can do
>>>> something, but that proof needs to look at each machine as a
>>>> specific machine.
>>>>
>>>> You claimed 'Proof of non-halting' just shows that No H which aborts
>>>> a simulation can ever simulate long enough to see the Halt state, which
>>>
>>> In exactly the same way that no H can simulate an infinite loop long
>>> enough to see this infinite loop stop running.
>>>
>>> I take it back that you are a liar, you just aren't very bright.
>>>
>>>
>>
>>
>> No, because there ARE patterns that do reliably detect that, as can
>> actually be proven. There ARE Theorems that have been proven that you
>> can use to prove that case. You just can't find one that works for the
>> H^ / H interaction, because it turns out that there really isn't one.
>>
>> If H answers about H^ <H^>, by construction H^ will make the answer
>> wrong. This is possible, and H^ does it.
>>
>
> Because a halt decider is a decider embedded_H is only accountable for
> computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
> behavior specified by these inputs.

On 1/22/2022 7:18 PM, Richard Damon wrote:
> On 1/22/22 8:07 PM, olcott wrote:
>> On 1/22/2022 6:34 PM, Richard Damon wrote:

> The input <H^> <H^>  EXACTLY represent H^ applied to <H^> or you have
> lied for the whole time that you are following the definitions of the
> Halting problem.
>
> Since ALL copies of a given computation (Turing Machine/Input) behave
> the same, H does need to give the answer that matchs the behavior of the
> computation that is using it.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

It is not true that Ĥ applied to ⟨Ĥ⟩ specifies the same sequence of
configurations as embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

--
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/22/22 8:33 PM, olcott wrote:
> On 1/22/2022 7:18 PM, Richard Damon wrote:
>> On 1/22/22 8:07 PM, olcott wrote:
>>> On 1/22/2022 6:34 PM, Richard Damon wrote:
>
>> The input <H^> <H^>  EXACTLY represent H^ applied to <H^> or you have
>> lied for the whole time that you are following the definitions of the
>> Halting problem.
>>
>> Since ALL copies of a given computation (Turing Machine/Input) behave
>> the same, H does need to give the answer that matchs the behavior of
>> the computation that is using it.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> It is not true that Ĥ applied to ⟨Ĥ⟩ specifies the same sequence of
> configurations as embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>

Yes, H applied to <H^> <H^> is a different computation then H^ applied
to <H^>, but what you keep on missing is that the requirement on H, to
be correct, is its answer must match what what the behavior of the
machine its input represents, which is the same as the behavior of
giving its same input to a UTM.

So, H applied to <H^> <H^> needs to answer about the behavior of H^
applied to <H^>.

Which shows that your previous statement:

> embedded_H is not accountable Ĥ applied to ⟨Ĥ⟩
> because this is not an actual input to embedded_H.

is a flat out lie, as the input to embedded H is <H^> <H^> which means
its answer needs to match the behavior of H^ applied to <H^>

I've lost track of how many times you have made this mistake.

FAIL

On 1/22/2022 8:04 PM, Richard Damon wrote:
>
> On 1/22/22 8:33 PM, olcott wrote:
>> On 1/22/2022 7:18 PM, Richard Damon wrote:
>>> On 1/22/22 8:07 PM, olcott wrote:
>>>> On 1/22/2022 6:34 PM, Richard Damon wrote:
>>
>>> The input <H^> <H^>  EXACTLY represent H^ applied to <H^> or you have
>>> lied for the whole time that you are following the definitions of the
>>> Halting problem.
>>>
>>> Since ALL copies of a given computation (Turing Machine/Input) behave
>>> the same, H does need to give the answer that matchs the behavior of
>>> the computation that is using it.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> It is not true that Ĥ applied to ⟨Ĥ⟩ specifies the same sequence of
>> configurations as embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>
> Yes, H applied to <H^> <H^> is a different computation then H^ applied
> to <H^>, but what you keep on missing is that the requirement on H, to
> be correct, is its answer must match what what the behavior of the
> machine its input represents, which is the same as the behavior of
> giving its same input to a UTM.
>
> So, H applied to <H^> <H^> needs to answer about the behavior of H^
> applied to <H^>.
>

That is not the way that deciders, thus halt deciders work. A decider
thus a halt decider only maps its input to an accept or reject state.

It must do this on the basis of the actual behavior specified by its
actual input. The most certain way to determine the actual behavior of
the actual input is for embedded_H to simulate this input.

Because we can see that there are no finite number of steps that
embedded_H can simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ such that the simulated input
⟨Ĥ⟩ ever reaches its own final state we know that this simulated input
never halts even though it is forced to stop running.

--
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/22/22 9:16 PM, olcott wrote:
> On 1/22/2022 8:04 PM, Richard Damon wrote:
>>
>> On 1/22/22 8:33 PM, olcott wrote:
>>> On 1/22/2022 7:18 PM, Richard Damon wrote:
>>>> On 1/22/22 8:07 PM, olcott wrote:
>>>>> On 1/22/2022 6:34 PM, Richard Damon wrote:
>>>
>>>> The input <H^> <H^>  EXACTLY represent H^ applied to <H^> or you
>>>> have lied for the whole time that you are following the definitions
>>>> of the Halting problem.
>>>>
>>>> Since ALL copies of a given computation (Turing Machine/Input)
>>>> behave the same, H does need to give the answer that matchs the
>>>> behavior of the computation that is using it.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> It is not true that Ĥ applied to ⟨Ĥ⟩ specifies the same sequence of
>>> configurations as embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> Yes, H applied to <H^> <H^> is a different computation then H^ applied
>> to <H^>, but what you keep on missing is that the requirement on H, to
>> be correct, is its answer must match what what the behavior of the
>> machine its input represents, which is the same as the behavior of
>> giving its same input to a UTM.
>>
>> So, H applied to <H^> <H^> needs to answer about the behavior of H^
>> applied to <H^>.
>>
>
> That is not the way that deciders, thus halt deciders work. A decider
> thus a halt decider only maps its input to an accept or reject state.
>
> It must do this on the basis of the actual behavior specified by its
> actual input. The most certain way to determine the actual behavior of
> the actual input is for embedded_H to simulate this input.
>
> Because we can see that there are no finite number of steps that
> embedded_H can simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ such that the simulated input
> ⟨Ĥ⟩ ever reaches its own final state we know that this simulated input
> never halts even though it is forced to stop running.
>
>

But you are missing that for H to be a CORRECT decider, its answer MUST
match its REQUIREMENT. You make a great WRONG decider.

That REQUIREMENT is that H goes to H.Qy if and only if the computation
its input represent halts (or equivalently UTM of its input will halt)
and to H.Qy if it NEVER will halt. This is NOT based on the partial
simulaton that H does, but the proper simulation of the UTM on the exact
input that H is looking at, and that H^ built on this H.

You make the false logic of varying H, but since that changes the input,
you get no real conclusions, except to prove that no H by your design
can ever prove its input halts.

For any GIVEN H, and thus input <H^> <H^> it is a fact that if H doesn't
abort then it will never answer, and if H does abort and go to H.Qn,
then the UTM simulation of that same input will end up at H^.Qn and Halt.

FAIL.

On 1/22/2022 8:33 PM, Richard Damon wrote:
> On 1/22/22 9:16 PM, olcott wrote:
>> On 1/22/2022 8:04 PM, Richard Damon wrote:
>>>
>>> On 1/22/22 8:33 PM, olcott wrote:
>>>> On 1/22/2022 7:18 PM, Richard Damon wrote:
>>>>> On 1/22/22 8:07 PM, olcott wrote:
>>>>>> On 1/22/2022 6:34 PM, Richard Damon wrote:
>>>>
>>>>> The input <H^> <H^>  EXACTLY represent H^ applied to <H^> or you
>>>>> have lied for the whole time that you are following the definitions
>>>>> of the Halting problem.
>>>>>
>>>>> Since ALL copies of a given computation (Turing Machine/Input)
>>>>> behave the same, H does need to give the answer that matchs the
>>>>> behavior of the computation that is using it.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> It is not true that Ĥ applied to ⟨Ĥ⟩ specifies the same sequence of
>>>> configurations as embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>
>>> Yes, H applied to <H^> <H^> is a different computation then H^
>>> applied to <H^>, but what you keep on missing is that the requirement
>>> on H, to be correct, is its answer must match what what the behavior
>>> of the machine its input represents, which is the same as the
>>> behavior of giving its same input to a UTM.
>>>
>>> So, H applied to <H^> <H^> needs to answer about the behavior of H^
>>> applied to <H^>.
>>>
>>
>> That is not the way that deciders, thus halt deciders work. A decider
>> thus a halt decider only maps its input to an accept or reject state.
>>
>> It must do this on the basis of the actual behavior specified by its
>> actual input. The most certain way to determine the actual behavior of
>> the actual input is for embedded_H to simulate this input.
>>
>> Because we can see that there are no finite number of steps that
>> embedded_H can simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ such that the simulated
>> input ⟨Ĥ⟩ ever reaches its own final state we know that this simulated
>> input never halts even though it is forced to stop running.
>>
>>
>
> But you are missing that for H to be a CORRECT decider, its answer MUST
> match its REQUIREMENT. You make a great WRONG decider.
>
> That REQUIREMENT is that H goes to H.Qy if and only if the computation
> its input represent halts (or equivalently UTM of its input will halt)
> and to H.Qy if it NEVER will halt. This is NOT based on the partial
> simulaton that H does, but the proper simulation of the UTM on the exact
> input that H is looking at, and that H^ built on this H.
>

Your understanding is based on rote memorization of textbooks
definitions that were insufficiently precise to fully account for the
subtleties of pathological self-reference.

No one ever bothered to discover these subtleties because they simply
assumed that that pathological self-reference was an impenetrable wall.

I have made pathological self-reference my primary research focus since
2004. It applies to the liar paradox, Gödel's 1931 Incompleteness
Theorem, the Tarski Undefinability Theorem and the Halting problem proofs.

The way that I define the job of a halt decider accounts for the
subtleties that are ignored by the textbook definitions.

A halt decider must base its halt status decision on what the behavior
of the pure simulation of the simulated input would be if this input was
allowed to continue uninterrupted.

> You make the false logic of varying H, but since that changes the input,
> you get no real conclusions, except to prove that no H by your design
> can ever prove its input halts.
>
> For any GIVEN H, and thus input <H^> <H^> it is a fact that if H doesn't
> abort then it will never answer, and if H does abort and go to H.Qn,
> then the UTM simulation of that same input will end up at H^.Qn and Halt.
>
> 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/22/22 9:50 PM, olcott wrote:
> On 1/22/2022 8:33 PM, Richard Damon wrote:
>> On 1/22/22 9:16 PM, olcott wrote:
>>> On 1/22/2022 8:04 PM, Richard Damon wrote:
>>>>
>>>> On 1/22/22 8:33 PM, olcott wrote:
>>>>> On 1/22/2022 7:18 PM, Richard Damon wrote:
>>>>>> On 1/22/22 8:07 PM, olcott wrote:
>>>>>>> On 1/22/2022 6:34 PM, Richard Damon wrote:
>>>>>
>>>>>> The input <H^> <H^>  EXACTLY represent H^ applied to <H^> or you
>>>>>> have lied for the whole time that you are following the
>>>>>> definitions of the Halting problem.
>>>>>>
>>>>>> Since ALL copies of a given computation (Turing Machine/Input)
>>>>>> behave the same, H does need to give the answer that matchs the
>>>>>> behavior of the computation that is using it.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> It is not true that Ĥ applied to ⟨Ĥ⟩ specifies the same sequence of
>>>>> configurations as embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>
>>>> Yes, H applied to <H^> <H^> is a different computation then H^
>>>> applied to <H^>, but what you keep on missing is that the
>>>> requirement on H, to be correct, is its answer must match what what
>>>> the behavior of the machine its input represents, which is the same
>>>> as the behavior of giving its same input to a UTM.
>>>>
>>>> So, H applied to <H^> <H^> needs to answer about the behavior of H^
>>>> applied to <H^>.
>>>>
>>>
>>> That is not the way that deciders, thus halt deciders work. A decider
>>> thus a halt decider only maps its input to an accept or reject state.
>>>
>>> It must do this on the basis of the actual behavior specified by its
>>> actual input. The most certain way to determine the actual behavior
>>> of the actual input is for embedded_H to simulate this input.
>>>
>>> Because we can see that there are no finite number of steps that
>>> embedded_H can simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ such that the simulated
>>> input ⟨Ĥ⟩ ever reaches its own final state we know that this
>>> simulated input never halts even though it is forced to stop running.
>>>
>>>
>>
>> But you are missing that for H to be a CORRECT decider, its answer
>> MUST match its REQUIREMENT. You make a great WRONG decider.
>>
>> That REQUIREMENT is that H goes to H.Qy if and only if the computation
>> its input represent halts (or equivalently UTM of its input will halt)
>> and to H.Qy if it NEVER will halt. This is NOT based on the partial
>> simulaton that H does, but the proper simulation of the UTM on the
>> exact input that H is looking at, and that H^ built on this H.
>>
>
> Your understanding is based on rote memorization of textbooks
> definitions that were insufficiently precise to fully account for the
> subtleties of pathological self-reference.

No, the definition is the definition.

I guess this is your ADMISSION that you are not following to REQUREMENTS
of the Halting Problem and thus just spreading your POOP.

>
> No one ever bothered to discover these subtleties because they simply
> assumed that that pathological self-reference was an impenetrable wall.

No, because there is NO special exemption for self reference.

Please provide a source that ALLOWS you to make this change.

FAIL.

>
> I have made pathological self-reference my primary research focus since
> 2004. It applies to the liar paradox, Gödel's 1931 Incompleteness
> Theorem, the Tarski Undefinability Theorem and the Halting problem proofs.

Self Reference is REAL. It may be 'Pathological' in your mind becuase it
kills some of your erroneous ideas of what it true.

>
> The way that I define the job of a halt decider accounts for the
> subtleties that are ignored by the textbook definitions.

Then you are just defining POOP.

FAIL.

>
> A halt decider must base its halt status decision on what the behavior
> of the pure simulation of the simulated input would be if this input was
> allowed to continue uninterrupted.

Right.

If H <H^> <H^> -> H.Qn then H^ <H^> -> H^.Qn and Halts, thus H was wrong.

That is the behavior of the UTM simulation of <H^> <H^> when H doesn't
interfere with it, only aborting its INTERNAL simulation of its input.

FAIL.

You look at the WRONG question, some of which are:

What does the aborted simulation of the input show: NOTHING.

What would the input do if the copy of H inside it was just a UTM: Wrong
Input.

FAIL.

>
>> You make the false logic of varying H, but since that changes the
>> input, you get no real conclusions, except to prove that no H by your
>> design can ever prove its input halts.
>>
>> For any GIVEN H, and thus input <H^> <H^> it is a fact that if H
>> doesn't abort then it will never answer, and if H does abort and go to
>> H.Qn, then the UTM simulation of that same input will end up at H^.Qn
>> and Halt.
>>
>> FAIL.
>>
>>
>
>

On 1/22/2022 3:36 PM, Richard Damon wrote:
> On 1/22/22 4:25 PM, olcott wrote:
>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>

>> This is true for infinite loops, infinite recursion, infinitely nested
>> simulation and all other non halting inputs:
>>
>> When-so-ever any simulated input to any simulating halt decider would
>> never reach the final state of this simulated input in any finite
>> number of steps it is always correct for the simulating halt decider
>> to abort its simulation and transition to its reject state.
>>
>
> Can you PROVE that statement, or is this just one of your false 'self
> evident truth'.

Anyone that knows that x86 language can tell that its easy to match the
infinite loop pattern:

_Infinite_Loop()
[000015fa](01) 55 push ebp
[000015fb](02) 8bec mov ebp,esp
[000015fd](02) ebfe jmp 000015fd
[000015ff](01) 5d pop ebp
[00001600](01) c3 ret
Size in bytes:(0007) [00001600]

---[000015fa][002126f0][002126f4] 55 push ebp
---[000015fb][002126f0][002126f4] 8bec mov ebp,esp
---[000015fd][002126f0][002126f4] ebfe jmp 000015fd
---[000015fd][002126f0][002126f4] ebfe jmp 000015fd

> Does the proof include the posibility that the input
> includes a copy of the decider?
>

It is always the case that a simulating halt decider can correctly base
its halt status decision on the behavior pure simulation of its input.

We know that this must be true because we know that the pure UTM
simulation of an Turing Machine description is defined to have
equivalent behavior to that of the direct execution of the same machine

> The problem is that IF the simulating halt decider does abort its input
> based on some condition, then it is no longer a source of truth for the
> halting status of that input.
>

It is not answering the question: Does the input stop running?

It is answering the question:
Would the pure simulation of the input ever stop running?

> It turns out that for H^, if H does abort its simulation, then it turns
> out that an actual simulation of the input proves that it will halt.
>

--
Copyright 2021 Pete Olcott

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