On 3/19/22 9:34 AM, olcott wrote:
> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>> simulation:
>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts,
>>>>>>>> and
>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does
>>>>>>>> not halt.
>>>>>>>> Feel fee to replace "halts" with "would reach its final state" (and
>>>>>>>> similarly for "does not halt") if it make you feel better.  Both
>>>>>>>> figures
>>>>>>>> of speech convey the same mathematical fact, but one is shorter
>>>>>>>> and fits
>>>>>>>> on a line.
>>>>>>>> What you can't do, if you want to keep talking about what Linz is
>>>>>>>> talking about, is replace the reference to a UTM with embedded_H.
>>>>>>>
>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>> Not in dispute.
>>>>>>
>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>> simulation to
>>>>>>> be a part of the decision process.
>>>>>> Not in dispute.
>>>>>>
>>>>>>> Embedded_H determines whether or not its simulated input would ever
>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>> Not in dispute.
>>>>>>
>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>> the
>>>>>>>>> copy of H embedded within Ĥ would never reach the final state
>>>>>>>>> of this
>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>>>>> definition of a halt decider.  If you think there is any point,
>>>>>>>> I'll
>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>
>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>> reports this that is most relevant.
>>>>>> Not in dispute (except for the poor wording).
>>>>>> If you want to know why you are still wrong after 14 years, you are
>>>>>> going to have to learn to follow what other people are saying.  Of
>>>>>> course, if you did that, you'd see all your mistakes, so you are much
>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>
>>>>>
>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt decider
>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>> simulation to embedded_H thus making the embedded_H transition to Ĥ.qn
>>>>> correct.
>>>> No.
>>>
>>> The reason that you only have a dogmatic reply rather than any
>>> supporting reasoning is that I am correct.
>>
>> No, it's because there is no evidence that you can accept the
>> explanations that are put to you.
>
> That is a bullshit excuse to hide the fact that you fail to understand
> what I said. You could provide an answer for posterity and for others
> that may eventually come to this post. The truth is you can't point out
> any specific error because there is no error.
>
>>   Do you really think it's worth my
>> while explaining, yet again, that re-defining what H should do is just
>> pointless?
>>
>> I'll take the time to explain if you ask intelligent questions, but my
>> repeating that reply to what you keep cutting and pasting is just a
>> waste of time.
>>
>
> All of the "rebuttals" never pointing out any specific error and were
> always some kind of ad hominem attack of another.

MOST of the rebuttals point out specific errors (or at least reference
previous attempts to point them out).

The issue s you don't seem to understand the meaning of the words enough
to understand what is being said.

A bit like trying to explain something 'adult' to a 3 year old.

>
>>> No one can find any error in the following only because there is no
>>> error to be found.
>>
>
> No one can find any error in the following only because there is no
> error to be found.
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>
> (1) If embedded_H does not abort the simulation of its input the
> simulation never stops and the simulated input never reaches its final
> state.
>
> (2) If embedded_H does abort the simulation of its input the simulation
> is aborted at some point shown above and the simulated input never
> reaches its final state.
>
> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
> configurations that never reach a final state. This in turn makes the
> transition to Ĥ.qn by embedded_H correct.

I have pointed out the error many times and you just ignore it because
you don't want to believe it.

The infinite loop described only exist if embedded_H never aborts its
simulation, and in that case, it never gives an answer.

If embedded_H aborts its simulation, and goes to Qn, then the top level
H^ applied to <H^> will go to H^.Qn and Halt, and thus <H^> <H^>, which
represents this, represents a HALTING computaiton, and thus embedded_H
is WRONG by DEFINITION.

>
>> You can't see the error.  That's not the same thing at all.
>>
>
> That no one pointed out a specific error is a verified fact.
> That no one pointed out an error because there is no error is a
> reasonably plausible conclusion.

Specifed errors have been pointed out MANY times. YOU just don't
understand them because you don't understand what any of this actually
means.

>
>> I some sense you clearly know that there is not halt decider because
>> there would be no need to re-define what the correct answer is if you
>> thought it were possible.
>>
>
> Everyone (including Linz) makes the mistake that the copy of the Linz H
> embedded in Ĥ must report on its own behavior never realizing that this
> is just not the way that deciders work.

No, YOU don't understand that this is EXACTLY how Deciders work. If the
question is about them, then answer about themselves.

The is no self-referential exception built into the definiton of a
decider. You might think it needs to be, because you don't understand
logic that uses forms of self-reference.

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

Can you PROVE That? That they are not ALLOWED to report on their own
behavior, even if that is the question put before them?

Or are you saying that BY DEFINITION a Halt Decider, as defined as a
decider that can report the halting status of ANY computation can not
exist as it might need to report on a copy of itself?

On 3/19/22 9:37 AM, olcott wrote:
> On 3/19/2022 8:28 AM, Richard Damon wrote:
>> On 3/19/22 9:08 AM, olcott wrote:
>>> On 3/19/2022 7:57 AM, Richard Damon wrote:
>>>> On 3/18/22 10:24 PM, olcott wrote:
>>>>> On 3/18/2022 8:05 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/18/2022 11:54 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> No BRAIN DEAD MORON this is not true, I keep calling you a
>>>>>>>>> BRAIN DEAD
>>>>>>>>> MORON because after I have explain all the details you cannot
>>>>>>>>> remember
>>>>>>>>> what I just said.
>>>>>>>> I see the petulant six-year-old is in residence today.
>>>>>>>>
>>>>>>>>> A decider maps its inputs to its own accept reject state.
>>>>>>>>> A halt decider does not compute the halt status of itself.
>>>>>>>>
>>>>>>>> A halt decider, let's call it H, maps the input <Ĥ> <Ĥ> to its
>>>>>>>> accept
>>>>>
>>>>> You have changed the subject away from the Linz proof's conclusion
>>>>> that deals with Ĥ applied to <Ĥ> and not H applied to <Ĥ> <Ĥ>.
>>>>>
>>>>
>>>> NO, you don't understand what the conclusion actually means. Perhaps
>>>> you don't even understand what 'Proof by Contradiction' means, since
>>>> I don't think the logic system you want to use supports it.
>>>
>>> Linz and I are talking about Ĥ applied to <Ĥ>,
>>> we are not talking about H applied to <Ĥ> <Ĥ>.
>>> You assume (against the verified facts) that it makes no difference.
>>
>> Right, but the argument also uses the definiton of what H applied to
>> <H^> <H^> does, which you don't seem to understand, because you are an
>> idiot.
>>
>>>
>>> </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>
>>>
>>
>> Right, and if you understood the logic used to present the
>> contradiction, you might undstand where you are wrong.
>
> Linz says that both the transition to Ĥ.qy and Ĥ.qn are the wrong
> answer, I prove that the transition to Ĥ.qn is the correct answer.
>
> Your only rebuttal to this proof was simply an ad hominem attack.
>

How is saying a Computation that Halts is a Non-Halting Computation.

Remember the DEFINITION of a Halt Decider is that H applied to <M> w
must only go to H.Qn if M applied to w never halts.

Since H^ applied to <H^> does Halt if H applied to <H^> <H^> goes to
H.Qn, then that is NOT the right answer.

Your proof uses wrong definitions.

On 3/19/22 9:40 AM, olcott wrote:
> On 3/19/2022 8:34 AM, Richard Damon wrote:
>> On 3/19/22 9:21 AM, olcott wrote:
>>> On 3/19/2022 8:14 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/18/2022 8:07 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>> simulation:
>>>>>>>>>>>>        Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>> halts, and
>>>>>>>>>>>>        Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>> does not halt.
>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>> state" (and
>>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>>> Both figures
>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>> on a line.
>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>> Linz is
>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>
>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>> Not in dispute.
>>>>>>>>>>
>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>> simulation to
>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>> Not in dispute.
>>>>>>>>>>
>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>> would ever
>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>>> Not in dispute.
>>>>>>>>>>
>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>> state of this
>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>> point, I'll
>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>
>>>>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>> you are
>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>> saying.  Of
>>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>>> are much
>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>
>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>>>>> decider
>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>>> simulation to embedded_H thus making the embedded_H transition
>>>>>>>>> to Ĥ.qn
>>>>>>>>> correct.
>>>>>>>>
>>>>>>>> No.
>>>>>>>
>>>>>>> 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.
>>>>>> None of this corrects the mistake -- my "no" still stands.  In
>>>>>> general,
>>>>>> giving more details will not correct a fundamental error.
>>>>>
>>>>> THIS IS YOUR FIRST MISTAKE:
>>>>> You have changed the subject away from the Linz proof's conclusion
>>>>> that deals with Ĥ applied to <Ĥ> and not H applied to <Ĥ> <Ĥ>.
>>>>
>>>> That's exactly what I was talking about.  What mistake did you think I
>>>> was pointing out?  Your providing more details about the mistake did
>>>> not
>>>> correct it.
>>>>
>>>
>>> I will take your continual dodge of the subject as an attempt to hide
>>> the fact that you fail to even comprehend the terminology. The idea
>>> of infinitely nested simulation is beyond you capacity to understand.
>>>
>>> You should be able to understand that the Linz proof's conclusion is
>>> not based on H applied to <Ĥ> <Ĥ> and instead is based on Ĥ applied
>>> to <Ĥ>.
>>>
>>
>> Except that is IS based on what H applied to <H^> <H^> does,
>
> </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>
>
> Until you get back to Ĥ applied to <Ĥ> everyone will know that you are a
> God damned liar.
>
>
Ok. H^ applied to <H^> will go to H^.Qn (which will halt) if and only if
H applied to <H^> <H^> goes to H.Qn, and H applied to <H^> <H^> is
allowed to go to H.Qn if and only if H^ applied to <H^> will never halt.

On 3/19/22 9:49 AM, olcott wrote:
> On 3/19/2022 8:42 AM, Richard Damon wrote:
>> On 3/19/22 9:38 AM, olcott wrote:
>>> On 3/19/2022 8:28 AM, Richard Damon wrote:
>>>> On 3/19/22 9:11 AM, olcott wrote:
>>>>> On 3/19/2022 8:00 AM, Richard Damon wrote:
>>>>>> On 3/18/22 10:55 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.
>>>>>>>
>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>> supporting reasoning is that I am correct.
>>>>>>
>>>>>> What, like you don't understand what a UTM is, or that the loop
>>>>>> you describe only occurs if embedded_H never aborts its
>>>>>> simulation, and the if it does, then H^ applied to <H^> actually
>>>>>> HALTS as the trace I showed you did, so embedded_H is wrong.
>>>>>>
>>>>>> The problem isn't that people haven't given you reasoned
>>>>>> rebuttals, the problem iis that YOU dogmaticaaly ignore anything
>>>>>> that disagrees with your fantasies.
>>>>>>
>>>>>> You are just PROVING how ignorant you are of this whole topic,
>>>>>> includig what basic logic means.
>>>>>>
>>>>>
>>>>> More rhetoric instead of reasoning.
>>>>> Find an actual error in the steps below.
>>>>>
>>>>> More rhetoric instead of reasoning.
>>>>> Find an actual error in the steps below.
>>>>>
>>>>> More rhetoric instead of reasoning.
>>>>> Find an actual error in the steps below.
>>>>>
>>>>> More rhetoric instead of reasoning.
>>>>> Find an actual error in the steps below.
>>>>>
>>>>> More rhetoric instead of reasoning.
>>>>> Find an actual error in the steps below.
>>>>>
>>>>>
>>>>
>>>> Good description of your position.
>>>>
>>>
>>> The following is reasoning defecation for brains:
>>
>> Yes, it is just POOP.
>>
>> The problem is that the infinite loop only happens if H doesn't abort
>> its simulation and thus it fails to be a decider.
> Whether or not embedded_H aborts its simulation of  ⟨Ĥ⟩ ⟨Ĥ⟩ the
> simulated input never reaches its own final state YOU BRAIN DEAD MORON.
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>
> There is no point in the above execution trace where the executing (not
> simulated) embedded_H can abort the simulation of its input where this
> simulated input reaches its own final state.
>

And that is your problem, the question isn't about the simulation done
by embedded_H, that is just your POOP. The question of the Halting
Problem is about the ACTUAL compuation, that is H^ applied to <H^>,
which can be equivalently looked at by the simulation by a UTM of the
input, but if embedded_H aborts its simulation, it isn't a UTM, so
doesn't count.

On 3/19/2022 8:51 AM, Richard Damon wrote:
>
> On 3/19/22 9:34 AM, olcott wrote:
>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>> simulation:
>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>> halts, and
>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does
>>>>>>>>> not halt.
>>>>>>>>> Feel fee to replace "halts" with "would reach its final state"
>>>>>>>>> (and
>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>> Both figures
>>>>>>>>> of speech convey the same mathematical fact, but one is shorter
>>>>>>>>> and fits
>>>>>>>>> on a line.
>>>>>>>>> What you can't do, if you want to keep talking about what Linz is
>>>>>>>>> talking about, is replace the reference to a UTM with embedded_H.
>>>>>>>>
>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>> Not in dispute.
>>>>>>>
>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>> simulation to
>>>>>>>> be a part of the decision process.
>>>>>>> Not in dispute.
>>>>>>>
>>>>>>>> Embedded_H determines whether or not its simulated input would ever
>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>> Not in dispute.
>>>>>>>
>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> by the
>>>>>>>>>> copy of H embedded within Ĥ would never reach the final state
>>>>>>>>>> of this
>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>>>>>> definition of a halt decider.  If you think there is any point,
>>>>>>>>> I'll
>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>
>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>> reports this that is most relevant.
>>>>>>> Not in dispute (except for the poor wording).
>>>>>>> If you want to know why you are still wrong after 14 years, you are
>>>>>>> going to have to learn to follow what other people are saying.  Of
>>>>>>> course, if you did that, you'd see all your mistakes, so you are
>>>>>>> much
>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>
>>>>>>
>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>> decider
>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>> simulation to embedded_H thus making the embedded_H transition to
>>>>>> Ĥ.qn
>>>>>> correct.
>>>>> No.
>>>>
>>>> The reason that you only have a dogmatic reply rather than any
>>>> supporting reasoning is that I am correct.
>>>
>>> No, it's because there is no evidence that you can accept the
>>> explanations that are put to you.
>>
>> That is a bullshit excuse to hide the fact that you fail to understand
>> what I said. You could provide an answer for posterity and for others
>> that may eventually come to this post. The truth is you can't point
>> out any specific error because there is no error.
>>
>>>   Do you really think it's worth my
>>> while explaining, yet again, that re-defining what H should do is just
>>> pointless?
>>>
>>> I'll take the time to explain if you ask intelligent questions, but my
>>> repeating that reply to what you keep cutting and pasting is just a
>>> waste of time.
>>>
>>
>> All of the "rebuttals" never pointing out any specific error and were
>> always some kind of ad hominem attack of another.
>
> MOST of the rebuttals point out specific errors (or at least reference
> previous attempts to point them out).
>
> The issue s you don't seem to understand the meaning of the words enough
> to understand what is being said.
>
> A bit like trying to explain something 'adult' to a 3 year old.
>
>>
>>>> No one can find any error in the following only because there is no
>>>> error to be found.
>>>
>>
>> No one can find any error in the following only because there is no
>> error to be found.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>> ⟨Ĥ4⟩...
>>
>> (1) If embedded_H does not abort the simulation of its input the
>> simulation never stops and the simulated input never reaches its final
>> state.
>>
>> (2) If embedded_H does abort the simulation of its input the simulation
>> is aborted at some point shown above and the simulated input never
>> reaches its final state.
>>
>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>> configurations that never reach a final state. This in turn makes the
>> transition to Ĥ.qn by embedded_H correct.
>
>
> I have pointed out the error many times and you just ignore it because
> you don't want to believe it.
>
> The infinite loop described only exist if embedded_H never aborts its
> simulation, and in that case, it never gives an answer.
>
> If embedded_H aborts its simulation, and goes to Qn, then the top level
> H^ applied to <H^> will go to H^.Qn and Halt,
In other words when the simulating halt decider copy of H embedded
within Ĥ correctly determines that its input will never reach its own
final state it transitions to Ĥ.qn and stops running.

Since itself is not an actual input to itself this does not form a
contradiction.

When embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn it has correctly computed the mapping
form its input to its own final reject 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/19/22 10:13 AM, olcott wrote:
> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>
>> On 3/19/22 9:34 AM, olcott wrote:
>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>> simulation:
>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>> halts, and
>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does
>>>>>>>>>> not halt.
>>>>>>>>>> Feel fee to replace "halts" with "would reach its final state"
>>>>>>>>>> (and
>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>> Both figures
>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>> shorter and fits
>>>>>>>>>> on a line.
>>>>>>>>>> What you can't do, if you want to keep talking about what Linz is
>>>>>>>>>> talking about, is replace the reference to a UTM with embedded_H.
>>>>>>>>>
>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>> Not in dispute.
>>>>>>>>
>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>> simulation to
>>>>>>>>> be a part of the decision process.
>>>>>>>> Not in dispute.
>>>>>>>>
>>>>>>>>> Embedded_H determines whether or not its simulated input would
>>>>>>>>> ever
>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>> Not in dispute.
>>>>>>>>
>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> by the
>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final state
>>>>>>>>>>> of this
>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>> point, I'll
>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>
>>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>>> reports this that is most relevant.
>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>> If you want to know why you are still wrong after 14 years, you are
>>>>>>>> going to have to learn to follow what other people are saying.  Of
>>>>>>>> course, if you did that, you'd see all your mistakes, so you are
>>>>>>>> much
>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>
>>>>>>>
>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>>> decider
>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>> simulation to embedded_H thus making the embedded_H transition to
>>>>>>> Ĥ.qn
>>>>>>> correct.
>>>>>> No.
>>>>>
>>>>> The reason that you only have a dogmatic reply rather than any
>>>>> supporting reasoning is that I am correct.
>>>>
>>>> No, it's because there is no evidence that you can accept the
>>>> explanations that are put to you.
>>>
>>> That is a bullshit excuse to hide the fact that you fail to
>>> understand what I said. You could provide an answer for posterity and
>>> for others that may eventually come to this post. The truth is you
>>> can't point out any specific error because there is no error.
>>>
>>>>   Do you really think it's worth my
>>>> while explaining, yet again, that re-defining what H should do is just
>>>> pointless?
>>>>
>>>> I'll take the time to explain if you ask intelligent questions, but my
>>>> repeating that reply to what you keep cutting and pasting is just a
>>>> waste of time.
>>>>
>>>
>>> All of the "rebuttals" never pointing out any specific error and were
>>> always some kind of ad hominem attack of another.
>>
>> MOST of the rebuttals point out specific errors (or at least reference
>> previous attempts to point them out).
>>
>> The issue s you don't seem to understand the meaning of the words
>> enough to understand what is being said.
>>
>> A bit like trying to explain something 'adult' to a 3 year old.
>>
>>>
>>>>> No one can find any error in the following only because there is no
>>>>> error to be found.
>>>>
>>>
>>> No one can find any error in the following only because there is no
>>> error to be found.
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>> ⟨Ĥ4⟩...
>>>
>>> (1) If embedded_H does not abort the simulation of its input the
>>> simulation never stops and the simulated input never reaches its
>>> final state.
>>>
>>> (2) If embedded_H does abort the simulation of its input the simulation
>>> is aborted at some point shown above and the simulated input never
>>> reaches its final state.
>>>
>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>> configurations that never reach a final state. This in turn makes the
>>> transition to Ĥ.qn by embedded_H correct.
>>
>>
>> I have pointed out the error many times and you just ignore it because
>> you don't want to believe it.
>>
>> The infinite loop described only exist if embedded_H never aborts its
>> simulation, and in that case, it never gives an answer.
>>
>> If embedded_H aborts its simulation, and goes to Qn, then the top
>> level H^ applied to <H^> will go to H^.Qn and Halt,
> In other words when the simulating halt decider copy of H embedded
> within Ĥ correctly determines that its input will never reach its own
> final state it transitions to Ĥ.qn and stops running.
Except that it never correctly determined this, since it used a false
premise in its logic.

>
> Since itself is not an actual input to itself this does not form a
> contradictio

Except that the input IS a 'copy' of itself, and thus must behave
exactly like it. You don't seem to understand this property of Turing
Machine. If you wish to dispute it, find an actual counter example.

>
> When embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn it has correctly computed the mapping
> form its input to its own final reject state.
>

On 3/19/2022 9:24 AM, Richard Damon wrote:
> On 3/19/22 10:13 AM, olcott wrote:
>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>
>>> On 3/19/22 9:34 AM, olcott wrote:
>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>> simulation:
>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>> halts, and
>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does
>>>>>>>>>>> not halt.
>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>> state" (and
>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>> Both figures
>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>> shorter and fits
>>>>>>>>>>> on a line.
>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>> Linz is
>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>> embedded_H.
>>>>>>>>>>
>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>> Not in dispute.
>>>>>>>>>
>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>> simulation to
>>>>>>>>>> be a part of the decision process.
>>>>>>>>> Not in dispute.
>>>>>>>>>
>>>>>>>>>> Embedded_H determines whether or not its simulated input would
>>>>>>>>>> ever
>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>> Not in dispute.
>>>>>>>>>
>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> by the
>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>> state of this
>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>> point, I'll
>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>
>>>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>>>> reports this that is most relevant.
>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>> If you want to know why you are still wrong after 14 years, you
>>>>>>>>> are
>>>>>>>>> going to have to learn to follow what other people are saying.  Of
>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>> are much
>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>>>> decider
>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>> simulation to embedded_H thus making the embedded_H transition
>>>>>>>> to Ĥ.qn
>>>>>>>> correct.
>>>>>>> No.
>>>>>>
>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>> supporting reasoning is that I am correct.
>>>>>
>>>>> No, it's because there is no evidence that you can accept the
>>>>> explanations that are put to you.
>>>>
>>>> That is a bullshit excuse to hide the fact that you fail to
>>>> understand what I said. You could provide an answer for posterity
>>>> and for others that may eventually come to this post. The truth is
>>>> you can't point out any specific error because there is no error.
>>>>
>>>>>   Do you really think it's worth my
>>>>> while explaining, yet again, that re-defining what H should do is just
>>>>> pointless?
>>>>>
>>>>> I'll take the time to explain if you ask intelligent questions, but my
>>>>> repeating that reply to what you keep cutting and pasting is just a
>>>>> waste of time.
>>>>>
>>>>
>>>> All of the "rebuttals" never pointing out any specific error and
>>>> were always some kind of ad hominem attack of another.
>>>
>>> MOST of the rebuttals point out specific errors (or at least
>>> reference previous attempts to point them out).
>>>
>>> The issue s you don't seem to understand the meaning of the words
>>> enough to understand what is being said.
>>>
>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>
>>>>
>>>>>> No one can find any error in the following only because there is no
>>>>>> error to be found.
>>>>>
>>>>
>>>> No one can find any error in the following only because there is no
>>>> error to be found.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>> ⟨Ĥ2⟩
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>> ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>> ⟨Ĥ4⟩...
>>>>
>>>> (1) If embedded_H does not abort the simulation of its input the
>>>> simulation never stops and the simulated input never reaches its
>>>> final state.
>>>>
>>>> (2) If embedded_H does abort the simulation of its input the simulation
>>>> is aborted at some point shown above and the simulated input never
>>>> reaches its final state.
>>>>
>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>> configurations that never reach a final state. This in turn makes
>>>> the transition to Ĥ.qn by embedded_H correct.
>>>
>>>
>>> I have pointed out the error many times and you just ignore it
>>> because you don't want to believe it.
>>>
>>> The infinite loop described only exist if embedded_H never aborts its
>>> simulation, and in that case, it never gives an answer.
>>>
>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>> In other words when the simulating halt decider copy of H embedded
>> within Ĥ correctly determines that its input will never reach its own
>> final state it transitions to Ĥ.qn and stops running.
> Except that it never correctly determined this, since it used a false
> premise in its logic.
>
>>
>> Since itself is not an actual input to itself this does not form a
>> contradictio
>
> Except that the input IS a 'copy' of itself, and thus must behave
> exactly like it. You don't seem to understand this property of Turing
> Machine. If you wish to dispute it, find an actual counter example.
It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

On 3/19/22 10:33 AM, olcott wrote:
> On 3/19/2022 9:24 AM, Richard Damon wrote:
>> On 3/19/22 10:13 AM, olcott wrote:
>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>
>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>> simulation:
>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>> halts, and
>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>> does not halt.
>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>> state" (and
>>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>>> Both figures
>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>> on a line.
>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>> Linz is
>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>
>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>> Not in dispute.
>>>>>>>>>>
>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>> simulation to
>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>> Not in dispute.
>>>>>>>>>>
>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>> would ever
>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>>> Not in dispute.
>>>>>>>>>>
>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>> state of this
>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from Linz's
>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>> point, I'll
>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>
>>>>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>> you are
>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>> saying.  Of
>>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>>> are much
>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>>>>> decider
>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>>> simulation to embedded_H thus making the embedded_H transition
>>>>>>>>> to Ĥ.qn
>>>>>>>>> correct.
>>>>>>>> No.
>>>>>>>
>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>> supporting reasoning is that I am correct.
>>>>>>
>>>>>> No, it's because there is no evidence that you can accept the
>>>>>> explanations that are put to you.
>>>>>
>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>> understand what I said. You could provide an answer for posterity
>>>>> and for others that may eventually come to this post. The truth is
>>>>> you can't point out any specific error because there is no error.
>>>>>
>>>>>>   Do you really think it's worth my
>>>>>> while explaining, yet again, that re-defining what H should do is
>>>>>> just
>>>>>> pointless?
>>>>>>
>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>> but my
>>>>>> repeating that reply to what you keep cutting and pasting is just a
>>>>>> waste of time.
>>>>>>
>>>>>
>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>> were always some kind of ad hominem attack of another.
>>>>
>>>> MOST of the rebuttals point out specific errors (or at least
>>>> reference previous attempts to point them out).
>>>>
>>>> The issue s you don't seem to understand the meaning of the words
>>>> enough to understand what is being said.
>>>>
>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>
>>>>>
>>>>>>> No one can find any error in the following only because there is no
>>>>>>> error to be found.
>>>>>>
>>>>>
>>>>> No one can find any error in the following only because there is no
>>>>> error to be found.
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>
>>>>> Then these steps would keep repeating:
>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>>> ⟨Ĥ2⟩
>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>>> ⟨Ĥ3⟩
>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>>> ⟨Ĥ4⟩...
>>>>>
>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>> simulation never stops and the simulated input never reaches its
>>>>> final state.
>>>>>
>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>> simulation
>>>>> is aborted at some point shown above and the simulated input never
>>>>> reaches its final state.
>>>>>
>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>> configurations that never reach a final state. This in turn makes
>>>>> the transition to Ĥ.qn by embedded_H correct.
>>>>
>>>>
>>>> I have pointed out the error many times and you just ignore it
>>>> because you don't want to believe it.
>>>>
>>>> The infinite loop described only exist if embedded_H never aborts
>>>> its simulation, and in that case, it never gives an answer.
>>>>
>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>> In other words when the simulating halt decider copy of H embedded
>>> within Ĥ correctly determines that its input will never reach its own
>>> final state it transitions to Ĥ.qn and stops running.
>> Except that it never correctly determined this, since it used a false
>> premise in its logic.
>>
>>>
>>> Since itself is not an actual input to itself this does not form a
>>> contradictio
>>
>> Except that the input IS a 'copy' of itself, and thus must behave
>> exactly like it. You don't seem to understand this property of Turing
>> Machine. If you wish to dispute it, find an actual counter example.
> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>

On 3/19/2022 9:47 AM, Richard Damon wrote:
>
> On 3/19/22 10:33 AM, olcott wrote:
>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>> On 3/19/22 10:13 AM, olcott wrote:
>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>> halts, and
>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>>>> Both figures
>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>>> Linz is
>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>
>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>> simulation to
>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>
>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>> would ever
>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>
>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>
>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>>> you are
>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>> saying.  Of
>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>>>> are much
>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>>>>>> decider
>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>>>> simulation to embedded_H thus making the embedded_H transition
>>>>>>>>>> to Ĥ.qn
>>>>>>>>>> correct.
>>>>>>>>> No.
>>>>>>>>
>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>
>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>> explanations that are put to you.
>>>>>>
>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>> understand what I said. You could provide an answer for posterity
>>>>>> and for others that may eventually come to this post. The truth is
>>>>>> you can't point out any specific error because there is no error.
>>>>>>
>>>>>>>   Do you really think it's worth my
>>>>>>> while explaining, yet again, that re-defining what H should do is
>>>>>>> just
>>>>>>> pointless?
>>>>>>>
>>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>>> but my
>>>>>>> repeating that reply to what you keep cutting and pasting is just a
>>>>>>> waste of time.
>>>>>>>
>>>>>>
>>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>>> were always some kind of ad hominem attack of another.
>>>>>
>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>> reference previous attempts to point them out).
>>>>>
>>>>> The issue s you don't seem to understand the meaning of the words
>>>>> enough to understand what is being said.
>>>>>
>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>
>>>>>>
>>>>>>>> No one can find any error in the following only because there is no
>>>>>>>> error to be found.
>>>>>>>
>>>>>>
>>>>>> No one can find any error in the following only because there is
>>>>>> no error to be found.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>> ⟨Ĥ1⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>
>>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>>> simulation never stops and the simulated input never reaches its
>>>>>> final state.
>>>>>>
>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>> simulation
>>>>>> is aborted at some point shown above and the simulated input never
>>>>>> reaches its final state.
>>>>>>
>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>> configurations that never reach a final state. This in turn makes
>>>>>> the transition to Ĥ.qn by embedded_H correct.
>>>>>
>>>>>
>>>>> I have pointed out the error many times and you just ignore it
>>>>> because you don't want to believe it.
>>>>>
>>>>> The infinite loop described only exist if embedded_H never aborts
>>>>> its simulation, and in that case, it never gives an answer.
>>>>>
>>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>>> In other words when the simulating halt decider copy of H embedded
>>>> within Ĥ correctly determines that its input will never reach its
>>>> own final state it transitions to Ĥ.qn and stops running.
>>> Except that it never correctly determined this, since it used a false
>>> premise in its logic.
>>>
>>>>
>>>> Since itself is not an actual input to itself this does not form a
>>>> contradictio
>>>
>>> Except that the input IS a 'copy' of itself, and thus must behave
>>> exactly like it. You don't seem to understand this property of Turing
>>> Machine. If you wish to dispute it, find an actual counter example.
>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩
>> is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>
> That isn't the question. The question is does the answer that embedded_H
> match the behavior of the computaition given as in input.
>
> The answer is NO.
>

On 3/19/2022 9:47 AM, Richard Damon wrote:
>
> On 3/19/22 10:33 AM, olcott wrote:
>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>> On 3/19/22 10:13 AM, olcott wrote:
>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>> halts, and
>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>>>> Both figures
>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>>> Linz is
>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>
>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>> simulation to
>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>
>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>> would ever
>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>
>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>
>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H correctly
>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>>> you are
>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>> saying.  Of
>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>>>> are much
>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating halt
>>>>>>>>>> decider
>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>>>> simulation to embedded_H thus making the embedded_H transition
>>>>>>>>>> to Ĥ.qn
>>>>>>>>>> correct.
>>>>>>>>> No.
>>>>>>>>
>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>
>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>> explanations that are put to you.
>>>>>>
>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>> understand what I said. You could provide an answer for posterity
>>>>>> and for others that may eventually come to this post. The truth is
>>>>>> you can't point out any specific error because there is no error.
>>>>>>
>>>>>>>   Do you really think it's worth my
>>>>>>> while explaining, yet again, that re-defining what H should do is
>>>>>>> just
>>>>>>> pointless?
>>>>>>>
>>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>>> but my
>>>>>>> repeating that reply to what you keep cutting and pasting is just a
>>>>>>> waste of time.
>>>>>>>
>>>>>>
>>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>>> were always some kind of ad hominem attack of another.
>>>>>
>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>> reference previous attempts to point them out).
>>>>>
>>>>> The issue s you don't seem to understand the meaning of the words
>>>>> enough to understand what is being said.
>>>>>
>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>
>>>>>>
>>>>>>>> No one can find any error in the following only because there is no
>>>>>>>> error to be found.
>>>>>>>
>>>>>>
>>>>>> No one can find any error in the following only because there is
>>>>>> no error to be found.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>> ⟨Ĥ1⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>
>>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>>> simulation never stops and the simulated input never reaches its
>>>>>> final state.
>>>>>>
>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>> simulation
>>>>>> is aborted at some point shown above and the simulated input never
>>>>>> reaches its final state.
>>>>>>
>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>> configurations that never reach a final state. This in turn makes
>>>>>> the transition to Ĥ.qn by embedded_H correct.
>>>>>
>>>>>
>>>>> I have pointed out the error many times and you just ignore it
>>>>> because you don't want to believe it.
>>>>>
>>>>> The infinite loop described only exist if embedded_H never aborts
>>>>> its simulation, and in that case, it never gives an answer.
>>>>>
>>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>>> In other words when the simulating halt decider copy of H embedded
>>>> within Ĥ correctly determines that its input will never reach its
>>>> own final state it transitions to Ĥ.qn and stops running.
>>> Except that it never correctly determined this, since it used a false
>>> premise in its logic.
>>>
>>>>
>>>> Since itself is not an actual input to itself this does not form a
>>>> contradictio
>>>
>>> Except that the input IS a 'copy' of itself, and thus must behave
>>> exactly like it. You don't seem to understand this property of Turing
>>> Machine. If you wish to dispute it, find an actual counter example.
>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩
>> is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>
> That isn't the question. The question is does the answer that embedded_H
> match the behavior of the computaition given as in input.
>
> The answer is NO.
>
> embedded_H <H^> <H^> -> Qn is only correct if H^ applied to <H^> will
> never halt,

On 3/19/22 11:18 AM, olcott wrote:
> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>
>> On 3/19/22 10:33 AM, olcott wrote:
>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>> halts, and
>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>>>>> Both figures
>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>>>> Linz is
>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>
>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>> would ever
>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>
>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>> correctly
>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>>>> you are
>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>>>>> are much
>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>> halt decider
>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>> correct.
>>>>>>>>>> No.
>>>>>>>>>
>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>
>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>> explanations that are put to you.
>>>>>>>
>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>> understand what I said. You could provide an answer for posterity
>>>>>>> and for others that may eventually come to this post. The truth
>>>>>>> is you can't point out any specific error because there is no error.
>>>>>>>
>>>>>>>>   Do you really think it's worth my
>>>>>>>> while explaining, yet again, that re-defining what H should do
>>>>>>>> is just
>>>>>>>> pointless?
>>>>>>>>
>>>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>>>> but my
>>>>>>>> repeating that reply to what you keep cutting and pasting is just a
>>>>>>>> waste of time.
>>>>>>>>
>>>>>>>
>>>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>>>> were always some kind of ad hominem attack of another.
>>>>>>
>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>> reference previous attempts to point them out).
>>>>>>
>>>>>> The issue s you don't seem to understand the meaning of the words
>>>>>> enough to understand what is being said.
>>>>>>
>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>
>>>>>>>
>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>> is no
>>>>>>>>> error to be found.
>>>>>>>>
>>>>>>>
>>>>>>> No one can find any error in the following only because there is
>>>>>>> no error to be found.
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>>> ⟨Ĥ1⟩
>>>>>>>
>>>>>>> Then these steps would keep repeating:
>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>
>>>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>>>> simulation never stops and the simulated input never reaches its
>>>>>>> final state.
>>>>>>>
>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>> simulation
>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>> never reaches its final state.
>>>>>>>
>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>>> configurations that never reach a final state. This in turn makes
>>>>>>> the transition to Ĥ.qn by embedded_H correct.
>>>>>>
>>>>>>
>>>>>> I have pointed out the error many times and you just ignore it
>>>>>> because you don't want to believe it.
>>>>>>
>>>>>> The infinite loop described only exist if embedded_H never aborts
>>>>>> its simulation, and in that case, it never gives an answer.
>>>>>>
>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>> In other words when the simulating halt decider copy of H embedded
>>>>> within Ĥ correctly determines that its input will never reach its
>>>>> own final state it transitions to Ĥ.qn and stops running.
>>>> Except that it never correctly determined this, since it used a
>>>> false premise in its logic.
>>>>
>>>>>
>>>>> Since itself is not an actual input to itself this does not form a
>>>>> contradictio
>>>>
>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>> exactly like it. You don't seem to understand this property of
>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>> example.
>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩
>>> is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> That isn't the question. The question is does the answer that
>> embedded_H match the behavior of the computaition given as in input.
>>
>> The answer is NO.
>>
>> embedded_H <H^> <H^> -> Qn is only correct if H^ applied to <H^> will
>> never halt,
>
> That is a God damned lie and you know it.
>
> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ would never reach its
> own final state ⟨Ĥ⟩.qn in a finite number of simulated steps.
>

On 3/19/22 10:51 AM, olcott wrote:
> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>
>> On 3/19/22 10:33 AM, olcott wrote:
>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>> halts, and
>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel better.
>>>>>>>>>>>>>> Both figures
>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>>>> Linz is
>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>
>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>> would ever
>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM mode.
>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>
>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>> correctly
>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>>>> you are
>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so you
>>>>>>>>>>>> are much
>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>> halt decider
>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely nested
>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>> correct.
>>>>>>>>>> No.
>>>>>>>>>
>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>
>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>> explanations that are put to you.
>>>>>>>
>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>> understand what I said. You could provide an answer for posterity
>>>>>>> and for others that may eventually come to this post. The truth
>>>>>>> is you can't point out any specific error because there is no error.
>>>>>>>
>>>>>>>>   Do you really think it's worth my
>>>>>>>> while explaining, yet again, that re-defining what H should do
>>>>>>>> is just
>>>>>>>> pointless?
>>>>>>>>
>>>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>>>> but my
>>>>>>>> repeating that reply to what you keep cutting and pasting is just a
>>>>>>>> waste of time.
>>>>>>>>
>>>>>>>
>>>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>>>> were always some kind of ad hominem attack of another.
>>>>>>
>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>> reference previous attempts to point them out).
>>>>>>
>>>>>> The issue s you don't seem to understand the meaning of the words
>>>>>> enough to understand what is being said.
>>>>>>
>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>
>>>>>>>
>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>> is no
>>>>>>>>> error to be found.
>>>>>>>>
>>>>>>>
>>>>>>> No one can find any error in the following only because there is
>>>>>>> no error to be found.
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>>> ⟨Ĥ1⟩
>>>>>>>
>>>>>>> Then these steps would keep repeating:
>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>
>>>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>>>> simulation never stops and the simulated input never reaches its
>>>>>>> final state.
>>>>>>>
>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>> simulation
>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>> never reaches its final state.
>>>>>>>
>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>>> configurations that never reach a final state. This in turn makes
>>>>>>> the transition to Ĥ.qn by embedded_H correct.
>>>>>>
>>>>>>
>>>>>> I have pointed out the error many times and you just ignore it
>>>>>> because you don't want to believe it.
>>>>>>
>>>>>> The infinite loop described only exist if embedded_H never aborts
>>>>>> its simulation, and in that case, it never gives an answer.
>>>>>>
>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>> In other words when the simulating halt decider copy of H embedded
>>>>> within Ĥ correctly determines that its input will never reach its
>>>>> own final state it transitions to Ĥ.qn and stops running.
>>>> Except that it never correctly determined this, since it used a
>>>> false premise in its logic.
>>>>
>>>>>
>>>>> Since itself is not an actual input to itself this does not form a
>>>>> contradictio
>>>>
>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>> exactly like it. You don't seem to understand this property of
>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>> example.
>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩
>>> is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> That isn't the question. The question is does the answer that
>> embedded_H match the behavior of the computaition given as in input.
>>
>> The answer is NO.
>>
>
> It is an easily verified fact that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
> embedded_H never reaches the final state of this simulated input in any
> finite number of steps of simulation.
>
> This is the point where you have pie dripping from your face and deny
> that pie exists.
>
>

olcott <NoOne@nowhere.com> wrote:
> On 3/19/2022 9:24 AM, Richard Damon wrote:
>> On 3/19/22 10:13 AM, olcott wrote:

[ .... ]

>>> Since itself is not an actual input to itself this does not form a
>>> contradictio

>> Except that the input IS a 'copy' of itself, and thus must behave
>> exactly like it. You don't seem to understand this property of Turing
>> Machine. If you wish to dispute it, find an actual counter example.

> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

It can't be so verified without the code of H, which you refuse to
publish, and which you certainly haven't written. (If you had, you'd be
less bullish about its purported properties.)

[ .... ]

> --
> Copyright 2021 Pete Olcott

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

--
Alan Mackenzie (Nuremberg, Germany).

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

Actually, what he is missing is that they are supposed to be the same,
and as H/embedded_H needs to ALWAYS behave finitely, and go to Qn only
if H^ applied to <H^> will never halt.

In actuality, it seems that at least in one scenario, their behavior IS
the same, that neither of them halt (and thus H fails to meet its
requirements). The other scenerio just results in H giving the wrong
answer (by neccesity by the construction of H^).

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

On 3/19/2022 11:12 AM, Richard Damon wrote:
> On 3/19/22 11:18 AM, olcott wrote:
>> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>>
>>> On 3/19/22 10:33 AM, olcott wrote:
>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>>> halts, and
>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel
>>>>>>>>>>>>>>> better. Both figures
>>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>>>>> Linz is
>>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>>> would ever
>>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM
>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>>>>> you are
>>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so
>>>>>>>>>>>>> you are much
>>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>>> halt decider
>>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely
>>>>>>>>>>>> nested
>>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>>> correct.
>>>>>>>>>>> No.
>>>>>>>>>>
>>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>>
>>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>>> explanations that are put to you.
>>>>>>>>
>>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>>> understand what I said. You could provide an answer for
>>>>>>>> posterity and for others that may eventually come to this post.
>>>>>>>> The truth is you can't point out any specific error because
>>>>>>>> there is no error.
>>>>>>>>
>>>>>>>>>   Do you really think it's worth my
>>>>>>>>> while explaining, yet again, that re-defining what H should do
>>>>>>>>> is just
>>>>>>>>> pointless?
>>>>>>>>>
>>>>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>>>>> but my
>>>>>>>>> repeating that reply to what you keep cutting and pasting is
>>>>>>>>> just a
>>>>>>>>> waste of time.
>>>>>>>>>
>>>>>>>>
>>>>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>>>>> were always some kind of ad hominem attack of another.
>>>>>>>
>>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>>> reference previous attempts to point them out).
>>>>>>>
>>>>>>> The issue s you don't seem to understand the meaning of the words
>>>>>>> enough to understand what is being said.
>>>>>>>
>>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>>
>>>>>>>>
>>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>>> is no
>>>>>>>>>> error to be found.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No one can find any error in the following only because there is
>>>>>>>> no error to be found.
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>
>>>>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>>>>> simulation never stops and the simulated input never reaches its
>>>>>>>> final state.
>>>>>>>>
>>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>>> simulation
>>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>>> never reaches its final state.
>>>>>>>>
>>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>>>> configurations that never reach a final state. This in turn
>>>>>>>> makes the transition to Ĥ.qn by embedded_H correct.
>>>>>>>
>>>>>>>
>>>>>>> I have pointed out the error many times and you just ignore it
>>>>>>> because you don't want to believe it.
>>>>>>>
>>>>>>> The infinite loop described only exist if embedded_H never aborts
>>>>>>> its simulation, and in that case, it never gives an answer.
>>>>>>>
>>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>>> In other words when the simulating halt decider copy of H embedded
>>>>>> within Ĥ correctly determines that its input will never reach its
>>>>>> own final state it transitions to Ĥ.qn and stops running.
>>>>> Except that it never correctly determined this, since it used a
>>>>> false premise in its logic.
>>>>>
>>>>>>
>>>>>> Since itself is not an actual input to itself this does not form a
>>>>>> contradictio
>>>>>
>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>> exactly like it. You don't seem to understand this property of
>>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>>> example.
>>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩
>>>> is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>
>>> That isn't the question. The question is does the answer that
>>> embedded_H match the behavior of the computaition given as in input.
>>>
>>> The answer is NO.
>>>
>>> embedded_H <H^> <H^> -> Qn is only correct if H^ applied to <H^> will
>>> never halt,
>>
>> That is a God damned lie and you know it.
>>
>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ would never reach its
>> own final state ⟨Ĥ⟩.qn in a finite number of simulated steps.
>>
>
> No, the DEFINITION of H is that H <H^> <H^> -> Qn only if H^ applied to
> <H^> will never reach a final state.
>

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

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

On 3/19/2022 11:16 AM, Richard Damon wrote:
> On 3/19/22 10:51 AM, olcott wrote:
>> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>>
>>> On 3/19/22 10:33 AM, olcott wrote:
>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms of
>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>>> halts, and
>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel
>>>>>>>>>>>>>>> better. Both figures
>>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>>> What you can't do, if you want to keep talking about what
>>>>>>>>>>>>>>> Linz is
>>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>>> would ever
>>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM
>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>>> If you want to know why you are still wrong after 14 years,
>>>>>>>>>>>>> you are
>>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so
>>>>>>>>>>>>> you are much
>>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>>> halt decider
>>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely
>>>>>>>>>>>> nested
>>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>>> correct.
>>>>>>>>>>> No.
>>>>>>>>>>
>>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>>
>>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>>> explanations that are put to you.
>>>>>>>>
>>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>>> understand what I said. You could provide an answer for
>>>>>>>> posterity and for others that may eventually come to this post.
>>>>>>>> The truth is you can't point out any specific error because
>>>>>>>> there is no error.
>>>>>>>>
>>>>>>>>>   Do you really think it's worth my
>>>>>>>>> while explaining, yet again, that re-defining what H should do
>>>>>>>>> is just
>>>>>>>>> pointless?
>>>>>>>>>
>>>>>>>>> I'll take the time to explain if you ask intelligent questions,
>>>>>>>>> but my
>>>>>>>>> repeating that reply to what you keep cutting and pasting is
>>>>>>>>> just a
>>>>>>>>> waste of time.
>>>>>>>>>
>>>>>>>>
>>>>>>>> All of the "rebuttals" never pointing out any specific error and
>>>>>>>> were always some kind of ad hominem attack of another.
>>>>>>>
>>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>>> reference previous attempts to point them out).
>>>>>>>
>>>>>>> The issue s you don't seem to understand the meaning of the words
>>>>>>> enough to understand what is being said.
>>>>>>>
>>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>>
>>>>>>>>
>>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>>> is no
>>>>>>>>>> error to be found.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No one can find any error in the following only because there is
>>>>>>>> no error to be found.
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>
>>>>>>>> (1) If embedded_H does not abort the simulation of its input the
>>>>>>>> simulation never stops and the simulated input never reaches its
>>>>>>>> final state.
>>>>>>>>
>>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>>> simulation
>>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>>> never reaches its final state.
>>>>>>>>
>>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>>>> configurations that never reach a final state. This in turn
>>>>>>>> makes the transition to Ĥ.qn by embedded_H correct.
>>>>>>>
>>>>>>>
>>>>>>> I have pointed out the error many times and you just ignore it
>>>>>>> because you don't want to believe it.
>>>>>>>
>>>>>>> The infinite loop described only exist if embedded_H never aborts
>>>>>>> its simulation, and in that case, it never gives an answer.
>>>>>>>
>>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the top
>>>>>>> level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>>> In other words when the simulating halt decider copy of H embedded
>>>>>> within Ĥ correctly determines that its input will never reach its
>>>>>> own final state it transitions to Ĥ.qn and stops running.
>>>>> Except that it never correctly determined this, since it used a
>>>>> false premise in its logic.
>>>>>
>>>>>>
>>>>>> Since itself is not an actual input to itself this does not form a
>>>>>> contradictio
>>>>>
>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>> exactly like it. You don't seem to understand this property of
>>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>>> example.
>>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩
>>>> is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>
>>> That isn't the question. The question is does the answer that
>>> embedded_H match the behavior of the computaition given as in input.
>>>
>>> The answer is NO.
>>>
>>
>> It is an easily verified fact that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>> by embedded_H never reaches the final state of this simulated input in
>> any finite number of steps of simulation.
>>
>> This is the point where you have pie dripping from your face and deny
>> that pie exists.
>>
>>
>
> Nope, it is trivial to verify that the CORRECT simulation of <H^> <H^>
> (by a UTM)

On 3/19/22 12:40 PM, olcott wrote:
> On 3/19/2022 11:12 AM, Richard Damon wrote:
>> On 3/19/22 11:18 AM, olcott wrote:
>>> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>>>
>>>> On 3/19/22 10:33 AM, olcott wrote:
>>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms
>>>>>>>>>>>>>>>> of simulation:
>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩
>>>>>>>>>>>>>>>> ⟨Ĥ⟩) halts, and
>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel
>>>>>>>>>>>>>>>> better. Both figures
>>>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>>>> What you can't do, if you want to keep talking about
>>>>>>>>>>>>>>>> what Linz is
>>>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>>>> would ever
>>>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM
>>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>>>> If you want to know why you are still wrong after 14
>>>>>>>>>>>>>> years, you are
>>>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so
>>>>>>>>>>>>>> you are much
>>>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely
>>>>>>>>>>>>> nested
>>>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>>>> correct.
>>>>>>>>>>>> No.
>>>>>>>>>>>
>>>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>>>
>>>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>>>> explanations that are put to you.
>>>>>>>>>
>>>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>>>> understand what I said. You could provide an answer for
>>>>>>>>> posterity and for others that may eventually come to this post.
>>>>>>>>> The truth is you can't point out any specific error because
>>>>>>>>> there is no error.
>>>>>>>>>
>>>>>>>>>>   Do you really think it's worth my
>>>>>>>>>> while explaining, yet again, that re-defining what H should do
>>>>>>>>>> is just
>>>>>>>>>> pointless?
>>>>>>>>>>
>>>>>>>>>> I'll take the time to explain if you ask intelligent
>>>>>>>>>> questions, but my
>>>>>>>>>> repeating that reply to what you keep cutting and pasting is
>>>>>>>>>> just a
>>>>>>>>>> waste of time.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> All of the "rebuttals" never pointing out any specific error
>>>>>>>>> and were always some kind of ad hominem attack of another.
>>>>>>>>
>>>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>>>> reference previous attempts to point them out).
>>>>>>>>
>>>>>>>> The issue s you don't seem to understand the meaning of the
>>>>>>>> words enough to understand what is being said.
>>>>>>>>
>>>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>>>> is no
>>>>>>>>>>> error to be found.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>> is no error to be found.
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>
>>>>>>>>> (1) If embedded_H does not abort the simulation of its input
>>>>>>>>> the simulation never stops and the simulated input never
>>>>>>>>> reaches its final state.
>>>>>>>>>
>>>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>>>> simulation
>>>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>>>> never reaches its final state.
>>>>>>>>>
>>>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>>>>> configurations that never reach a final state. This in turn
>>>>>>>>> makes the transition to Ĥ.qn by embedded_H correct.
>>>>>>>>
>>>>>>>>
>>>>>>>> I have pointed out the error many times and you just ignore it
>>>>>>>> because you don't want to believe it.
>>>>>>>>
>>>>>>>> The infinite loop described only exist if embedded_H never
>>>>>>>> aborts its simulation, and in that case, it never gives an answer.
>>>>>>>>
>>>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the
>>>>>>>> top level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>>>> In other words when the simulating halt decider copy of H
>>>>>>> embedded within Ĥ correctly determines that its input will never
>>>>>>> reach its own final state it transitions to Ĥ.qn and stops running.
>>>>>> Except that it never correctly determined this, since it used a
>>>>>> false premise in its logic.
>>>>>>
>>>>>>>
>>>>>>> Since itself is not an actual input to itself this does not form
>>>>>>> a contradictio
>>>>>>
>>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>>> exactly like it. You don't seem to understand this property of
>>>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>>>> example.
>>>>> It can be empirically verified that the behavior of Ĥ applied to
>>>>> ⟨Ĥ⟩ is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>
>>>> That isn't the question. The question is does the answer that
>>>> embedded_H match the behavior of the computaition given as in input.
>>>>
>>>> The answer is NO.
>>>>
>>>> embedded_H <H^> <H^> -> Qn is only correct if H^ applied to <H^>
>>>> will never halt,
>>>
>>> That is a God damned lie and you know it.
>>>
>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ would never reach its
>>> own final state ⟨Ĥ⟩.qn in a finite number of simulated steps.
>>>
>>
>> No, the DEFINITION of H is that H <H^> <H^> -> Qn only if H^ applied
>> to <H^> will never reach a final state.
>>
>
> You know that is a damned lie.

On 3/19/2022 11:33 AM, Richard Damon wrote:
> On 3/19/22 12:22 PM, Alan Mackenzie wrote:
>> olcott <NoOne@nowhere.com> wrote:
>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>> On 3/19/22 10:13 AM, olcott wrote:
>>
>> [ .... ]
>>
>>>>> Since itself is not an actual input to itself this does not form a
>>>>> contradictio
>>
>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>> exactly like it. You don't seem to understand this property of Turing
>>>> Machine. If you wish to dispute it, find an actual counter example.
>>
>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
>>> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> It can't be so verified without the code of H, which you refuse to
>> publish, and which you certainly haven't written.  (If you had, you'd be
>> less bullish about its purported properties.)
>>
>> [ .... ]
>>
>
> Actually, what he is missing is that they are supposed to be the same,
> and as H/embedded_H needs to ALWAYS behave finitely, and go to Qn only
> if H^ applied to <H^> will never halt.

No this is the moronic mistake of having a halt decider decide the halt
status of a non-input non-finite string and no decider can ever do that.

Deciders ONLY compute the mapping from their input finite strings to
their own accept or reject state.

--
Copyright 2021 Pete Olcott

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

On 3/19/2022 11:49 AM, Richard Damon wrote:
> On 3/19/22 12:40 PM, olcott wrote:
>> On 3/19/2022 11:12 AM, Richard Damon wrote:
>>> On 3/19/22 11:18 AM, olcott wrote:
>>>> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/19/22 10:33 AM, olcott wrote:
>>>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms
>>>>>>>>>>>>>>>>> of simulation:
>>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩) halts, and
>>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩) does not halt.
>>>>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel
>>>>>>>>>>>>>>>>> better. Both figures
>>>>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>>>>> What you can't do, if you want to keep talking about
>>>>>>>>>>>>>>>>> what Linz is
>>>>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>>>>> would ever
>>>>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM
>>>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the
>>>>>>>>>>>>>>>>>> final state of this
>>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically
>>>>>>>>>>>>>>>>> from Linz's
>>>>>>>>>>>>>>>>> definition of a halt decider.  If you think there is
>>>>>>>>>>>>>>>>> any point, I'll
>>>>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>>>>> If you want to know why you are still wrong after 14
>>>>>>>>>>>>>>> years, you are
>>>>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so
>>>>>>>>>>>>>>> you are much
>>>>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely
>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>> No.
>>>>>>>>>>>>
>>>>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>>>>
>>>>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>>>>> explanations that are put to you.
>>>>>>>>>>
>>>>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>>>>> understand what I said. You could provide an answer for
>>>>>>>>>> posterity and for others that may eventually come to this
>>>>>>>>>> post. The truth is you can't point out any specific error
>>>>>>>>>> because there is no error.
>>>>>>>>>>
>>>>>>>>>>>   Do you really think it's worth my
>>>>>>>>>>> while explaining, yet again, that re-defining what H should
>>>>>>>>>>> do is just
>>>>>>>>>>> pointless?
>>>>>>>>>>>
>>>>>>>>>>> I'll take the time to explain if you ask intelligent
>>>>>>>>>>> questions, but my
>>>>>>>>>>> repeating that reply to what you keep cutting and pasting is
>>>>>>>>>>> just a
>>>>>>>>>>> waste of time.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> All of the "rebuttals" never pointing out any specific error
>>>>>>>>>> and were always some kind of ad hominem attack of another.
>>>>>>>>>
>>>>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>>>>> reference previous attempts to point them out).
>>>>>>>>>
>>>>>>>>> The issue s you don't seem to understand the meaning of the
>>>>>>>>> words enough to understand what is being said.
>>>>>>>>>
>>>>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>> No one can find any error in the following only because
>>>>>>>>>>>> there is no
>>>>>>>>>>>> error to be found.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>>> is no error to be found.
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>
>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>
>>>>>>>>>> (1) If embedded_H does not abort the simulation of its input
>>>>>>>>>> the simulation never stops and the simulated input never
>>>>>>>>>> reaches its final state.
>>>>>>>>>>
>>>>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>>>>> simulation
>>>>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>>>>> never reaches its final state.
>>>>>>>>>>
>>>>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence
>>>>>>>>>> of configurations that never reach a final state. This in turn
>>>>>>>>>> makes the transition to Ĥ.qn by embedded_H correct.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have pointed out the error many times and you just ignore it
>>>>>>>>> because you don't want to believe it.
>>>>>>>>>
>>>>>>>>> The infinite loop described only exist if embedded_H never
>>>>>>>>> aborts its simulation, and in that case, it never gives an answer.
>>>>>>>>>
>>>>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the
>>>>>>>>> top level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>>>>> In other words when the simulating halt decider copy of H
>>>>>>>> embedded within Ĥ correctly determines that its input will never
>>>>>>>> reach its own final state it transitions to Ĥ.qn and stops running.
>>>>>>> Except that it never correctly determined this, since it used a
>>>>>>> false premise in its logic.
>>>>>>>
>>>>>>>>
>>>>>>>> Since itself is not an actual input to itself this does not form
>>>>>>>> a contradictio
>>>>>>>
>>>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>>>> exactly like it. You don't seem to understand this property of
>>>>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>>>>> example.
>>>>>> It can be empirically verified that the behavior of Ĥ applied to
>>>>>> ⟨Ĥ⟩ is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>
>>>>> That isn't the question. The question is does the answer that
>>>>> embedded_H match the behavior of the computaition given as in input.
>>>>>
>>>>> The answer is NO.
>>>>>
>>>>> embedded_H <H^> <H^> -> Qn is only correct if H^ applied to <H^>
>>>>> will never halt,
>>>>
>>>> That is a God damned lie and you know it.
>>>>
>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ would never reach
>>>> its own final state ⟨Ĥ⟩.qn in a finite number of simulated steps.
>>>>
>>>
>>> No, the DEFINITION of H is that H <H^> <H^> -> Qn only if H^ applied
>>> to <H^> will never reach a final state.
>>>
>>
>> You know that is a damned lie.
>
> ITS THE DEFINITION, it CAN'T BE A LIE, unless YOU ARE LYING about
> working on Halting,

On 3/19/22 12:44 PM, olcott wrote:
> On 3/19/2022 11:22 AM, Alan Mackenzie wrote:
>> olcott <NoOne@nowhere.com> wrote:
>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>> On 3/19/22 10:13 AM, olcott wrote:
>>
>> [ .... ]
>>
>>>>> Since itself is not an actual input to itself this does not form a
>>>>> contradictio
>>
>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>> exactly like it. You don't seem to understand this property of Turing
>>>> Machine. If you wish to dispute it, find an actual counter example.
>>
>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
>>> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> It can't be so verified without the code of H, which you refuse to
>> publish, and which you certainly haven't written.  (If you had, you'd be
>> less bullish about its purported properties.)
>>
>
> That we know that embedded_H is a simulating halt decider that aborts
> its simulation and rejects its input as soon as it detects an infinitely
> repeating behavior pattern tells us that rejecting its input would be
> correct on the basis of this infinitely repeating behavior pattern that
> we can see:  (This by itself refutes Linz).
>

Except that no such finite pattern exists in H^ applied to <H^>, so
there is no pattern of H to use to abort it.

>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>
> There is no point in the above execution trace where the executing (not
> simulated) embedded_H can abort the simulation of its input where this
> simulated input reaches its own final state.

Except it isn't the 'simulation' (by embedded_H) that matters, but the
actual behavior of the computation it describes (which is H^ applied to
<H^>) and we know that that Halt if embedded_H aborts and goes to Qn.

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

But the ACTUAL execution (which is what matters) halts.

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

And the ACTUAL exectution is what matters, not the simulation. Your
looking at the WRONG source of truth.

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

On 3/19/22 12:47 PM, olcott wrote:
> On 3/19/2022 11:16 AM, Richard Damon wrote:
>> On 3/19/22 10:51 AM, olcott wrote:
>>> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>>>
>>>> On 3/19/22 10:33 AM, olcott wrote:
>>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms
>>>>>>>>>>>>>>>> of simulation:
>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩
>>>>>>>>>>>>>>>> ⟨Ĥ⟩) halts, and
>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩)
>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its final
>>>>>>>>>>>>>>>> state" (and
>>>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel
>>>>>>>>>>>>>>>> better. Both figures
>>>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one is
>>>>>>>>>>>>>>>> shorter and fits
>>>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>>>> What you can't do, if you want to keep talking about
>>>>>>>>>>>>>>>> what Linz is
>>>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Embedded_H determines whether or not its simulated input
>>>>>>>>>>>>>>> would ever
>>>>>>>>>>>>>>> reach its final state if embedded_H remained in pure UTM
>>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the final
>>>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically from
>>>>>>>>>>>>>>>> Linz's
>>>>>>>>>>>>>>>> definition of a halt decider.  If you think there is any
>>>>>>>>>>>>>>>> point, I'll
>>>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>>>> If you want to know why you are still wrong after 14
>>>>>>>>>>>>>> years, you are
>>>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so
>>>>>>>>>>>>>> you are much
>>>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely
>>>>>>>>>>>>> nested
>>>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>>>> correct.
>>>>>>>>>>>> No.
>>>>>>>>>>>
>>>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>>>
>>>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>>>> explanations that are put to you.
>>>>>>>>>
>>>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>>>> understand what I said. You could provide an answer for
>>>>>>>>> posterity and for others that may eventually come to this post.
>>>>>>>>> The truth is you can't point out any specific error because
>>>>>>>>> there is no error.
>>>>>>>>>
>>>>>>>>>>   Do you really think it's worth my
>>>>>>>>>> while explaining, yet again, that re-defining what H should do
>>>>>>>>>> is just
>>>>>>>>>> pointless?
>>>>>>>>>>
>>>>>>>>>> I'll take the time to explain if you ask intelligent
>>>>>>>>>> questions, but my
>>>>>>>>>> repeating that reply to what you keep cutting and pasting is
>>>>>>>>>> just a
>>>>>>>>>> waste of time.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> All of the "rebuttals" never pointing out any specific error
>>>>>>>>> and were always some kind of ad hominem attack of another.
>>>>>>>>
>>>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>>>> reference previous attempts to point them out).
>>>>>>>>
>>>>>>>> The issue s you don't seem to understand the meaning of the
>>>>>>>> words enough to understand what is being said.
>>>>>>>>
>>>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>>>> is no
>>>>>>>>>>> error to be found.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>> is no error to be found.
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>
>>>>>>>>> (1) If embedded_H does not abort the simulation of its input
>>>>>>>>> the simulation never stops and the simulated input never
>>>>>>>>> reaches its final state.
>>>>>>>>>
>>>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>>>> simulation
>>>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>>>> never reaches its final state.
>>>>>>>>>
>>>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence of
>>>>>>>>> configurations that never reach a final state. This in turn
>>>>>>>>> makes the transition to Ĥ.qn by embedded_H correct.
>>>>>>>>
>>>>>>>>
>>>>>>>> I have pointed out the error many times and you just ignore it
>>>>>>>> because you don't want to believe it.
>>>>>>>>
>>>>>>>> The infinite loop described only exist if embedded_H never
>>>>>>>> aborts its simulation, and in that case, it never gives an answer.
>>>>>>>>
>>>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the
>>>>>>>> top level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>>>> In other words when the simulating halt decider copy of H
>>>>>>> embedded within Ĥ correctly determines that its input will never
>>>>>>> reach its own final state it transitions to Ĥ.qn and stops running.
>>>>>> Except that it never correctly determined this, since it used a
>>>>>> false premise in its logic.
>>>>>>
>>>>>>>
>>>>>>> Since itself is not an actual input to itself this does not form
>>>>>>> a contradictio
>>>>>>
>>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>>> exactly like it. You don't seem to understand this property of
>>>>>> Turing Machine. If you wish to dispute it, find an actual counter
>>>>>> example.
>>>>> It can be empirically verified that the behavior of Ĥ applied to
>>>>> ⟨Ĥ⟩ is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>
>>>> That isn't the question. The question is does the answer that
>>>> embedded_H match the behavior of the computaition given as in input.
>>>>
>>>> The answer is NO.
>>>>
>>>
>>> It is an easily verified fact that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>> by embedded_H never reaches the final state of this simulated input
>>> in any finite number of steps of simulation.
>>>
>>> This is the point where you have pie dripping from your face and deny
>>> that pie exists.
>>>
>>>
>>
>> Nope, it is trivial to verify that the CORRECT simulation of <H^> <H^>
>> (by a UTM)
>
> This is the point where you become a God damned liar.
> I say that when embedded_H uses its UTM functionality to simulate its
> input ⟨Ĥ⟩ ⟨Ĥ⟩ an infinitely repeating pattern is derived that we can see.
>
>

On 3/19/22 12:56 PM, olcott wrote:
> On 3/19/2022 11:49 AM, Richard Damon wrote:
>> On 3/19/22 12:40 PM, olcott wrote:
>>> On 3/19/2022 11:12 AM, Richard Damon wrote:
>>>> On 3/19/22 11:18 AM, olcott wrote:
>>>>> On 3/19/2022 9:47 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/19/22 10:33 AM, olcott wrote:
>>>>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>>>>>>> On 3/19/2022 8:51 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 3/19/22 9:34 AM, olcott wrote:
>>>>>>>>>>> On 3/19/2022 8:18 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/18/2022 11:40 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/16/2022 8:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I've shown you how to write Linz's conditions in terms
>>>>>>>>>>>>>>>>>> of simulation:
>>>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩) halts, and
>>>>>>>>>>>>>>>>>>       Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩) does not halt.
>>>>>>>>>>>>>>>>>> Feel fee to replace "halts" with "would reach its
>>>>>>>>>>>>>>>>>> final state" (and
>>>>>>>>>>>>>>>>>> similarly for "does not halt") if it make you feel
>>>>>>>>>>>>>>>>>> better. Both figures
>>>>>>>>>>>>>>>>>> of speech convey the same mathematical fact, but one
>>>>>>>>>>>>>>>>>> is shorter and fits
>>>>>>>>>>>>>>>>>> on a line.
>>>>>>>>>>>>>>>>>> What you can't do, if you want to keep talking about
>>>>>>>>>>>>>>>>>> what Linz is
>>>>>>>>>>>>>>>>>> talking about, is replace the reference to a UTM with
>>>>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Embedded_H has a full UTM as a part of it.
>>>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The Linz ⊢* wild card state transition allows for a UTM
>>>>>>>>>>>>>>>>> simulation to
>>>>>>>>>>>>>>>>> be a part of the decision process.
>>>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Embedded_H determines whether or not its simulated
>>>>>>>>>>>>>>>>> input would ever
>>>>>>>>>>>>>>>>> reach its final state if embedded_H remained in pure
>>>>>>>>>>>>>>>>> UTM mode.
>>>>>>>>>>>>>>>> Not in dispute.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It <is> the case that the correct pure simulation of
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>>>>>>>>>>>>>>>>>> copy of H embedded within Ĥ would never reach the
>>>>>>>>>>>>>>>>>>> final state of this
>>>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>> Irrelevant.  What matters is what follows logically
>>>>>>>>>>>>>>>>>> from Linz's
>>>>>>>>>>>>>>>>>> definition of a halt decider.  If you think there is
>>>>>>>>>>>>>>>>>> any point, I'll
>>>>>>>>>>>>>>>>>> write it out again for you in terms of UTMs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the input to embedded_H never halts and embedded_H
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> reports this that is most relevant.
>>>>>>>>>>>>>>>> Not in dispute (except for the poor wording).
>>>>>>>>>>>>>>>> If you want to know why you are still wrong after 14
>>>>>>>>>>>>>>>> years, you are
>>>>>>>>>>>>>>>> going to have to learn to follow what other people are
>>>>>>>>>>>>>>>> saying.  Of
>>>>>>>>>>>>>>>> course, if you did that, you'd see all your mistakes, so
>>>>>>>>>>>>>>>> you are much
>>>>>>>>>>>>>>>> better off remaining ignorant of what's being said to you.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the Linz H is embedded in the Linz Ĥ as a simulating
>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>> then the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H presents infinitely
>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>> simulation to embedded_H thus making the embedded_H
>>>>>>>>>>>>>>> transition to Ĥ.qn
>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>> No.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The reason that you only have a dogmatic reply rather than any
>>>>>>>>>>>>> supporting reasoning is that I am correct.
>>>>>>>>>>>>
>>>>>>>>>>>> No, it's because there is no evidence that you can accept the
>>>>>>>>>>>> explanations that are put to you.
>>>>>>>>>>>
>>>>>>>>>>> That is a bullshit excuse to hide the fact that you fail to
>>>>>>>>>>> understand what I said. You could provide an answer for
>>>>>>>>>>> posterity and for others that may eventually come to this
>>>>>>>>>>> post. The truth is you can't point out any specific error
>>>>>>>>>>> because there is no error.
>>>>>>>>>>>
>>>>>>>>>>>>   Do you really think it's worth my
>>>>>>>>>>>> while explaining, yet again, that re-defining what H should
>>>>>>>>>>>> do is just
>>>>>>>>>>>> pointless?
>>>>>>>>>>>>
>>>>>>>>>>>> I'll take the time to explain if you ask intelligent
>>>>>>>>>>>> questions, but my
>>>>>>>>>>>> repeating that reply to what you keep cutting and pasting is
>>>>>>>>>>>> just a
>>>>>>>>>>>> waste of time.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> All of the "rebuttals" never pointing out any specific error
>>>>>>>>>>> and were always some kind of ad hominem attack of another.
>>>>>>>>>>
>>>>>>>>>> MOST of the rebuttals point out specific errors (or at least
>>>>>>>>>> reference previous attempts to point them out).
>>>>>>>>>>
>>>>>>>>>> The issue s you don't seem to understand the meaning of the
>>>>>>>>>> words enough to understand what is being said.
>>>>>>>>>>
>>>>>>>>>> A bit like trying to explain something 'adult' to a 3 year old.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>> No one can find any error in the following only because
>>>>>>>>>>>>> there is no
>>>>>>>>>>>>> error to be found.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No one can find any error in the following only because there
>>>>>>>>>>> is no error to be found.
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>
>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0
>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1
>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2
>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>
>>>>>>>>>>> (1) If embedded_H does not abort the simulation of its input
>>>>>>>>>>> the simulation never stops and the simulated input never
>>>>>>>>>>> reaches its final state.
>>>>>>>>>>>
>>>>>>>>>>> (2) If embedded_H does abort the simulation of its input the
>>>>>>>>>>> simulation
>>>>>>>>>>> is aborted at some point shown above and the simulated input
>>>>>>>>>>> never reaches its final state.
>>>>>>>>>>>
>>>>>>>>>>> This proves that ⟨Ĥ⟩ ⟨Ĥ⟩ presents embedded_H with a sequence
>>>>>>>>>>> of configurations that never reach a final state. This in
>>>>>>>>>>> turn makes the transition to Ĥ.qn by embedded_H correct.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have pointed out the error many times and you just ignore it
>>>>>>>>>> because you don't want to believe it.
>>>>>>>>>>
>>>>>>>>>> The infinite loop described only exist if embedded_H never
>>>>>>>>>> aborts its simulation, and in that case, it never gives an
>>>>>>>>>> answer.
>>>>>>>>>>
>>>>>>>>>> If embedded_H aborts its simulation, and goes to Qn, then the
>>>>>>>>>> top level H^ applied to <H^> will go to H^.Qn and Halt,
>>>>>>>>> In other words when the simulating halt decider copy of H
>>>>>>>>> embedded within Ĥ correctly determines that its input will
>>>>>>>>> never reach its own final state it transitions to Ĥ.qn and
>>>>>>>>> stops running.
>>>>>>>> Except that it never correctly determined this, since it used a
>>>>>>>> false premise in its logic.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Since itself is not an actual input to itself this does not
>>>>>>>>> form a contradictio
>>>>>>>>
>>>>>>>> Except that the input IS a 'copy' of itself, and thus must
>>>>>>>> behave exactly like it. You don't seem to understand this
>>>>>>>> property of Turing Machine. If you wish to dispute it, find an
>>>>>>>> actual counter example.
>>>>>>> It can be empirically verified that the behavior of Ĥ applied to
>>>>>>> ⟨Ĥ⟩ is not the same as the behavior of embedded_H applied to ⟨Ĥ⟩
>>>>>>> ⟨Ĥ⟩.
>>>>>>>
>>>>>>
>>>>>> That isn't the question. The question is does the answer that
>>>>>> embedded_H match the behavior of the computaition given as in input.
>>>>>>
>>>>>> The answer is NO.
>>>>>>
>>>>>> embedded_H <H^> <H^> -> Qn is only correct if H^ applied to <H^>
>>>>>> will never halt,
>>>>>
>>>>> That is a God damned lie and you know it.
>>>>>
>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ would never reach
>>>>> its own final state ⟨Ĥ⟩.qn in a finite number of simulated steps.
>>>>>
>>>>
>>>> No, the DEFINITION of H is that H <H^> <H^> -> Qn only if H^ applied
>>>> to <H^> will never reach a final state.
>>>>
>>>
>>> You know that is a damned lie.
>>
>> ITS THE DEFINITION, it CAN'T BE A LIE, unless YOU ARE LYING about
>> working on Halting,
>
>
> The definition of decider prohibits any decider from reporting on any
> non-input non-finite string: MORON.

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

Just shows who is the moron.

The DEFINITION of a Halt Decider is that a Halt Decider applied to the
string <M> w needs to report on the behavior of M applied to w.

So, yes the INPUT is <H^> <H^>, but the OUTPUT/MAPPING is based on H^
applied to <H^>, dispite what you want to cliam.

Just shows how little you understand how this works.

On 3/19/2022 12:19 PM, Richard Damon wrote:
> On 3/19/22 12:44 PM, olcott wrote:
>> On 3/19/2022 11:22 AM, Alan Mackenzie wrote:
>>> olcott <NoOne@nowhere.com> wrote:
>>>> On 3/19/2022 9:24 AM, Richard Damon wrote:
>>>>> On 3/19/22 10:13 AM, olcott wrote:
>>>
>>> [ .... ]
>>>
>>>>>> Since itself is not an actual input to itself this does not form a
>>>>>> contradictio
>>>
>>>>> Except that the input IS a 'copy' of itself, and thus must behave
>>>>> exactly like it. You don't seem to understand this property of Turing
>>>>> Machine. If you wish to dispute it, find an actual counter example.
>>>
>>>> It can be empirically verified that the behavior of Ĥ applied to ⟨Ĥ⟩ is
>>>> not the same as the behavior of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> It can't be so verified without the code of H, which you refuse to
>>> publish, and which you certainly haven't written.  (If you had, you'd be
>>> less bullish about its purported properties.)
>>>
>>
>> That we know that embedded_H is a simulating halt decider that aborts
>> its simulation and rejects its input as soon as it detects an
>> infinitely repeating behavior pattern tells us that rejecting its
>> input would be correct on the basis of this infinitely repeating
>> behavior pattern that we can see:  (This by itself refutes Linz).
>>
>
>
> Except that no such finite pattern exists in H^ applied to <H^>, so
> there is no pattern of H to use to abort it.
You are too stupid to know the difference between finite and infinite.

--
Copyright 2021 Pete Olcott

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