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

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

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.

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

You deny the essence of Truth (It is NOT 'Proof')

I would suggest YOU give thought about the salvation of your soul.

Do YOU believe in the one True God, do YOU believe in his promises.

You can not actually PROVE that God exists, so with your mindset, you
deny that he is a Truth. If you deny that he exists, he will not
acknowledge you in the judgement.

It appears that you have condemned youself to spend your eternity
working on these erroneous proofs to show that 'given enough time' your
decider can come up with the right answer, which it can't

Your words are filled with LIES, because you reject the actual
definitions, just because you don't like them, or maybe because you just
refuse to learn them. But those that reject Truth have no place with THE
Truth.

Truth has a source, but it isn't the workings of Man. Your instance on
Proof being supreme makes it a FALSE GOD.

You have become a DAMNED LIAR (I think LITERALLY)

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.

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

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

--
Ben.

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.

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

BY DEFINITION, a UTM generates EXACTLY the same behavior as the machine
it is simulating the description of, which means that UTM of a
non-halting machine must be non-halting, thus IF H actually did a real
UTM, it could never abort its simulation.

And once it does abort its simulation, it no longer has 'proof' that the
machine it was simulating was non-halting, only that it isn't halting in
less than a SPECIFIC finite N. It could be Halting with a number of
steps greater than N (as H^ applied to <H^> is)

Then you make the statement:

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

which is irrelevent, because the definition isn't that the SHD can
simulate to the final state, it is that the machihe actually reaches a
final state, and if H -> Qn then H^ also goes to Qn and Halts.

You then make a number of silly errors about deciders not needing to
decide on themselves, since what they need to decide on it their input,
and that input CAN contain copies of themselves, and thus they might
need to actual decide on something that they do.

Then you make the silly comment about embedded_H 'changing' its
behavior. Turing Machins can do no such thing. The HAVE a behavior that
is defined an dependent on their input, but they can never 'change' that.

The embedded_H that is part of H^ has exactly the same behavior as the
embedded_H that is deciding on <H^> <H^>, and will do EXACTLY the same
thing,

This is a FUNDAMENTAL property of Computations.

If you want to claim differently, PROVIDE AN ACTUAL EXAMPLE.

DETAIL in code. Not just handwaving that it can be different.

This is you biggest Fairy Dust Powered Unicorn performing Magic to make
the impossible happen.

You embedded_H is NOT your actual decider, (and thus neither is H) but
you seem to presume some 'God' over the machine that gives it the right
answer that it won't tell the other copy. This is NOT valid.
FAIL.

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.

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

YOU just make 'religous' arguments that it MUST be right because it is
the only thing that makes sense to you, no matter how many 'rules' you
need to break.

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.

> YOU just make 'religous' arguments that it MUST be right because it is
> the only thing that makes sense to you, no matter how many 'rules' you
> need to break.
>
>

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

The simulation by your SHD is proved incorrect as it gives the wrong
behavior for the simulation of <H^> <H^> when it is compared to H^
applied to >H^>

BY DEFINITION of a UTM, they both must agree.

If H <H^> <H^> -> Qn, then it is trivial to show that H^ applied to <H^>
Halts, and you have even agreed to this, and thus, BY DEFINITION, the
'CORRECT' simulation of <H^> <H^> must indicate HALTING.

Since your SHD indicates otherwise, it MUST BE WRONG.

DEFINITION.

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 (it matters what the
actual machine does, not what the (partial) simulation by the Halt
Decider shows.

It then needs to continue with sound logic and not do errors like assume
that the copy of H inside H^ behaves differently than the copy of H
doing the deciding, which is impossible.

In other words, you don't have a sound proof, but just some idiotic
ramblings that you try to makes sound sort of presentable with fancy words.

>
>> YOU just make 'religous' arguments that it MUST be right because it is
>> the only thing that makes sense to you, no matter how many 'rules' you
>> need to break.
>>
>>
>
>

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.

--
Copyright 2021 Pete Olcott

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

On 3/19/2022 8: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.

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

Because of the 'recursive' relationship of H^ and H, there is NO finite
pattern in the simulation of <H^> <H^> that conclusively proves that it
is non-halting. Any such pattern that is added to H causes the H^ that
is based on this H to be halting, and thus the pattern is incorrect.

I have proved this before, but guess it was above your head or your
lying heart blinded you to its truth,

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.

You change the meaning to the deciders simulation, which is NOT a
correct transformation.

H^ applied to <H^> does halt if H applied to <H^> <H^> goes to Qn so
that answer MUST be incorrect, since the mapping (for an actual Halting
Decider) of the input <H^> <H^> is based on the Computation H applied
to <H^> BY DEFINITION.

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.

--
Copyright 2021 Pete Olcott

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

On 3/19/2022 8: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.

--
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 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, and thus NO H ever gives the non-halting answer it might
have figured out and just DIES with the knowledge and is thus still WRONG.

Once embedded_H aborts its simulation and goes to Qn then the top level
H^ applied to <H^> also goes to H^.Qn and HALTS.

Since the DEFINITION of Halting is based on the ACTUAL TURING MACHINE
and that is what a ACTUAL HALTING DECIDER needs to answer on, H is just
wrong.

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.

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

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?

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

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

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.

--
Copyright 2021 Pete Olcott

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