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/2022 10:02 PM, Richard Damon wrote:
>
> 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.
>>
>
> There is an actual 'self' of embedded_H that is embedded in the H^
> machine, and this sub-machine is given the input <H^> <H^> to decide on,
> by simulating if that is its pleasure.
>
> So in part YES, embedded_H is simulation a representaiton of itself. (it
> is a category error to say it is simulation its actual self, or even a
> copy of itself).
>
> There also MUST be a Turing Machine H, which is the origial decider that
> is claimed to be correct, as an actual independent machine, and the
> behavior of the embedded copy of it must behave exactly like this
> independent copy or you didn't build H^ correctly.
>
> This actual machine H has terminal state H.Qy and H.Qn (or possibly just
> named Qy and Qn), and when we embedded a copy of that machine H into H^,
> then the states H.Qy and H.Qn become the exact equivalent states H^.Qy
> and H^.Qn, and if H applied to <M> w goes to H.Qn then the embedded copy
> you are calling goes to its equivalenet state to H.Qn which IS H^.Qn
>
> Unless you are going to claim that identical copies of a Turing Machine
> given exactly the same input can behave differently, they are
> effectively the identical state. Unless you want to say that the 2 that
> you get from 1+1 is different than the 2 you get from 5-3, you are going
> to run into problems claiming they are different.
>
> If you DO want to claim that identical copies of a Turing Machine given
> exactly the same input can do something different, please provide an
> ACTAUL example, or STFU.
>
> Until you do, then it is an established fact that if H <M> <M> goes to
> state H.Qn, then it is a fact that the H^ that has a copy of that H in
> it goes to H^.Qn and halts when applied to the input <M>, so H^ applied
> to <H^> will halt if H applied to <H^> <H^> goes to H.Qn claiming that
> input represents a non-halting computation, but that computation is
> EXACTLY H^ applied to <H^> which we just showed halted.

On 3/17/2022 9:36 AM, André G. Isaak wrote:
> On 2022-03-17 08:06, olcott wrote:
>
>> This is the key part where you err.
>> Ĥ applied to ⟨Ĥ⟩ differs from embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Yes, those are two entirely different computations. And Ĥ applied to ⟨Ĥ⟩
> is the computation which H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is required to answer about.
>
>> Ĥ applied to ⟨Ĥ⟩ reaches its final state only when embedded_H applied
>> to ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation.
>
> Yes, Ĥ applied to ⟨Ĥ⟩ reaches its final state which means that it halts.
> It doesn't matter *why* it reaches it's final state. If it does, the
> correct answer for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ to give is HALTS.
>
>> This falls under the general principle that when-so-ever the
>> simulation of any input to a simulating halt decider must be aborted
>> to prevent its infinite simulation this input is correctly rejected as
>> non-halting.
>
> That's not recognized general principle.
>

Not yet. It is self-evidently correct though.

> André
>

--
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/17/2022 5:30 PM, Richard Damon wrote:
>
> On 3/17/22 5:30 PM, olcott wrote:
>> On 3/17/2022 3:36 PM, Richard Damon wrote:
>>>
>>> On 3/17/22 4:00 PM, olcott wrote:
>>>> On 3/17/2022 2:30 PM, Richard Damon wrote:
>>>>>
>>>>> On 3/17/22 10:06 AM, olcott wrote:
>>>>>> On 3/16/2022 10:02 PM, Richard Damon wrote:
>>>>>> Ĥ applied to ⟨Ĥ⟩ reaches its final state only when embedded_H
>>>>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation.
>>>>>
>>>>> Right, but it DOES reach its final state, so embedded_H, to be
>>>>> correct, must take that into account. it doesn't, so it gives the
>>>>> WRONG answer.
>>>>>
>>>>
>>>> No BRAIN DEAD MORON the simulated ⟨Ĥ⟩ never reaches its own final
>>>> state.
>>>>
>>>
>>> The CORRECT Simulation shows that it does.
>>>
>>> H's simulation only doesn't reach that final state because H aborted
>>> it simulation.
>>>
>>
>> We are not talking about the simulation reaching the final state of
>> the simulation BRAIN DEAD MORON we are talking about the simulated
>> input reaching its own final state.
>>
>> 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 simulated input never reaches its own final state whether or not
>> embedded_H aborts this simulation.
>>
>
> No, because if embedded_H aborts its simulation, then the trace must be:
>
> When H^ is applied <H^>
> H^0 copies its input <H^1> to <H^2> then H0 simulates <H^1> <H^2>
> H^1 copies its input <H^2> to <H^3> then H1 simulates <H^2> <H^3>
> H^2 copies its input <H^3> to <H^4> then H2 simulates <H^3> <H^4>
> ... n levels (to when H0 aborts
> H0 goes to H0.Qn and H^0 HALTS.
>

Incorrect notation.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩...
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩

When the original executing (not simulated) embedded_H sees the
infinitely repeating pattern then it aborts its simulation killing every
simulation in the whole process tree.

> I.E. if embedded_H will only simulate a finite number of iterations, and
> them abort its simulation, there is NO infinite simulation that happens.

No BRAIN DEAD MORON the question is:
Can the simulated ⟨Ĥ⟩ possibly ever reach its own final state?
(a) embedded_H does not abort its simulation: NO
(b) embedded_H aborts its simulation: NO

It is all covered by the self-evidently correct general principle:

When-so-ever the simulation of any input to a simulating halt decider
must be aborted to prevent its infinite simulation this input is
correctly rejected as non-halting.

--
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/18/2022 11:40 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> 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.
>
> No.
>

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

(1) If embedded_H does not abort the simulation of its input the
simulation never stops and the simulated input never reaches its final
state.

(2) If embedded_H does abort the simulation of its input the simulation
is aborted at some point shown above and the simulated input never
reaches its final state.

This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
configurations that never reach a final state. This in turn makes the
transition to Ĥ.qn by embedded_H correct.

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

--
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/18/2022 11:54 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> No BRAIN DEAD MORON this is not true, I keep calling you a BRAIN DEAD
>> MORON because after I have explain all the details you cannot remember
>> what I just said.
>
> I see the petulant six-year-old is in residence today.
>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>
> A halt decider, let's call it H, maps the input <Ĥ> <Ĥ> to its accept
> state if (and only if) Ĥ enter a final state on input <Ĥ>,

No that is entirely incorrect.

embedded_H maps its input <Ĥ> <Ĥ> to its Ĥ.qn final reject state if the
correctly simulated input <Ĥ> <Ĥ> would never reach its own final state
of <Ĥ>.qn in any finite number of steps of simulation.

> and it maps
> <Ĥ> <Ĥ> to its reject state if (and only if) Ĥ does not enter a final
> state on input <Ĥ>.
>
> No such H exists.
>
> You implicitly accept this fact because you propose an H which does not
> meet this specification but I can't see why you think anyone would care
> about it.
>

--
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/18/2022 11:54 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> No BRAIN DEAD MORON this is not true, I keep calling you a BRAIN DEAD
>> MORON because after I have explain all the details you cannot remember
>> what I just said.
>
> I see the petulant six-year-old is in residence today.
>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>
> A halt decider, let's call it H, maps the input <Ĥ> <Ĥ> to its accept
> state if (and only if) Ĥ enter a final state on input <Ĥ>, and it maps
> <Ĥ> <Ĥ> to its reject state if (and only if) Ĥ does not enter a final
> state on input <Ĥ>.
>

No that is entirely incorrect. You have changed the subject away from
the Linz proof's conclusion that no matter what state Ĥ applied to <Ĥ>
transitions to a contradiction is derived.

</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

Here is the correct analysis of Ĥ applied to <Ĥ> (no contradiction):

embedded_H maps its input <Ĥ> <Ĥ> to its Ĥ.qn final reject state if the
correctly simulated input <Ĥ> <Ĥ> would never reach its own final state
of <Ĥ>.qn in any finite number of steps of simulation.

> No such H exists.
>
> You implicitly accept this fact because you propose an H which does not
> meet this specification but I can't see why you think anyone would care
> about it.
>

--
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/18/2022 12:55 PM, Richard Damon wrote:
> On 3/18/22 1:41 PM, olcott wrote:
>> On 3/18/2022 11:54 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> No BRAIN DEAD MORON this is not true, I keep calling you a BRAIN DEAD
>>>> MORON because after I have explain all the details you cannot remember
>>>> what I just said.
>>>
>>> I see the petulant six-year-old is in residence today.
>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>
>>> A halt decider, let's call it H, maps the input <Ĥ> <Ĥ> to its accept
>>> state if (and only if) Ĥ enter a final state on input <Ĥ>,
>>
>> No that is entirely incorrect.
>
> It the DEFINITION!!!!
>
>>
>> embedded_H maps its input <Ĥ> <Ĥ> to its Ĥ.qn final reject state if
>> the correctly simulated input <Ĥ> <Ĥ> would never reach its own final
>> state of <Ĥ>.qn in any finite number of steps of simulation.
>
> WRONG CRITERIA.

A decider computes the mapping from its input to its own accept or
reject state.

A halt decider computes the mapping from its input to its own accept or
reject state on the basis of the behavior specified by its input.

Since a simulating halt decider has a complete UTM as a part of its own
functionality it can examine the behavior of the correct pure simulation
of N steps of simulation.

If the input specifies a halting computation then the simulation will
complete in N steps.

If the input specifies a non halting sequence of configurations then the
simulation would never complete in any finite number of steps.

If simulation would never complete in any finite number of steps, then
it would be necessarily correct for the simulating halt decider to
reject this input.

> That is just your POOP which no one cares about. We care
> about the simulation by a REAL UTM, which matches the actual behavior of
> the Turing Machine / Input combination represented by the input, not the
> behavior that H sees in its partial simulation.
>
>>
>>
>>> and it maps
>>> <Ĥ> <Ĥ> to its reject state if (and only if) Ĥ does not enter a final
>>> state on input <Ĥ>.
>>>
>>> No such H exists.
>>>
>>> You implicitly accept this fact because you propose an H which does not
>>> meet this specification but I can't see why you think anyone would care
>>> about it.
>>>
>>
>>
>

--
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/18/2022 11:40 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> 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.
>
> No.

The reason that you only have a dogmatic reply rather than any
supporting reasoning is that I am correct.

No one can find any error in the following only because there is no
error to be found.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

(1) If embedded_H does not abort the simulation of its input the
simulation never stops and the simulated input never reaches its final
state.

(2) If embedded_H does abort the simulation of its input the simulation
is aborted at some point shown above and the simulated input never
reaches its final state.

This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
configurations that never reach a final state. This in turn makes the
transition to Ĥ.qn by embedded_H 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/19/2022 8:10 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/18/2022 8:05 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/18/2022 11:54 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> No BRAIN DEAD MORON this is not true, I keep calling you a BRAIN DEAD
>>>>>> MORON because after I have explain all the details you cannot remember
>>>>>> what I just said.
>>>>> I see the petulant six-year-old is in residence today.
>>>>>
>>>>>> A decider maps its inputs to its own accept reject state.
>>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A halt decider, let's call it H, maps the input <Ĥ> <Ĥ> to its accept
>>
>> You have changed the subject away from the Linz proof's conclusion
>> that deals with Ĥ applied to <Ĥ> and not H applied to <Ĥ> <Ĥ>.
>
> You made an incorrect statement about a halt decider. I corrected it.
> You will ignore the correction. The conversation remains exactly as it
> was years ago.
>

You can't manage to stay on the topic at hand and can only do one
dishonest dodge or another because you cannot find any error in the
essence of my statements.

Perhaps in your case the concept of infinitely nested simulation is
beyond your capacity to understand so all that you can do is dodge this
subject to hide the fact that you don't even know the terminology.

No one can find any error in the following only because there is no
error to be found.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

(1) If embedded_H does not abort the simulation of its input the
simulation never stops and the simulated input never reaches its final
state.

(2) If embedded_H does abort the simulation of its input the simulation
is aborted at some point shown above and the simulated input never
reaches its final state.

This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
configurations that never reach a final state. This in turn makes the
transition to Ĥ.qn by embedded_H 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/19/2022 8:18 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> 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.
>>> No.
>>
>> The reason that you only have a dogmatic reply rather than any
>> supporting reasoning is that I am correct.
>
> No, it's because there is no evidence that you can accept the
> explanations that are put to you.

That is a bullshit excuse to hide the fact that you fail to understand
what I said. You could provide an answer for posterity and for others
that may eventually come to this post. The truth is you can't point out
any specific error because there is no error.

> Do you really think it's worth my
> while explaining, yet again, that re-defining what H should do is just
> pointless?
>
> I'll take the time to explain if you ask intelligent questions, but my
> repeating that reply to what you keep cutting and pasting is just a
> waste of time.
>

All of the "rebuttals" never pointing out any specific error and were
always some kind of ad hominem attack of another.

>> No one can find any error in the following only because there is no
>> error to be found.
>

No one can find any error in the following only because there is no
error to be found.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

(1) If embedded_H does not abort the simulation of its input the
simulation never stops and the simulated input never reaches its final
state.

(2) If embedded_H does abort the simulation of its input the simulation
is aborted at some point shown above and the simulated input never
reaches its final state.

This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
configurations that never reach a final state. This in turn makes the
transition to Ĥ.qn by embedded_H correct.

> You can't see the error. That's not the same thing at all.
>

That no one pointed out a specific error is a verified fact.
That no one pointed out an error because there is no error is a
reasonably plausible conclusion.

> I some sense you clearly know that there is not halt decider because
> there would be no need to re-define what the correct answer is if you
> thought it were possible.
>

Everyone (including Linz) makes the mistake that the copy of the Linz H
embedded in Ĥ must report on its own behavior never realizing that this
is just not the way that deciders work.

It is an easily verified fact that simulating halt deciders (like all
deciders) only compute the mapping from their inputs, thus are not even
allowed to report on their own behavior.

--
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/19/2022 11:22 AM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>> On 3/19/22 10:13 AM, olcott wrote:
>
> [ .... ]
>
>>>> Since itself is not an actual input to itself this does not form a
>>>> contradictio
>
>>> Except that the input IS a 'copy' of itself, and thus must behave
>>> exactly like it. You don't seem to understand this property of Turing
>>> Machine. If you wish to dispute it, find an actual counter example.
>
>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
>> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> It can't be so verified without the code of H, which you refuse to
> publish, and which you certainly haven't written. (If you had, you'd be
> less bullish about its purported properties.)
>

That we know that embedded_H is a simulating halt decider that aborts
its simulation and rejects its input as soon as it detects an infinitely
repeating behavior pattern tells us that rejecting its input would be
correct on the basis of this infinitely repeating behavior pattern that
we can see: (This by itself refutes Linz).

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

There is no point in the above execution trace where the executing (not
simulated) embedded_H can abort the simulation of its input where this
simulated input reaches its own final state.

When the original executing (not simulated) embedded_H sees the
infinitely repeating pattern then it aborts its simulation killing every
simulation in the whole process tree.

The above repeating pattern shows that the correctly simulated input to
embedded_H would never reach its final state of ⟨Ĥ⟩.qn in asny finite
number of steps conclusively proving that this simulated input never
halts. This enables embedded_H to abort its simulation and correctly
transition to Ĥ.qn.

> [ .... ]
>
>> --
>> Copyright 2021 Pete Olcott
>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>

--
Copyright 2021 Pete Olcott

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

On 3/19/2022 12:29 PM, Richard Damon wrote:
> On 3/19/22 12:53 PM, olcott wrote:
>> On 3/19/2022 11:33 AM, Richard Damon wrote:
>>> On 3/19/22 12:22 PM, Alan Mackenzie wrote:
>>>> olcott <NoOne@nowhere.com> wrote:
>>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>
>>>> [ .... ]
>>>>
>>>>>>> Since itself is not an actual input to itself this does not form a
>>>>>>> contradictio
>>>>
>>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>>> exactly like it. You don't seem to understand this property of Turing
>>>>>> Machine. If you wish to dispute it, find an actual counter example.
>>>>
>>>>> It can be empirically verified that the behavior of Ĥ applied to
>>>>> ⟨Ĥ⟩ is
>>>>> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> It can't be so verified without the code of H, which you refuse to
>>>> publish, and which you certainly haven't written.  (If you had,
>>>> you'd be
>>>> less bullish about its purported properties.)
>>>>
>>>> [ .... ]
>>>>
>>>
>>> Actually, what he is missing is that they are supposed to be the
>>> same, and as H/embedded_H needs to ALWAYS behave finitely, and go to
>>> Qn only if H^ applied to <H^> will never halt.
>>
>> No this is the moronic mistake of having a halt decider decide the
>> halt status of a non-input non-finite string and no decider can ever
>> do that.
>>
>> Deciders ONLY compute the mapping from their input finite strings to
>> their own accept or reject state.
>>
>
> Just shows who is the moron.
>
> The DEFINITION of a Halt Decider is that a Halt Decider applied to the
> string <M> w needs to report on the behavior of M applied to w.

Every textbook has that incorrectly.
A halt decider (because it is a decider) must report on the behavior
specified by its finite string input.

The behavior that is actually specified by this input is the actual
behavior of this input when it is correctly simulated by its simulating
halt decider.

--
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/19/2022 1:18 PM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>> On 3/19/2022 12:55 PM, Alan Mackenzie wrote:
>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>> On 3/19/2022 11:22 AM, Alan Mackenzie wrote:
>>>>> olcott <NoOne@nowhere.com> wrote:
>
> [ .... ]
>
>>>>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
>>>>>> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
>>>>> It can't be so verified without the code of H, which you refuse to
>>>>> publish, and which you certainly haven't written. (If you had, you'd be
>>>>> less bullish about its purported properties.)
>
>>>> That we know that embedded_H is a simulating halt decider that aborts
>>>> its simulation and rejects its input as soon as it detects an infinitely
>>>> repeating behavior pattern tells us that rejecting its input would be
>>>> correct on the basis of this infinitely repeating behavior pattern that
>>>> we can see: (This by itself refutes Linz).
>
>>> That is not "empirical verification". "Empirical verification" would be
>>> running H on a Turing Machine and checking whether or not it has the
>>> properties purported by you. We actually know, through mathematical
>>> reasoning, that it does not.
>
>>> Just as a matter of interest, your recent posts have been very
>>> repetitive. You are not saying anything new. You are also not saying
>>> anything correct. Now might be a very good time to cease posting on this
>>> newsgroup, and devote your time and energies to something more
>>> life-enhancing.
>
>> Like everyone else, I prove my point, ....
>
> You fail to prove your point. What you call your "proofs" are not
> logically sound.
>
>> .... you erase the part that proved my point and then claim that I did
>> not prove my point.
>
> Richard and Ben (and one or two others) have pointed out the deficiencies
> in what you call your proof, and done so very many times. You reply with
> abuse and insults, to a large extent. I've no desire to become a
> recipient of such abuse.
No one can possibly point out an error in these three points:

(1) A halt decider (because it is a decider) must report on the behavior
specified by its finite string input.

(2) The behavior that is actually specified by this input is the actual
behavior of this input when it is correctly simulated by its simulating
halt decider (which contains a full UTM).

(3) If a simulating halt decider (SHD) aborts its simulation only
because it correctly detected that its simulation would never stop
unless it was aborted then the SHD is necessarily correct when its
rejects this input.

--
Copyright 2021 Pete Olcott

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