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.

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

It refutes nothing.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

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

Non response noted.

I shall feel free to quote this ridiculous remark about what ⟨Ĥ⟩ ⟨Ĥ⟩
encodes unless you tell me you no longer stand by it (i.e. that it is
indeed one of the mistakes you say are never pointed out to you).

--
Ben.

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

--
Ben.

On 3/18/2022 11:38 AM, Richard Damon wrote:
> On 3/18/22 11:58 AM, olcott wrote:
>> On 3/18/2022 10:49 AM, Richard Damon wrote:
>>>
>>> On 3/18/22 10:53 AM, olcott wrote:
>>>> On 3/18/2022 9:47 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/18/22 10:14 AM, olcott wrote:
>>>>>> On 3/18/2022 8:22 AM, Richard Damon wrote:
>>>>>>> On 3/17/22 10:56 PM, olcott wrote (many times):
>>>>>>>
>>>>>>>> neither a partial nor a full simulation of the input
>>>>>>>> could possibly reach the final state of this input
>>>>>>>>
>>>>>>>
>>>>>>> 3 year old behavior and a LIE.
>>>>>>>
>>>>>>> A CORRECT FULL SIMULATION of the input WILL reach the final state
>>>>>>> if H aborts its simulation,
>>>>>> So in other words once a process has been killed such that it is
>>>>>> no longer running it will still finish running even though it is
>>>>>> dead.
>>>>>
>>>>> Category Error. Turing Machines are NOT 'Processes' like in a
>>>>> computer. The simulation isn't the actual machine, just a
>>>>> simulation of it.
>>>>>
>>>> There is a Turing machine that is being executed: embedded_H and
>>>> there is a Turing machine description: ⟨Ĥ⟩ that is being simulated
>>>> by this first Turing machine. When embedded_H aborts its simulation,
>>>> the simulated machine: ⟨Ĥ⟩ immediately stops and is totally dead.
>>>>
>>>
>>> The SIMULATION stops, the behavior of the ACTUAL Turing Machine,
>>> which is what HALT refers to, does NOT.
>>>
>>
>> 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.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>> A decider maps its inputs to its own accept reject state.
>> A halt decider does not compute the halt status of itself.
>>
>
> Your 3 year old mind doesn't understand what a decider does.
>
> A decider needs to map its input to the CORRECT output based on the map
> it is computing.
>
> Yes, a halt decider doesn't normally decide on itself,

Can't possibly decide on itself.

> but it does need
> to decide based on what its input specifies,

Which is behavior that cannot possibly reach any final state of the
simulated input no matter what:
(a) It has been aborted before it reaches a finals state.
(b) It has not been aborted thus never reaches its final state.

--
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/22 1:29 PM, olcott wrote:
> On 3/18/2022 11:38 AM, Richard Damon wrote:
>> On 3/18/22 11:58 AM, olcott wrote:
>>> On 3/18/2022 10:49 AM, Richard Damon wrote:
>>>>
>>>> On 3/18/22 10:53 AM, olcott wrote:
>>>>> On 3/18/2022 9:47 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/18/22 10:14 AM, olcott wrote:
>>>>>>> On 3/18/2022 8:22 AM, Richard Damon wrote:
>>>>>>>> On 3/17/22 10:56 PM, olcott wrote (many times):
>>>>>>>>
>>>>>>>>> neither a partial nor a full simulation of the input
>>>>>>>>> could possibly reach the final state of this input
>>>>>>>>>
>>>>>>>>
>>>>>>>> 3 year old behavior and a LIE.
>>>>>>>>
>>>>>>>> A CORRECT FULL SIMULATION of the input WILL reach the final
>>>>>>>> state if H aborts its simulation,
>>>>>>> So in other words once a process has been killed such that it is
>>>>>>> no longer running it will still finish running even though it is
>>>>>>> dead.
>>>>>>
>>>>>> Category Error. Turing Machines are NOT 'Processes' like in a
>>>>>> computer. The simulation isn't the actual machine, just a
>>>>>> simulation of it.
>>>>>>
>>>>> There is a Turing machine that is being executed: embedded_H and
>>>>> there is a Turing machine description: ⟨Ĥ⟩ that is being simulated
>>>>> by this first Turing machine. When embedded_H aborts its
>>>>> simulation, the simulated machine: ⟨Ĥ⟩ immediately stops and is
>>>>> totally dead.
>>>>>
>>>>
>>>> The SIMULATION stops, the behavior of the ACTUAL Turing Machine,
>>>> which is what HALT refers to, does NOT.
>>>>
>>>
>>> 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.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>> A decider maps its inputs to its own accept reject state.
>>> A halt decider does not compute the halt status of itself.
>>>
>>
>> Your 3 year old mind doesn't understand what a decider does.
>>
>> A decider needs to map its input to the CORRECT output based on the
>> map it is computing.
>>
>> Yes, a halt decider doesn't normally decide on itself,
>
> Can't possibly decide on itself.

But if it is part of the input, it MUST, so you are just proving that NO
Halt Decider can decide correctly on ALL input, so the Halting Theorem
is PROVEN (and you do not have a counter-example).

>
>> but it does need to decide based on what its input specifies,
>
> Which is behavior that cannot possibly reach any final state of the
> simulated input no matter what:
> (a) It has been aborted before it reaches a finals state.
> (b) It has not been aborted thus never reaches its final state.
>

In case (a) the SIMULATION has been aborted, not the actual machine,
which is what the question is asking about, and THAT reaches its final
state, as does the CORRECT simulation of the input by a ACTUAL UTM. Thus
the "Non-Halting' answer is WRONG, and H is not a correct Halting Decider.

In case (b) your decider fails to answer, and thus fails to even be a
decider, let alone a correct decider.

In NEITHER case, is H a correct Halt Decider, so it is not a
counter-example to the Turing/Linz proof.

FAIL.

You are using the wrong criteria, so just making statements about your
own POOP, which NO ONE cares about.

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

On 3/18/22 1:37 PM, olcott wrote:
> 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.

The fact that an ABORTED simulation doesn't reach a final state proves
NOTHING.

And, it has been proved, that in this case the CORRECT simulation, will
reach a final state, so the computation is proved HALTING.

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

NOPE. Just that embedded_H is maybe a correct POOP decider.

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

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:53 PM, Richard Damon wrote:
> On 3/18/22 1:29 PM, olcott wrote:
>> On 3/18/2022 11:38 AM, Richard Damon wrote:
>>> On 3/18/22 11:58 AM, olcott wrote:
>>>> On 3/18/2022 10:49 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/18/22 10:53 AM, olcott wrote:
>>>>>> On 3/18/2022 9:47 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/18/22 10:14 AM, olcott wrote:
>>>>>>>> On 3/18/2022 8:22 AM, Richard Damon wrote:
>>>>>>>>> On 3/17/22 10:56 PM, olcott wrote (many times):
>>>>>>>>>
>>>>>>>>>> neither a partial nor a full simulation of the input
>>>>>>>>>> could possibly reach the final state of this input
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 3 year old behavior and a LIE.
>>>>>>>>>
>>>>>>>>> A CORRECT FULL SIMULATION of the input WILL reach the final
>>>>>>>>> state if H aborts its simulation,
>>>>>>>> So in other words once a process has been killed such that it is
>>>>>>>> no longer running it will still finish running even though it is
>>>>>>>> dead.
>>>>>>>
>>>>>>> Category Error. Turing Machines are NOT 'Processes' like in a
>>>>>>> computer. The simulation isn't the actual machine, just a
>>>>>>> simulation of it.
>>>>>>>
>>>>>> There is a Turing machine that is being executed: embedded_H and
>>>>>> there is a Turing machine description: ⟨Ĥ⟩ that is being simulated
>>>>>> by this first Turing machine. When embedded_H aborts its
>>>>>> simulation, the simulated machine: ⟨Ĥ⟩ immediately stops and is
>>>>>> totally dead.
>>>>>>
>>>>>
>>>>> The SIMULATION stops, the behavior of the ACTUAL Turing Machine,
>>>>> which is what HALT refers to, does NOT.
>>>>>
>>>>
>>>> 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.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>> A decider maps its inputs to its own accept reject state.
>>>> A halt decider does not compute the halt status of itself.
>>>>
>>>
>>> Your 3 year old mind doesn't understand what a decider does.
>>>
>>> A decider needs to map its input to the CORRECT output based on the
>>> map it is computing.
>>>
>>> Yes, a halt decider doesn't normally decide on itself,
>>
>> Can't possibly decide on itself.
>
> But if it is part of the input, it MUST, so you are just proving that NO
> Halt Decider can decide correctly on ALL input,
No knucklehead that is not what I am saying at all.
A decider can be applied to its own Turing machine description.
A decider cannot be applied to its own executing Turing machine.

--
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/22 1:58 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 <Ĥ>, 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.

No, that is EXACT what that was based on.

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

You are missing the requirements on the legs, having changed the wording
of M appled to w, which is equivelent to the CORRECT SIMULTION BY A UTM
of <M> w, to the (partial) simulation done by H of <M> w, which is NOT
equivalent.

If H^ ends up in H^.Qn, and halts, then that means that H went to Qn
which BY ITS DEFINITION, it can only do if the input to H (<H^> <H^>
represents a Non-Halting Computation. Since H^ applied to <H^> did Halt
when run, that shows this is not true, so H did not meet its requirements.

It absolutely does not matter if an H that aborts its simulation never
saw the halting state, it matters what would have happened if that same
input was given to a REAL UTM (not the H that played one on TV).

You have just FAILED.

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

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/22 2:17 PM, olcott wrote:
> On 3/18/2022 12:53 PM, Richard Damon wrote:
>> On 3/18/22 1:29 PM, olcott wrote:
>>> On 3/18/2022 11:38 AM, Richard Damon wrote:
>>>> On 3/18/22 11:58 AM, olcott wrote:
>>>>> On 3/18/2022 10:49 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/18/22 10:53 AM, olcott wrote:
>>>>>>> On 3/18/2022 9:47 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 3/18/22 10:14 AM, olcott wrote:
>>>>>>>>> On 3/18/2022 8:22 AM, Richard Damon wrote:
>>>>>>>>>> On 3/17/22 10:56 PM, olcott wrote (many times):
>>>>>>>>>>
>>>>>>>>>>> neither a partial nor a full simulation of the input
>>>>>>>>>>> could possibly reach the final state of this input
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 3 year old behavior and a LIE.
>>>>>>>>>>
>>>>>>>>>> A CORRECT FULL SIMULATION of the input WILL reach the final
>>>>>>>>>> state if H aborts its simulation,
>>>>>>>>> So in other words once a process has been killed such that it
>>>>>>>>> is no longer running it will still finish running even though
>>>>>>>>> it is dead.
>>>>>>>>
>>>>>>>> Category Error. Turing Machines are NOT 'Processes' like in a
>>>>>>>> computer. The simulation isn't the actual machine, just a
>>>>>>>> simulation of it.
>>>>>>>>
>>>>>>> There is a Turing machine that is being executed: embedded_H and
>>>>>>> there is a Turing machine description: ⟨Ĥ⟩ that is being
>>>>>>> simulated by this first Turing machine. When embedded_H aborts
>>>>>>> its simulation, the simulated machine: ⟨Ĥ⟩ immediately stops and
>>>>>>> is totally dead.
>>>>>>>
>>>>>>
>>>>>> The SIMULATION stops, the behavior of the ACTUAL Turing Machine,
>>>>>> which is what HALT refers to, does NOT.
>>>>>>
>>>>>
>>>>> 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.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>> A decider maps its inputs to its own accept reject state.
>>>>> A halt decider does not compute the halt status of itself.
>>>>>
>>>>
>>>> Your 3 year old mind doesn't understand what a decider does.
>>>>
>>>> A decider needs to map its input to the CORRECT output based on the
>>>> map it is computing.
>>>>
>>>> Yes, a halt decider doesn't normally decide on itself,
>>>
>>> Can't possibly decide on itself.
>>
>> But if it is part of the input, it MUST, so you are just proving that
>> NO Halt Decider can decide correctly on ALL input,
> No knucklehead that is not what I am saying at all.
> A decider can be applied to its own Turing machine description.
> A decider cannot be applied to its own executing Turing machine.
>

And it wasn't, H needs to CORRECTLY decide on the input <H^> <H^> whose
MAPPING is based on the BEHAVIOR of H^ applied to <H^> even though that
contains a copy of H.

Thus the CORRECT answer depends on its own behavior, which you keep on
trying to deny because you like your Herring Red.

On 3/18/2022 12:57 PM, Richard Damon wrote:
> On 3/18/22 1:37 PM, olcott wrote:
>> 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.
>
> The fact that an ABORTED simulation doesn't reach a final state proves
> NOTHING.
>
> And, it has been proved, that in this case the CORRECT simulation, will
> reach a final state, so the computation is proved HALTING.
>

Try and show all of the details of exactly how the correctly simulated
input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.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

On 3/18/22 2:32 PM, olcott wrote:
> On 3/18/2022 12:57 PM, Richard Damon wrote:
>> On 3/18/22 1:37 PM, olcott wrote:
>>> 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.
>>
>> The fact that an ABORTED simulation doesn't reach a final state proves
>> NOTHING.
>>
>> And, it has been proved, that in this case the CORRECT simulation,
>> will reach a final state, so the computation is proved HALTING.
>>
>
> Try and show all of the details of exactly how the correctly simulated
> input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>

I've done it many times for you.

Assuming H stops on the FIRST occurance of seeing a recursive call to H
<H^> <H^> (to keep the trace shorted)

CORRECT simulation is by UTM (not H)

UTM <H^0> <H^1>
UTM Simulates H^0 coping its input <H^1> to <H^2>
UTM Simulates H^0 using H0 <H^1> <H^2>
UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to <H^3>
UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
UTM Simulates H0 deciding that the input will never halt
UTM Simulates H0 going to State H0.Qn
UTM sees that State H0.Qn is the same as H^0.Qn
UTM sees that H^0.Qn is a final state.
UTM HALTS.

Thus the CORRECT simulation of <H^> <H^> reached its final state of H^.Qn

Note, the simulation done by H is NOT a correct simulation as it is only
a PARTIAL simulation, and a partial simulation NEVER directly proves
non-halting.

On 3/18/2022 2:16 PM, Richard Damon wrote:
> On 3/18/22 2:32 PM, olcott wrote:
>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>> On 3/18/22 1:37 PM, olcott wrote:
>>>> 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.
>>>
>>> The fact that an ABORTED simulation doesn't reach a final state
>>> proves NOTHING.
>>>
>>> And, it has been proved, that in this case the CORRECT simulation,
>>> will reach a final state, so the computation is proved HALTING.
>>>
>>
>> Try and show all of the details of exactly how the correctly simulated
>> input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>
>
> I've done it many times for you.
>
> Assuming H stops on the FIRST occurance of seeing a recursive call to H
> <H^> <H^> (to keep the trace shorted)
>
> CORRECT simulation is by UTM (not H)
>
> UTM <H^0> <H^1>
> UTM Simulates H^0 coping its input <H^1> to <H^2>
> UTM Simulates H^0 using H0 <H^1> <H^2>
> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to <H^3>
> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
> UTM Simulates H0 deciding that the input will never halt
> UTM Simulates H0 going to State H0.Qn
> UTM sees that State H0.Qn is the same as H^0.Qn
> UTM sees that H^0.Qn is a final state.
> UTM HALTS.
>
> Thus the CORRECT simulation of <H^> <H^> reached its final state of H^.Qn
>
> Note, the simulation done by H is NOT a correct simulation as it is only
> a PARTIAL simulation, and a partial simulation NEVER directly proves
> non-halting.
>
>

The correct simulation is made by the UTM that is embedded within
embedded_H. It continues to perform a pure simulation of its input until:
(1) Its input reaches the final state of this input.
(2) It detects that its pure simulation of its input would never reach
the final state of 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

On 3/18/22 2:28 PM, olcott wrote:
> 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.

And the definition of a Halt Decider is that behavior is specifed by the
ACTUAL behavior of the ACTUAL TURING MACHINE the input represents, or
equivalently by the simulation of an ACTUAL DEFINITION FOLLOWING UTM.

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

Except the change to make it abort makes it no longer a UTM, so this
statement is FALSE. By DEFINITION, a UTM applied to the representation
of a non-halting computation NEVER stops. Your 'H' fails that definition.

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

Nope. Not a determinable operation. You can't always tell that the
simulation of an input will NEVER halt in finite time. You are assuming
that someone has created a Halt Decider to prove that your Halt Decider
can be made. This is the fallacy of assuming your conclusion.

It has been show that there exists NO finite patterns in an H^ built
from an H that uses that pattern to detect halting that is correct.

ANY such pattern, by construction, when added to H becomes incorrect in
the H^ built from that H, because H^ will Halt when its H goes to H.Qn.

FAIL

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

On 3/18/22 3:22 PM, olcott wrote:
> On 3/18/2022 2:16 PM, Richard Damon wrote:
>> On 3/18/22 2:32 PM, olcott wrote:
>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> The fact that an ABORTED simulation doesn't reach a final state
>>>> proves NOTHING.
>>>>
>>>> And, it has been proved, that in this case the CORRECT simulation,
>>>> will reach a final state, so the computation is proved HALTING.
>>>>
>>>
>>> Try and show all of the details of exactly how the correctly
>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>
>>
>> I've done it many times for you.
>>
>> Assuming H stops on the FIRST occurance of seeing a recursive call to
>> H <H^> <H^> (to keep the trace shorted)
>>
>> CORRECT simulation is by UTM (not H)
>>
>> UTM <H^0> <H^1>
>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>> UTM Simulates H^0 using H0 <H^1> <H^2>
>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to <H^3>
>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>> UTM Simulates H0 deciding that the input will never halt
>> UTM Simulates H0 going to State H0.Qn
>> UTM sees that State H0.Qn is the same as H^0.Qn
>> UTM sees that H^0.Qn is a final state.
>> UTM HALTS.
>>
>> Thus the CORRECT simulation of <H^> <H^> reached its final state of H^.Qn
>>
>> Note, the simulation done by H is NOT a correct simulation as it is
>> only a PARTIAL simulation, and a partial simulation NEVER directly
>> proves non-halting.
>>
>>
>
> The correct simulation is made by the UTM that is embedded within
> embedded_H. It continues to perform a pure simulation of its input until:
> (1) Its input reaches the final state of this input.
> (2) It detects that its pure simulation of its input would never reach
> the final state of this input.
>

There is no UTM embedded in an embedded_H that aborts its simulation, so
whatever simulation it gives that causes embedded_H to abort is
incorrect. That is DEFINITIONALLY IMPOSSIBLE.

By Construction, if H <H^> <H^> -> H.Qn then H^ <H^>, the computation
the previous is deciding on, also goes to H^.Qn and Halts, and thus H
was WRONG.

You just don't understand anything about this topic, and have so many
false definitions that you are incapable of actually reasoning about
Turing Machines.

You logic if filled with the assumption of Fairy Dust Powered Unicorns
to do the Magic you need to acheive the impossible results you claim.

On 3/18/2022 2:26 PM, Richard Damon wrote:
>
> On 3/18/22 3:22 PM, olcott wrote:
>> On 3/18/2022 2:16 PM, Richard Damon wrote:
>>> On 3/18/22 2:32 PM, olcott wrote:
>>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>>> 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.
>>>>>
>>>>> The fact that an ABORTED simulation doesn't reach a final state
>>>>> proves NOTHING.
>>>>>
>>>>> And, it has been proved, that in this case the CORRECT simulation,
>>>>> will reach a final state, so the computation is proved HALTING.
>>>>>
>>>>
>>>> Try and show all of the details of exactly how the correctly
>>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>>
>>>
>>> I've done it many times for you.
>>>
>>> Assuming H stops on the FIRST occurance of seeing a recursive call to
>>> H <H^> <H^> (to keep the trace shorted)
>>>
>>> CORRECT simulation is by UTM (not H)
>>>
>>> UTM <H^0> <H^1>
>>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>>> UTM Simulates H^0 using H0 <H^1> <H^2>
>>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to <H^3>
>>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>>> UTM Simulates H0 deciding that the input will never halt
>>> UTM Simulates H0 going to State H0.Qn
>>> UTM sees that State H0.Qn is the same as H^0.Qn
>>> UTM sees that H^0.Qn is a final state.
>>> UTM HALTS.
>>>
>>> Thus the CORRECT simulation of <H^> <H^> reached its final state of
>>> H^.Qn
>>>
>>> Note, the simulation done by H is NOT a correct simulation as it is
>>> only a PARTIAL simulation, and a partial simulation NEVER directly
>>> proves non-halting.
>>>
>>>
>>
>> The correct simulation is made by the UTM that is embedded within
>> embedded_H. It continues to perform a pure simulation of its input until:
>> (1) Its input reaches the final state of this input.
>> (2) It detects that its pure simulation of its input would never reach
>> the final state of this input.
>>
>
> There is no UTM embedded in an embedded_H that aborts its simulation,

In BASIC when let X = 5 is executed one is not free to disbelieve that X
has the value of 5.

Likewise when it is stipulated the embedded_H has all of the
functionality of a UTM one is not free to disagree with this stipulation
(not even if one is an actual BRAIN DEAD MORON).

On 3/18/22 3:56 PM, olcott wrote:
> On 3/18/2022 2:26 PM, Richard Damon wrote:
>>
>> On 3/18/22 3:22 PM, olcott wrote:
>>> On 3/18/2022 2:16 PM, Richard Damon wrote:
>>>> On 3/18/22 2:32 PM, olcott wrote:
>>>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>>>> 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.
>>>>>>
>>>>>> The fact that an ABORTED simulation doesn't reach a final state
>>>>>> proves NOTHING.
>>>>>>
>>>>>> And, it has been proved, that in this case the CORRECT simulation,
>>>>>> will reach a final state, so the computation is proved HALTING.
>>>>>>
>>>>>
>>>>> Try and show all of the details of exactly how the correctly
>>>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>>>
>>>>
>>>> I've done it many times for you.
>>>>
>>>> Assuming H stops on the FIRST occurance of seeing a recursive call
>>>> to H <H^> <H^> (to keep the trace shorted)
>>>>
>>>> CORRECT simulation is by UTM (not H)
>>>>
>>>> UTM <H^0> <H^1>
>>>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>>>> UTM Simulates H^0 using H0 <H^1> <H^2>
>>>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to
>>>> <H^3>
>>>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>>>> UTM Simulates H0 deciding that the input will never halt
>>>> UTM Simulates H0 going to State H0.Qn
>>>> UTM sees that State H0.Qn is the same as H^0.Qn
>>>> UTM sees that H^0.Qn is a final state.
>>>> UTM HALTS.
>>>>
>>>> Thus the CORRECT simulation of <H^> <H^> reached its final state of
>>>> H^.Qn
>>>>
>>>> Note, the simulation done by H is NOT a correct simulation as it is
>>>> only a PARTIAL simulation, and a partial simulation NEVER directly
>>>> proves non-halting.
>>>>
>>>>
>>>
>>> The correct simulation is made by the UTM that is embedded within
>>> embedded_H. It continues to perform a pure simulation of its input
>>> until:
>>> (1) Its input reaches the final state of this input.
>>> (2) It detects that its pure simulation of its input would never
>>> reach the final state of this input.
>>>
>>
>> There is no UTM embedded in an embedded_H that aborts its simulation,
>
> In BASIC when let X = 5 is executed one is not free to disbelieve that X
> has the value of 5.
>
> Likewise when it is stipulated the embedded_H has all of the
> functionality of a UTM one is not free to disagree with this stipulation
> (not even if one is an actual BRAIN DEAD MORON).
>

On 3/18/2022 3:48 PM, Richard Damon wrote:
> On 3/18/22 3:56 PM, olcott wrote:
>> On 3/18/2022 2:26 PM, Richard Damon wrote:
>>>
>>> On 3/18/22 3:22 PM, olcott wrote:
>>>> On 3/18/2022 2:16 PM, Richard Damon wrote:
>>>>> On 3/18/22 2:32 PM, olcott wrote:
>>>>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>
>>>>>>> The fact that an ABORTED simulation doesn't reach a final state
>>>>>>> proves NOTHING.
>>>>>>>
>>>>>>> And, it has been proved, that in this case the CORRECT
>>>>>>> simulation, will reach a final state, so the computation is
>>>>>>> proved HALTING.
>>>>>>>
>>>>>>
>>>>>> Try and show all of the details of exactly how the correctly
>>>>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>>>>
>>>>>
>>>>> I've done it many times for you.
>>>>>
>>>>> Assuming H stops on the FIRST occurance of seeing a recursive call
>>>>> to H <H^> <H^> (to keep the trace shorted)
>>>>>
>>>>> CORRECT simulation is by UTM (not H)
>>>>>
>>>>> UTM <H^0> <H^1>
>>>>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>>>>> UTM Simulates H^0 using H0 <H^1> <H^2>
>>>>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to
>>>>> <H^3>
>>>>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>>>>> UTM Simulates H0 deciding that the input will never halt
>>>>> UTM Simulates H0 going to State H0.Qn
>>>>> UTM sees that State H0.Qn is the same as H^0.Qn
>>>>> UTM sees that H^0.Qn is a final state.
>>>>> UTM HALTS.
>>>>>
>>>>> Thus the CORRECT simulation of <H^> <H^> reached its final state of
>>>>> H^.Qn
>>>>>
>>>>> Note, the simulation done by H is NOT a correct simulation as it is
>>>>> only a PARTIAL simulation, and a partial simulation NEVER directly
>>>>> proves non-halting.
>>>>>
>>>>>
>>>>
>>>> The correct simulation is made by the UTM that is embedded within
>>>> embedded_H. It continues to perform a pure simulation of its input
>>>> until:
>>>> (1) Its input reaches the final state of this input.
>>>> (2) It detects that its pure simulation of its input would never
>>>> reach the final state of this input.
>>>>
>>>
>>> There is no UTM embedded in an embedded_H that aborts its simulation,
>>
>> In BASIC when let X = 5 is executed one is not free to disbelieve that
>> X has the value of 5.
>>
>> Likewise when it is stipulated the embedded_H has all of the
>> functionality of a UTM one is not free to disagree with this
>> stipulation (not even if one is an actual BRAIN DEAD MORON).
>>
>
> You can't 'stipulate' a lie and make it True.
>
> BY DEFINITION, a UTM will NEVER abort its simulation.
>

On 3/18/22 4:58 PM, olcott wrote:
> On 3/18/2022 3:48 PM, Richard Damon wrote:
>> On 3/18/22 3:56 PM, olcott wrote:
>>> On 3/18/2022 2:26 PM, Richard Damon wrote:
>>>>
>>>> On 3/18/22 3:22 PM, olcott wrote:
>>>>> On 3/18/2022 2:16 PM, Richard Damon wrote:
>>>>>> On 3/18/22 2:32 PM, olcott wrote:
>>>>>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>>>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> The fact that an ABORTED simulation doesn't reach a final state
>>>>>>>> proves NOTHING.
>>>>>>>>
>>>>>>>> And, it has been proved, that in this case the CORRECT
>>>>>>>> simulation, will reach a final state, so the computation is
>>>>>>>> proved HALTING.
>>>>>>>>
>>>>>>>
>>>>>>> Try and show all of the details of exactly how the correctly
>>>>>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>>>>>
>>>>>>
>>>>>> I've done it many times for you.
>>>>>>
>>>>>> Assuming H stops on the FIRST occurance of seeing a recursive call
>>>>>> to H <H^> <H^> (to keep the trace shorted)
>>>>>>
>>>>>> CORRECT simulation is by UTM (not H)
>>>>>>
>>>>>> UTM <H^0> <H^1>
>>>>>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>>>>>> UTM Simulates H^0 using H0 <H^1> <H^2>
>>>>>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2> to
>>>>>> <H^3>
>>>>>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>>>>>> UTM Simulates H0 deciding that the input will never halt
>>>>>> UTM Simulates H0 going to State H0.Qn
>>>>>> UTM sees that State H0.Qn is the same as H^0.Qn
>>>>>> UTM sees that H^0.Qn is a final state.
>>>>>> UTM HALTS.
>>>>>>
>>>>>> Thus the CORRECT simulation of <H^> <H^> reached its final state
>>>>>> of H^.Qn
>>>>>>
>>>>>> Note, the simulation done by H is NOT a correct simulation as it
>>>>>> is only a PARTIAL simulation, and a partial simulation NEVER
>>>>>> directly proves non-halting.
>>>>>>
>>>>>>
>>>>>
>>>>> The correct simulation is made by the UTM that is embedded within
>>>>> embedded_H. It continues to perform a pure simulation of its input
>>>>> until:
>>>>> (1) Its input reaches the final state of this input.
>>>>> (2) It detects that its pure simulation of its input would never
>>>>> reach the final state of this input.
>>>>>
>>>>
>>>> There is no UTM embedded in an embedded_H that aborts its simulation,
>>>
>>> In BASIC when let X = 5 is executed one is not free to disbelieve
>>> that X has the value of 5.
>>>
>>> Likewise when it is stipulated the embedded_H has all of the
>>> functionality of a UTM one is not free to disagree with this
>>> stipulation (not even if one is an actual BRAIN DEAD MORON).
>>>
>>
>> You can't 'stipulate' a lie and make it True.
>>
>> BY DEFINITION, a UTM will NEVER abort its simulation.
>>
>
> I am stipulating that embedded_H contains all of the functionality of a
> UTM, thus is capable of simulating every Turing machine description that
> specifies a halting computation all the way until this input reaches its
> own final state.

On 3/18/2022 4:15 PM, Richard Damon wrote:
> On 3/18/22 4:58 PM, olcott wrote:
>> On 3/18/2022 3:48 PM, Richard Damon wrote:
>>> On 3/18/22 3:56 PM, olcott wrote:
>>>> On 3/18/2022 2:26 PM, Richard Damon wrote:
>>>>>
>>>>> On 3/18/22 3:22 PM, olcott wrote:
>>>>>> On 3/18/2022 2:16 PM, Richard Damon wrote:
>>>>>>> On 3/18/22 2:32 PM, olcott wrote:
>>>>>>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>>>>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> The fact that an ABORTED simulation doesn't reach a final state
>>>>>>>>> proves NOTHING.
>>>>>>>>>
>>>>>>>>> And, it has been proved, that in this case the CORRECT
>>>>>>>>> simulation, will reach a final state, so the computation is
>>>>>>>>> proved HALTING.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Try and show all of the details of exactly how the correctly
>>>>>>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>>>>>>
>>>>>>>
>>>>>>> I've done it many times for you.
>>>>>>>
>>>>>>> Assuming H stops on the FIRST occurance of seeing a recursive
>>>>>>> call to H <H^> <H^> (to keep the trace shorted)
>>>>>>>
>>>>>>> CORRECT simulation is by UTM (not H)
>>>>>>>
>>>>>>> UTM <H^0> <H^1>
>>>>>>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>>>>>>> UTM Simulates H^0 using H0 <H^1> <H^2>
>>>>>>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2>
>>>>>>> to <H^3>
>>>>>>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>>>>>>> UTM Simulates H0 deciding that the input will never halt
>>>>>>> UTM Simulates H0 going to State H0.Qn
>>>>>>> UTM sees that State H0.Qn is the same as H^0.Qn
>>>>>>> UTM sees that H^0.Qn is a final state.
>>>>>>> UTM HALTS.
>>>>>>>
>>>>>>> Thus the CORRECT simulation of <H^> <H^> reached its final state
>>>>>>> of H^.Qn
>>>>>>>
>>>>>>> Note, the simulation done by H is NOT a correct simulation as it
>>>>>>> is only a PARTIAL simulation, and a partial simulation NEVER
>>>>>>> directly proves non-halting.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> The correct simulation is made by the UTM that is embedded within
>>>>>> embedded_H. It continues to perform a pure simulation of its input
>>>>>> until:
>>>>>> (1) Its input reaches the final state of this input.
>>>>>> (2) It detects that its pure simulation of its input would never
>>>>>> reach the final state of this input.
>>>>>>
>>>>>
>>>>> There is no UTM embedded in an embedded_H that aborts its simulation,
>>>>
>>>> In BASIC when let X = 5 is executed one is not free to disbelieve
>>>> that X has the value of 5.
>>>>
>>>> Likewise when it is stipulated the embedded_H has all of the
>>>> functionality of a UTM one is not free to disagree with this
>>>> stipulation (not even if one is an actual BRAIN DEAD MORON).
>>>>
>>>
>>> You can't 'stipulate' a lie and make it True.
>>>
>>> BY DEFINITION, a UTM will NEVER abort its simulation.
>>>
>>
>> I am stipulating that embedded_H contains all of the functionality of
>> a UTM, thus is capable of simulating every Turing machine description
>> that specifies a halting computation all the way until this input
>> reaches its own final state.
>
> Which it doesn't have BY DEFINITION.

On 3/18/22 5:41 PM, olcott wrote:
> On 3/18/2022 4:15 PM, Richard Damon wrote:
>> On 3/18/22 4:58 PM, olcott wrote:
>>> On 3/18/2022 3:48 PM, Richard Damon wrote:
>>>> On 3/18/22 3:56 PM, olcott wrote:
>>>>> On 3/18/2022 2:26 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/18/22 3:22 PM, olcott wrote:
>>>>>>> On 3/18/2022 2:16 PM, Richard Damon wrote:
>>>>>>>> On 3/18/22 2:32 PM, olcott wrote:
>>>>>>>>> On 3/18/2022 12:57 PM, Richard Damon wrote:
>>>>>>>>>> On 3/18/22 1:37 PM, olcott wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> The fact that an ABORTED simulation doesn't reach a final
>>>>>>>>>> state proves NOTHING.
>>>>>>>>>>
>>>>>>>>>> And, it has been proved, that in this case the CORRECT
>>>>>>>>>> simulation, will reach a final state, so the computation is
>>>>>>>>>> proved HALTING.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Try and show all of the details of exactly how the correctly
>>>>>>>>> simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ will reach its own final state of ⟨Ĥ⟩.qn
>>>>>>>>>
>>>>>>>>
>>>>>>>> I've done it many times for you.
>>>>>>>>
>>>>>>>> Assuming H stops on the FIRST occurance of seeing a recursive
>>>>>>>> call to H <H^> <H^> (to keep the trace shorted)
>>>>>>>>
>>>>>>>> CORRECT simulation is by UTM (not H)
>>>>>>>>
>>>>>>>> UTM <H^0> <H^1>
>>>>>>>> UTM Simulates H^0 coping its input <H^1> to <H^2>
>>>>>>>> UTM Simulates H^0 using H0 <H^1> <H^2>
>>>>>>>> UTM Simulates H0 simulating <H^1> <H^2> copying its input <H^2>
>>>>>>>> to <H^3>
>>>>>>>> UTM Simulates H0 simulating <H^1> using H1 <H^2> <H^3>
>>>>>>>> UTM Simulates H0 deciding that the input will never halt
>>>>>>>> UTM Simulates H0 going to State H0.Qn
>>>>>>>> UTM sees that State H0.Qn is the same as H^0.Qn
>>>>>>>> UTM sees that H^0.Qn is a final state.
>>>>>>>> UTM HALTS.
>>>>>>>>
>>>>>>>> Thus the CORRECT simulation of <H^> <H^> reached its final state
>>>>>>>> of H^.Qn
>>>>>>>>
>>>>>>>> Note, the simulation done by H is NOT a correct simulation as it
>>>>>>>> is only a PARTIAL simulation, and a partial simulation NEVER
>>>>>>>> directly proves non-halting.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> The correct simulation is made by the UTM that is embedded within
>>>>>>> embedded_H. It continues to perform a pure simulation of its
>>>>>>> input until:
>>>>>>> (1) Its input reaches the final state of this input.
>>>>>>> (2) It detects that its pure simulation of its input would never
>>>>>>> reach the final state of this input.
>>>>>>>
>>>>>>
>>>>>> There is no UTM embedded in an embedded_H that aborts its simulation,
>>>>>
>>>>> In BASIC when let X = 5 is executed one is not free to disbelieve
>>>>> that X has the value of 5.
>>>>>
>>>>> Likewise when it is stipulated the embedded_H has all of the
>>>>> functionality of a UTM one is not free to disagree with this
>>>>> stipulation (not even if one is an actual BRAIN DEAD MORON).
>>>>>
>>>>
>>>> You can't 'stipulate' a lie and make it True.
>>>>
>>>> BY DEFINITION, a UTM will NEVER abort its simulation.
>>>>
>>>
>>> I am stipulating that embedded_H contains all of the functionality of
>>> a UTM, thus is capable of simulating every Turing machine description
>>> that specifies a halting computation all the way until this input
>>> reaches its own final state.
>>
>> Which it doesn't have BY DEFINITION.
>
> You just said that there does not exist any Turing machine description
> that can be simulated until this simulated machine reaches its own final
> state, in other words there is no such that as a Turing machine that
> halts. You are a nitwit.
>