On 3/16/22 3:10 PM, olcott wrote:
> On 3/16/2022 12:37 PM, Mike Terry wrote:
>> On 16/03/2022 17:20, olcott wrote:
>>> On 3/16/2022 12:04 PM, Mike Terry wrote:
>>>> On 16/03/2022 14:15, olcott wrote:
>>>>> On 3/16/2022 2:21 AM, Jeff Barnett wrote:
>>>>>> On 3/15/2022 4:02 PM, olcott wrote:
>>>>>>> On 3/15/2022 4:48 PM, Jeff Barnett wrote:
>>>>>>>> On 3/15/2022 1:44 PM, olcott wrote:
>>>>>>>>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>>>>>>>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>>>>>>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>>>>>>>>
>>>>>>>>>>     <MAJOR SNIP>
>>>>>>>>>>
>>>>>>>>>>>> So how would you describe a compiler which is
>>>>>>>>>>>> "bootstrapped", i.e. fed its own
>>>>>>>>>>>> source code?
>>>>>>>>>>>
>>>>>>>>>>> A compiler that is fed its own source-code is not the same
>>>>>>>>>>> because the compiler does not execute this source-code.
>>>>>>>>>> This is one of your best Peter. Along the way you've had 100s
>>>>>>>>>> of messages that have said that simulation as a basis for a
>>>>>>>>>> Halting Problem solution is hopeless. Of course you pay no
>>>>>>>>>> attention because it's unlikely you understood what you were
>>>>>>>>>> being told. So here you are looping back over years of the
>>>>>>>>>> same bone headed approach.
>>>>>>>>>>
>>>>>>>>>> Let's start with a few basics:
>>>>>>>>>>
>>>>>>>>>> Nothing executes source code; even an interpreter ingests it
>>>>>>>>>> first.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> A compiler the compiles its own source-code is nothing at all
>>>>>>>>> like executing this source code.
>>>>>>>>
>>>>>>>> You really do have rocks in your head. Think for at least 2
>>>>>>>> seconds before responding and getting it all wrong. The mistakes
>>>>>>>> you are making with the above statement are so basic that I
>>>>>>>> hardly know where to start. As I've been told many times it's
>>>>>>>> harder to teach Kindergarten than grad students. And in this
>>>>>>>> instance, with you, we have a sixty year old crawling around in
>>>>>>>> diapers.
>>>>>>>>
>>>>>>>>> An interpreter that interprets source code can be reasonably
>>>>>>>>> construed as running this source code.
>>>>>>>>
>>>>>>>> Perhaps. The issue is it really doesn't know that it is it's own
>>>>>>>> source code, does it? And, in fact, neither it nor any observer
>>>>>>>> is aware of any vicious self reference. Only a dunce would worry
>>>>>>>> about it. You do worry don't you?
>>>>>>>
>>>>>>> In other words you are saying that no one is bright enough to be
>>>>>>> able to detect what is essentially infinite recursion.
>>>>>> You soiled your diapers again. I said nothing of the sort. I will
>>>>>> say it now though, nobody is intelligent enough to systematically
>>>>>> (by algorithm) spot infinite recursion. God can't do it either.
>>>>>> It's not theoretically possible. Only an ignorant nitwit would not
>>>>>> know that and prattle on for years about it.
>>>>>>
>>>>>
>>>>> I already have a group of many experts that concur that infinite
>>>>> recursion can be detected and the criterion measure by which it is
>>>>> correctly detected.
>>>>
>>>> I'm afraid that you lack the intellect to understand exactly what
>>>> other people are saying on technical issues.  How many times have
>>>> you quoted me (and others here) as supporting something you've
>>>> claimed, whereas it turns out you had just misunderstood some remark
>>>> that had been made? [Answer: lots of times!]
>>>>
>>>> You also have a habit of going elsewhere, and "tricking" the people
>>>> there into "agreeing" with some claim you've made here by not
>>>> properly explaining the full context of your claim.  Then you come
>>>> back here selectively quoting some "expert" to suggest he is
>>>> supporting you. [Like when you went to the x86 group and showed them
>>>> your "trace" asking them if they could see what's going on, and got
>>>> one of them to say "it's looping...".  You failed to mention the
>>>> trace was not the "processor trace" they would naturally expect, and
>>>> that there was simulation involved, and that your trace was in fact
>>>> some kind of "merged simulation trace", and that you were using this
>>>> trace to disprove the Halting Problem theorem.]
>>>>
>>>> It's been pointed out to you many times that algorithms exhist that
>>>> can identify /some/ infinite loops/recursions as such, but no
>>>> algorithm detects ALL non-halting behaviour.
>>>>
>>>> And specifically, your test (looking for more than one call to a
>>>> particular address etc.) is /unsound/ when you try to use it on your
>>>> "merged simulation" trace.  No expert would say otherwise if they
>>>> had been given the full context, so probably you've just tricked
>>>> someone again...
>>>>
>>>>
>>>> Mike.
>>>
>>> None-the-less is is self-evident that the input presented to the copy
>>> of the Linz H embedded at Ĥ.qx does specify infinitely nested
>>> simulation to simulating halt decider embedded_H thus proving that a
>>> transition to Ĥ.qn by embedded_H would be correct.
>>
>> You mean self-evident TO YOU.  To people who have an understanding of
>> TMs it is simply wrong or meaningless (depending on how tolerant
>> people are of your wishy-washy phrasing).
>>
>>
>> Mike.
>>
>
> They simply dogmatically state that the believe that I am wrong about
> this yet cannot point to the specific error because there is none:
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> 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⟩...
>
> The above repeating pattern shows that the correctly simulated input to
> embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
> proving that this simulated input never halts. This enables embedded_H
> to abort its simulation and correctly transition to Ĥ.qn.
>

The error has been pointed out to you many times, but you seem either
too dumb or too dishonest to see/admit the error.

In fact, YOU have even previous provided the trace of H^ applied to <H^>
(or actually P(P) ) that shows that this computation halts, even though
H 'correctly' said that it would never halt, and you were using
convoluted logic to try to claim that it wasn't actually the behavior of
P(P) that mattered.

This PROVES that you claim is incorrect, and you are just being a
pathological liar about it because you can't accept that in Mathematics,
your 'precious' rule that ALL Truth must be Provable, or it isn't really
Truth doesn't hold, because it uses a different concept of Trutht (and
even basic rules of logic).

Allm you have done over that past years is ruin your reputation and
condemn yourself to a life of lying about what you are talking about, as
the real Truth just hurts too much to your soul.

On 3/16/22 4:22 PM, olcott wrote:
> On 3/16/2022 3:11 PM, André G. Isaak wrote:
>> On 2022-03-15 15:44, olcott wrote:
>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>> On 2022-03-15 08:51, olcott wrote:
>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>
>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>
>>>>>>>>> Again, I'll repeat the question which you dishonestly snipped
>>>>>>>>> rather
>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>> repeating it
>>>>>>>>> five times.
>>>>>>>>>
>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be
>>>>>>>>> passed
>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>>>>> reference
>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass
>>>>>>>> this
>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>> Machines.
>>>>>>>
>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as
>>>>>>> an input
>>>>>>> to your decider, then your decider is broken since it must be
>>>>>>> able to
>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>
>>>>>> Though that would actually be a genuine contribution to computer
>>>>>> science.
>>>>>> If you could devise a language such that a large subset of halting
>>>>>> and
>>>>>> non-halting machines could be described, but not machines for
>>>>>> which the
>>>>>> halting status is difficult or impossible for a predefined halt
>>>>>> decider to determine.
>>>>>
>>>>> André does not seem to be able to comprehend that a Turing machine
>>>>> decider cannot possibly have its own self or an encoding of its own
>>>>> self as its input. The closest thing possible that it can have is
>>>>> an encoding of another different instance of itself.
>>>>
>>>> Computations don't have different instances. What would it even mean
>>>> to 'instantiate' a computation?
>>>>
>>>> André
>>>>
>>>
>>> A Turing machine UTM that is simulating its own Turing machine
>>> description is two distinct instances: (executed and simulated) even
>>> if computer science does not bother to pay attention to this level of
>>> detail, or have the terminology to express it.
>>
>> You're confusing computations and Turing Machines.
>>
>> If you pass a UTM a description of itself, it will determine what UTM
>> applied to an empty tape will do.
>>
>> UTM ⟨UTM⟩
>>
>> and
>>
>> UTM ∅
>>
>> are entirely distinct computations.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> In the above: Ĥ applied to ⟨Ĥ⟩ and the ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H
> vary by exactly one level of indirect reference.
>
> embedded_H does not, cannot, and its not supposed to report on the exact
> same computation that contains itself.
>
> embedded_H computes the mapping of its input ⟨Ĥ⟩ ⟨Ĥ⟩ a final state of
> embedded_H.

And this proves you aren't working on the Halting Problem, since BY
DEFINITION the halt decider applied to <M> w needs to report on the
behavior of M applied to w which means that embedded_H applied to <H^>
<H^> needs to report on the behavior of H^ applied to <H^> (the 'level
of indirection' difference being part of the DEFINITION of the mapping
that the decider is to compute).

There is NO 'exception' in the definition for M containing a copy of the
Halt Decider, so you can't claim one.

Since you say this isn't what embedded_H is doing, it is NOT a Halt
Decider, so you fail.

>
>> They are not different 'instances' of some computation. Every
>> "instance" of
>>
>> M ⟨I⟩
>>
>> is the exact same computation. So there is no point in talking about
>> "instances".
>>
>> Do you actually understand what instantiation means?
>>
>> André
>>
>
> What Does Instantiate Mean?
> Instantiate (a verb) and instantiation (the noun) in computer science
> refer to the creation of an object (or an “instance” of a given class)
> in an object-oriented programming (OOP) language. Referencing a class
> declaration, an instantiated object is named and created, in memory or
> on disk.
>
> https://www.techopedia.com/definition/26857/instantiate#:~:text=Instantiate%20(a%20verb)%20and%20instantiation,in%20memory%20or%20on%20disk.
>
>
>
>

On 3/16/22 10:33 AM, olcott wrote:
> On 3/16/2022 6:05 AM, Richard Damon wrote:
>> On 3/15/22 11:32 PM, olcott wrote:
>>> On 3/15/2022 10:02 PM, Richard Damon wrote:
>>>> On 3/15/22 10:43 PM, olcott wrote:
>>>>> On 3/15/2022 9:38 PM, Richard Damon wrote:
>>>>>> On 3/15/22 10:29 PM, olcott wrote:
>>>>>>> On 3/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>> On 3/15/22 9:15 PM, olcott wrote:
>>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>>>>>>> repeating it
>>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which
>>>>>>>>>>>>>>> can be passed
>>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible
>>>>>>>>>>>>>> to pass this
>>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>>>>>>>> Machines.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be
>>>>>>>>>>>>> given as an input
>>>>>>>>>>>>> to your decider, then your decider is broken since it must
>>>>>>>>>>>>> be able to
>>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>>> computer science.
>>>>>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>>>>>> halting and
>>>>>>>>>>>> non-halting machines could be described, but not machines
>>>>>>>>>>>> for which the
>>>>>>>>>>>> halting status is difficult or impossible for a predefined
>>>>>>>>>>>> halt decider to determine.
>>>>>>>>>>>
>>>>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>>>>> machine decider cannot possibly have its own self or an
>>>>>>>>>>> encoding of its own self as its input. The closest thing
>>>>>>>>>>> possible that it can have is an encoding of another different
>>>>>>>>>>> instance of itself.
>>>>>>>>>>
>>>>>>>>>> Computations don't have different instances. What would it
>>>>>>>>>> even mean to 'instantiate' a computation?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Back to the key point:
>>>>>>>>>
>>>>>>>>> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when
>>>>>>>>> correctly simulated by the UTM within embedded_H is the same as
>>>>>>>>> these finite strings specifying non-halting behavior when
>>>>>>>>> correctly interpreted by a BASIC in interpreter.
>>>>>>>>>
>>>>>>>>> 10 PRINT "Hello, World!"
>>>>>>>>> 20 goto 10
>>>>>>>>> 30 END
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>
>>>>>>>>> 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⟩...
>>>>>>>>>
>>>>>>>>> The above repeating pattern shows that the correctly simulated
>>>>>>>>> input to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>>>>>>> conclusively proving that this simulated input never halts.
>>>>>>>>> This enables embedded_H to abort its simulation and correctly
>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> But that infinite behavor only occurs if the embedded_H NEVER
>>>>>>>> aborts its simulation and thus it fails at the requirement to
>>>>>>>> GIVE the answer.
>>>>>>>>
>>>>>>>
>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>
>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>
>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>
>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Which only happens if embedded_H never aborts its simulation,
>>>>> No idiot it happens no matter what !
>>>>> No idiot it happens no matter what !
>>>>> No idiot it happens no matter what !
>>>>> No idiot it happens no matter what !
>>>>> No idiot it happens no matter what !
>>>>>
>>>>
>>>> Nope, unless you can prove that two copies of the exact same
>>>> algorithm given the exact same data can give differerent results (by
>>>> showing an ACTUAL example that does it) it is proven otherwise and
>>>> you are proved to be just a pathological liar.
>>> This conclusively proves that I am correct.
>>> Saying that you simply don't believe it is not any rebuttal!
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> 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⟩...
>>>
>>> The above repeating pattern shows that the correctly simulated input
>>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>> conclusively proving that this simulated input never halts. This
>>> enables embedded_H to abort its simulation and correctly transition
>>> to Ĥ.qn.
>>>
>>
>> Nope, smae mistake. Just proves that you can't prove you claim and
>> also that you like to LIE by improper clipping.
>>
>> Note, you OMITTED the challenge, (Quoted below), so you are obviously
>> being INTENTIONAL about your failure:
>>
>>>
>>> If ANY copy of embedded_H applied to <H^> <H^> goes to Qn, then the
>>> top level embedded_H will also go to Qn and the H^ that it is
>>> embedded in goes to H^.Qn and HALT, and NOT infinite pattern occurs.
>>>
>>> Just Denying what is proven before your eyes proves that you are
>>> either a pathological liar or delusional and have lost all grasp of
>>> the truth.
>>>
>>> Please try to show where my proof is wrong.
>>>
>>> Show how an H^ built on an embedded_H that aborts its simulation of
>>> <H^> <H^> doesn't halt, or prove that two identical copies of a
>>> machine can behave differently when given identical information.
>>> (Since you claim it happens in this case too)
>>>
>>> Failure to do this just proves you are lying.
>>
>
> I just proved what the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is.
> I have no idea what you mean by improper clipping.

On 3/16/2022 5:41 PM, Richard Damon wrote:
> On 3/16/22 3:10 PM, olcott wrote:
>> On 3/16/2022 12:37 PM, Mike Terry wrote:
>>> On 16/03/2022 17:20, olcott wrote:
>>>> On 3/16/2022 12:04 PM, Mike Terry wrote:
>>>>> On 16/03/2022 14:15, olcott wrote:
>>>>>> On 3/16/2022 2:21 AM, Jeff Barnett wrote:
>>>>>>> On 3/15/2022 4:02 PM, olcott wrote:
>>>>>>>> On 3/15/2022 4:48 PM, Jeff Barnett wrote:
>>>>>>>>> On 3/15/2022 1:44 PM, olcott wrote:
>>>>>>>>>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>>>>>>>>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>>>>>>>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>>>>>>>>>
>>>>>>>>>>>     <MAJOR SNIP>
>>>>>>>>>>>
>>>>>>>>>>>>> So how would you describe a compiler which is
>>>>>>>>>>>>> "bootstrapped", i.e. fed its own
>>>>>>>>>>>>> source code?
>>>>>>>>>>>>
>>>>>>>>>>>> A compiler that is fed its own source-code is not the same
>>>>>>>>>>>> because the compiler does not execute this source-code.
>>>>>>>>>>> This is one of your best Peter. Along the way you've had 100s
>>>>>>>>>>> of messages that have said that simulation as a basis for a
>>>>>>>>>>> Halting Problem solution is hopeless. Of course you pay no
>>>>>>>>>>> attention because it's unlikely you understood what you were
>>>>>>>>>>> being told. So here you are looping back over years of the
>>>>>>>>>>> same bone headed approach.
>>>>>>>>>>>
>>>>>>>>>>> Let's start with a few basics:
>>>>>>>>>>>
>>>>>>>>>>> Nothing executes source code; even an interpreter ingests it
>>>>>>>>>>> first.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A compiler the compiles its own source-code is nothing at all
>>>>>>>>>> like executing this source code.
>>>>>>>>>
>>>>>>>>> You really do have rocks in your head. Think for at least 2
>>>>>>>>> seconds before responding and getting it all wrong. The
>>>>>>>>> mistakes you are making with the above statement are so basic
>>>>>>>>> that I hardly know where to start. As I've been told many times
>>>>>>>>> it's harder to teach Kindergarten than grad students. And in
>>>>>>>>> this instance, with you, we have a sixty year old crawling
>>>>>>>>> around in diapers.
>>>>>>>>>
>>>>>>>>>> An interpreter that interprets source code can be reasonably
>>>>>>>>>> construed as running this source code.
>>>>>>>>>
>>>>>>>>> Perhaps. The issue is it really doesn't know that it is it's
>>>>>>>>> own source code, does it? And, in fact, neither it nor any
>>>>>>>>> observer is aware of any vicious self reference. Only a dunce
>>>>>>>>> would worry about it. You do worry don't you?
>>>>>>>>
>>>>>>>> In other words you are saying that no one is bright enough to be
>>>>>>>> able to detect what is essentially infinite recursion.
>>>>>>> You soiled your diapers again. I said nothing of the sort. I will
>>>>>>> say it now though, nobody is intelligent enough to systematically
>>>>>>> (by algorithm) spot infinite recursion. God can't do it either.
>>>>>>> It's not theoretically possible. Only an ignorant nitwit would
>>>>>>> not know that and prattle on for years about it.
>>>>>>>
>>>>>>
>>>>>> I already have a group of many experts that concur that infinite
>>>>>> recursion can be detected and the criterion measure by which it is
>>>>>> correctly detected.
>>>>>
>>>>> I'm afraid that you lack the intellect to understand exactly what
>>>>> other people are saying on technical issues.  How many times have
>>>>> you quoted me (and others here) as supporting something you've
>>>>> claimed, whereas it turns out you had just misunderstood some
>>>>> remark that had been made? [Answer: lots of times!]
>>>>>
>>>>> You also have a habit of going elsewhere, and "tricking" the people
>>>>> there into "agreeing" with some claim you've made here by not
>>>>> properly explaining the full context of your claim.  Then you come
>>>>> back here selectively quoting some "expert" to suggest he is
>>>>> supporting you. [Like when you went to the x86 group and showed
>>>>> them your "trace" asking them if they could see what's going on,
>>>>> and got one of them to say "it's looping...".  You failed to
>>>>> mention the trace was not the "processor trace" they would
>>>>> naturally expect, and that there was simulation involved, and that
>>>>> your trace was in fact some kind of "merged simulation trace", and
>>>>> that you were using this trace to disprove the Halting Problem
>>>>> theorem.]
>>>>>
>>>>> It's been pointed out to you many times that algorithms exhist that
>>>>> can identify /some/ infinite loops/recursions as such, but no
>>>>> algorithm detects ALL non-halting behaviour.
>>>>>
>>>>> And specifically, your test (looking for more than one call to a
>>>>> particular address etc.) is /unsound/ when you try to use it on
>>>>> your "merged simulation" trace.  No expert would say otherwise if
>>>>> they had been given the full context, so probably you've just
>>>>> tricked someone again...
>>>>>
>>>>>
>>>>> Mike.
>>>>
>>>> None-the-less is is self-evident that the input presented to the
>>>> copy of the Linz H embedded at Ĥ.qx does specify infinitely nested
>>>> simulation to simulating halt decider embedded_H thus proving that a
>>>> transition to Ĥ.qn by embedded_H would be correct.
>>>
>>> You mean self-evident TO YOU.  To people who have an understanding of
>>> TMs it is simply wrong or meaningless (depending on how tolerant
>>> people are of your wishy-washy phrasing).
>>>
>>>
>>> Mike.
>>>
>>
>> They simply dogmatically state that the believe that I am wrong about
>> this yet cannot point to the specific error because there is none:
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> 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⟩...
>>
>> The above repeating pattern shows that the correctly simulated input
>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
>> proving that this simulated input never halts. This enables embedded_H
>> to abort its simulation and correctly transition to Ĥ.qn.
>>
>
> The error has been pointed out to you many times, but you seem either
> too dumb or too dishonest to see/admit the error.
>
You cannot show that the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H can
possibly ever reach its own final state ⟨Ĥ⟩.qn in any finite number of
simulated steps YOU FREAKING BRAIN DEAD MORON!

On 3/16/2022 5:45 PM, Richard Damon wrote:
> On 3/16/22 4:22 PM, olcott wrote:
>> On 3/16/2022 3:11 PM, André G. Isaak wrote:
>>> On 2022-03-15 15:44, olcott wrote:
>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>
>>>>>>>>>> Again, I'll repeat the question which you dishonestly snipped
>>>>>>>>>> rather
>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>> repeating it
>>>>>>>>>> five times.
>>>>>>>>>>
>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be
>>>>>>>>>> passed
>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>>>>>> reference
>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>>>>>>>> pass this
>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>>> Machines.
>>>>>>>>
>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as
>>>>>>>> an input
>>>>>>>> to your decider, then your decider is broken since it must be
>>>>>>>> able to
>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>> Though that would actually be a genuine contribution to computer
>>>>>>> science.
>>>>>>> If you could devise a language such that a large subset of
>>>>>>> halting and
>>>>>>> non-halting machines could be described, but not machines for
>>>>>>> which the
>>>>>>> halting status is difficult or impossible for a predefined halt
>>>>>>> decider to determine.
>>>>>>
>>>>>> André does not seem to be able to comprehend that a Turing machine
>>>>>> decider cannot possibly have its own self or an encoding of its
>>>>>> own self as its input. The closest thing possible that it can have
>>>>>> is an encoding of another different instance of itself.
>>>>>
>>>>> Computations don't have different instances. What would it even
>>>>> mean to 'instantiate' a computation?
>>>>>
>>>>> André
>>>>>
>>>>
>>>> A Turing machine UTM that is simulating its own Turing machine
>>>> description is two distinct instances: (executed and simulated) even
>>>> if computer science does not bother to pay attention to this level
>>>> of detail, or have the terminology to express it.
>>>
>>> You're confusing computations and Turing Machines.
>>>
>>> If you pass a UTM a description of itself, it will determine what UTM
>>> applied to an empty tape will do.
>>>
>>> UTM ⟨UTM⟩
>>>
>>> and
>>>
>>> UTM ∅
>>>
>>> are entirely distinct computations.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> In the above: Ĥ applied to ⟨Ĥ⟩ and the ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H
>> vary by exactly one level of indirect reference.
>>
>> embedded_H does not, cannot, and its not supposed to report on the
>> exact same computation that contains itself.
>>
>> embedded_H computes the mapping of its input ⟨Ĥ⟩ ⟨Ĥ⟩ a final state of
>> embedded_H.
>
> And this proves you aren't working on the Halting Problem,
All deciders compute the mapping from their inputs to their own final
state BRAIN DEAD MORON!

--
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 3/16/2022 5:49 PM, Richard Damon wrote:
> On 3/16/22 10:33 AM, olcott wrote:
>> On 3/16/2022 6:05 AM, Richard Damon wrote:
>>> On 3/15/22 11:32 PM, olcott wrote:
>>>> On 3/15/2022 10:02 PM, Richard Damon wrote:
>>>>> On 3/15/22 10:43 PM, olcott wrote:
>>>>>> On 3/15/2022 9:38 PM, Richard Damon wrote:
>>>>>>> On 3/15/22 10:29 PM, olcott wrote:
>>>>>>>> On 3/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>>> On 3/15/22 9:15 PM, olcott wrote:
>>>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>>>>>>>> repeating it
>>>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which
>>>>>>>>>>>>>>>> can be passed
>>>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible
>>>>>>>>>>>>>>> to pass this
>>>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>>>> There are no 'levels of indirection' when discussing
>>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be
>>>>>>>>>>>>>> given as an input
>>>>>>>>>>>>>> to your decider, then your decider is broken since it must
>>>>>>>>>>>>>> be able to
>>>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>>>> computer science.
>>>>>>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>>>>>>> halting and
>>>>>>>>>>>>> non-halting machines could be described, but not machines
>>>>>>>>>>>>> for which the
>>>>>>>>>>>>> halting status is difficult or impossible for a predefined
>>>>>>>>>>>>> halt decider to determine.
>>>>>>>>>>>>
>>>>>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>>>>>> machine decider cannot possibly have its own self or an
>>>>>>>>>>>> encoding of its own self as its input. The closest thing
>>>>>>>>>>>> possible that it can have is an encoding of another
>>>>>>>>>>>> different instance of itself.
>>>>>>>>>>>
>>>>>>>>>>> Computations don't have different instances. What would it
>>>>>>>>>>> even mean to 'instantiate' a computation?
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Back to the key point:
>>>>>>>>>>
>>>>>>>>>> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when
>>>>>>>>>> correctly simulated by the UTM within embedded_H is the same
>>>>>>>>>> as these finite strings specifying non-halting behavior when
>>>>>>>>>> correctly interpreted by a BASIC in interpreter.
>>>>>>>>>>
>>>>>>>>>> 10 PRINT "Hello, World!"
>>>>>>>>>> 20 goto 10
>>>>>>>>>> 30 END
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>
>>>>>>>>>> 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⟩...
>>>>>>>>>>
>>>>>>>>>> The above repeating pattern shows that the correctly simulated
>>>>>>>>>> input to embedded_H would never reach its final state of
>>>>>>>>>> ⟨Ĥ⟩.qn conclusively proving that this simulated input never
>>>>>>>>>> halts. This enables embedded_H to abort its simulation and
>>>>>>>>>> correctly transition to Ĥ.qn.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But that infinite behavor only occurs if the embedded_H NEVER
>>>>>>>>> aborts its simulation and thus it fails at the requirement to
>>>>>>>>> GIVE the answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>
>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>
>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>
>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Which only happens if embedded_H never aborts its simulation,
>>>>>> No idiot it happens no matter what !
>>>>>> No idiot it happens no matter what !
>>>>>> No idiot it happens no matter what !
>>>>>> No idiot it happens no matter what !
>>>>>> No idiot it happens no matter what !
>>>>>>
>>>>>
>>>>> Nope, unless you can prove that two copies of the exact same
>>>>> algorithm given the exact same data can give differerent results
>>>>> (by showing an ACTUAL example that does it) it is proven otherwise
>>>>> and you are proved to be just a pathological liar.
>>>> This conclusively proves that I am correct.
>>>> Saying that you simply don't believe it is not any rebuttal!
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> 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⟩...
>>>>
>>>> The above repeating pattern shows that the correctly simulated input
>>>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>> conclusively proving that this simulated input never halts. This
>>>> enables embedded_H to abort its simulation and correctly transition
>>>> to Ĥ.qn.
>>>>
>>>
>>> Nope, smae mistake. Just proves that you can't prove you claim and
>>> also that you like to LIE by improper clipping.
>>>
>>> Note, you OMITTED the challenge, (Quoted below), so you are obviously
>>> being INTENTIONAL about your failure:
>>>
>>>>
>>>> If ANY copy of embedded_H applied to <H^> <H^> goes to Qn, then the
>>>> top level embedded_H will also go to Qn and the H^ that it is
>>>> embedded in goes to H^.Qn and HALT, and NOT infinite pattern occurs.
>>>>
>>>> Just Denying what is proven before your eyes proves that you are
>>>> either a pathological liar or delusional and have lost all grasp of
>>>> the truth.
>>>>
>>>> Please try to show where my proof is wrong.
>>>>
>>>> Show how an H^ built on an embedded_H that aborts its simulation of
>>>> <H^> <H^> doesn't halt, or prove that two identical copies of a
>>>> machine can behave differently when given identical information.
>>>> (Since you claim it happens in this case too)
>>>>
>>>> Failure to do this just proves you are lying.
>>>
>>
>> I just proved what the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is.
>> I have no idea what you mean by improper clipping.
>
> Jsut proves that you don't understand what Truth is.
>
>>
>> H.q0 ⟨M⟩ w ⊢* H.qy ----- iff UTM( ⟨M⟩, w ) reaches the final state of M
>> H.q0 ⟨M⟩ w ⊢* H.qn ----- iff UTM( ⟨M⟩, w ) would never reach the final
>> state of M
>>
>> Simulating halt decider H performs a pure simulation of its input as
>> if it was a UTM unless and until it detects an infinitely repeating
>> pattern. Then it aborts the simulation of its input and transitions to
>> its final reject state. Otherwise H transitions to its accept state
>> when its simulation ends.
>>
>> 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 ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>>
>>
>
> Which is all a LIE by your own admision.
>
> Since you keep on removing my comment, I will not repeat them, but just
> point out that even YOUR have previously ADMITTED that the equivalnt of
> H^ applied to <H^> does Halt when H decides on <H^> <H^> as non-halting.
>

On 3/16/22 6:56 PM, olcott wrote:
> On 3/16/2022 5:41 PM, Richard Damon wrote:
>> On 3/16/22 3:10 PM, olcott wrote:
>>> On 3/16/2022 12:37 PM, Mike Terry wrote:
>>>> On 16/03/2022 17:20, olcott wrote:
>>>>> On 3/16/2022 12:04 PM, Mike Terry wrote:
>>>>>> On 16/03/2022 14:15, olcott wrote:
>>>>>>> On 3/16/2022 2:21 AM, Jeff Barnett wrote:
>>>>>>>> On 3/15/2022 4:02 PM, olcott wrote:
>>>>>>>>> On 3/15/2022 4:48 PM, Jeff Barnett wrote:
>>>>>>>>>> On 3/15/2022 1:44 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>>>>>>>>>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>>>>>>>>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>     <MAJOR SNIP>
>>>>>>>>>>>>
>>>>>>>>>>>>>> So how would you describe a compiler which is
>>>>>>>>>>>>>> "bootstrapped", i.e. fed its own
>>>>>>>>>>>>>> source code?
>>>>>>>>>>>>>
>>>>>>>>>>>>> A compiler that is fed its own source-code is not the same
>>>>>>>>>>>>> because the compiler does not execute this source-code.
>>>>>>>>>>>> This is one of your best Peter. Along the way you've had
>>>>>>>>>>>> 100s of messages that have said that simulation as a basis
>>>>>>>>>>>> for a Halting Problem solution is hopeless. Of course you
>>>>>>>>>>>> pay no attention because it's unlikely you understood what
>>>>>>>>>>>> you were being told. So here you are looping back over years
>>>>>>>>>>>> of the same bone headed approach.
>>>>>>>>>>>>
>>>>>>>>>>>> Let's start with a few basics:
>>>>>>>>>>>>
>>>>>>>>>>>> Nothing executes source code; even an interpreter ingests it
>>>>>>>>>>>> first.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> A compiler the compiles its own source-code is nothing at all
>>>>>>>>>>> like executing this source code.
>>>>>>>>>>
>>>>>>>>>> You really do have rocks in your head. Think for at least 2
>>>>>>>>>> seconds before responding and getting it all wrong. The
>>>>>>>>>> mistakes you are making with the above statement are so basic
>>>>>>>>>> that I hardly know where to start. As I've been told many
>>>>>>>>>> times it's harder to teach Kindergarten than grad students.
>>>>>>>>>> And in this instance, with you, we have a sixty year old
>>>>>>>>>> crawling around in diapers.
>>>>>>>>>>
>>>>>>>>>>> An interpreter that interprets source code can be reasonably
>>>>>>>>>>> construed as running this source code.
>>>>>>>>>>
>>>>>>>>>> Perhaps. The issue is it really doesn't know that it is it's
>>>>>>>>>> own source code, does it? And, in fact, neither it nor any
>>>>>>>>>> observer is aware of any vicious self reference. Only a dunce
>>>>>>>>>> would worry about it. You do worry don't you?
>>>>>>>>>
>>>>>>>>> In other words you are saying that no one is bright enough to
>>>>>>>>> be able to detect what is essentially infinite recursion.
>>>>>>>> You soiled your diapers again. I said nothing of the sort. I
>>>>>>>> will say it now though, nobody is intelligent enough to
>>>>>>>> systematically (by algorithm) spot infinite recursion. God can't
>>>>>>>> do it either. It's not theoretically possible. Only an ignorant
>>>>>>>> nitwit would not know that and prattle on for years about it.
>>>>>>>>
>>>>>>>
>>>>>>> I already have a group of many experts that concur that infinite
>>>>>>> recursion can be detected and the criterion measure by which it
>>>>>>> is correctly detected.
>>>>>>
>>>>>> I'm afraid that you lack the intellect to understand exactly what
>>>>>> other people are saying on technical issues.  How many times have
>>>>>> you quoted me (and others here) as supporting something you've
>>>>>> claimed, whereas it turns out you had just misunderstood some
>>>>>> remark that had been made? [Answer: lots of times!]
>>>>>>
>>>>>> You also have a habit of going elsewhere, and "tricking" the
>>>>>> people there into "agreeing" with some claim you've made here by
>>>>>> not properly explaining the full context of your claim.  Then you
>>>>>> come back here selectively quoting some "expert" to suggest he is
>>>>>> supporting you. [Like when you went to the x86 group and showed
>>>>>> them your "trace" asking them if they could see what's going on,
>>>>>> and got one of them to say "it's looping...".  You failed to
>>>>>> mention the trace was not the "processor trace" they would
>>>>>> naturally expect, and that there was simulation involved, and that
>>>>>> your trace was in fact some kind of "merged simulation trace", and
>>>>>> that you were using this trace to disprove the Halting Problem
>>>>>> theorem.]
>>>>>>
>>>>>> It's been pointed out to you many times that algorithms exhist
>>>>>> that can identify /some/ infinite loops/recursions as such, but no
>>>>>> algorithm detects ALL non-halting behaviour.
>>>>>>
>>>>>> And specifically, your test (looking for more than one call to a
>>>>>> particular address etc.) is /unsound/ when you try to use it on
>>>>>> your "merged simulation" trace.  No expert would say otherwise if
>>>>>> they had been given the full context, so probably you've just
>>>>>> tricked someone again...
>>>>>>
>>>>>>
>>>>>> Mike.
>>>>>
>>>>> None-the-less is is self-evident that the input presented to the
>>>>> copy of the Linz H embedded at Ĥ.qx does specify infinitely nested
>>>>> simulation to simulating halt decider embedded_H thus proving that
>>>>> a transition to Ĥ.qn by embedded_H would be correct.
>>>>
>>>> You mean self-evident TO YOU.  To people who have an understanding
>>>> of TMs it is simply wrong or meaningless (depending on how tolerant
>>>> people are of your wishy-washy phrasing).
>>>>
>>>>
>>>> Mike.
>>>>
>>>
>>> They simply dogmatically state that the believe that I am wrong about
>>> this yet cannot point to the specific error because there is none:
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> 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⟩...
>>>
>>> The above repeating pattern shows that the correctly simulated input
>>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>> conclusively proving that this simulated input never halts. This
>>> enables embedded_H to abort its simulation and correctly transition
>>> to Ĥ.qn.
>>>
>>
>> The error has been pointed out to you many times, but you seem either
>> too dumb or too dishonest to see/admit the error.
>>
> You cannot show that the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H can
> possibly ever reach its own final state ⟨Ĥ⟩.qn in any finite number of
> simulated steps YOU FREAKING BRAIN DEAD MORON!
>
> Ĥ.qn is not the final state of any simulated input:
> YOU FREAKING BRAIN DEAD MORON!
>
> Ĥ.qn is only the final state of the simulating halt decider
> YOU FREAKING BRAIN DEAD MORON!
>

On 3/16/22 7:03 PM, olcott wrote:
> On 3/16/2022 5:45 PM, Richard Damon wrote:
>> On 3/16/22 4:22 PM, olcott wrote:
>>> On 3/16/2022 3:11 PM, André G. Isaak wrote:
>>>> On 2022-03-15 15:44, olcott wrote:
>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>
>>>>>>>>>>> Again, I'll repeat the question which you dishonestly snipped
>>>>>>>>>>> rather
>>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>>> repeating it
>>>>>>>>>>> five times.
>>>>>>>>>>>
>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be
>>>>>>>>>>> passed
>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>>>>>>> reference
>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>>>>>>>>> pass this
>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>>>> Machines.
>>>>>>>>>
>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as
>>>>>>>>> an input
>>>>>>>>> to your decider, then your decider is broken since it must be
>>>>>>>>> able to
>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>> Though that would actually be a genuine contribution to computer
>>>>>>>> science.
>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>> halting and
>>>>>>>> non-halting machines could be described, but not machines for
>>>>>>>> which the
>>>>>>>> halting status is difficult or impossible for a predefined halt
>>>>>>>> decider to determine.
>>>>>>>
>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>> machine decider cannot possibly have its own self or an encoding
>>>>>>> of its own self as its input. The closest thing possible that it
>>>>>>> can have is an encoding of another different instance of itself.
>>>>>>
>>>>>> Computations don't have different instances. What would it even
>>>>>> mean to 'instantiate' a computation?
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> A Turing machine UTM that is simulating its own Turing machine
>>>>> description is two distinct instances: (executed and simulated)
>>>>> even if computer science does not bother to pay attention to this
>>>>> level of detail, or have the terminology to express it.
>>>>
>>>> You're confusing computations and Turing Machines.
>>>>
>>>> If you pass a UTM a description of itself, it will determine what
>>>> UTM applied to an empty tape will do.
>>>>
>>>> UTM ⟨UTM⟩
>>>>
>>>> and
>>>>
>>>> UTM ∅
>>>>
>>>> are entirely distinct computations.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> In the above: Ĥ applied to ⟨Ĥ⟩ and the ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
>>> embedded_H vary by exactly one level of indirect reference.
>>>
>>> embedded_H does not, cannot, and its not supposed to report on the
>>> exact same computation that contains itself.
>>>
>>> embedded_H computes the mapping of its input ⟨Ĥ⟩ ⟨Ĥ⟩ a final state of
>>> embedded_H.
>>
>> And this proves you aren't working on the Halting Problem,
> All deciders compute the mapping from their inputs to their own final
> state BRAIN DEAD MORON!
>

But they must go to the CORRECT state, so all you are showing is that
Truth means nothing to you.

The CORRECT answer for H <H^> <H^> MUST (by DEFINITION) be based on the
behavior of H^ applied to <H^>, which Halts if H goes to Qn, so H is
proven to be incorrect.

H <M> w must go to H.Qy iff M w halts and to H.Qn iff M w never halts.

Since H^ <H^> will Halt if H <H^> <H^> goes to H.Qn, that answer is BY
DEFINITION incorrect, as H BY DEFINITION needed to have gone to H.Qy for
that input.

On 3/16/22 7:06 PM, olcott wrote:
> On 3/16/2022 5:49 PM, Richard Damon wrote:
>> On 3/16/22 10:33 AM, olcott wrote:
>>> On 3/16/2022 6:05 AM, Richard Damon wrote:
>>>> On 3/15/22 11:32 PM, olcott wrote:
>>>>> On 3/15/2022 10:02 PM, Richard Damon wrote:
>>>>>> On 3/15/22 10:43 PM, olcott wrote:
>>>>>>> On 3/15/2022 9:38 PM, Richard Damon wrote:
>>>>>>>> On 3/15/22 10:29 PM, olcott wrote:
>>>>>>>>> On 3/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/22 9:15 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>>>>>> than answering. I won't bother putting it in all caps
>>>>>>>>>>>>>>>>> or repeating it
>>>>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which
>>>>>>>>>>>>>>>>> can be passed
>>>>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible
>>>>>>>>>>>>>>>> to pass this
>>>>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>>>>> There are no 'levels of indirection' when discussing
>>>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be
>>>>>>>>>>>>>>> given as an input
>>>>>>>>>>>>>>> to your decider, then your decider is broken since it
>>>>>>>>>>>>>>> must be able to
>>>>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>>>>> computer science.
>>>>>>>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>>>>>>>> halting and
>>>>>>>>>>>>>> non-halting machines could be described, but not machines
>>>>>>>>>>>>>> for which the
>>>>>>>>>>>>>> halting status is difficult or impossible for a predefined
>>>>>>>>>>>>>> halt decider to determine.
>>>>>>>>>>>>>
>>>>>>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>>>>>>> machine decider cannot possibly have its own self or an
>>>>>>>>>>>>> encoding of its own self as its input. The closest thing
>>>>>>>>>>>>> possible that it can have is an encoding of another
>>>>>>>>>>>>> different instance of itself.
>>>>>>>>>>>>
>>>>>>>>>>>> Computations don't have different instances. What would it
>>>>>>>>>>>> even mean to 'instantiate' a computation?
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Back to the key point:
>>>>>>>>>>>
>>>>>>>>>>> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when
>>>>>>>>>>> correctly simulated by the UTM within embedded_H is the same
>>>>>>>>>>> as these finite strings specifying non-halting behavior when
>>>>>>>>>>> correctly interpreted by a BASIC in interpreter.
>>>>>>>>>>>
>>>>>>>>>>> 10 PRINT "Hello, World!"
>>>>>>>>>>> 20 goto 10
>>>>>>>>>>> 30 END
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>
>>>>>>>>>>> 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⟩...
>>>>>>>>>>>
>>>>>>>>>>> The above repeating pattern shows that the correctly
>>>>>>>>>>> simulated input to embedded_H would never reach its final
>>>>>>>>>>> state of ⟨Ĥ⟩.qn conclusively proving that this simulated
>>>>>>>>>>> input never halts. This enables embedded_H to abort its
>>>>>>>>>>> simulation and correctly transition to Ĥ.qn.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But that infinite behavor only occurs if the embedded_H NEVER
>>>>>>>>>> aborts its simulation and thus it fails at the requirement to
>>>>>>>>>> GIVE the answer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>
>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>
>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>
>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which only happens if embedded_H never aborts its simulation,
>>>>>>> No idiot it happens no matter what !
>>>>>>> No idiot it happens no matter what !
>>>>>>> No idiot it happens no matter what !
>>>>>>> No idiot it happens no matter what !
>>>>>>> No idiot it happens no matter what !
>>>>>>>
>>>>>>
>>>>>> Nope, unless you can prove that two copies of the exact same
>>>>>> algorithm given the exact same data can give differerent results
>>>>>> (by showing an ACTUAL example that does it) it is proven otherwise
>>>>>> and you are proved to be just a pathological liar.
>>>>> This conclusively proves that I am correct.
>>>>> Saying that you simply don't believe it is not any rebuttal!
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>
>>>>> 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⟩...
>>>>>
>>>>> The above repeating pattern shows that the correctly simulated
>>>>> input to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>>> conclusively proving that this simulated input never halts. This
>>>>> enables embedded_H to abort its simulation and correctly transition
>>>>> to Ĥ.qn.
>>>>>
>>>>
>>>> Nope, smae mistake. Just proves that you can't prove you claim and
>>>> also that you like to LIE by improper clipping.
>>>>
>>>> Note, you OMITTED the challenge, (Quoted below), so you are
>>>> obviously being INTENTIONAL about your failure:
>>>>
>>>>>
>>>>> If ANY copy of embedded_H applied to <H^> <H^> goes to Qn, then the
>>>>> top level embedded_H will also go to Qn and the H^ that it is
>>>>> embedded in goes to H^.Qn and HALT, and NOT infinite pattern occurs.
>>>>>
>>>>> Just Denying what is proven before your eyes proves that you are
>>>>> either a pathological liar or delusional and have lost all grasp of
>>>>> the truth.
>>>>>
>>>>> Please try to show where my proof is wrong.
>>>>>
>>>>> Show how an H^ built on an embedded_H that aborts its simulation of
>>>>> <H^> <H^> doesn't halt, or prove that two identical copies of a
>>>>> machine can behave differently when given identical information.
>>>>> (Since you claim it happens in this case too)
>>>>>
>>>>> Failure to do this just proves you are lying.
>>>>
>>>
>>> I just proved what the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is.
>>> I have no idea what you mean by improper clipping.
>>
>> Jsut proves that you don't understand what Truth is.
>>
>>>
>>> H.q0 ⟨M⟩ w ⊢* H.qy ----- iff UTM( ⟨M⟩, w ) reaches the final state of M
>>> H.q0 ⟨M⟩ w ⊢* H.qn ----- iff UTM( ⟨M⟩, w ) would never reach the
>>> final state of M
>>>
>>> Simulating halt decider H performs a pure simulation of its input as
>>> if it was a UTM unless and until it detects an infinitely repeating
>>> pattern. Then it aborts the simulation of its input and transitions
>>> to its final reject state. Otherwise H transitions to its accept
>>> state when its simulation ends.
>>>
>>> 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 ∞
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>> state.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>> final state.
>>>
>>>
>>
>> Which is all a LIE by your own admision.
>>
>> Since you keep on removing my comment, I will not repeat them, but
>> just point out that even YOUR have previously ADMITTED that the
>> equivalnt of H^ applied to <H^> does Halt when H decides on <H^> <H^>
>> as non-halting.
>>
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
> possibly reach its own final state in any finite number of simulated steps.
>

On 3/16/2022 6:22 PM, Richard Damon wrote:
> On 3/16/22 6:56 PM, olcott wrote:
>> On 3/16/2022 5:41 PM, Richard Damon wrote:
>>> On 3/16/22 3:10 PM, olcott wrote:
>>>> On 3/16/2022 12:37 PM, Mike Terry wrote:
>>>>> On 16/03/2022 17:20, olcott wrote:
>>>>>> On 3/16/2022 12:04 PM, Mike Terry wrote:
>>>>>>> On 16/03/2022 14:15, olcott wrote:
>>>>>>>> On 3/16/2022 2:21 AM, Jeff Barnett wrote:
>>>>>>>>> On 3/15/2022 4:02 PM, olcott wrote:
>>>>>>>>>> On 3/15/2022 4:48 PM, Jeff Barnett wrote:
>>>>>>>>>>> On 3/15/2022 1:44 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>>>>>>>>>>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>     <MAJOR SNIP>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So how would you describe a compiler which is
>>>>>>>>>>>>>>> "bootstrapped", i.e. fed its own
>>>>>>>>>>>>>>> source code?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A compiler that is fed its own source-code is not the same
>>>>>>>>>>>>>> because the compiler does not execute this source-code.
>>>>>>>>>>>>> This is one of your best Peter. Along the way you've had
>>>>>>>>>>>>> 100s of messages that have said that simulation as a basis
>>>>>>>>>>>>> for a Halting Problem solution is hopeless. Of course you
>>>>>>>>>>>>> pay no attention because it's unlikely you understood what
>>>>>>>>>>>>> you were being told. So here you are looping back over
>>>>>>>>>>>>> years of the same bone headed approach.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Let's start with a few basics:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nothing executes source code; even an interpreter ingests
>>>>>>>>>>>>> it first.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A compiler the compiles its own source-code is nothing at
>>>>>>>>>>>> all like executing this source code.
>>>>>>>>>>>
>>>>>>>>>>> You really do have rocks in your head. Think for at least 2
>>>>>>>>>>> seconds before responding and getting it all wrong. The
>>>>>>>>>>> mistakes you are making with the above statement are so basic
>>>>>>>>>>> that I hardly know where to start. As I've been told many
>>>>>>>>>>> times it's harder to teach Kindergarten than grad students.
>>>>>>>>>>> And in this instance, with you, we have a sixty year old
>>>>>>>>>>> crawling around in diapers.
>>>>>>>>>>>
>>>>>>>>>>>> An interpreter that interprets source code can be reasonably
>>>>>>>>>>>> construed as running this source code.
>>>>>>>>>>>
>>>>>>>>>>> Perhaps. The issue is it really doesn't know that it is it's
>>>>>>>>>>> own source code, does it? And, in fact, neither it nor any
>>>>>>>>>>> observer is aware of any vicious self reference. Only a dunce
>>>>>>>>>>> would worry about it. You do worry don't you?
>>>>>>>>>>
>>>>>>>>>> In other words you are saying that no one is bright enough to
>>>>>>>>>> be able to detect what is essentially infinite recursion.
>>>>>>>>> You soiled your diapers again. I said nothing of the sort. I
>>>>>>>>> will say it now though, nobody is intelligent enough to
>>>>>>>>> systematically (by algorithm) spot infinite recursion. God
>>>>>>>>> can't do it either. It's not theoretically possible. Only an
>>>>>>>>> ignorant nitwit would not know that and prattle on for years
>>>>>>>>> about it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I already have a group of many experts that concur that infinite
>>>>>>>> recursion can be detected and the criterion measure by which it
>>>>>>>> is correctly detected.
>>>>>>>
>>>>>>> I'm afraid that you lack the intellect to understand exactly what
>>>>>>> other people are saying on technical issues.  How many times have
>>>>>>> you quoted me (and others here) as supporting something you've
>>>>>>> claimed, whereas it turns out you had just misunderstood some
>>>>>>> remark that had been made? [Answer: lots of times!]
>>>>>>>
>>>>>>> You also have a habit of going elsewhere, and "tricking" the
>>>>>>> people there into "agreeing" with some claim you've made here by
>>>>>>> not properly explaining the full context of your claim.  Then you
>>>>>>> come back here selectively quoting some "expert" to suggest he is
>>>>>>> supporting you. [Like when you went to the x86 group and showed
>>>>>>> them your "trace" asking them if they could see what's going on,
>>>>>>> and got one of them to say "it's looping...".  You failed to
>>>>>>> mention the trace was not the "processor trace" they would
>>>>>>> naturally expect, and that there was simulation involved, and
>>>>>>> that your trace was in fact some kind of "merged simulation
>>>>>>> trace", and that you were using this trace to disprove the
>>>>>>> Halting Problem theorem.]
>>>>>>>
>>>>>>> It's been pointed out to you many times that algorithms exhist
>>>>>>> that can identify /some/ infinite loops/recursions as such, but
>>>>>>> no algorithm detects ALL non-halting behaviour.
>>>>>>>
>>>>>>> And specifically, your test (looking for more than one call to a
>>>>>>> particular address etc.) is /unsound/ when you try to use it on
>>>>>>> your "merged simulation" trace.  No expert would say otherwise if
>>>>>>> they had been given the full context, so probably you've just
>>>>>>> tricked someone again...
>>>>>>>
>>>>>>>
>>>>>>> Mike.
>>>>>>
>>>>>> None-the-less is is self-evident that the input presented to the
>>>>>> copy of the Linz H embedded at Ĥ.qx does specify infinitely nested
>>>>>> simulation to simulating halt decider embedded_H thus proving that
>>>>>> a transition to Ĥ.qn by embedded_H would be correct.
>>>>>
>>>>> You mean self-evident TO YOU.  To people who have an understanding
>>>>> of TMs it is simply wrong or meaningless (depending on how tolerant
>>>>> people are of your wishy-washy phrasing).
>>>>>
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> They simply dogmatically state that the believe that I am wrong
>>>> about this yet cannot point to the specific error because there is
>>>> none:
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> 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⟩...
>>>>
>>>> The above repeating pattern shows that the correctly simulated input
>>>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>> conclusively proving that this simulated input never halts. This
>>>> enables embedded_H to abort its simulation and correctly transition
>>>> to Ĥ.qn.
>>>>
>>>
>>> The error has been pointed out to you many times, but you seem either
>>> too dumb or too dishonest to see/admit the error.
>>>
>> You cannot show that the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H can
>> possibly ever reach its own final state ⟨Ĥ⟩.qn in any finite number of
>> simulated steps YOU FREAKING BRAIN DEAD MORON!
>>
>> Ĥ.qn is not the final state of any simulated input:
>> YOU FREAKING BRAIN DEAD MORON!
>>
>> Ĥ.qn is only the final state of the simulating halt decider
>> YOU FREAKING BRAIN DEAD MORON!
>>
>
> But I CAN and HAVE proven that the CORRECT simulation of <H^> <H^> by an
> ACTUAL UTM does reach that state.
Not at all because you are a BRAIN DEAD MORON you are simply TOO DAMNED
STUPID to know the difference between when the simulated input reaches
the final state of this simulated input and when the directly executed
halt decider reaches its own final state.

On 3/16/2022 6:25 PM, Richard Damon wrote:
> On 3/16/22 7:03 PM, olcott wrote:
>> On 3/16/2022 5:45 PM, Richard Damon wrote:
>>> On 3/16/22 4:22 PM, olcott wrote:
>>>> On 3/16/2022 3:11 PM, André G. Isaak wrote:
>>>>> On 2022-03-15 15:44, olcott wrote:
>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>
>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>> snipped rather
>>>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>>>> repeating it
>>>>>>>>>>>> five times.
>>>>>>>>>>>>
>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can
>>>>>>>>>>>> be passed
>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>>>>>>>> reference
>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>>>>>>>>>> pass this
>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>>>>> Machines.
>>>>>>>>>>
>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given
>>>>>>>>>> as an input
>>>>>>>>>> to your decider, then your decider is broken since it must be
>>>>>>>>>> able to
>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>> computer science.
>>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>>> halting and
>>>>>>>>> non-halting machines could be described, but not machines for
>>>>>>>>> which the
>>>>>>>>> halting status is difficult or impossible for a predefined halt
>>>>>>>>> decider to determine.
>>>>>>>>
>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>> machine decider cannot possibly have its own self or an encoding
>>>>>>>> of its own self as its input. The closest thing possible that it
>>>>>>>> can have is an encoding of another different instance of itself.
>>>>>>>
>>>>>>> Computations don't have different instances. What would it even
>>>>>>> mean to 'instantiate' a computation?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> A Turing machine UTM that is simulating its own Turing machine
>>>>>> description is two distinct instances: (executed and simulated)
>>>>>> even if computer science does not bother to pay attention to this
>>>>>> level of detail, or have the terminology to express it.
>>>>>
>>>>> You're confusing computations and Turing Machines.
>>>>>
>>>>> If you pass a UTM a description of itself, it will determine what
>>>>> UTM applied to an empty tape will do.
>>>>>
>>>>> UTM ⟨UTM⟩
>>>>>
>>>>> and
>>>>>
>>>>> UTM ∅
>>>>>
>>>>> are entirely distinct computations.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> In the above: Ĥ applied to ⟨Ĥ⟩ and the ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
>>>> embedded_H vary by exactly one level of indirect reference.
>>>>
>>>> embedded_H does not, cannot, and its not supposed to report on the
>>>> exact same computation that contains itself.
>>>>
>>>> embedded_H computes the mapping of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to a final state
>>>> of embedded_H.
>>>
>>> And this proves you aren't working on the Halting Problem,
>> All deciders compute the mapping from their inputs to their own final
>> state BRAIN DEAD MORON!
>>
>
> But they must go to the CORRECT state, so all you are showing is that
> Truth means nothing to you.
>

You just said that the fact that the halt decider computes the mapping
from its input to its own final state proves that I am not working on
the halting problem YOU BRAIN DEAD MORON!

--
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 3/16/2022 6:30 PM, Richard Damon wrote:
> On 3/16/22 7:06 PM, olcott wrote:
>> On 3/16/2022 5:49 PM, Richard Damon wrote:
>>> On 3/16/22 10:33 AM, olcott wrote:
>>>> On 3/16/2022 6:05 AM, Richard Damon wrote:
>>>>> On 3/15/22 11:32 PM, olcott wrote:
>>>>>> On 3/15/2022 10:02 PM, Richard Damon wrote:
>>>>>>> On 3/15/22 10:43 PM, olcott wrote:
>>>>>>>> On 3/15/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>> On 3/15/22 10:29 PM, olcott wrote:
>>>>>>>>>> On 3/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/15/22 9:15 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>>>>>>> than answering. I won't bother putting it in all caps
>>>>>>>>>>>>>>>>>> or repeating it
>>>>>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which
>>>>>>>>>>>>>>>>>> can be passed
>>>>>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly
>>>>>>>>>>>>>>>>> impossible to pass this
>>>>>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>>>>>> There are no 'levels of indirection' when discussing
>>>>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be
>>>>>>>>>>>>>>>> given as an input
>>>>>>>>>>>>>>>> to your decider, then your decider is broken since it
>>>>>>>>>>>>>>>> must be able to
>>>>>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>>>>>> computer science.
>>>>>>>>>>>>>>> If you could devise a language such that a large subset
>>>>>>>>>>>>>>> of halting and
>>>>>>>>>>>>>>> non-halting machines could be described, but not machines
>>>>>>>>>>>>>>> for which the
>>>>>>>>>>>>>>> halting status is difficult or impossible for a
>>>>>>>>>>>>>>> predefined halt decider to determine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>>>>>>>> machine decider cannot possibly have its own self or an
>>>>>>>>>>>>>> encoding of its own self as its input. The closest thing
>>>>>>>>>>>>>> possible that it can have is an encoding of another
>>>>>>>>>>>>>> different instance of itself.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Computations don't have different instances. What would it
>>>>>>>>>>>>> even mean to 'instantiate' a computation?
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Back to the key point:
>>>>>>>>>>>>
>>>>>>>>>>>> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior
>>>>>>>>>>>> when correctly simulated by the UTM within embedded_H is the
>>>>>>>>>>>> same as these finite strings specifying non-halting behavior
>>>>>>>>>>>> when correctly interpreted by a BASIC in interpreter.
>>>>>>>>>>>>
>>>>>>>>>>>> 10 PRINT "Hello, World!"
>>>>>>>>>>>> 20 goto 10
>>>>>>>>>>>> 30 END
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>
>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> The above repeating pattern shows that the correctly
>>>>>>>>>>>> simulated input to embedded_H would never reach its final
>>>>>>>>>>>> state of ⟨Ĥ⟩.qn conclusively proving that this simulated
>>>>>>>>>>>> input never halts. This enables embedded_H to abort its
>>>>>>>>>>>> simulation and correctly transition to Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But that infinite behavor only occurs if the embedded_H NEVER
>>>>>>>>>>> aborts its simulation and thus it fails at the requirement to
>>>>>>>>>>> GIVE the answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>
>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>
>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>
>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which only happens if embedded_H never aborts its simulation,
>>>>>>>> No idiot it happens no matter what !
>>>>>>>> No idiot it happens no matter what !
>>>>>>>> No idiot it happens no matter what !
>>>>>>>> No idiot it happens no matter what !
>>>>>>>> No idiot it happens no matter what !
>>>>>>>>
>>>>>>>
>>>>>>> Nope, unless you can prove that two copies of the exact same
>>>>>>> algorithm given the exact same data can give differerent results
>>>>>>> (by showing an ACTUAL example that does it) it is proven
>>>>>>> otherwise and you are proved to be just a pathological liar.
>>>>>> This conclusively proves that I am correct.
>>>>>> Saying that you simply don't believe it is not any rebuttal!
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩
>>>>>> ⟨Ĥ2⟩
>>>>>>
>>>>>> 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⟩...
>>>>>>
>>>>>> The above repeating pattern shows that the correctly simulated
>>>>>> input to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>>>> conclusively proving that this simulated input never halts. This
>>>>>> enables embedded_H to abort its simulation and correctly
>>>>>> transition to Ĥ.qn.
>>>>>>
>>>>>
>>>>> Nope, smae mistake. Just proves that you can't prove you claim and
>>>>> also that you like to LIE by improper clipping.
>>>>>
>>>>> Note, you OMITTED the challenge, (Quoted below), so you are
>>>>> obviously being INTENTIONAL about your failure:
>>>>>
>>>>>>
>>>>>> If ANY copy of embedded_H applied to <H^> <H^> goes to Qn, then
>>>>>> the top level embedded_H will also go to Qn and the H^ that it is
>>>>>> embedded in goes to H^.Qn and HALT, and NOT infinite pattern occurs.
>>>>>>
>>>>>> Just Denying what is proven before your eyes proves that you are
>>>>>> either a pathological liar or delusional and have lost all grasp
>>>>>> of the truth.
>>>>>>
>>>>>> Please try to show where my proof is wrong.
>>>>>>
>>>>>> Show how an H^ built on an embedded_H that aborts its simulation
>>>>>> of <H^> <H^> doesn't halt, or prove that two identical copies of a
>>>>>> machine can behave differently when given identical information.
>>>>>> (Since you claim it happens in this case too)
>>>>>>
>>>>>> Failure to do this just proves you are lying.
>>>>>
>>>>
>>>> I just proved what the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is.
>>>> I have no idea what you mean by improper clipping.
>>>
>>> Jsut proves that you don't understand what Truth is.
>>>
>>>>
>>>> H.q0 ⟨M⟩ w ⊢* H.qy ----- iff UTM( ⟨M⟩, w ) reaches the final state of M
>>>> H.q0 ⟨M⟩ w ⊢* H.qn ----- iff UTM( ⟨M⟩, w ) would never reach the
>>>> final state of M
>>>>
>>>> Simulating halt decider H performs a pure simulation of its input as
>>>> if it was a UTM unless and until it detects an infinitely repeating
>>>> pattern. Then it aborts the simulation of its input and transitions
>>>> to its final reject state. Otherwise H transitions to its accept
>>>> state when its simulation ends.
>>>>
>>>> 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 ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>> final state.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>> its final state.
>>>>
>>>>
>>>
>>> Which is all a LIE by your own admision.
>>>
>>> Since you keep on removing my comment, I will not repeat them, but
>>> just point out that even YOUR have previously ADMITTED that the
>>> equivalnt of H^ applied to <H^> does Halt when H decides on <H^> <H^>
>>> as non-halting.
>>>
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>> possibly reach its own final state in any finite number of simulated
>> steps.
>>
>
> You are wrong, and stuck in your own infinite loop (maybe you need to
> abort your self).
>
YOU ARE JUST TOO FREAKING STUPID TO KNOW the difference between the
direct execution of the halt decider that reaches its own final state
and its simulated input that cannot possibly ever reach its own final
state.

On 3/16/22 7:38 PM, olcott wrote:
> On 3/16/2022 6:30 PM, Richard Damon wrote:
>> On 3/16/22 7:06 PM, olcott wrote:
>>> On 3/16/2022 5:49 PM, Richard Damon wrote:
>>>> On 3/16/22 10:33 AM, olcott wrote:
>>>>> On 3/16/2022 6:05 AM, Richard Damon wrote:
>>>>>> On 3/15/22 11:32 PM, olcott wrote:
>>>>>>> On 3/15/2022 10:02 PM, Richard Damon wrote:
>>>>>>>> On 3/15/22 10:43 PM, olcott wrote:
>>>>>>>>> On 3/15/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/22 10:29 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/15/22 9:15 PM, olcott wrote:
>>>>>>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G.
>>>>>>>>>>>>>>>> Isaak wrote:
>>>>>>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>>>>>>>> than answering. I won't bother putting it in all caps
>>>>>>>>>>>>>>>>>>> or repeating it
>>>>>>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string
>>>>>>>>>>>>>>>>>>> which can be passed
>>>>>>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly
>>>>>>>>>>>>>>>>>> impossible to pass this
>>>>>>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>>>>>>> There are no 'levels of indirection' when discussing
>>>>>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be
>>>>>>>>>>>>>>>>> given as an input
>>>>>>>>>>>>>>>>> to your decider, then your decider is broken since it
>>>>>>>>>>>>>>>>> must be able to
>>>>>>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>>>>>>> computer science.
>>>>>>>>>>>>>>>> If you could devise a language such that a large subset
>>>>>>>>>>>>>>>> of halting and
>>>>>>>>>>>>>>>> non-halting machines could be described, but not
>>>>>>>>>>>>>>>> machines for which the
>>>>>>>>>>>>>>>> halting status is difficult or impossible for a
>>>>>>>>>>>>>>>> predefined halt decider to determine.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> André does not seem to be able to comprehend that a
>>>>>>>>>>>>>>> Turing machine decider cannot possibly have its own self
>>>>>>>>>>>>>>> or an encoding of its own self as its input. The closest
>>>>>>>>>>>>>>> thing possible that it can have is an encoding of another
>>>>>>>>>>>>>>> different instance of itself.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Computations don't have different instances. What would it
>>>>>>>>>>>>>> even mean to 'instantiate' a computation?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Back to the key point:
>>>>>>>>>>>>>
>>>>>>>>>>>>> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior
>>>>>>>>>>>>> when correctly simulated by the UTM within embedded_H is
>>>>>>>>>>>>> the same as these finite strings specifying non-halting
>>>>>>>>>>>>> behavior when correctly interpreted by a BASIC in interpreter.
>>>>>>>>>>>>>
>>>>>>>>>>>>> 10 PRINT "Hello, World!"
>>>>>>>>>>>>> 20 goto 10
>>>>>>>>>>>>> 30 END
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H
>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above repeating pattern shows that the correctly
>>>>>>>>>>>>> simulated input to embedded_H would never reach its final
>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn conclusively proving that this simulated
>>>>>>>>>>>>> input never halts. This enables embedded_H to abort its
>>>>>>>>>>>>> simulation and correctly transition to Ĥ.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But that infinite behavor only occurs if the embedded_H
>>>>>>>>>>>> NEVER aborts its simulation and thus it fails at the
>>>>>>>>>>>> requirement to GIVE the answer.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>
>>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>
>>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>
>>>>>>>>>>> correctly simulated input to embedded_H would never reach its
>>>>>>>>>>> final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which only happens if embedded_H never aborts its simulation,
>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, unless you can prove that two copies of the exact same
>>>>>>>> algorithm given the exact same data can give differerent results
>>>>>>>> (by showing an ACTUAL example that does it) it is proven
>>>>>>>> otherwise and you are proved to be just a pathological liar.
>>>>>>> This conclusively proves that I am correct.
>>>>>>> Saying that you simply don't believe it is not any rebuttal!
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩
>>>>>>> ⟨Ĥ2⟩
>>>>>>>
>>>>>>> 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⟩...
>>>>>>>
>>>>>>> The above repeating pattern shows that the correctly simulated
>>>>>>> input to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>>>>> conclusively proving that this simulated input never halts. This
>>>>>>> enables embedded_H to abort its simulation and correctly
>>>>>>> transition to Ĥ.qn.
>>>>>>>
>>>>>>
>>>>>> Nope, smae mistake. Just proves that you can't prove you claim and
>>>>>> also that you like to LIE by improper clipping.
>>>>>>
>>>>>> Note, you OMITTED the challenge, (Quoted below), so you are
>>>>>> obviously being INTENTIONAL about your failure:
>>>>>>
>>>>>>>
>>>>>>> If ANY copy of embedded_H applied to <H^> <H^> goes to Qn, then
>>>>>>> the top level embedded_H will also go to Qn and the H^ that it is
>>>>>>> embedded in goes to H^.Qn and HALT, and NOT infinite pattern occurs.
>>>>>>>
>>>>>>> Just Denying what is proven before your eyes proves that you are
>>>>>>> either a pathological liar or delusional and have lost all grasp
>>>>>>> of the truth.
>>>>>>>
>>>>>>> Please try to show where my proof is wrong.
>>>>>>>
>>>>>>> Show how an H^ built on an embedded_H that aborts its simulation
>>>>>>> of <H^> <H^> doesn't halt, or prove that two identical copies of
>>>>>>> a machine can behave differently when given identical
>>>>>>> information. (Since you claim it happens in this case too)
>>>>>>>
>>>>>>> Failure to do this just proves you are lying.
>>>>>>
>>>>>
>>>>> I just proved what the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is.
>>>>> I have no idea what you mean by improper clipping.
>>>>
>>>> Jsut proves that you don't understand what Truth is.
>>>>
>>>>>
>>>>> H.q0 ⟨M⟩ w ⊢* H.qy ----- iff UTM( ⟨M⟩, w ) reaches the final state
>>>>> of M
>>>>> H.q0 ⟨M⟩ w ⊢* H.qn ----- iff UTM( ⟨M⟩, w ) would never reach the
>>>>> final state of M
>>>>>
>>>>> Simulating halt decider H performs a pure simulation of its input
>>>>> as if it was a UTM unless and until it detects an infinitely
>>>>> repeating pattern. Then it aborts the simulation of its input and
>>>>> transitions to its final reject state. Otherwise H transitions to
>>>>> its accept state when its simulation ends.
>>>>>
>>>>> 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 ∞
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>> final state.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>> its final state.
>>>>>
>>>>>
>>>>
>>>> Which is all a LIE by your own admision.
>>>>
>>>> Since you keep on removing my comment, I will not repeat them, but
>>>> just point out that even YOUR have previously ADMITTED that the
>>>> equivalnt of H^ applied to <H^> does Halt when H decides on <H^>
>>>> <H^> as non-halting.
>>>>
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>> possibly reach its own final state in any finite number of simulated
>>> steps.
>>>
>>
>> You are wrong, and stuck in your own infinite loop (maybe you need to
>> abort your self).
>>
> YOU ARE JUST TOO FREAKING STUPID TO KNOW the difference between the
> direct execution of the halt decider that reaches its own final state
> and its simulated input that cannot possibly ever reach its own final
> state.
>
>

On 3/16/22 7:35 PM, olcott wrote:
> On 3/16/2022 6:25 PM, Richard Damon wrote:
>> On 3/16/22 7:03 PM, olcott wrote:
>>> On 3/16/2022 5:45 PM, Richard Damon wrote:
>>>> On 3/16/22 4:22 PM, olcott wrote:
>>>>> On 3/16/2022 3:11 PM, André G. Isaak wrote:
>>>>>> On 2022-03-15 15:44, olcott wrote:
>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>>>>> repeating it
>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>
>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can
>>>>>>>>>>>>> be passed
>>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>> indirect reference
>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>>>>>>>>>>> pass this
>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>>>>>> Machines.
>>>>>>>>>>>
>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given
>>>>>>>>>>> as an input
>>>>>>>>>>> to your decider, then your decider is broken since it must be
>>>>>>>>>>> able to
>>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>> computer science.
>>>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>>>> halting and
>>>>>>>>>> non-halting machines could be described, but not machines for
>>>>>>>>>> which the
>>>>>>>>>> halting status is difficult or impossible for a predefined
>>>>>>>>>> halt decider to determine.
>>>>>>>>>
>>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>>> machine decider cannot possibly have its own self or an
>>>>>>>>> encoding of its own self as its input. The closest thing
>>>>>>>>> possible that it can have is an encoding of another different
>>>>>>>>> instance of itself.
>>>>>>>>
>>>>>>>> Computations don't have different instances. What would it even
>>>>>>>> mean to 'instantiate' a computation?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> A Turing machine UTM that is simulating its own Turing machine
>>>>>>> description is two distinct instances: (executed and simulated)
>>>>>>> even if computer science does not bother to pay attention to this
>>>>>>> level of detail, or have the terminology to express it.
>>>>>>
>>>>>> You're confusing computations and Turing Machines.
>>>>>>
>>>>>> If you pass a UTM a description of itself, it will determine what
>>>>>> UTM applied to an empty tape will do.
>>>>>>
>>>>>> UTM ⟨UTM⟩
>>>>>>
>>>>>> and
>>>>>>
>>>>>> UTM ∅
>>>>>>
>>>>>> are entirely distinct computations.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> In the above: Ĥ applied to ⟨Ĥ⟩ and the ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
>>>>> embedded_H vary by exactly one level of indirect reference.
>>>>>
>>>>> embedded_H does not, cannot, and its not supposed to report on the
>>>>> exact same computation that contains itself.
>>>>>
>>>>> embedded_H computes the mapping of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to a final
>>>>> state of embedded_H.
>>>>
>>>> And this proves you aren't working on the Halting Problem,
>>> All deciders compute the mapping from their inputs to their own final
>>> state BRAIN DEAD MORON!
>>>
>>
>> But they must go to the CORRECT state, so all you are showing is that
>> Truth means nothing to you.
>>
>
> You just said that the fact that the halt decider computes the mapping
> from its input to its own final state proves that I am not working on
> the halting problem YOU BRAIN DEAD MORON!
>
>

You just prove that you can't read, and LIE by deceptive clipping.

Since you reject that actual definition of the mapping of a Halt
Decider, and claim your H CAN'T be held to that, it just isn't a Halt
Decider.

PERIOD.

You are just living in your own fantasy world where nothing is actually
real or true, just figments of your own imagination.

You are going to be sorely disapointed when the Truth meets you face to
face and can't find any of it in you.

On 3/16/2022 7:41 PM, Richard Damon wrote:
> On 3/16/22 7:38 PM, olcott wrote:
>> On 3/16/2022 6:30 PM, Richard Damon wrote:
>>> On 3/16/22 7:06 PM, olcott wrote:
>>>> On 3/16/2022 5:49 PM, Richard Damon wrote:
>>>>> On 3/16/22 10:33 AM, olcott wrote:
>>>>>> On 3/16/2022 6:05 AM, Richard Damon wrote:
>>>>>>> On 3/15/22 11:32 PM, olcott wrote:
>>>>>>>> On 3/15/2022 10:02 PM, Richard Damon wrote:
>>>>>>>>> On 3/15/22 10:43 PM, olcott wrote:
>>>>>>>>>> On 3/15/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/15/22 10:29 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/15/22 9:15 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G.
>>>>>>>>>>>>>>>>> Isaak wrote:
>>>>>>>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Again, I'll repeat the question which you
>>>>>>>>>>>>>>>>>>>> dishonestly snipped rather
>>>>>>>>>>>>>>>>>>>> than answering. I won't bother putting it in all
>>>>>>>>>>>>>>>>>>>> caps or repeating it
>>>>>>>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string
>>>>>>>>>>>>>>>>>>>> which can be passed
>>>>>>>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly
>>>>>>>>>>>>>>>>>>> impossible to pass this
>>>>>>>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>>>>>>>> There are no 'levels of indirection' when discussing
>>>>>>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be
>>>>>>>>>>>>>>>>>> given as an input
>>>>>>>>>>>>>>>>>> to your decider, then your decider is broken since it
>>>>>>>>>>>>>>>>>> must be able to
>>>>>>>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>>>>>>>> computer science.
>>>>>>>>>>>>>>>>> If you could devise a language such that a large subset
>>>>>>>>>>>>>>>>> of halting and
>>>>>>>>>>>>>>>>> non-halting machines could be described, but not
>>>>>>>>>>>>>>>>> machines for which the
>>>>>>>>>>>>>>>>> halting status is difficult or impossible for a
>>>>>>>>>>>>>>>>> predefined halt decider to determine.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> André does not seem to be able to comprehend that a
>>>>>>>>>>>>>>>> Turing machine decider cannot possibly have its own self
>>>>>>>>>>>>>>>> or an encoding of its own self as its input. The closest
>>>>>>>>>>>>>>>> thing possible that it can have is an encoding of
>>>>>>>>>>>>>>>> another different instance of itself.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Computations don't have different instances. What would
>>>>>>>>>>>>>>> it even mean to 'instantiate' a computation?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Back to the key point:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior
>>>>>>>>>>>>>> when correctly simulated by the UTM within embedded_H is
>>>>>>>>>>>>>> the same as these finite strings specifying non-halting
>>>>>>>>>>>>>> behavior when correctly interpreted by a BASIC in
>>>>>>>>>>>>>> interpreter.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 10 PRINT "Hello, World!"
>>>>>>>>>>>>>> 20 goto 10
>>>>>>>>>>>>>> 30 END
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above repeating pattern shows that the correctly
>>>>>>>>>>>>>> simulated input to embedded_H would never reach its final
>>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn conclusively proving that this simulated
>>>>>>>>>>>>>> input never halts. This enables embedded_H to abort its
>>>>>>>>>>>>>> simulation and correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But that infinite behavor only occurs if the embedded_H
>>>>>>>>>>>>> NEVER aborts its simulation and thus it fails at the
>>>>>>>>>>>>> requirement to GIVE the answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> correctly simulated input to embedded_H would never reach
>>>>>>>>>>>> its final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>>
>>>>>>>>>>>> correctly simulated input to embedded_H would never reach
>>>>>>>>>>>> its final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>>
>>>>>>>>>>>> correctly simulated input to embedded_H would never reach
>>>>>>>>>>>> its final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>>
>>>>>>>>>>>> correctly simulated input to embedded_H would never reach
>>>>>>>>>>>> its final state of ⟨Ĥ⟩.qn
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which only happens if embedded_H never aborts its simulation,
>>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>>> No idiot it happens no matter what !
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, unless you can prove that two copies of the exact same
>>>>>>>>> algorithm given the exact same data can give differerent
>>>>>>>>> results (by showing an ACTUAL example that does it) it is
>>>>>>>>> proven otherwise and you are proved to be just a pathological
>>>>>>>>> liar.
>>>>>>>> This conclusively proves that I am correct.
>>>>>>>> Saying that you simply don't believe it is not any rebuttal!
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>
>>>>>>>> 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⟩...
>>>>>>>>
>>>>>>>> The above repeating pattern shows that the correctly simulated
>>>>>>>> input to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>>>>>> conclusively proving that this simulated input never halts. This
>>>>>>>> enables embedded_H to abort its simulation and correctly
>>>>>>>> transition to Ĥ.qn.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, smae mistake. Just proves that you can't prove you claim
>>>>>>> and also that you like to LIE by improper clipping.
>>>>>>>
>>>>>>> Note, you OMITTED the challenge, (Quoted below), so you are
>>>>>>> obviously being INTENTIONAL about your failure:
>>>>>>>
>>>>>>>>
>>>>>>>> If ANY copy of embedded_H applied to <H^> <H^> goes to Qn, then
>>>>>>>> the top level embedded_H will also go to Qn and the H^ that it
>>>>>>>> is embedded in goes to H^.Qn and HALT, and NOT infinite pattern
>>>>>>>> occurs.
>>>>>>>>
>>>>>>>> Just Denying what is proven before your eyes proves that you are
>>>>>>>> either a pathological liar or delusional and have lost all grasp
>>>>>>>> of the truth.
>>>>>>>>
>>>>>>>> Please try to show where my proof is wrong.
>>>>>>>>
>>>>>>>> Show how an H^ built on an embedded_H that aborts its simulation
>>>>>>>> of <H^> <H^> doesn't halt, or prove that two identical copies of
>>>>>>>> a machine can behave differently when given identical
>>>>>>>> information. (Since you claim it happens in this case too)
>>>>>>>>
>>>>>>>> Failure to do this just proves you are lying.
>>>>>>>
>>>>>>
>>>>>> I just proved what the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is.
>>>>>> I have no idea what you mean by improper clipping.
>>>>>
>>>>> Jsut proves that you don't understand what Truth is.
>>>>>
>>>>>>
>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy ----- iff UTM( ⟨M⟩, w ) reaches the final state
>>>>>> of M
>>>>>> H.q0 ⟨M⟩ w ⊢* H.qn ----- iff UTM( ⟨M⟩, w ) would never reach the
>>>>>> final state of M
>>>>>>
>>>>>> Simulating halt decider H performs a pure simulation of its input
>>>>>> as if it was a UTM unless and until it detects an infinitely
>>>>>> repeating pattern. Then it aborts the simulation of its input and
>>>>>> transitions to its final reject state. Otherwise H transitions to
>>>>>> its accept state when its simulation ends.
>>>>>>
>>>>>> 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 ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>>> its final state.
>>>>>>
>>>>>>
>>>>>
>>>>> Which is all a LIE by your own admision.
>>>>>
>>>>> Since you keep on removing my comment, I will not repeat them, but
>>>>> just point out that even YOUR have previously ADMITTED that the
>>>>> equivalnt of H^ applied to <H^> does Halt when H decides on <H^>
>>>>> <H^> as non-halting.
>>>>>
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>> It is a fact that the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot
>>>> possibly reach its own final state in any finite number of simulated
>>>> steps.
>>>>
>>>
>>> You are wrong, and stuck in your own infinite loop (maybe you need to
>>> abort your self).
>>>
>> YOU ARE JUST TOO FREAKING STUPID TO KNOW the difference between the
>> direct execution of the halt decider that reaches its own final state
>> and its simulated input that cannot possibly ever reach its own final
>> state.
>>
>>
>
> No, YOU are to stupid to understand that H isn't being asked about its
> own simulation, but the behavior of the computation it has been given
> the description of.

On 3/16/22 7:32 PM, olcott wrote:
> On 3/16/2022 6:22 PM, Richard Damon wrote:
>> On 3/16/22 6:56 PM, olcott wrote:
>>> On 3/16/2022 5:41 PM, Richard Damon wrote:
>>>> On 3/16/22 3:10 PM, olcott wrote:
>>>>> On 3/16/2022 12:37 PM, Mike Terry wrote:
>>>>>> On 16/03/2022 17:20, olcott wrote:
>>>>>>> On 3/16/2022 12:04 PM, Mike Terry wrote:
>>>>>>>> On 16/03/2022 14:15, olcott wrote:
>>>>>>>>> On 3/16/2022 2:21 AM, Jeff Barnett wrote:
>>>>>>>>>> On 3/15/2022 4:02 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2022 4:48 PM, Jeff Barnett wrote:
>>>>>>>>>>>> On 3/15/2022 1:44 PM, olcott wrote:
>>>>>>>>>>>>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>>>>>>>>>>>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>     <MAJOR SNIP>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So how would you describe a compiler which is
>>>>>>>>>>>>>>>> "bootstrapped", i.e. fed its own
>>>>>>>>>>>>>>>> source code?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A compiler that is fed its own source-code is not the
>>>>>>>>>>>>>>> same because the compiler does not execute this source-code.
>>>>>>>>>>>>>> This is one of your best Peter. Along the way you've had
>>>>>>>>>>>>>> 100s of messages that have said that simulation as a basis
>>>>>>>>>>>>>> for a Halting Problem solution is hopeless. Of course you
>>>>>>>>>>>>>> pay no attention because it's unlikely you understood what
>>>>>>>>>>>>>> you were being told. So here you are looping back over
>>>>>>>>>>>>>> years of the same bone headed approach.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Let's start with a few basics:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nothing executes source code; even an interpreter ingests
>>>>>>>>>>>>>> it first.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A compiler the compiles its own source-code is nothing at
>>>>>>>>>>>>> all like executing this source code.
>>>>>>>>>>>>
>>>>>>>>>>>> You really do have rocks in your head. Think for at least 2
>>>>>>>>>>>> seconds before responding and getting it all wrong. The
>>>>>>>>>>>> mistakes you are making with the above statement are so
>>>>>>>>>>>> basic that I hardly know where to start. As I've been told
>>>>>>>>>>>> many times it's harder to teach Kindergarten than grad
>>>>>>>>>>>> students. And in this instance, with you, we have a sixty
>>>>>>>>>>>> year old crawling around in diapers.
>>>>>>>>>>>>
>>>>>>>>>>>>> An interpreter that interprets source code can be
>>>>>>>>>>>>> reasonably construed as running this source code.
>>>>>>>>>>>>
>>>>>>>>>>>> Perhaps. The issue is it really doesn't know that it is it's
>>>>>>>>>>>> own source code, does it? And, in fact, neither it nor any
>>>>>>>>>>>> observer is aware of any vicious self reference. Only a
>>>>>>>>>>>> dunce would worry about it. You do worry don't you?
>>>>>>>>>>>
>>>>>>>>>>> In other words you are saying that no one is bright enough to
>>>>>>>>>>> be able to detect what is essentially infinite recursion.
>>>>>>>>>> You soiled your diapers again. I said nothing of the sort. I
>>>>>>>>>> will say it now though, nobody is intelligent enough to
>>>>>>>>>> systematically (by algorithm) spot infinite recursion. God
>>>>>>>>>> can't do it either. It's not theoretically possible. Only an
>>>>>>>>>> ignorant nitwit would not know that and prattle on for years
>>>>>>>>>> about it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I already have a group of many experts that concur that
>>>>>>>>> infinite recursion can be detected and the criterion measure by
>>>>>>>>> which it is correctly detected.
>>>>>>>>
>>>>>>>> I'm afraid that you lack the intellect to understand exactly
>>>>>>>> what other people are saying on technical issues.  How many
>>>>>>>> times have you quoted me (and others here) as supporting
>>>>>>>> something you've claimed, whereas it turns out you had just
>>>>>>>> misunderstood some remark that had been made? [Answer: lots of
>>>>>>>> times!]
>>>>>>>>
>>>>>>>> You also have a habit of going elsewhere, and "tricking" the
>>>>>>>> people there into "agreeing" with some claim you've made here by
>>>>>>>> not properly explaining the full context of your claim.  Then
>>>>>>>> you come back here selectively quoting some "expert" to suggest
>>>>>>>> he is supporting you. [Like when you went to the x86 group and
>>>>>>>> showed them your "trace" asking them if they could see what's
>>>>>>>> going on, and got one of them to say "it's looping...".  You
>>>>>>>> failed to mention the trace was not the "processor trace" they
>>>>>>>> would naturally expect, and that there was simulation involved,
>>>>>>>> and that your trace was in fact some kind of "merged simulation
>>>>>>>> trace", and that you were using this trace to disprove the
>>>>>>>> Halting Problem theorem.]
>>>>>>>>
>>>>>>>> It's been pointed out to you many times that algorithms exhist
>>>>>>>> that can identify /some/ infinite loops/recursions as such, but
>>>>>>>> no algorithm detects ALL non-halting behaviour.
>>>>>>>>
>>>>>>>> And specifically, your test (looking for more than one call to a
>>>>>>>> particular address etc.) is /unsound/ when you try to use it on
>>>>>>>> your "merged simulation" trace.  No expert would say otherwise
>>>>>>>> if they had been given the full context, so probably you've just
>>>>>>>> tricked someone again...
>>>>>>>>
>>>>>>>>
>>>>>>>> Mike.
>>>>>>>
>>>>>>> None-the-less is is self-evident that the input presented to the
>>>>>>> copy of the Linz H embedded at Ĥ.qx does specify infinitely
>>>>>>> nested simulation to simulating halt decider embedded_H thus
>>>>>>> proving that a transition to Ĥ.qn by embedded_H would be correct.
>>>>>>
>>>>>> You mean self-evident TO YOU.  To people who have an understanding
>>>>>> of TMs it is simply wrong or meaningless (depending on how
>>>>>> tolerant people are of your wishy-washy phrasing).
>>>>>>
>>>>>>
>>>>>> Mike.
>>>>>>
>>>>>
>>>>> They simply dogmatically state that the believe that I am wrong
>>>>> about this yet cannot point to the specific error because there is
>>>>> none:
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>
>>>>> 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⟩...
>>>>>
>>>>> The above repeating pattern shows that the correctly simulated
>>>>> input to embedded_H would never reach its final state of ⟨Ĥ⟩.qn
>>>>> conclusively proving that this simulated input never halts. This
>>>>> enables embedded_H to abort its simulation and correctly transition
>>>>> to Ĥ.qn.
>>>>>
>>>>
>>>> The error has been pointed out to you many times, but you seem
>>>> either too dumb or too dishonest to see/admit the error.
>>>>
>>> You cannot show that the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H can
>>> possibly ever reach its own final state ⟨Ĥ⟩.qn in any finite number
>>> of simulated steps YOU FREAKING BRAIN DEAD MORON!
>>>
>>> Ĥ.qn is not the final state of any simulated input:
>>> YOU FREAKING BRAIN DEAD MORON!
>>>
>>> Ĥ.qn is only the final state of the simulating halt decider
>>> YOU FREAKING BRAIN DEAD MORON!
>>>
>>
>> But I CAN and HAVE proven that the CORRECT simulation of <H^> <H^> by
>> an ACTUAL UTM does reach that state.
> Not at all because you are a BRAIN DEAD MORON you are simply TOO DAMNED
> STUPID to know the difference between when the simulated input reaches
> the final state of this simulated input and when the directly executed
> halt decider reaches its own final state.
>

On 3/16/2022 7:44 PM, Richard Damon wrote:
> On 3/16/22 7:35 PM, olcott wrote:
>> On 3/16/2022 6:25 PM, Richard Damon wrote:
>>> On 3/16/22 7:03 PM, olcott wrote:
>>>> On 3/16/2022 5:45 PM, Richard Damon wrote:
>>>>> On 3/16/22 4:22 PM, olcott wrote:
>>>>>> On 3/16/2022 3:11 PM, André G. Isaak wrote:
>>>>>>> On 2022-03-15 15:44, olcott wrote:
>>>>>>>> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>>>>>>>>> On 2022-03-15 08:51, olcott wrote:
>>>>>>>>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>>>>>>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>>>>>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>>>>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> <snip nonresponsive post>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Again, I'll repeat the question which you dishonestly
>>>>>>>>>>>>>> snipped rather
>>>>>>>>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>>>>>>>>> repeating it
>>>>>>>>>>>>>> five times.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can
>>>>>>>>>>>>>> be passed
>>>>>>>>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of
>>>>>>>>>>>>> indirect reference
>>>>>>>>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>>>>>>>>>>>> pass this
>>>>>>>>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>>>>>>>>> There are no 'levels of indirection' when discussing Turing
>>>>>>>>>>>> Machines.
>>>>>>>>>>>>
>>>>>>>>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given
>>>>>>>>>>>> as an input
>>>>>>>>>>>> to your decider, then your decider is broken since it must
>>>>>>>>>>>> be able to
>>>>>>>>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>> Though that would actually be a genuine contribution to
>>>>>>>>>>> computer science.
>>>>>>>>>>> If you could devise a language such that a large subset of
>>>>>>>>>>> halting and
>>>>>>>>>>> non-halting machines could be described, but not machines for
>>>>>>>>>>> which the
>>>>>>>>>>> halting status is difficult or impossible for a predefined
>>>>>>>>>>> halt decider to determine.
>>>>>>>>>>
>>>>>>>>>> André does not seem to be able to comprehend that a Turing
>>>>>>>>>> machine decider cannot possibly have its own self or an
>>>>>>>>>> encoding of its own self as its input. The closest thing
>>>>>>>>>> possible that it can have is an encoding of another different
>>>>>>>>>> instance of itself.
>>>>>>>>>
>>>>>>>>> Computations don't have different instances. What would it even
>>>>>>>>> mean to 'instantiate' a computation?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> A Turing machine UTM that is simulating its own Turing machine
>>>>>>>> description is two distinct instances: (executed and simulated)
>>>>>>>> even if computer science does not bother to pay attention to
>>>>>>>> this level of detail, or have the terminology to express it.
>>>>>>>
>>>>>>> You're confusing computations and Turing Machines.
>>>>>>>
>>>>>>> If you pass a UTM a description of itself, it will determine what
>>>>>>> UTM applied to an empty tape will do.
>>>>>>>
>>>>>>> UTM ⟨UTM⟩
>>>>>>>
>>>>>>> and
>>>>>>>
>>>>>>> UTM ∅
>>>>>>>
>>>>>>> are entirely distinct computations.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> In the above: Ĥ applied to ⟨Ĥ⟩ and the ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
>>>>>> embedded_H vary by exactly one level of indirect reference.
>>>>>>
>>>>>> embedded_H does not, cannot, and its not supposed to report on the
>>>>>> exact same computation that contains itself.
>>>>>>
>>>>>> embedded_H computes the mapping of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to a final
>>>>>> state of embedded_H.
>>>>>
>>>>> And this proves you aren't working on the Halting Problem,
>>>> All deciders compute the mapping from their inputs to their own
>>>> final state BRAIN DEAD MORON!
>>>>
>>>
>>> But they must go to the CORRECT state, so all you are showing is that
>>> Truth means nothing to you.
>>>
>>
>> You just said that the fact that the halt decider computes the mapping
>> from its input to its own final state proves that I am not working on
>> the halting problem YOU BRAIN DEAD MORON!
>>
>>
>
> You just prove that you can't read, and LIE by deceptive clipping.
>

I only clip after the point that I am responding to.

You freaking screwed up and forgot that deciders compute the mapping
from their inputs to their own final states.

--
Copyright 2021 Pete Olcott

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