On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>
>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>
>>>>>> So what string, according to you, encodes the computation Ĥ applied
>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>> encodings as strings then they are not, in fact, different
>>>>>> computations at all.
>>>>
>>>> No Comment?
>>>>
>>>> I know you've been asked this question before and have consistently
>>>> ignored it. According to a recent post of yours that constitutes
>>>> justification for a repetitive all-caps temper tantrum!
>>> I once tried to get a direct answer to this question. I asked 12 times
>>> in consecutive posts but never got one.
>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>> computation I got this dazzling display of equivocation:
>>> "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>> computation.
>>> When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT encode a
>>> halting computation."
>>> Bear in mind that at time, PO's machines were magic: two identical state
>>> transition functions could entail transitions to different states when
>>> presented with identical inputs. He has since backed off from some of
>>> these remarks, but it never exactly clear which previous claims he would
>>> now accept were wrong.
>>
>> None-the-less...
>
> You mean you won't comment on the above but would rather present new
> junk about BASIC. Oh well... I can't stop you.
>

None-the-less none of what you have ever said shows that I am incorrect.
You always dodge to the left or dodge to the right and never directly
address my actual points.

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>
>> I've shown you how to write Linz's conditions in terms of simulation:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if UTM(Ĥ⟩ ⟨Ĥ⟩) does not halt.
>> Feel fee to replace "halts" with "would reach its final state" (and
>> similarly for "does not halt") if it make you feel better. Both figures
>> of speech convey the same mathematical fact, but one is shorter and fits
>> on a line.
>> What you can't do, if you want to keep talking about what Linz is
>> talking about, is replace the reference to a UTM with embedded_H.
>
> Embedded_H has a full UTM as a part of it.

Not in dispute.

> The Linz ⊢* wild card state transition allows for a UTM simulation to
> be a part of the decision process.

Not in dispute.

> Embedded_H determines whether or not its simulated input would ever
> reach its final state if embedded_H remained in pure UTM mode.

Not in dispute.

>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>> copy of H embedded within Ĥ would never reach the final state of this
>>> input ⟨Ĥ⟩.qn.
>> Irrelevant. What matters is what follows logically from Linz's
>> definition of a halt decider. If you think there is any point, I'll
>> write it out again for you in terms of UTMs.
>
> If the input to embedded_H never halts and embedded_H correctly
> reports this that is most relevant.

Not in dispute (except for the poor wording).

If you want to know why you are still wrong after 14 years, you are
going to have to learn to follow what other people are saying. Of
course, if you did that, you'd see all your mistakes, so you are much
better off remaining ignorant of what's being said to you.

--
Ben.

On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>
>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>
>>>>>> So what string, according to you, encodes the computation Ĥ applied
>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>> encodings as strings then they are not, in fact, different
>>>>>> computations at all.
>>>>
>>>> No Comment?
>>>>
>>>> I know you've been asked this question before and have consistently
>>>> ignored it. According to a recent post of yours that constitutes
>>>> justification for a repetitive all-caps temper tantrum!
>>> I once tried to get a direct answer to this question. I asked 12 times
>>> in consecutive posts but never got one.
>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>> computation I got this dazzling display of equivocation:
>>> "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>> computation.
>>> When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT encode a
>>> halting computation."
>>> Bear in mind that at time, PO's machines were magic: two identical state
>>> transition functions could entail transitions to different states when
>>> presented with identical inputs. He has since backed off from some of
>>> these remarks, but it never exactly clear which previous claims he would
>>> now accept were wrong.
>>
>> None-the-less...
>
> You mean you won't comment on the above but would rather present new
> junk about BASIC. Oh well... I can't stop you.
>

It is true that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach
its own final state in any finite steps of simulation by embedded_H.
This means that it is an established fact that this inputs specifies a
non-halting sequence of configurations.

This means that the Linz proof that says:

<Linz:1990:320>
Now Ĥ is a Turing machine, so that it will have some description in Σ*,
say ŵ . This string, in addition to being the description of Ĥ can also
be used as input string. We can therefore legitimately ask what would
happen if Ĥ is applied to ŵ .
…
The contradiction tells us that our assumption of the existence of H,
and hence the assumption of the decidability of the halting problem,
must be false.
</Linz:1990:320>

is refuted because no contradiction is formed when Ĥ is applied to ⟨Ĥ⟩.

Here is the full context:
https://www.liarparadox.org/Linz_Proof.pdf

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>
>>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>>
>>>>>>> So what string, according to you, encodes the computation Ĥ applied
>>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>>> encodings as strings then they are not, in fact, different
>>>>>>> computations at all.
>>>>>
>>>>> No Comment?
>>>>>
>>>>> I know you've been asked this question before and have consistently
>>>>> ignored it. According to a recent post of yours that constitutes
>>>>> justification for a repetitive all-caps temper tantrum!
>>>> I once tried to get a direct answer to this question. I asked 12 times
>>>> in consecutive posts but never got one.
>>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>> computation I got this dazzling display of equivocation:
>>>> "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>> computation.
>>>> When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT encode a
>>>> halting computation."
>>>> Bear in mind that at time, PO's machines were magic: two identical state
>>>> transition functions could entail transitions to different states when
>>>> presented with identical inputs. He has since backed off from some of
>>>> these remarks, but it never exactly clear which previous claims he would
>>>> now accept were wrong.
>>>
>>> None-the-less...
>>
>> You mean you won't comment on the above but would rather present new
>> junk about BASIC. Oh well... I can't stop you.
>
> None-the-less none of what you have ever said shows that I am
> incorrect.

Ah! So from your point of view I did not point out an error in the post
you replied to. That means you /still/ think that:

"When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
computation. When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES
NOT encode a halting computation."

That's useful to know. Either your strings or your TMs are still
magic. Sadly, that means you have nothing to say about the halting
problem for Turing machines. You need to fix that before anyone can
take you seriously.

--
Ben.

On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>
>>> I've shown you how to write Linz's conditions in terms of simulation:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if UTM(Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>> Feel fee to replace "halts" with "would reach its final state" (and
>>> similarly for "does not halt") if it make you feel better. Both figures
>>> of speech convey the same mathematical fact, but one is shorter and fits
>>> on a line.
>>> What you can't do, if you want to keep talking about what Linz is
>>> talking about, is replace the reference to a UTM with embedded_H.
>>
>> Embedded_H has a full UTM as a part of it.
>
> Not in dispute.
>
>> The Linz ⊢* wild card state transition allows for a UTM simulation to
>> be a part of the decision process.
>
> Not in dispute.
>
>> Embedded_H determines whether or not its simulated input would ever
>> reach its final state if embedded_H remained in pure UTM mode.
>
> Not in dispute.
>
>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>> copy of H embedded within Ĥ would never reach the final state of this
>>>> input ⟨Ĥ⟩.qn.
>>> Irrelevant. What matters is what follows logically from Linz's
>>> definition of a halt decider. If you think there is any point, I'll
>>> write it out again for you in terms of UTMs.
>>
>> If the input to embedded_H never halts and embedded_H correctly
>> reports this that is most relevant.
>
> Not in dispute (except for the poor wording).
>
> If you want to know why you are still wrong after 14 years, you are
> going to have to learn to follow what other people are saying. Of
> course, if you did that, you'd see all your mistakes, so you are much
> better off remaining ignorant of what's being said to you.
>

When the Linz H is embedded in the Linz Ĥ as a simulating halt decider
then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
simulation to embedded_H thus making the embedded_H transition to Ĥ.qn
correct.

This refutes the Linz proof because the Linz proof concludes that Ĥ
applied to ⟨Ĥ⟩ results in a contradiction. (see direct quote below).

</Linz:1990:320>
Now Ĥ is a Turing machine, so that it will have some description in Σ*,
say ŵ . This string, in addition to being the description of Ĥ can also
be used as input string. We can therefore legitimately ask what would
happen if Ĥ is applied to ŵ .
…
The contradiction tells us that our assumption of the existence of H,
and hence the assumption of the decidability of the halting problem,
must be false.
</Linz:1990:320>

https://www.liarparadox.org/Linz_Proof.pdf

--
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 8:36 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>>
>>>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>>>
>>>>>>>> So what string, according to you, encodes the computation Ĥ applied
>>>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>>>> encodings as strings then they are not, in fact, different
>>>>>>>> computations at all.
>>>>>>
>>>>>> No Comment?
>>>>>>
>>>>>> I know you've been asked this question before and have consistently
>>>>>> ignored it. According to a recent post of yours that constitutes
>>>>>> justification for a repetitive all-caps temper tantrum!
>>>>> I once tried to get a direct answer to this question. I asked 12 times
>>>>> in consecutive posts but never got one.
>>>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>> computation I got this dazzling display of equivocation:
>>>>> "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>> computation.
>>>>> When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT encode a
>>>>> halting computation."
>>>>> Bear in mind that at time, PO's machines were magic: two identical state
>>>>> transition functions could entail transitions to different states when
>>>>> presented with identical inputs. He has since backed off from some of
>>>>> these remarks, but it never exactly clear which previous claims he would
>>>>> now accept were wrong.
>>>>
>>>> None-the-less...
>>>
>>> You mean you won't comment on the above but would rather present new
>>> junk about BASIC. Oh well... I can't stop you.
>>
>> None-the-less none of what you have ever said shows that I am
>> incorrect.
>
> Ah! So from your point of view I did not point out an error in the post
> you replied to. That means you /still/ think that:
>
> "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
> computation. When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES
> NOT encode a halting computation."
>

THIS IS THE ONLY POINT THAT MATTERS
THIS IS THE ONLY POINT THAT MATTERS
THIS IS THE ONLY POINT THAT MATTERS
THIS IS THE ONLY POINT THAT MATTERS

That the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would never reach the
final state of this simulated input in any finite number of steps of
correct simulation by embedded_H conclusively proves that a mapping from
this input to the reject state of embedded_H is correct.

> That's useful to know. Either your strings or your TMs are still
> magic. Sadly, that means you have nothing to say about the halting
> problem for Turing machines. You need to fix that before anyone can
> take you seriously.
>

--
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/22 9:16 PM, olcott wrote:
> On 3/16/2022 8:08 PM, Richard Damon wrote:
>> On 3/16/22 8:51 PM, olcott wrote:
>>> On 3/16/2022 7:47 PM, Richard Damon wrote:
>>>> 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.
>>>>>
>>>>
>>>> If the simulation doesn't match the actual exectution, then it isn't
>>>> a correct simulation.
>>>
>>> It is a verifiable fact that the pure simulation of the input to
>>> embedded_H would never halt in any finite number of steps of simulation.
>>>
>>> Quit being a "Putin says he is rescuing Ukraine" liar.
>>>
>>>
>>
>> Another Fallicy, you like them don't you. Doesn't help your arguement
>> one bit, and just shows you have nothing to stand on.
>>
>> It is only 'verifiable' that the pure simulation does this if H is
>> JUST a pure simulator and never aborts.
>>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>

On 3/16/22 9:11 PM, olcott wrote:
> On 3/16/2022 7:59 PM, Richard Damon wrote:
>> On 3/16/22 8:47 PM, olcott wrote:
>>> 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.
>>>
>>
>> No, you clip off parts that relate to what you are answering.
>
> As soon as you indicated that you don't know what a decider is I
> stopped. All of the rest of you points were anchored in the error of not
> knowing what a decider is.
>

On 3/16/22 9:15 PM, olcott wrote:
> On 3/16/2022 8:03 PM, Richard Damon wrote:
>> On 3/16/22 8:45 PM, olcott wrote:
>>> 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.
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> That does this when embedded_H simulates it...
>>>
>>> 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⟩...
>>>
>>>
>>
>> Back to this again? Have fun running around forever in circles.
>>
>> This ONLY happens if embedded_H never aborts its simulation,
>
> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the simulated
> input cannot reach its own final state of ⟨Ĥ⟩.qn.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
> an entirely different final state: Ĥ.qn these are not the same.
>
>

On 3/16/22 9:51 PM, olcott wrote:
> On 3/16/2022 8:36 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>>>
>>>>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>>> So what string, according to you, encodes the computation Ĥ
>>>>>>>>> applied
>>>>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>>>>> encodings as strings then they are not, in fact, different
>>>>>>>>> computations at all.
>>>>>>>
>>>>>>> No Comment?
>>>>>>>
>>>>>>> I know you've been asked this question before and have consistently
>>>>>>> ignored it. According to a recent post of yours that constitutes
>>>>>>> justification for a repetitive all-caps temper tantrum!
>>>>>> I once tried to get a direct answer to this question.  I asked 12
>>>>>> times
>>>>>> in consecutive posts but never got one.
>>>>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>>> computation I got this dazzling display of equivocation:
>>>>>>      "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a
>>>>>> halting
>>>>>>       computation.
>>>>>>       When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT
>>>>>> encode a
>>>>>>       halting computation."
>>>>>> Bear in mind that at time, PO's machines were magic: two identical
>>>>>> state
>>>>>> transition functions could entail transitions to different states
>>>>>> when
>>>>>> presented with identical inputs.  He has since backed off from
>>>>>> some of
>>>>>> these remarks, but it never exactly clear which previous claims he
>>>>>> would
>>>>>> now accept were wrong.
>>>>>
>>>>> None-the-less...
>>>>
>>>> You mean you won't comment on the above but would rather present new
>>>> junk about BASIC.  Oh well...  I can't stop you.
>>>
>>> None-the-less none of what you have ever said shows that I am
>>> incorrect.
>>
>> Ah!  So from your point of view I did not point out an error in the post
>> you replied to.  That means you /still/ think that:
>>
>>    "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>    computation.  When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES
>>    NOT encode a halting computation."
>>
>
> THIS IS THE ONLY POINT THAT MATTERS
> THIS IS THE ONLY POINT THAT MATTERS
> THIS IS THE ONLY POINT THAT MATTERS
> THIS IS THE ONLY POINT THAT MATTERS
>
> That the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would never reach the
> final state of this simulated input in any finite number of steps of
> correct simulation by embedded_H conclusively proves that a mapping from
> this input to the reject state of embedded_H is correct.

Except that 'correct simulation by embedded_H' only has meaning if
embedded_H is actually a UTM, and in that case it can NEVER abort its
simulation, an thus fails to be a decider for the input <H^><H^>

FAIL.

Otherwise, you are just living out the liars paradox, with YOU being the
liar.

>
>> That's useful to know.  Either your strings or your TMs are still
>> magic.  Sadly, that means you have nothing to say about the halting
>> problem for Turing machines.  You need to fix that before anyone can
>> take you seriously.
>>
>
>

On 3/16/2022 8:54 PM, Richard Damon wrote:
> On 3/16/22 9:16 PM, olcott wrote:
>> On 3/16/2022 8:08 PM, Richard Damon wrote:
>>> On 3/16/22 8:51 PM, olcott wrote:
>>>> On 3/16/2022 7:47 PM, Richard Damon wrote:
>>>>> 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.
>>>>>>
>>>>>
>>>>> If the simulation doesn't match the actual exectution, then it
>>>>> isn't a correct simulation.
>>>>
>>>> It is a verifiable fact that the pure simulation of the input to
>>>> embedded_H would never halt in any finite number of steps of
>>>> simulation.
>>>>
>>>> Quit being a "Putin says he is rescuing Ukraine" liar.
>>>>
>>>>
>>>
>>> Another Fallicy, you like them don't you. Doesn't help your arguement
>>> one bit, and just shows you have nothing to stand on.
>>>
>>> It is only 'verifiable' that the pure simulation does this if H is
>>> JUST a pure simulator and never aborts.
>>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>>
>
> Already disproven and you are just showing you are ignorant of how
> Turing Machines work,
>
> Because, in FACT, unless you are LYING about building H^ correctly, the
> final state of H^, H^.Qn IS the exact same state as the H.Qn

On 3/16/2022 8:56 PM, Richard Damon wrote:
> On 3/16/22 9:11 PM, olcott wrote:
>> On 3/16/2022 7:59 PM, Richard Damon wrote:
>>> On 3/16/22 8:47 PM, olcott wrote:
>>>> 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.
>>>>
>>>
>>> No, you clip off parts that relate to what you are answering.
>>
>> As soon as you indicated that you don't know what a decider is I
>> stopped. All of the rest of you points were anchored in the error of
>> not knowing what a decider is.
>>
>
> Nope, I know EXACTLY what a decider is,

On 3/16/22 9:34 PM, olcott wrote:
> On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>
>>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>>
>>>>>>> So what string, according to you, encodes the computation Ĥ applied
>>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>>> encodings as strings then they are not, in fact, different
>>>>>>> computations at all.
>>>>>
>>>>> No Comment?
>>>>>
>>>>> I know you've been asked this question before and have consistently
>>>>> ignored it. According to a recent post of yours that constitutes
>>>>> justification for a repetitive all-caps temper tantrum!
>>>> I once tried to get a direct answer to this question.  I asked 12 times
>>>> in consecutive posts but never got one.
>>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>> computation I got this dazzling display of equivocation:
>>>>     "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>      computation.
>>>>      When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT
>>>> encode a
>>>>      halting computation."
>>>> Bear in mind that at time, PO's machines were magic: two identical
>>>> state
>>>> transition functions could entail transitions to different states when
>>>> presented with identical inputs.  He has since backed off from some of
>>>> these remarks, but it never exactly clear which previous claims he
>>>> would
>>>> now accept were wrong.
>>>
>>> None-the-less...
>>
>> You mean you won't comment on the above but would rather present new
>> junk about BASIC.  Oh well...  I can't stop you.
>>
>
> It is true that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach
> its own final state in any finite steps of simulation by embedded_H.
> This means that it is an established fact that this inputs specifies a
> non-halting sequence of configurations.

Nope, that only hold if embedded_H is ACTUAL a UTM, and thus BY
DEFINITION can't abort its simulation, and thus won't be a decider for
the input <H^> <H^>

>
> This means that the Linz proof that says:
>
> <Linz:1990:320>
> Now Ĥ is a Turing machine, so that it will have some description in Σ*,
> say ŵ . This string, in addition to being the description of Ĥ can also
> be used as input string. We can therefore legitimately ask what would
> happen if Ĥ is applied to ŵ .
> …
> The contradiction tells us that our assumption of the existence of H,
> and hence the assumption of the decidability of the halting problem,
> must be false.
> </Linz:1990:320>
>
> is refuted because no contradiction is formed when Ĥ is applied to ⟨Ĥ⟩.

Except that your H, by your logic, never answered.

If H aborts its simulation, then it is NOT the definition of correct
simulation, and we need to look at UTM <H^> <H^>, which has been shown
DOES halt if H >H^> <H^> -> H.Qn

FAIL.

>
> Here is the full context:
> https://www.liarparadox.org/Linz_Proof.pdf
>

On 3/16/22 9:44 PM, olcott wrote:
> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> I've shown you how to write Linz's conditions in terms of simulation:
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>> Feel fee to replace "halts" with "would reach its final state" (and
>>>> similarly for "does not halt") if it make you feel better.  Both
>>>> figures
>>>> of speech convey the same mathematical fact, but one is shorter and
>>>> fits
>>>> on a line.
>>>> What you can't do, if you want to keep talking about what Linz is
>>>> talking about, is replace the reference to a UTM with embedded_H.
>>>
>>> Embedded_H has a full UTM as a part of it.
>>
>> Not in dispute.
>>
>>> The Linz ⊢* wild card state transition allows for a UTM simulation to
>>> be a part of the decision process.
>>
>> Not in dispute.
>>
>>> Embedded_H determines whether or not its simulated input would ever
>>> reach its final state if embedded_H remained in pure UTM mode.
>>
>> Not in dispute.
>>
>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>>> copy of H embedded within Ĥ would never reach the final state of this
>>>>> input ⟨Ĥ⟩.qn.
>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>> definition of a halt decider.  If you think there is any point, I'll
>>>> write it out again for you in terms of UTMs.
>>>
>>> If the input to embedded_H never halts and embedded_H correctly
>>> reports this that is most relevant.
>>
>> Not in dispute (except for the poor wording).
>>
>> If you want to know why you are still wrong after 14 years, you are
>> going to have to learn to follow what other people are saying.  Of
>> course, if you did that, you'd see all your mistakes, so you are much
>> better off remaining ignorant of what's being said to you.
>>
>
> When the Linz H is embedded in the Linz Ĥ as a simulating halt decider
> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
> simulation to embedded_H thus making the embedded_H transition to Ĥ.qn
> correct.
>
> This refutes the Linz proof because the Linz proof concludes that Ĥ
> applied to ⟨Ĥ⟩ results in a contradiction. (see direct quote below).
>
> </Linz:1990:320>
> Now Ĥ is a Turing machine, so that it will have some description in Σ*,
> say ŵ . This string, in addition to being the description of Ĥ can also
> be used as input string. We can therefore legitimately ask what would
> happen if Ĥ is applied to ŵ .
> …
> The contradiction tells us that our assumption of the existence of H,
> and hence the assumption of the decidability of the halting problem,
> must be false.
> </Linz:1990:320>
>
>
>
> https://www.liarparadox.org/Linz_Proof.pdf
>

Nope, proven elsewhere MANY times.

You are just proving you don't know what you are talking about.

On 3/16/2022 9:00 PM, Richard Damon wrote:
> On 3/16/22 9:15 PM, olcott wrote:
>> On 3/16/2022 8:03 PM, Richard Damon wrote:
>>> On 3/16/22 8:45 PM, olcott wrote:
>>>> 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.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> That does this when embedded_H simulates it...
>>>>
>>>> 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⟩...
>>>>
>>>>
>>>
>>> Back to this again? Have fun running around forever in circles.
>>>
>>> This ONLY happens if embedded_H never aborts its simulation,
>>
>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>
>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider has
>> an entirely different final state: Ĥ.qn these are not the same.
>>

On 3/16/2022 9:05 PM, Richard Damon wrote:
> On 3/16/22 9:34 PM, olcott wrote:
>> On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>>
>>>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>>>
>>>>>>>> So what string, according to you, encodes the computation Ĥ applied
>>>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>>>> encodings as strings then they are not, in fact, different
>>>>>>>> computations at all.
>>>>>>
>>>>>> No Comment?
>>>>>>
>>>>>> I know you've been asked this question before and have consistently
>>>>>> ignored it. According to a recent post of yours that constitutes
>>>>>> justification for a repetitive all-caps temper tantrum!
>>>>> I once tried to get a direct answer to this question.  I asked 12
>>>>> times
>>>>> in consecutive posts but never got one.
>>>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>> computation I got this dazzling display of equivocation:
>>>>>     "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>>      computation.
>>>>>      When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT
>>>>> encode a
>>>>>      halting computation."
>>>>> Bear in mind that at time, PO's machines were magic: two identical
>>>>> state
>>>>> transition functions could entail transitions to different states when
>>>>> presented with identical inputs.  He has since backed off from some of
>>>>> these remarks, but it never exactly clear which previous claims he
>>>>> would
>>>>> now accept were wrong.
>>>>
>>>> None-the-less...
>>>
>>> You mean you won't comment on the above but would rather present new
>>> junk about BASIC.  Oh well...  I can't stop you.
>>>
>>
>> It is true that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach
>> its own final state in any finite steps of simulation by embedded_H.
>> This means that it is an established fact that this inputs specifies a
>> non-halting sequence of configurations.
>
> Nope, that only hold if embedded_H is ACTUAL a UTM, and thus BY
> DEFINITION can't abort its simulation, and thus won't be a decider for
> the input <H^> <H^>
>
>
>>
>> This means that the Linz proof that says:
>>
>> <Linz:1990:320>
>> Now Ĥ is a Turing machine, so that it will have some description in
>> Σ*, say ŵ . This string, in addition to being the description of Ĥ can
>> also be used as input string. We can therefore legitimately ask what
>> would happen if Ĥ is applied to ŵ .
>> …
>> The contradiction tells us that our assumption of the existence of H,
>> and hence the assumption of the decidability of the halting problem,
>> must be false.
>> </Linz:1990:320>
>>
>> is refuted because no contradiction is formed when Ĥ is applied to ⟨Ĥ⟩.
>
> Except that your H, by your logic, never answered.
>
> If H aborts its simulation, then it is NOT the definition of correct
> simulation, and we need to look at UTM <H^> <H^>, which has been shown
> DOES halt if H >H^> <H^> -> H.Qn
>
> FAIL.
>

THE ONLY POINT THAT MATTERS
THE ONLY POINT THAT MATTERS
THE ONLY POINT THAT MATTERS
THE ONLY POINT THAT MATTERS

That the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would never reach the
final state of this simulated input in any finite number of steps of
correct simulation conclusively proves that a mapping from this input to
the reject state of embedded_H is correct.

--
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 9:07 PM, Richard Damon wrote:
> On 3/16/22 9:44 PM, olcott wrote:
>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> I've shown you how to write Linz's conditions in terms of simulation:
>>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>>> Feel fee to replace "halts" with "would reach its final state" (and
>>>>> similarly for "does not halt") if it make you feel better.  Both
>>>>> figures
>>>>> of speech convey the same mathematical fact, but one is shorter and
>>>>> fits
>>>>> on a line.
>>>>> What you can't do, if you want to keep talking about what Linz is
>>>>> talking about, is replace the reference to a UTM with embedded_H.
>>>>
>>>> Embedded_H has a full UTM as a part of it.
>>>
>>> Not in dispute.
>>>
>>>> The Linz ⊢* wild card state transition allows for a UTM simulation to
>>>> be a part of the decision process.
>>>
>>> Not in dispute.
>>>
>>>> Embedded_H determines whether or not its simulated input would ever
>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>
>>> Not in dispute.
>>>
>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>>>> copy of H embedded within Ĥ would never reach the final state of this
>>>>>> input ⟨Ĥ⟩.qn.
>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>> definition of a halt decider.  If you think there is any point, I'll
>>>>> write it out again for you in terms of UTMs.
>>>>
>>>> If the input to embedded_H never halts and embedded_H correctly
>>>> reports this that is most relevant.
>>>
>>> Not in dispute (except for the poor wording).
>>>
>>> If you want to know why you are still wrong after 14 years, you are
>>> going to have to learn to follow what other people are saying.  Of
>>> course, if you did that, you'd see all your mistakes, so you are much
>>> better off remaining ignorant of what's being said to you.
>>>
>>
>> When the Linz H is embedded in the Linz Ĥ as a simulating halt decider
>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>> simulation to embedded_H thus making the embedded_H transition to Ĥ.qn
>> correct.
>>
>> This refutes the Linz proof because the Linz proof concludes that Ĥ
>> applied to ⟨Ĥ⟩ results in a contradiction. (see direct quote below).
>>
>> </Linz:1990:320>
>> Now Ĥ is a Turing machine, so that it will have some description in
>> Σ*, say ŵ . This string, in addition to being the description of Ĥ can
>> also be used as input string. We can therefore legitimately ask what
>> would happen if Ĥ is applied to ŵ .
>> …
>> The contradiction tells us that our assumption of the existence of H,
>> and hence the assumption of the decidability of the halting problem,
>> must be false.
>> </Linz:1990:320>
>>
>>
>>
>> https://www.liarparadox.org/Linz_Proof.pdf
>>
>
> Nope, proven elsewhere MANY times.
>
> You are just proving you don't know what you are talking about.

THE ONLY POINT THAT MATTERS
THE ONLY POINT THAT MATTERS
THE ONLY POINT THAT MATTERS
THE ONLY POINT THAT MATTERS

That the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would never reach the
final state of this simulated input in any finite number of steps of
correct simulation conclusively proves that a mapping from this input to
the reject state of embedded_H is correct.

--
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 9:03 PM, Richard Damon wrote:
> On 3/16/22 9:51 PM, olcott wrote:
>> On 3/16/2022 8:36 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/16/2022 8:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/12/2022 8:55 PM, Ben Bacarisse wrote:
>>>>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>>>>
>>>>>>>>> On 3/12/2022 5:57 PM, André G. Isaak wrote:
>>>>>>>
>>>>>>>>>> So what string, according to you, encodes the computation Ĥ
>>>>>>>>>> applied
>>>>>>>>>> to ⟨Ĥ⟩? If these two "different" computations don't have separate
>>>>>>>>>> encodings as strings then they are not, in fact, different
>>>>>>>>>> computations at all.
>>>>>>>>
>>>>>>>> No Comment?
>>>>>>>>
>>>>>>>> I know you've been asked this question before and have consistently
>>>>>>>> ignored it. According to a recent post of yours that constitutes
>>>>>>>> justification for a repetitive all-caps temper tantrum!
>>>>>>> I once tried to get a direct answer to this question.  I asked 12
>>>>>>> times
>>>>>>> in consecutive posts but never got one.
>>>>>>> Later, on the related question of whether ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>>>> computation I got this dazzling display of equivocation:
>>>>>>>      "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a
>>>>>>> halting
>>>>>>>       computation.
>>>>>>>       When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT
>>>>>>> encode a
>>>>>>>       halting computation."
>>>>>>> Bear in mind that at time, PO's machines were magic: two
>>>>>>> identical state
>>>>>>> transition functions could entail transitions to different states
>>>>>>> when
>>>>>>> presented with identical inputs.  He has since backed off from
>>>>>>> some of
>>>>>>> these remarks, but it never exactly clear which previous claims
>>>>>>> he would
>>>>>>> now accept were wrong.
>>>>>>
>>>>>> None-the-less...
>>>>>
>>>>> You mean you won't comment on the above but would rather present new
>>>>> junk about BASIC.  Oh well...  I can't stop you.
>>>>
>>>> None-the-less none of what you have ever said shows that I am
>>>> incorrect.
>>>
>>> Ah!  So from your point of view I did not point out an error in the post
>>> you replied to.  That means you /still/ think that:
>>>
>>>    "When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>    computation.  When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES
>>>    NOT encode a halting computation."
>>>
>>
>> THIS IS THE ONLY POINT THAT MATTERS
>> THIS IS THE ONLY POINT THAT MATTERS
>> THIS IS THE ONLY POINT THAT MATTERS
>> THIS IS THE ONLY POINT THAT MATTERS
>>
>> That the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would never reach the
>> final state of this simulated input in any finite number of steps of
>> correct simulation by embedded_H conclusively proves that a mapping
>> from this input to the reject state of embedded_H is correct.
>
> Except that 'correct simulation by embedded_H' only has meaning if
> embedded_H is actually
embedded_H has all of the functionality of a UTM and is able to
(a) Perfectly simulate its input as if it was a UTM.
(b) Watch the behavior of this simulated input.
(c) Match the behavior of this simulated input with infinite behavior
patterns.

As soon as an infinite behavior pattern is correctly matched embedded_H
has complete proof that its input would never reach the final state of
this input, thus the input never halts even if aborted.

Since we can see that there is an infinite behavior pattern we can see
that a transition to the embedded_H reject state would be correct.

This by itself refutes the Linz proof because the Linz proof concludes
that Ĥ applied to ⟨Ĥ⟩ results in a contradiction. (see direct quote
below) and there is no actual contradiction.

</Linz:1990:320>
Now Ĥ is a Turing machine, so that it will have some description in Σ*,
say ŵ . This string, in addition to being the description of Ĥ can also
be used as input string. We can therefore legitimately ask what would
happen if Ĥ is applied to ŵ .
…
The contradiction tells us that our assumption of the existence of H,
and hence the assumption of the decidability of the halting problem,
must be false.
</Linz:1990:320>

--
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/22 10:04 PM, olcott wrote:
> On 3/16/2022 8:54 PM, Richard Damon wrote:
>> On 3/16/22 9:16 PM, olcott wrote:
>>> On 3/16/2022 8:08 PM, Richard Damon wrote:
>>>> On 3/16/22 8:51 PM, olcott wrote:
>>>>> On 3/16/2022 7:47 PM, Richard Damon wrote:
>>>>>> 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.
>>>>>>>
>>>>>>
>>>>>> If the simulation doesn't match the actual exectution, then it
>>>>>> isn't a correct simulation.
>>>>>
>>>>> It is a verifiable fact that the pure simulation of the input to
>>>>> embedded_H would never halt in any finite number of steps of
>>>>> simulation.
>>>>>
>>>>> Quit being a "Putin says he is rescuing Ukraine" liar.
>>>>>
>>>>>
>>>>
>>>> Another Fallicy, you like them don't you. Doesn't help your
>>>> arguement one bit, and just shows you have nothing to stand on.
>>>>
>>>> It is only 'verifiable' that the pure simulation does this if H is
>>>> JUST a pure simulator and never aborts.
>>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>>
>>> Whether embedded_H aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ or not the
>>> simulated input cannot reach its own final state of ⟨Ĥ⟩.qn.
>>>
>>> The simulated input has a final state: ⟨Ĥ⟩.qn and the halt decider
>>> has an entirely different final state: Ĥ.qn these are not the same.
>>>
>>>
>>
>> Already disproven and you are just showing you are ignorant of how
>> Turing Machines work,
>>
>> Because, in FACT, unless you are LYING about building H^ correctly,
>> the final state of H^, H^.Qn IS the exact same state as the H.Qn
>
> So you are saying that embedded_H is simulating its actual self and is
> never ever being directly executed?
>
> It is not the exact one-and-the-same state. It is a copy of an
> equivalent state in an entirely different process.
>

On 3/16/22 10:04 PM, olcott wrote:
> On 3/16/2022 8:56 PM, Richard Damon wrote:
>> On 3/16/22 9:11 PM, olcott wrote:
>>> On 3/16/2022 7:59 PM, Richard Damon wrote:
>>>> On 3/16/22 8:47 PM, olcott wrote:
>>>>> 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.
>>>>>
>>>>
>>>> No, you clip off parts that relate to what you are answering.
>>>
>>> As soon as you indicated that you don't know what a decider is I
>>> stopped. All of the rest of you points were anchored in the error of
>>> not knowing what a decider is.
>>>
>>
>> Nope, I know EXACTLY what a decider is,
>
> Anyone can see that your words about prove that you do not.
>
>