On 2/1/2022 8:48 PM, Richard Damon wrote:
> On 2/1/22 9:41 PM, olcott wrote:
>> On 2/1/2022 8:21 PM, Richard Damon wrote:
>>> On 2/1/22 9:14 PM, olcott wrote:
>>>> On 2/1/2022 7:55 PM, Richard Damon wrote:
>>>>> On 2/1/22 8:47 PM, olcott wrote:
>>>>>> On 2/1/2022 7:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/1/22 8:03 PM, olcott wrote:
>>>>>>>> On 2/1/2022 6:25 PM, Richard Damon wrote:
>>>>>>>>> On 2/1/22 5:18 PM, olcott wrote:
>>>>>>>>>> On 2/1/2022 4:12 PM, wij wrote:
>>>>>>>>>>> On Wednesday, 2 February 2022 at 05:36:39 UTC+8, olcott wrote:
>>>>>>>>>>>> On 2/1/2022 3:23 PM, wij wrote:
>>>>>>>>>>>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>>>>>>>>>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>>>>>>>>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>>>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> These statements need the conditions, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> corresponding state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified as an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>> syntactically
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>> from you above
>>>>>>>>>>>>>>>>>>>>>>>>>>> statement the right answer is based on if
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means
>>>>>>>>>>>>>>>>>>>>>>>>>>> if H^ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is
>>>>>>>>>>>>>>>>>>>>>>>>>> that you cannot
>>>>>>>>>>>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is
>>>>>>>>>>>>>>>>>>>>>>>>>> as if you either
>>>>>>>>>>>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are
>>>>>>>>>>>>>>>>>>>>>>>>>> addicted to
>>>>>>>>>>>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input
>>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H and
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> After we have mutual agreement on this point
>>>>>>>>>>>>>>>>>>>>>>>>>> we will move on
>>>>>>>>>>>>>>>>>>>>>>>>>> to the points that logically follow from this
>>>>>>>>>>>>>>>>>>>>>>>>>> one.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Richard does not accept that the input to the
>>>>>>>>>>>>>>>>>>>>>>>> copy of Linz H
>>>>>>>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting
>>>>>>>>>>>>>>>>>>>>>>>> that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, but apparently you can't understand actual
>>>>>>>>>>>>>>>>>>>>>>> English words.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT
>>>>>>>>>>>>>>>>>>>>>>> ANSWER that H must
>>>>>>>>>>>>>>>>>>>>>>> give is based on the behavior of H^ applied to
>>>>>>>>>>>>>>>>>>>>>>> <H^> BECAUSE OF
>>>>>>>>>>>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In other words Sum(3,5) must return the value of
>>>>>>>>>>>>>>>>>>>>>> Sum(7,8)?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Any moron knows that a function is only
>>>>>>>>>>>>>>>>>>>>>> accountable for its actual
>>>>>>>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS
>>>>>>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>>>>>>> DEFINITION of the Halting Problem that H is being
>>>>>>>>>>>>>>>>>>>>> asked to decide
>>>>>>>>>>>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>> No that is not it. That is like saying "by
>>>>>>>>>>>>>>>>>>>> definition" Sum(3,5) is
>>>>>>>>>>>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again your RED HERRING.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if
>>>>>>>>>>>>>>>>>>> it doesn't
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> AGREED?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>>>>>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly
>>>>>>>>>>>>>>>>>> transition to ⟨Ĥ⟩.qn ?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you say 'No', then you aren't doing the halting
>>>>>>>>>>>>>>>>> problem, as the
>>>>>>>>>>>>>>>>> requirement I stated is EXACTLY the requirement of the
>>>>>>>>>>>>>>>>> Halting Problem.
>>>>>>>>>>>>>>>> The halting problem is vague on the definition of
>>>>>>>>>>>>>>>> halting, it includes
>>>>>>>>>>>>>>>> that a machine has stopped running and that a machine
>>>>>>>>>>>>>>>> cannot reach its
>>>>>>>>>>>>>>>> final state. My definition only includes the latter.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sounds like a NDTM.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is not a NDTM, a Turing Machine only actually halts
>>>>>>>>>>>>>> when it reaches
>>>>>>>>>>>>>> its own final state. People not very familiar with this
>>>>>>>>>>>>>> material may get
>>>>>>>>>>>>>> confused and believe that a TM halts when its stops
>>>>>>>>>>>>>> running because its
>>>>>>>>>>>>>> simulation has been aborted. This key distinction is not
>>>>>>>>>>>>>> typically
>>>>>>>>>>>>>> specified in most halting problem proofs.
>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>> whenever it enters
>>>>>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Where did Linz mention 'simulation' and 'abort'?
>>>>>>>>>>>> I have shown how my system directly applies to the actual
>>>>>>>>>>>> halting
>>>>>>>>>>>> problem and it can be understood as correct by anyone that
>>>>>>>>>>>> understands
>>>>>>>>>>>> the halting problem at a much deeper level than rote
>>>>>>>>>>>> memorization.
>>>>>>>>>>>>
>>>>>>>>>>>> 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
>>>>>>>>>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly
>>>>>>>>>>>> transition to
>>>>>>>>>>>> ⟨Ĥ⟩.qn ? (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>>>>>>>>>>>>> You are defining POOP [Richard Damon]
>>>>>>>>>>>>> André had recommended many online sites for you to learn or
>>>>>>>>>>>>> test, I forget which posts it is.
>>>>>>>>>>>>> But I think C program is more simpler.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> --
>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>> André had recommended many online sites for you to learn or
>>>>>>>>>>> test, I forget which posts it is.
>>>>>>>>>>> Type it into a TM simulator and prove your claim, your words
>>>>>>>>>>> are meaningless.
>>>>>>>>>>
>>>>>>>>>> I have already proved that I know one key fact about halt
>>>>>>>>>> deciders that no one else here seems to know.
>>>>>>>>>>
>>>>>>>>>> No one here understands that because a halt decider is a
>>>>>>>>>> decider that it must compute the mapping from its inputs to an
>>>>>>>>>> accept of reject state on the basis of the actual behavior
>>>>>>>>>> specified by these inputs.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And the ACTUAL BEHAVIOR of the input <H^> <H^> is EXACTLY the
>>>>>>>>> behavior of H^ applied to <H^> which does Halt if H goes to H.Qn.
>>>>>>>>
>>>>>>>>
>>>>>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly
>>>>>>>> transition to ⟨Ĥ⟩.qn ?
>>>>>>>
>>>>>>> Doesn't matter if embedded_H is not a ACTUAL UTM.
>>>>>>>
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩
>>>>>> ⟨Ĥ2⟩
>>>>>>
>>>>>> As soon as embedded_H correctly recognizes this as an infinite
>>>>>> behavior pattern:
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
>>>>>> ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
>>>>>> ⟨Ĥ4⟩
>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>>>> ⟨Ĥ5⟩...
>>>>>>
>>>>>> Then embedded_H can correctly abort the simulation of its input
>>>>>> and correctly transition to Ĥ.qn.
>>>>>>
>>>>>> The above words can be verified as completely true entirely on the
>>>>>> basis of their meaning.
>>>>>>
>>>>>
>>>>>
>>>>> Nope, proven otherwise.
>>>>>
>>>>
>>>> What I said above is true by logical necessity and you simply aren't
>>>> bright enough to understand this.
>>>>
>>>
>>> Then you can provide a step by step proof of it?
>>>
>>>> If X then Y and if Y then Z and X then Z. There is no way around this.
>>>
>>> And what are your X, Y and Z?
>>>
>>>
>>>>
>>>> If embedded_H correctly recognizes that its input specifies non
>>>> halting behavior then it is necessarily correct for embedded_H to
>>>> report this
>>>> non halting behavior.
>>>
>>> *IF* it correct recognizes. Since there is no pattern in H's
>>> simulation of <H^> <H^> THAT IS a proof of non-halting
>> You must be a liar.
>>
>> Then these steps would keep repeating:
>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>     Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>     Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>> ⟨Ĥ5⟩...
>
> But if H <H^> <H^> -> H.Qn aften N steps, then it is also true that the
> computation H1 <H^> <H^> -> H.Qn after N steps and the pattern ends.

This is a woeful lack of basic software engineering skill on your part.
When a process is terminated by the operating system no aspect of this
process continues to execute at all.

embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩. When it kills its simulation every
simulation that was simulated by any level of ⟨Ĥ⟩ is also immediately
killed off because its parent process has been terminated.

--
Copyright 2021 Pete Olcott

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