Peter Olcott wrote:
> On 3/19/2022 9:23 PM, Python wrote:
>> Peter Olcott wrote:
>>> On 3/19/2022 8:52 PM, Richard Damon wrote:
>> ...
>>>> No, Halting is the Turing Machine reaching the final state in a
>>>> finite number of steps.
>>>>
>>>
>>> So in other words you think that it can reach its final state in an
>>> infinite number of steps?
>>
>> This is most idiotic answer you've ever posted. And you've posted many.
>>
>> Seriously Peter, you are embarrassing yourself.
>>
>
> I merely correctly pointed out the "finite number of steps" does not
> change the meaning thus is not required.

Very funny indeed. You're not in position to make such puns given all
fallacies and disgusting insults you've posted aimed at people who
tried to help you. You are a psychopath, a demented delusional one.

On 3/19/2022 9:44 PM, Python wrote:
> Peter Olcott wrote:
>> On 3/19/2022 9:23 PM, Python wrote:
>>> Peter Olcott wrote:
>>>> On 3/19/2022 8:52 PM, Richard Damon wrote:
>>> ...
>>>>> No, Halting is the Turing Machine reaching the final state in a
>>>>> finite number of steps.
>>>>>
>>>>
>>>> So in other words you think that it can reach its final state in an
>>>> infinite number of steps?
>>>
>>> This is most idiotic answer you've ever posted. And you've posted many.
>>>
>>> Seriously Peter, you are embarrassing yourself.
>>>
>>
>> I merely correctly pointed out the "finite number of steps" does not
>> change the meaning thus is not required.
>
> Very funny indeed. You're not in position to make such puns given all
> fallacies and disgusting insults you've posted aimed at people who
> tried to help you. You are a psychopath, a demented delusional one.

As Ben pointed out people are only here to make fun of me.

--
Copyright 2021 Pete Olcott

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

Peter Olcott wrote:
> On 3/19/2022 9:44 PM, Python wrote:
>> Peter Olcott wrote:
>>> On 3/19/2022 9:23 PM, Python wrote:
>>>> Peter Olcott wrote:
>>>>> On 3/19/2022 8:52 PM, Richard Damon wrote:
>>>> ...
>>>>>> No, Halting is the Turing Machine reaching the final state in a
>>>>>> finite number of steps.
>>>>>>
>>>>>
>>>>> So in other words you think that it can reach its final state in an
>>>>> infinite number of steps?
>>>>
>>>> This is most idiotic answer you've ever posted. And you've posted many.
>>>>
>>>> Seriously Peter, you are embarrassing yourself.
>>>>
>>>
>>> I merely correctly pointed out the "finite number of steps" does not
>>> change the meaning thus is not required.
>>
>> Very funny indeed. You're not in position to make such puns given all
>> fallacies and disgusting insults you've posted aimed at people who
>> tried to help you. You are a psychopath, a demented delusional one.
>
> As Ben pointed out people are only here to make fun of me.

"fun"? No. It's SAD.

On 3/19/2022 10:05 PM, Python wrote:
> Peter Olcott wrote:
>> On 3/19/2022 9:44 PM, Python wrote:
>>> Peter Olcott wrote:
>>>> On 3/19/2022 9:23 PM, Python wrote:
>>>>> Peter Olcott wrote:
>>>>>> On 3/19/2022 8:52 PM, Richard Damon wrote:
>>>>> ...
>>>>>>> No, Halting is the Turing Machine reaching the final state in a
>>>>>>> finite number of steps.
>>>>>>>
>>>>>>
>>>>>> So in other words you think that it can reach its final state in
>>>>>> an infinite number of steps?
>>>>>
>>>>> This is most idiotic answer you've ever posted. And you've posted
>>>>> many.
>>>>>
>>>>> Seriously Peter, you are embarrassing yourself.
>>>>>
>>>>
>>>> I merely correctly pointed out the "finite number of steps" does not
>>>> change the meaning thus is not required.
>>>
>>> Very funny indeed. You're not in position to make such puns given all
>>> fallacies and disgusting insults you've posted aimed at people who
>>> tried to help you. You are a psychopath, a demented delusional one.
>>
>> As Ben pointed out people are only here to make fun of me.
>
> "fun"? No. It's SAD.

Fun as in sadistic pleasure of tormenting someone that has stage 4 cancer.

--
Copyright 2021 Pete Olcott

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

Peter Olcott wrote:
> On 3/19/2022 10:05 PM, Python wrote:
>> Peter Olcott wrote:
>>> On 3/19/2022 9:44 PM, Python wrote:
>>>> Peter Olcott wrote:
>>>>> On 3/19/2022 9:23 PM, Python wrote:
>>>>>> Peter Olcott wrote:
>>>>>>> On 3/19/2022 8:52 PM, Richard Damon wrote:
>>>>>> ...
>>>>>>>> No, Halting is the Turing Machine reaching the final state in a
>>>>>>>> finite number of steps.
>>>>>>>>
>>>>>>>
>>>>>>> So in other words you think that it can reach its final state in
>>>>>>> an infinite number of steps?
>>>>>>
>>>>>> This is most idiotic answer you've ever posted. And you've posted
>>>>>> many.
>>>>>>
>>>>>> Seriously Peter, you are embarrassing yourself.
>>>>>>
>>>>>
>>>>> I merely correctly pointed out the "finite number of steps" does
>>>>> not change the meaning thus is not required.
>>>>
>>>> Very funny indeed. You're not in position to make such puns given all
>>>> fallacies and disgusting insults you've posted aimed at people who
>>>> tried to help you. You are a psychopath, a demented delusional one.
>>>
>>> As Ben pointed out people are only here to make fun of me.
>>
>> "fun"? No. It's SAD.
>
> Fun as in sadistic pleasure of tormenting someone that has stage 4 cancer.

You are inflicting that to yourself by posting fallacies, lies and
libels.

On 3/19/2022 10:42 PM, Python wrote:
> Peter Olcott wrote:
>> On 3/19/2022 10:05 PM, Python wrote:
>>> Peter Olcott wrote:
>>>> On 3/19/2022 9:44 PM, Python wrote:
>>>>> Peter Olcott wrote:
>>>>>> On 3/19/2022 9:23 PM, Python wrote:
>>>>>>> Peter Olcott wrote:
>>>>>>>> On 3/19/2022 8:52 PM, Richard Damon wrote:
>>>>>>> ...
>>>>>>>>> No, Halting is the Turing Machine reaching the final state in a
>>>>>>>>> finite number of steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So in other words you think that it can reach its final state in
>>>>>>>> an infinite number of steps?
>>>>>>>
>>>>>>> This is most idiotic answer you've ever posted. And you've posted
>>>>>>> many.
>>>>>>>
>>>>>>> Seriously Peter, you are embarrassing yourself.
>>>>>>>
>>>>>>
>>>>>> I merely correctly pointed out the "finite number of steps" does
>>>>>> not change the meaning thus is not required.
>>>>>
>>>>> Very funny indeed. You're not in position to make such puns given all
>>>>> fallacies and disgusting insults you've posted aimed at people who
>>>>> tried to help you. You are a psychopath, a demented delusional one.
>>>>
>>>> As Ben pointed out people are only here to make fun of me.
>>>
>>> "fun"? No. It's SAD.
>>
>> Fun as in sadistic pleasure of tormenting someone that has stage 4
>> cancer.
>
> You are inflicting that to yourself by posting fallacies, lies and
> libels.

The bottom line is that I am correct and you can't point out any error.

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 3/19/2022 7:29 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> A copy of Linz H ...
>>
>> Linz is talking about Turing machines but you are not. Your magic
>> PO-machines have the property that "exact copies" (your words) can
>> behave differently when applied (your word) to the same input.
>> To address Linz's proof you need to be talking about TMs, not magic
>> PO-machines.
>
> (1) H and Ĥ aren't exact copies strcmp() proves that they differ by
> the appended states. H and Ĥ use strcmp() as part of the decision
> criteria.

No one ever said they were. You, however, did say that H and embedded_H
are exact copies:

"Linz [...] requires that Ĥ.qx is an exact copy of H."
"Ĥ includes an exact copy of H embedded at its state Ĥ.qx"
"Ĥ.qx <is> an exact copy of H"

> (2) I made all of this moot months ago by only focusing on the copy of
> H that is embedded within Ĥ, so when people bring up H I must tell
> this this is off topic.

The mistake does not go away because you refuse to talk about it. You
have made your ploy very clear. Here you are saying it quite
explicitly:

"Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
corresponds to
H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"

This is a magic machine where the same state transition function entails
different transitions on identical inputs.

And here you are saying it slightly different words just hours ago:

"The behavior of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is different than the behavior
of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩"

There is no getting away from this nonsense. You need to fix now or you
will remain a laughing stock.

> The key topic now is:
> How can embedded_H applied to <Ĥ> <Ĥ> transition to Ĥ.qn causing Ĥ
> applied to <Ĥ> to halt WITHOUT FORMING ANY CONTRADICTION ?

Your answer is simple: magic PO-machines:

"Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
corresponds to
H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"

It won't wash. It's a joke. Stop it.

--
Ben.

On 3/19/2022 11:08 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/19/2022 7:29 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> A copy of Linz H ...
>>>
>>> Linz is talking about Turing machines but you are not. Your magic
>>> PO-machines have the property that "exact copies" (your words) can
>>> behave differently when applied (your word) to the same input.
>>> To address Linz's proof you need to be talking about TMs, not magic
>>> PO-machines.
>>
>> (1) H and Ĥ aren't exact copies strcmp() proves that they differ by
>> the appended states. H and Ĥ use strcmp() as part of the decision
>> criteria.
>
> No one ever said they were. You, however, did say that H and embedded_H
> are exact copies:
>

embedded_H is an exact copy of H in the it has the same state
transitions. Its Turing machine description has the infinite loop state
appended to the end, this a string comparison of the machine
descriptions will not match.

> "Linz [...] requires that Ĥ.qx is an exact copy of H."
> "Ĥ includes an exact copy of H embedded at its state Ĥ.qx"
> "Ĥ.qx <is> an exact copy of H"
>
>> (2) I made all of this moot months ago by only focusing on the copy of
>> H that is embedded within Ĥ, so when people bring up H I must tell
>> this this is off topic.
>
> The mistake does not go away because you refuse to talk about it. You
> have made your ploy very clear. Here you are saying it quite
> explicitly:
>

It is not longer in any part of my proof, so it is moot.

> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
> corresponds to
> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>
> This is a magic machine where the same state transition function entails
> different transitions on identical inputs.
>
> And here you are saying it slightly different words just hours ago:
>
> "The behavior of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is different than the behavior
> of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩"
>
> There is no getting away from this nonsense. You need to fix now or you
> will remain a laughing stock.
>

It is no longer part of the proof and my time is limited.

>> The key topic now is:
>> How can embedded_H applied to <Ĥ> <Ĥ> transition to Ĥ.qn causing Ĥ
>> applied to <Ĥ> to halt WITHOUT FORMING ANY CONTRADICTION ?
>
> Your answer is simple:

and provided at the root of this thread.

--
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:08 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
On 3/19/2022 11:10 PM, Ben Bacarisse wrote:
> Google's AI at it's finest? Your recent posts are indeed a joke.
>

You say without reviewing them.

--
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:17 PM, olcott wrote:
> On 3/19/2022 8:50 PM, Richard Damon wrote:
>> On 3/19/22 9:31 PM, olcott wrote:
>>> On 3/19/2022 8:25 PM, Richard Damon wrote:
>>>> On 3/19/22 9:12 PM, olcott wrote:
>>>>> On 3/19/2022 8:04 PM, Richard Damon wrote:
>>>>>> On 3/19/22 8:51 PM, olcott wrote:
>>>>>>> On 3/19/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 3/19/22 8:24 PM, olcott wrote:
>>>>>>>>> On 3/19/2022 7:20 PM, Richard Damon wrote:
>>>>>>>>>> On 3/19/22 8:00 PM, olcott wrote:
>>>>>>>>>>> On 3/19/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/19/22 7:47 PM, olcott wrote:
>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>
>>>>>>>>>>>>> When a halt decider bases its halt status decision on the
>>>>>>>>>>>>> behavior of its simulated input then all of the
>>>>>>>>>>>>> conventional halting problem counter example inputs would
>>>>>>>>>>>>> be determined to be non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *By these two principles this proof is validated*
>>>>>>>>>>>>>
>>>>>>>>>>>>> (1) A halt decider (because it is a decider) must report on
>>>>>>>>>>>>> the behavior specified by its finite string input. A
>>>>>>>>>>>>> decider computes the mapping from its input finite strings
>>>>>>>>>>>>> to an accept or reject state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>>> behavior of this input when it is correctly simulated by
>>>>>>>>>>>>> its simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key point that that everyone (including Peter Linz) has
>>>>>>>>>>>>> an impossibly difficult time with is that embedded_H can
>>>>>>>>>>>>> correctly transition to Ĥ.qn indicting that its input does
>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everyone (including Peter Linz) incorrectly believes that
>>>>>>>>>>>>> this is contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everyone assumes the the behavior of the executed Ĥ applied
>>>>>>>>>>>>> ⟨Ĥ⟩ must be the same as the input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>> embedded_H or it is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> We can easily verify that the correct behavior of Ĥ applied
>>>>>>>>>>>>> ⟨Ĥ⟩ is not the same as the correct behavior as the input
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No one ever bothers to do this because of their deep
>>>>>>>>>>>>> religious conviction that they must either be the same or
>>>>>>>>>>>>> be incorrect.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Just more of your Fairy Dust Powered Unicorns that do magic
>>>>>>>>>>>> to make imppssible things happen.
>>>>>>>>>>>>
>>>>>>>>>>>> Just more UNSOUND LOGIC.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>> If you paid very close attention as if the salvation of your
>>>>>>>>>>> soul depended on the accuracy of your evaluation you would
>>>>>>>>>>> see that I have been correct all along.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, you logic in NONSENSE, you assert things without any
>>>>>>>>>> evidence.
>>>>>>>>>>
>>>>>>>>> I prove my point and you skip over the proof because you only
>>>>>>>>> want to play head games.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Really??
>>>>>>>>
>>>>>>>> One BIG lile is:
>>>>>>>>
>>>>>>>>>
>>>>>>>>> (2) The behavior specified by this input is the actual behavior
>>>>>>>>> of this input when it is correctly simulated by its simulating
>>>>>>>>> halt decider (SHD) that contains a full UTM.
>>>>>>>>
>>>>>>>> Because your SHD can't actually correctly simulate as a UTM and
>>>>>>>> abort it simulation at the same time.
>>>>>>>>
>>>>>>> That is like saying that a car cannot run because it cannot run
>>>>>>> and stop running at the same time.
>>>>>>>
>>>>>>
>>>>>> Nope, just shows you still don't understand what a UTM is.
>>>>>>
>>>>>
>>>>> As long as the SHD can correctly simulate enough steps of its input
>>>>> to correctly detect an infinite behavior pattern then it can
>>>>> correctly reject its input on this basis because that means that
>>>>> the simulated input cannot possibly ever reach its own final state
>>>>> which conclusively proves that it specifies a non-halting sequence
>>>>> of configurations.
>>>>>
>>>>> People that are not dumber than a box of rocks will understand that
>>>>> the above is necessarily correct.
>>>>>
>>>>
>>>> Yes, if it CAN correcly simulate enough states of its input to
>>>> correctly detect an infinite behavior.
>>>>
>>>> The problem is that this is not guaranteed to exist. So you are just
>>>> beleiving in Fairy Dust Powered Unicorns to perform their magic.
>>>>
>>>
>>> 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⟩...
>>>
>>> You acknowledged that the above sequence proves proves infinite
>>> behavior. Thus you can I can both see that a transition to Ĥ.qn would
>>> be correct.
>>>
>>
>> It is ONLY an infinite sequence if NO embedded_H abort there simulations,
>
> This is the part where the label of BRAIN DEAD MORON applies to you.
> As long as embedded_H correctly determines that its simulated input ⟨Ĥ⟩
> ⟨Ĥ⟩ cannot possibly reach its final state embedded_H can correctly
> reject this input.
>

On 3/19/22 10:18 PM, olcott wrote:
> On 3/19/2022 8:52 PM, Richard Damon wrote:
>>
>> On 3/19/22 9:32 PM, olcott wrote:
>>> On 3/19/2022 8:29 PM, Richard Damon wrote:
>>>> On 3/19/22 9:15 PM, olcott wrote:
>>>>> On 3/19/2022 8:08 PM, Richard Damon wrote:
>>>>>> On 3/19/22 9:00 PM, olcott wrote:
>>>>>>> On 3/19/2022 7:56 PM, Richard Damon wrote:
>>>>>>>> On 3/19/22 8:42 PM, olcott wrote:
>>>>>>>>> On 3/19/2022 7:29 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> A copy of Linz H ...
>>>>>>>>>>
>>>>>>>>>> Linz is talking about Turing machines but you are not.  Your
>>>>>>>>>> magic
>>>>>>>>>> PO-machines have the property that "exact copies" (your words)
>>>>>>>>>> can
>>>>>>>>>> behave differently when applied (your word) to the same input.
>>>>>>>>>>
>>>>>>>>>> To address Linz's proof you need to be talking about TMs, not
>>>>>>>>>> magic
>>>>>>>>>> PO-machines.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> (1) H and Ĥ aren't exact copies strcmp() proves that they
>>>>>>>>> differ by the appended states. H and Ĥ use strcmp() as part of
>>>>>>>>> the decision criteria.
>>>>>>>>>
>>>>>>>>> (2) I made all of this moot months ago by only focusing on the
>>>>>>>>> copy of H that is embedded within Ĥ, so when people bring up H
>>>>>>>>> I must tell this this is off topic.
>>>>>>>>>
>>>>>>>>> The key topic now is:
>>>>>>>>> How can embedded_H applied to <Ĥ> <Ĥ> transition to Ĥ.qn
>>>>>>>>> causing Ĥ applied to <Ĥ> to halt WITHOUT FORMING ANY
>>>>>>>>> CONTRADICTION ?
>>>>>>>>>
>>>>>>>>> Everyone assumes that this is impossible with such deep
>>>>>>>>> religious conviction that when I explain all the details many
>>>>>>>>> hundreds of times no one hears a single word.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that you never actually use the right definitions of
>>>>>>>> things or go into actual proofs.
>>>>>>>>
>>>>>>>
>>>>>>> A proof is any sequence of steps that necessitates a conclusion.
>>>>>>> People assume that a proof is far more limited so they ignore my
>>>>>>> proofs.
>>>>>>
>>>>>> But it must START from correct information and uses valid logic to
>>>>>> be a sound proof.
>>>>>>
>>>>>> You can 'prove' the earth is flat if you want and don't need to
>>>>>> conform to actual 'facts'
>>>>>>
>>>>>> You start with the WRONG definition of Halting
>>>>>
>>>>>
>>>>> Halting is reaching a final state, nothing else is halting. As long
>>>>> as a SHD correctly determines that its simulated input cannot
>>>>> possibly reach its final state it can correctly reject this input.
>>>>>
>>>>
>>>> Halting is the ACTUAL Turing Machine reaching its final state.
>>>>
>>>
>>> Halting is an executed or simulated Turing machine reaching final state.
>>>
>>>
>>
>> No, Halting is the Turing Machine reaching the final state in a finite
>> number of steps.
>>
>
> So in other words you think that it can reach its final state in an
> infinite number of steps?

There are some machines that you can show will, in a countable infinite
number of steps, reach a final state, but since it is not a finite
number, it is not called halting.

>
>> You can show that the Turing Machine would halt or not by the
>> simulation of by UTM. A 'Non-UTM' simulation that aborts part way
>> doesn't prove non-halting.
>>
>> Read the definition again.
>
>

On 3/19/22 10:49 PM, olcott wrote:
>
> As Ben pointed out people are only here to make fun of me.
>

The problem is you make it so easy because you make such STUPID mistakes.

On 3/19/22 11:43 PM, olcott wrote:

> The bottom line is that I am correct and you can't point out any error.
>
>

No, the bottom line is people have pointed out TONS of errors, but you
don't understand things well enough to comprend them, so you ignore them.

You are, literally, the man who looks at the universe and says it is wrong.

On 3/20/22 12:16 AM, olcott wrote:
> On 3/19/2022 11:08 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/19/2022 7:29 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> A copy of Linz H ...
>>>>
>>>> Linz is talking about Turing machines but you are not.  Your magic
>>>> PO-machines have the property that "exact copies" (your words) can
>>>> behave differently when applied (your word) to the same input.
>>>> To address Linz's proof you need to be talking about TMs, not magic
>>>> PO-machines.
>>>
>>> (1) H and Ĥ aren't exact copies strcmp() proves that they differ by
>>> the appended states. H and Ĥ use strcmp() as part of the decision
>>> criteria.
>>
>> No one ever said they were.  You, however, did say that H and embedded_H
>> are exact copies:
>>
>
> embedded_H is an exact copy of H in the it has the same state
> transitions. Its Turing machine description has the infinite loop state
> appended to the end, this a string comparison of the machine
> descriptions will not match.

Which says it is part why in the transformation of H to H^, but every
comment about its behavior still holds, as it still has a copy of H in
it that has to behave just like that 'original' H. Thus embedded_H goes
to Qy and Qn in exactly the same way as H does.

>
>>    "Linz [...] requires that Ĥ.qx is an exact copy of H."
>>    "Ĥ includes an exact copy of H embedded at its state Ĥ.qx"
>>    "Ĥ.qx <is> an exact copy of H"
>>
>>> (2) I made all of this moot months ago by only focusing on the copy of
>>> H that is embedded within Ĥ, so when people bring up H I must tell
>>> this this is off topic.
>>
>> The mistake does not go away because you refuse to talk about it.  You
>> have made your ploy very clear.  Here you are saying it quite
>> explicitly:
>>
>
> It is not longer in any part of my proof, so it is moot.

No, it HAS to be part of your proof, as the requirements are on H, so
without admitting to an H, you have no proof.

>
>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>      corresponds to
>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>
>> This is a magic machine where the same state transition function entails
>> different transitions on identical inputs.
>>
>> And here you are saying it slightly different words just hours ago:
>>
>>    "The behavior of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is different than the behavior
>>    of embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩"
>>
>> There is no getting away from this nonsense.  You need to fix now or you
>> will remain a laughing stock.
>>
>
> It is no longer part of the proof and my time is limited.

Maybe not obfuscating things would let you move faster. YOU are the one
who has 'wasted' a lot of time complaining that people talk about H and
not embedded_H when they both do exactly the same thing for the cases in
question.

>
>>> The key topic now is:
>>> How can embedded_H applied to <Ĥ> <Ĥ> transition to Ĥ.qn causing Ĥ
>>> applied to <Ĥ> to halt WITHOUT FORMING ANY CONTRADICTION ?
>>
>> Your answer is simple:
>
> and provided at the root of this thread.
>

Which shows you are wrong. The Errors HAVE been pointed out, and you
have just igonored the responses.

YOU have bad definitions, and logical errors so your work is worthless.

FAIL.

On 2022-03-20 00:42:33 +0000, olcott said:

> (2) I made all of this moot months ago by only focusing on the copy of
> H that is embedded within Ĥ, so when people bring up H I must tell this
> this is off topic.

H cannot be off topic as it was introduced to the discussion in the
originnal posting by Pete Olcott. The topic, as identifed in the
subject line, is Linz Halting Problem Proof, and H is an essential
constituent of that proof, therefore definitely on topic.

Mikko

On 3/20/2022 6:07 AM, Richard Damon wrote:
> On 3/19/22 10:17 PM, olcott wrote:
>> On 3/19/2022 8:50 PM, Richard Damon wrote:
>>> On 3/19/22 9:31 PM, olcott wrote:
>>>> On 3/19/2022 8:25 PM, Richard Damon wrote:
>>>>> On 3/19/22 9:12 PM, olcott wrote:
>>>>>> On 3/19/2022 8:04 PM, Richard Damon wrote:
>>>>>>> On 3/19/22 8:51 PM, olcott wrote:
>>>>>>>> On 3/19/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 3/19/22 8:24 PM, olcott wrote:
>>>>>>>>>> On 3/19/2022 7:20 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/19/22 8:00 PM, olcott wrote:
>>>>>>>>>>>> On 3/19/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/19/22 7:47 PM, olcott wrote:
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When a halt decider bases its halt status decision on the
>>>>>>>>>>>>>> behavior of its simulated input then all of the
>>>>>>>>>>>>>> conventional halting problem counter example inputs would
>>>>>>>>>>>>>> be determined to be non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> never reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *By these two principles this proof is validated*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) A halt decider (because it is a decider) must report
>>>>>>>>>>>>>> on the behavior specified by its finite string input. A
>>>>>>>>>>>>>> decider computes the mapping from its input finite strings
>>>>>>>>>>>>>> to an accept or reject state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>>>> behavior of this input when it is correctly simulated by
>>>>>>>>>>>>>> its simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key point that that everyone (including Peter Linz)
>>>>>>>>>>>>>> has an impossibly difficult time with is that embedded_H
>>>>>>>>>>>>>> can correctly transition to Ĥ.qn indicting that its input
>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone (including Peter Linz) incorrectly believes that
>>>>>>>>>>>>>> this is contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone assumes the the behavior of the executed Ĥ
>>>>>>>>>>>>>> applied ⟨Ĥ⟩ must be the same as the input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> simulated by embedded_H or it is wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We can easily verify that the correct behavior of Ĥ
>>>>>>>>>>>>>> applied ⟨Ĥ⟩ is not the same as the correct behavior as the
>>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No one ever bothers to do this because of their deep
>>>>>>>>>>>>>> religious conviction that they must either be the same or
>>>>>>>>>>>>>> be incorrect.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just more of your Fairy Dust Powered Unicorns that do magic
>>>>>>>>>>>>> to make imppssible things happen.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just more UNSOUND LOGIC.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>> If you paid very close attention as if the salvation of your
>>>>>>>>>>>> soul depended on the accuracy of your evaluation you would
>>>>>>>>>>>> see that I have been correct all along.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, you logic in NONSENSE, you assert things without any
>>>>>>>>>>> evidence.
>>>>>>>>>>>
>>>>>>>>>> I prove my point and you skip over the proof because you only
>>>>>>>>>> want to play head games.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Really??
>>>>>>>>>
>>>>>>>>> One BIG lile is:
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>> behavior of this input when it is correctly simulated by its
>>>>>>>>>> simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>
>>>>>>>>> Because your SHD can't actually correctly simulate as a UTM and
>>>>>>>>> abort it simulation at the same time.
>>>>>>>>>
>>>>>>>> That is like saying that a car cannot run because it cannot run
>>>>>>>> and stop running at the same time.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, just shows you still don't understand what a UTM is.
>>>>>>>
>>>>>>
>>>>>> As long as the SHD can correctly simulate enough steps of its
>>>>>> input to correctly detect an infinite behavior pattern then it can
>>>>>> correctly reject its input on this basis because that means that
>>>>>> the simulated input cannot possibly ever reach its own final state
>>>>>> which conclusively proves that it specifies a non-halting sequence
>>>>>> of configurations.
>>>>>>
>>>>>> People that are not dumber than a box of rocks will understand
>>>>>> that the above is necessarily correct.
>>>>>>
>>>>>
>>>>> Yes, if it CAN correcly simulate enough states of its input to
>>>>> correctly detect an infinite behavior.
>>>>>
>>>>> The problem is that this is not guaranteed to exist. So you are
>>>>> just beleiving in Fairy Dust Powered Unicorns to perform their magic.
>>>>>
>>>>
>>>> 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⟩...
>>>>
>>>> You acknowledged that the above sequence proves proves infinite
>>>> behavior. Thus you can I can both see that a transition to Ĥ.qn
>>>> would be correct.
>>>>
>>>
>>> It is ONLY an infinite sequence if NO embedded_H abort there
>>> simulations,
>>
>> This is the part where the label of BRAIN DEAD MORON applies to you.
>> As long as embedded_H correctly determines that its simulated input
>> ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its final state embedded_H can correctly
>> reject this input.
>>
>
> Right, but it hasn't done that, and you seem to be too dumb to
> understand why. It has (incorrectly) assumed that the copy of embedded_H
> within all the simulated H^s will NEVER abort their simulations,

On 3/20/2022 9:17 AM, olcott wrote:
> On 3/20/2022 6:07 AM, Richard Damon wrote:
>> On 3/19/22 10:17 PM, olcott wrote:
>>> On 3/19/2022 8:50 PM, Richard Damon wrote:
>>>> On 3/19/22 9:31 PM, olcott wrote:
>>>>> On 3/19/2022 8:25 PM, Richard Damon wrote:
>>>>>> On 3/19/22 9:12 PM, olcott wrote:
>>>>>>> On 3/19/2022 8:04 PM, Richard Damon wrote:
>>>>>>>> On 3/19/22 8:51 PM, olcott wrote:
>>>>>>>>> On 3/19/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 3/19/22 8:24 PM, olcott wrote:
>>>>>>>>>>> On 3/19/2022 7:20 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/19/22 8:00 PM, olcott wrote:
>>>>>>>>>>>>> On 3/19/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/19/22 7:47 PM, olcott wrote:
>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When a halt decider bases its halt status decision on the
>>>>>>>>>>>>>>> behavior of its simulated input then all of the
>>>>>>>>>>>>>>> conventional halting problem counter example inputs would
>>>>>>>>>>>>>>> be determined to be non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>> never reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *By these two principles this proof is validated*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (1) A halt decider (because it is a decider) must report
>>>>>>>>>>>>>>> on the behavior specified by its finite string input. A
>>>>>>>>>>>>>>> decider computes the mapping from its input finite
>>>>>>>>>>>>>>> strings to an accept or reject state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>>>>> behavior of this input when it is correctly simulated by
>>>>>>>>>>>>>>> its simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key point that that everyone (including Peter Linz)
>>>>>>>>>>>>>>> has an impossibly difficult time with is that embedded_H
>>>>>>>>>>>>>>> can correctly transition to Ĥ.qn indicting that its input
>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everyone (including Peter Linz) incorrectly believes that
>>>>>>>>>>>>>>> this is contradictory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everyone assumes the the behavior of the executed Ĥ
>>>>>>>>>>>>>>> applied ⟨Ĥ⟩ must be the same as the input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> simulated by embedded_H or it is wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can easily verify that the correct behavior of Ĥ
>>>>>>>>>>>>>>> applied ⟨Ĥ⟩ is not the same as the correct behavior as
>>>>>>>>>>>>>>> the input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No one ever bothers to do this because of their deep
>>>>>>>>>>>>>>> religious conviction that they must either be the same or
>>>>>>>>>>>>>>> be incorrect.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just more of your Fairy Dust Powered Unicorns that do
>>>>>>>>>>>>>> magic to make imppssible things happen.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just more UNSOUND LOGIC.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you paid very close attention as if the salvation of
>>>>>>>>>>>>> your soul depended on the accuracy of your evaluation you
>>>>>>>>>>>>> would see that I have been correct all along.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, you logic in NONSENSE, you assert things without any
>>>>>>>>>>>> evidence.
>>>>>>>>>>>>
>>>>>>>>>>> I prove my point and you skip over the proof because you only
>>>>>>>>>>> want to play head games.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Really??
>>>>>>>>>>
>>>>>>>>>> One BIG lile is:
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>> behavior of this input when it is correctly simulated by its
>>>>>>>>>>> simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>
>>>>>>>>>> Because your SHD can't actually correctly simulate as a UTM
>>>>>>>>>> and abort it simulation at the same time.
>>>>>>>>>>
>>>>>>>>> That is like saying that a car cannot run because it cannot run
>>>>>>>>> and stop running at the same time.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, just shows you still don't understand what a UTM is.
>>>>>>>>
>>>>>>>
>>>>>>> As long as the SHD can correctly simulate enough steps of its
>>>>>>> input to correctly detect an infinite behavior pattern then it
>>>>>>> can correctly reject its input on this basis because that means
>>>>>>> that the simulated input cannot possibly ever reach its own final
>>>>>>> state which conclusively proves that it specifies a non-halting
>>>>>>> sequence of configurations.
>>>>>>>
>>>>>>> People that are not dumber than a box of rocks will understand
>>>>>>> that the above is necessarily correct.
>>>>>>>
>>>>>>
>>>>>> Yes, if it CAN correcly simulate enough states of its input to
>>>>>> correctly detect an infinite behavior.
>>>>>>
>>>>>> The problem is that this is not guaranteed to exist. So you are
>>>>>> just beleiving in Fairy Dust Powered Unicorns to perform their magic.
>>>>>>
>>>>>
>>>>> 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⟩...
>>>>>
>>>>> You acknowledged that the above sequence proves proves infinite
>>>>> behavior. Thus you can I can both see that a transition to Ĥ.qn
>>>>> would be correct.
>>>>>
>>>>
>>>> It is ONLY an infinite sequence if NO embedded_H abort there
>>>> simulations,
>>>
>>> This is the part where the label of BRAIN DEAD MORON applies to you.
>>> As long as embedded_H correctly determines that its simulated input
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its final state embedded_H can
>>> correctly reject this input.
>>>
>>
>> Right, but it hasn't done that, and you seem to be too dumb to
>> understand why. It has (incorrectly) assumed that the copy of
>> embedded_H within all the simulated H^s will NEVER abort their
>> simulations,
>
> It is not possible that the copy of embedded_H will abort its simulation
> because the simulation is not aborted until the minimum abort criteria
> is met and the outermost embedded_H sees more of the execution trace
> than any copy.
>
> It is known that every PHD will always abort its simulation whenever it

On 3/20/2022 6:07 AM, Richard Damon wrote:
> On 3/19/22 10:17 PM, olcott wrote:
>> On 3/19/2022 8:50 PM, Richard Damon wrote:
>>> On 3/19/22 9:31 PM, olcott wrote:
>>>> On 3/19/2022 8:25 PM, Richard Damon wrote:
>>>>> On 3/19/22 9:12 PM, olcott wrote:
>>>>>> On 3/19/2022 8:04 PM, Richard Damon wrote:
>>>>>>> On 3/19/22 8:51 PM, olcott wrote:
>>>>>>>> On 3/19/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 3/19/22 8:24 PM, olcott wrote:
>>>>>>>>>> On 3/19/2022 7:20 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/19/22 8:00 PM, olcott wrote:
>>>>>>>>>>>> On 3/19/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/19/22 7:47 PM, olcott wrote:
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When a halt decider bases its halt status decision on the
>>>>>>>>>>>>>> behavior of its simulated input then all of the
>>>>>>>>>>>>>> conventional halting problem counter example inputs would
>>>>>>>>>>>>>> be determined to be non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> never reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *By these two principles this proof is validated*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) A halt decider (because it is a decider) must report
>>>>>>>>>>>>>> on the behavior specified by its finite string input. A
>>>>>>>>>>>>>> decider computes the mapping from its input finite strings
>>>>>>>>>>>>>> to an accept or reject state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>>>> behavior of this input when it is correctly simulated by
>>>>>>>>>>>>>> its simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key point that that everyone (including Peter Linz)
>>>>>>>>>>>>>> has an impossibly difficult time with is that embedded_H
>>>>>>>>>>>>>> can correctly transition to Ĥ.qn indicting that its input
>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone (including Peter Linz) incorrectly believes that
>>>>>>>>>>>>>> this is contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone assumes the the behavior of the executed Ĥ
>>>>>>>>>>>>>> applied ⟨Ĥ⟩ must be the same as the input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> simulated by embedded_H or it is wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We can easily verify that the correct behavior of Ĥ
>>>>>>>>>>>>>> applied ⟨Ĥ⟩ is not the same as the correct behavior as the
>>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No one ever bothers to do this because of their deep
>>>>>>>>>>>>>> religious conviction that they must either be the same or
>>>>>>>>>>>>>> be incorrect.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just more of your Fairy Dust Powered Unicorns that do magic
>>>>>>>>>>>>> to make imppssible things happen.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just more UNSOUND LOGIC.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>> If you paid very close attention as if the salvation of your
>>>>>>>>>>>> soul depended on the accuracy of your evaluation you would
>>>>>>>>>>>> see that I have been correct all along.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, you logic in NONSENSE, you assert things without any
>>>>>>>>>>> evidence.
>>>>>>>>>>>
>>>>>>>>>> I prove my point and you skip over the proof because you only
>>>>>>>>>> want to play head games.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Really??
>>>>>>>>>
>>>>>>>>> One BIG lile is:
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>> behavior of this input when it is correctly simulated by its
>>>>>>>>>> simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>
>>>>>>>>> Because your SHD can't actually correctly simulate as a UTM and
>>>>>>>>> abort it simulation at the same time.
>>>>>>>>>
>>>>>>>> That is like saying that a car cannot run because it cannot run
>>>>>>>> and stop running at the same time.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, just shows you still don't understand what a UTM is.
>>>>>>>
>>>>>>
>>>>>> As long as the SHD can correctly simulate enough steps of its
>>>>>> input to correctly detect an infinite behavior pattern then it can
>>>>>> correctly reject its input on this basis because that means that
>>>>>> the simulated input cannot possibly ever reach its own final state
>>>>>> which conclusively proves that it specifies a non-halting sequence
>>>>>> of configurations.
>>>>>>
>>>>>> People that are not dumber than a box of rocks will understand
>>>>>> that the above is necessarily correct.
>>>>>>
>>>>>
>>>>> Yes, if it CAN correcly simulate enough states of its input to
>>>>> correctly detect an infinite behavior.
>>>>>
>>>>> The problem is that this is not guaranteed to exist. So you are
>>>>> just beleiving in Fairy Dust Powered Unicorns to perform their magic.
>>>>>
>>>>
>>>> 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⟩...
>>>>
>>>> You acknowledged that the above sequence proves proves infinite
>>>> behavior. Thus you can I can both see that a transition to Ĥ.qn
>>>> would be correct.
>>>>
>>>
>>> It is ONLY an infinite sequence if NO embedded_H abort there
>>> simulations,
>>
>> This is the part where the label of BRAIN DEAD MORON applies to you.
>> As long as embedded_H correctly determines that its simulated input
>> ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its final state embedded_H can correctly
>> reject this input.
>>
>
> Right, but it hasn't done that, and you seem to be too dumb to
> understand why. It has (incorrectly) assumed that the copy of embedded_H
> within all the simulated H^s will NEVER abort their simulations, which
> they WILL do if we actually ran them, just like this one is going to do.
>
> FALSE PREMISE, UNSOUND LOGIG, WRONG ANSWER.
>
>
>> Since we can see that the simulated input to embedded_H cannot
>> possibly reach its final state after three invocations that means that
>> if embedded_H transitions to Ĥ.qn after three invocations then we know
>> it would be correct.
>>
>
> No, because when it does that, it breaks its assumption that the
> embedded_H in H^s will never abort their simulations. It failed to
> notice THEIR abort counter counting.
>
> You forgert that ALL copies of a given Turing Machine, given the same
> input, will do the same thing.
>

olcott <NoOne@nowhere.com> wrote:
> On 3/20/2022 9:17 AM, olcott wrote:
>> On 3/20/2022 6:07 AM, Richard Damon wrote:

[ .... ]

>> It is not possible that the copy of embedded_H will abort its simulation
>> because the simulation is not aborted until the minimum abort criteria
>> is met and the outermost embedded_H sees more of the execution trace
>> than any copy.

>>> It failed to notice THEIR abort counter counting.

>>> You forget that ALL copies of a given Turing Machine, given the same
>>> input, will do the same thing.

> They are at different levels of recursive invocation thus the outermost
> one sees the abort criteria first and then aborts all the rest.

Thus incorrectly aborting them. They are terminating computations, since
had the outermost level not aborted them, they would have reached a
terminating state (i.e., when the next level aborted). So it is wrong to
abort them and declare that they are non-halting.

Can we not end this fruitless discussion now? There is no halting
detector program, and there cannot be one. We know that.

> --
> 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/20/2022 10:01 AM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>> On 3/20/2022 9:17 AM, olcott wrote:
>>> On 3/20/2022 6:07 AM, Richard Damon wrote:
>
> [ .... ]
>
>>> It is not possible that the copy of embedded_H will abort its simulation
>>> because the simulation is not aborted until the minimum abort criteria
>>> is met and the outermost embedded_H sees more of the execution trace
>>> than any copy.
>
>>>> It failed to notice THEIR abort counter counting.
>
>>>> You forget that ALL copies of a given Turing Machine, given the same
>>>> input, will do the same thing.
>
>> They are at different levels of recursive invocation thus the outermost
>> one sees the abort criteria first and then aborts all the rest.
>
> Thus incorrectly aborting them. They are terminating computations, since
> had the outermost level not aborted them, they would have reached a
> terminating state (i.e., when the next level aborted). So it is wrong to
> abort them and declare that they are non-halting.
>
> Can we not end this fruitless discussion now? There is no halting
> detector program, and there cannot be one. We know that.
>

This is my legacy before I die of cancer.

When-so-ever any simulating halt decider must abort the simulation of
its input to prevent the infinite simulation of the input it always
correctly rejects this input as non-halting.

Just like with infinite recursion when any of the recursive invocations
is terminated the whole chain stops running. As long as at least one of
these invocations must be aborted then the whole recursive chain was
infinitely recursive.

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

olcott <NoOne@nowhere.com> wrote:
> On 3/20/2022 10:01 AM, Alan Mackenzie wrote:
>> olcott <NoOne@nowhere.com> wrote:
>>> On 3/20/2022 9:17 AM, olcott wrote:
>>>> On 3/20/2022 6:07 AM, Richard Damon wrote:

>> [ .... ]

>>>> It is not possible that the copy of embedded_H will abort its simulation
>>>> because the simulation is not aborted until the minimum abort criteria
>>>> is met and the outermost embedded_H sees more of the execution trace
>>>> than any copy.

>>>>> It failed to notice THEIR abort counter counting.

>>>>> You forget that ALL copies of a given Turing Machine, given the same
>>>>> input, will do the same thing.

>>> They are at different levels of recursive invocation thus the outermost
>>> one sees the abort criteria first and then aborts all the rest.

>> Thus incorrectly aborting them. They are terminating computations, since
>> had the outermost level not aborted them, they would have reached a
>> terminating state (i.e., when the next level aborted). So it is wrong to
>> abort them and declare that they are non-halting.

>> Can we not end this fruitless discussion now? There is no halting
>> detector program, and there cannot be one. We know that.

> This is my legacy before I die of cancer.

> When-so-ever any simulating halt decider must abort the simulation of
> its input to prevent the infinite simulation of the input it always
> correctly rejects this input as non-halting.

This isn't the situation here. The purported halt decider DOESN'T need
to abort its target, since that target would have terminated of its own
accord. So the purported halt decider falsely categorises its target as
non-halting.

> Just like with infinite recursion when any of the recursive invocations
> is terminated the whole chain stops running. As long as at least one of
> these invocations must be aborted then the whole recursive chain was
> infinitely recursive.

There's no "must" here. The abortion is unnecessary, since the
apparently infinite chain would stop on its own, without the outermost
level aborting it.

> --
> Copyright 2021 Pete Olcott

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

--
Alan Mackenzie (Nuremberg, Germany).

On 3/20/2022 10:50 AM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>> On 3/20/2022 10:01 AM, Alan Mackenzie wrote:
>>> olcott <NoOne@nowhere.com> wrote:
>>>> On 3/20/2022 9:17 AM, olcott wrote:
>>>>> On 3/20/2022 6:07 AM, Richard Damon wrote:
>
>>> [ .... ]
>
>>>>> It is not possible that the copy of embedded_H will abort its simulation
>>>>> because the simulation is not aborted until the minimum abort criteria
>>>>> is met and the outermost embedded_H sees more of the execution trace
>>>>> than any copy.
>
>>>>>> It failed to notice THEIR abort counter counting.
>
>>>>>> You forget that ALL copies of a given Turing Machine, given the same
>>>>>> input, will do the same thing.
>
>>>> They are at different levels of recursive invocation thus the outermost
>>>> one sees the abort criteria first and then aborts all the rest.
>
>>> Thus incorrectly aborting them. They are terminating computations, since
>>> had the outermost level not aborted them, they would have reached a
>>> terminating state (i.e., when the next level aborted). So it is wrong to
>>> abort them and declare that they are non-halting.
>
>>> Can we not end this fruitless discussion now? There is no halting
>>> detector program, and there cannot be one. We know that.
>
>
>> This is my legacy before I die of cancer.
>
>> When-so-ever any simulating halt decider must abort the simulation of
>> its input to prevent the infinite simulation of the input it always
>> correctly rejects this input as non-halting.
>
> This isn't the situation here. The purported halt decider DOESN'T need
> to abort its target, since that target would have terminated of its own
> accord.

I have been through this dozens of times.
There is nothing that you can say that is a correct rebuttal.

Unless at least one of the instances of embedded_H aborts its simulation
the simulation never stops.

> So the purported halt decider falsely categorises its target as
> non-halting.
>
>> Just like with infinite recursion when any of the recursive invocations
>> is terminated the whole chain stops running. As long as at least one of
>> these invocations must be aborted then the whole recursive chain was
>> infinitely recursive.
>
> There's no "must" here. The abortion is unnecessary, since the
> apparently infinite chain would stop on its own, without the outermost
> level aborting it.
>
>> --
>> Copyright 2021 Pete Olcott
>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>

--
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/20/22 10:17 AM, olcott wrote:
> On 3/20/2022 6:07 AM, Richard Damon wrote:
>> On 3/19/22 10:17 PM, olcott wrote:
>>> On 3/19/2022 8:50 PM, Richard Damon wrote:
>>>> On 3/19/22 9:31 PM, olcott wrote:
>>>>> On 3/19/2022 8:25 PM, Richard Damon wrote:
>>>>>> On 3/19/22 9:12 PM, olcott wrote:
>>>>>>> On 3/19/2022 8:04 PM, Richard Damon wrote:
>>>>>>>> On 3/19/22 8:51 PM, olcott wrote:
>>>>>>>>> On 3/19/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 3/19/22 8:24 PM, olcott wrote:
>>>>>>>>>>> On 3/19/2022 7:20 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/19/22 8:00 PM, olcott wrote:
>>>>>>>>>>>>> On 3/19/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/19/22 7:47 PM, olcott wrote:
>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When a halt decider bases its halt status decision on the
>>>>>>>>>>>>>>> behavior of its simulated input then all of the
>>>>>>>>>>>>>>> conventional halting problem counter example inputs would
>>>>>>>>>>>>>>> be determined to be non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>> never reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *By these two principles this proof is validated*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (1) A halt decider (because it is a decider) must report
>>>>>>>>>>>>>>> on the behavior specified by its finite string input. A
>>>>>>>>>>>>>>> decider computes the mapping from its input finite
>>>>>>>>>>>>>>> strings to an accept or reject state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>>>>> behavior of this input when it is correctly simulated by
>>>>>>>>>>>>>>> its simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key point that that everyone (including Peter Linz)
>>>>>>>>>>>>>>> has an impossibly difficult time with is that embedded_H
>>>>>>>>>>>>>>> can correctly transition to Ĥ.qn indicting that its input
>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everyone (including Peter Linz) incorrectly believes that
>>>>>>>>>>>>>>> this is contradictory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everyone assumes the the behavior of the executed Ĥ
>>>>>>>>>>>>>>> applied ⟨Ĥ⟩ must be the same as the input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> simulated by embedded_H or it is wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can easily verify that the correct behavior of Ĥ
>>>>>>>>>>>>>>> applied ⟨Ĥ⟩ is not the same as the correct behavior as
>>>>>>>>>>>>>>> the input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No one ever bothers to do this because of their deep
>>>>>>>>>>>>>>> religious conviction that they must either be the same or
>>>>>>>>>>>>>>> be incorrect.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just more of your Fairy Dust Powered Unicorns that do
>>>>>>>>>>>>>> magic to make imppssible things happen.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just more UNSOUND LOGIC.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you paid very close attention as if the salvation of
>>>>>>>>>>>>> your soul depended on the accuracy of your evaluation you
>>>>>>>>>>>>> would see that I have been correct all along.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, you logic in NONSENSE, you assert things without any
>>>>>>>>>>>> evidence.
>>>>>>>>>>>>
>>>>>>>>>>> I prove my point and you skip over the proof because you only
>>>>>>>>>>> want to play head games.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Really??
>>>>>>>>>>
>>>>>>>>>> One BIG lile is:
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>> behavior of this input when it is correctly simulated by its
>>>>>>>>>>> simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>
>>>>>>>>>> Because your SHD can't actually correctly simulate as a UTM
>>>>>>>>>> and abort it simulation at the same time.
>>>>>>>>>>
>>>>>>>>> That is like saying that a car cannot run because it cannot run
>>>>>>>>> and stop running at the same time.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, just shows you still don't understand what a UTM is.
>>>>>>>>
>>>>>>>
>>>>>>> As long as the SHD can correctly simulate enough steps of its
>>>>>>> input to correctly detect an infinite behavior pattern then it
>>>>>>> can correctly reject its input on this basis because that means
>>>>>>> that the simulated input cannot possibly ever reach its own final
>>>>>>> state which conclusively proves that it specifies a non-halting
>>>>>>> sequence of configurations.
>>>>>>>
>>>>>>> People that are not dumber than a box of rocks will understand
>>>>>>> that the above is necessarily correct.
>>>>>>>
>>>>>>
>>>>>> Yes, if it CAN correcly simulate enough states of its input to
>>>>>> correctly detect an infinite behavior.
>>>>>>
>>>>>> The problem is that this is not guaranteed to exist. So you are
>>>>>> just beleiving in Fairy Dust Powered Unicorns to perform their magic.
>>>>>>
>>>>>
>>>>> 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⟩...
>>>>>
>>>>> You acknowledged that the above sequence proves proves infinite
>>>>> behavior. Thus you can I can both see that a transition to Ĥ.qn
>>>>> would be correct.
>>>>>
>>>>
>>>> It is ONLY an infinite sequence if NO embedded_H abort there
>>>> simulations,
>>>
>>> This is the part where the label of BRAIN DEAD MORON applies to you.
>>> As long as embedded_H correctly determines that its simulated input
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its final state embedded_H can
>>> correctly reject this input.
>>>
>>
>> Right, but it hasn't done that, and you seem to be too dumb to
>> understand why. It has (incorrectly) assumed that the copy of
>> embedded_H within all the simulated H^s will NEVER abort their
>> simulations,
>
> It is not possible that the copy of embedded_H will abort its simulation
> because the simulation is not aborted until the minimum abort criteria
> is met and the outermost embedded_H sees more of the execution trace
> than any copy.

On 3/20/22 10:24 AM, olcott wrote:
> On 3/20/2022 9:17 AM, olcott wrote:
>> On 3/20/2022 6:07 AM, Richard Damon wrote:
>>> On 3/19/22 10:17 PM, olcott wrote:
>>>> On 3/19/2022 8:50 PM, Richard Damon wrote:
>>>>> On 3/19/22 9:31 PM, olcott wrote:
>>>>>> On 3/19/2022 8:25 PM, Richard Damon wrote:
>>>>>>> On 3/19/22 9:12 PM, olcott wrote:
>>>>>>>> On 3/19/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>> On 3/19/22 8:51 PM, olcott wrote:
>>>>>>>>>> On 3/19/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 3/19/22 8:24 PM, olcott wrote:
>>>>>>>>>>>> On 3/19/2022 7:20 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/19/22 8:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/19/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/19/22 7:47 PM, olcott wrote:
>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When a halt decider bases its halt status decision on
>>>>>>>>>>>>>>>> the behavior of its simulated input then all of the
>>>>>>>>>>>>>>>> conventional halting problem counter example inputs
>>>>>>>>>>>>>>>> would be determined to be non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating
>>>>>>>>>>>>>>>> halt decider (SHD).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> never reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *By these two principles this proof is validated*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) A halt decider (because it is a decider) must report
>>>>>>>>>>>>>>>> on the behavior specified by its finite string input. A
>>>>>>>>>>>>>>>> decider computes the mapping from its input finite
>>>>>>>>>>>>>>>> strings to an accept or reject state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>>>>>> behavior of this input when it is correctly simulated by
>>>>>>>>>>>>>>>> its simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The key point that that everyone (including Peter Linz)
>>>>>>>>>>>>>>>> has an impossibly difficult time with is that embedded_H
>>>>>>>>>>>>>>>> can correctly transition to Ĥ.qn indicting that its
>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Everyone (including Peter Linz) incorrectly believes
>>>>>>>>>>>>>>>> that this is contradictory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Everyone assumes the the behavior of the executed Ĥ
>>>>>>>>>>>>>>>> applied ⟨Ĥ⟩ must be the same as the input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> simulated by embedded_H or it is wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We can easily verify that the correct behavior of Ĥ
>>>>>>>>>>>>>>>> applied ⟨Ĥ⟩ is not the same as the correct behavior as
>>>>>>>>>>>>>>>> the input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No one ever bothers to do this because of their deep
>>>>>>>>>>>>>>>> religious conviction that they must either be the same
>>>>>>>>>>>>>>>> or be incorrect.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just more of your Fairy Dust Powered Unicorns that do
>>>>>>>>>>>>>>> magic to make imppssible things happen.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just more UNSOUND LOGIC.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you paid very close attention as if the salvation of
>>>>>>>>>>>>>> your soul depended on the accuracy of your evaluation you
>>>>>>>>>>>>>> would see that I have been correct all along.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, you logic in NONSENSE, you assert things without any
>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>
>>>>>>>>>>>> I prove my point and you skip over the proof because you
>>>>>>>>>>>> only want to play head games.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Really??
>>>>>>>>>>>
>>>>>>>>>>> One BIG lile is:
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> (2) The behavior specified by this input is the actual
>>>>>>>>>>>> behavior of this input when it is correctly simulated by its
>>>>>>>>>>>> simulating halt decider (SHD) that contains a full UTM.
>>>>>>>>>>>
>>>>>>>>>>> Because your SHD can't actually correctly simulate as a UTM
>>>>>>>>>>> and abort it simulation at the same time.
>>>>>>>>>>>
>>>>>>>>>> That is like saying that a car cannot run because it cannot
>>>>>>>>>> run and stop running at the same time.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, just shows you still don't understand what a UTM is.
>>>>>>>>>
>>>>>>>>
>>>>>>>> As long as the SHD can correctly simulate enough steps of its
>>>>>>>> input to correctly detect an infinite behavior pattern then it
>>>>>>>> can correctly reject its input on this basis because that means
>>>>>>>> that the simulated input cannot possibly ever reach its own
>>>>>>>> final state which conclusively proves that it specifies a
>>>>>>>> non-halting sequence of configurations.
>>>>>>>>
>>>>>>>> People that are not dumber than a box of rocks will understand
>>>>>>>> that the above is necessarily correct.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, if it CAN correcly simulate enough states of its input to
>>>>>>> correctly detect an infinite behavior.
>>>>>>>
>>>>>>> The problem is that this is not guaranteed to exist. So you are
>>>>>>> just beleiving in Fairy Dust Powered Unicorns to perform their
>>>>>>> magic.
>>>>>>>
>>>>>>
>>>>>> 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⟩...
>>>>>>
>>>>>> You acknowledged that the above sequence proves proves infinite
>>>>>> behavior. Thus you can I can both see that a transition to Ĥ.qn
>>>>>> would be correct.
>>>>>>
>>>>>
>>>>> It is ONLY an infinite sequence if NO embedded_H abort there
>>>>> simulations,
>>>>
>>>> This is the part where the label of BRAIN DEAD MORON applies to you.
>>>> As long as embedded_H correctly determines that its simulated input
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its final state embedded_H can
>>>> correctly reject this input.
>>>>
>>>
>>> Right, but it hasn't done that, and you seem to be too dumb to
>>> understand why. It has (incorrectly) assumed that the copy of
>>> embedded_H within all the simulated H^s will NEVER abort their
>>> simulations,
>>
>> It is not possible that the copy of embedded_H will abort its
>> simulation because the simulation is not aborted until the minimum
>> abort criteria is met and the outermost embedded_H sees more of the
>> execution trace than any copy.
>>
>> It is known that every PHD will always abort its simulation whenever it
>
> It is known that every SHD will always abort its simulation whenever it
>
>> correctly determines that its simulated input will never reach its
>> final state.
>>
>>> which they WILL do if we actually ran them, just like this one is
>>> going to do.
>>>
>>> FALSE PREMISE, UNSOUND LOGIG, WRONG ANSWER.
>>>
>>>
>>>> Since we can see that the simulated input to embedded_H cannot
>>>> possibly reach its final state after three invocations that means
>>>> that if embedded_H transitions to Ĥ.qn after three invocations then
>>>> we know it would be correct.
>>>>
>>>
>>> No, because when it does that, it breaks its assumption that the
>>> embedded_H in H^s will never abort their simulations.
>>
>> The is the most stupid thing that you ever said. It is axiomatically
>> known that all PHDs will always abort the simulation of their input as
>> soon as they detect that this simulated input would not otherwise stop
>> running.
>>
>>> It failed to notice THEIR abort counter counting.
>>>
>>> You forgert that ALL copies of a given Turing Machine, given the same
>>> input, will do the same thing.
>>>
>
> They are at different levels of recursive invocation thus the outermost
> one sees the abort criteria first and then aborts all the rest.
>
>

On 3/20/22 11:20 AM, olcott wrote:
> On 3/20/2022 10:01 AM, Alan Mackenzie wrote:
>> olcott <NoOne@nowhere.com> wrote:
>>> On 3/20/2022 9:17 AM, olcott wrote:
>>>> On 3/20/2022 6:07 AM, Richard Damon wrote:
>>
>> [ .... ]
>>
>>>> It is not possible that the copy of embedded_H will abort its
>>>> simulation
>>>> because the simulation is not aborted until the minimum abort criteria
>>>> is met and the outermost embedded_H sees more of the execution trace
>>>> than any copy.
>>
>>>>> It failed to notice THEIR abort counter counting.
>>
>>>>> You forget that ALL copies of a given Turing Machine, given the same
>>>>> input, will do the same thing.
>>
>>> They are at different levels of recursive invocation thus the outermost
>>> one sees the abort criteria first and then aborts all the rest.
>>
>> Thus incorrectly aborting them.  They are terminating computations, since
>> had the outermost level not aborted them, they would have reached a
>> terminating state (i.e., when the next level aborted).  So it is wrong to
>> abort them and declare that they are non-halting.
>>
>> Can we not end this fruitless discussion now?  There is no halting
>> detector program, and there cannot be one.  We know that.
>>
>
> This is my legacy before I die of cancer.
>
> When-so-ever any simulating halt decider must abort the simulation of
> its input to prevent the infinite simulation of the input it always
> correctly rejects this input as non-halting.

Yep, that will be your legacy, you will be know for the FALSE THEOREM
you have proposed.

>
> Just like with infinite recursion when any of the recursive invocations
> is terminated the whole chain stops running. As long as at least one of
> these invocations must be aborted then the whole recursive chain was
> infinitely recursive.
>

Right, the SIMULATIONS were all aborted, but the actual machine is not,
and it HALTS.

FAIL.

RIP.

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