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:I have shown how my system directly applies to the actual halting
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:https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
The halting problem is vague on the definition of halting, it >>>>>>>>>> includes
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:No that is not it. That is like saying "by definition" >>>>>>>>>>>>>> Sum(3,5) is
On 1/31/2022 6:41 PM, Richard Damon wrote:Don't know how you get that from what I said.
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)? >>>>>>>>>>>>>>>
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^>
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.
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.
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'?
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.
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:I have shown how my system directly applies to the actual halting >>>>>>>> problem and it can be understood as correct by anyone that
On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote: >>>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine >>>>>>>>>>
The halting problem is vague on the definition of halting, >>>>>>>>>>>> it includes
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:No that is not it. That is like saying "by definition" >>>>>>>>>>>>>>>> Sum(3,5) is
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^>
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.
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.
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'?
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.
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:I have shown how my system directly applies to the actual halting >>>>>>>>>> problem and it can be understood as correct by anyone that >>>>>>>>>> understands
On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote: >>>>>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine >>>>>>>>>>>>
Sounds like a NDTM.The halting problem is vague on the definition of halting, >>>>>>>>>>>>>> it includes
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:
being asked about Sum(7,8).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
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.
that a machine has stopped running and that a machine >>>>>>>>>>>>>> cannot reach its
final state. My definition only includes the latter. >>>>>>>>>>>>>
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'?
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?
You must be a liar.
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
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:You must be a liar.
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:I have shown how my system directly applies to the actual >>>>>>>>>>>> halting
On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote: >>>>>>>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine >>>>>>>>>>>>>>
Sounds like a NDTM.The halting problem is vague on the definition of >>>>>>>>>>>>>>>> halting, it includes
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:
being asked about Sum(7,8).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
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.
that a machine has stopped running and that a machine >>>>>>>>>>>>>>>> cannot reach its
final state. My definition only includes the latter. >>>>>>>>>>>>>>>
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'?
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
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.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 428 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 110:26:17 |
| Calls: | 9,053 |
| Files: | 13,395 |
| Messages: | 6,016,034 |