A SHD computes the mapping from its input to its own accept or reject
state based on whether or not the pure simulation of its simulated input
could reach its own final state in a finite number of simulated steps.

The following simplifies the syntax for the definition of the Linz
Turing machine Ĥ, it is now a single machine with a single start state.
A copy of Linz H is embedded at Ĥ.qx

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

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

The above shows that the simulated input to embedded_H never reaches its
own final state whether or not its simulation is aborted.
(a) If the simulation is not aborted the above sequence never ends.
(b) If the simulation is aborted the entire chain of recursive
simulations immediately stops.

In no case does the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ ever reach its final state
⟨Ĥ⟩.qn thus never meets the Linz definition of halting:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234) Thus if embedded_H rejects its input it
is necessarily correct.

Because all halt deciders are deciders they compute the mapping from
their input finite strings inputs to their own accept or reject state.
Halt deciders (because they are deciders) do not compute any mappings
from non-finite string non-inputs.

No halt decider ever determines the halt status of the computation that
contains its actual self thus embedded_H does not compute the mapping
from Ĥ ⟨Ĥ⟩ because it is neither an input nor a finite string.

Even Linz was confused by this. embedded_H is not supposed to report on
itself or the computation that it is contained within.

Halting problem undecidability and infinitely nested simulation (V4)

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/25/2022 3:29 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> A SHD computes the mapping from its input to its own accept or reject
>> state based on whether or not the pure simulation of its simulated
>> input could reach its own final state in a finite number of simulated
>> steps.
>>
>> The following simplifies the syntax for the definition of the Linz
>> Turing machine Ĥ, it is now a single machine with a single start
>> state. A copy of Linz H is embedded at Ĥ.qx
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>
> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.
>

No it turns out to be the case that a halt decider is not allowed to
report on its own behavior because itself is neither an input nor a
finite string. Deciders must compute the mapping from their input finite
strings to an accept or reject state.

>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>
> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ does not halt.
>

No it turns out to be the case that a halt decider is not allowed to
report on its own behavior because itself is neither an input nor a
finite string. Deciders must compute the mapping from their input finite
strings to an accept or reject state.

>> 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⟩...
>
> The ... is wrong for any Ĥ that meets Linz's definitions. You can talk
> about a TM that acts like this, but since it's not what Linz is talking
> about any conclusions you draw don't apply the proof.
>

Linz merely doesn't bother to notice what happens when H is a simulating
halt decider.

--
Copyright 2022 Pete Olcott

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

On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> A SHD computes the mapping from its input to its own accept or reject
>> state based on whether or not the pure simulation of its simulated
>> input could reach its own final state in a finite number of simulated
>> steps.
>>
>> The following simplifies the syntax for the definition of the Linz
>> Turing machine Ĥ, it is now a single machine with a single start
>> state. A copy of Linz H is embedded at Ĥ.qx
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>
> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>
> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ does not halt.
>
>> 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⟩...
>
> The ... is wrong for any Ĥ that meets Linz's definitions. You can talk
> about a TM that acts like this, but since it's not what Linz is talking
> about any conclusions you draw don't apply the proof.
>

Even Richard understands that unless embedded_H aborts its simulation of
its input: ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulation never stops.

What Richard get get wrong:
He believes that aborting the simulation of the input causes this
aborted input to reach its final state.

--
Copyright 2022 Pete Olcott

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

On 3/25/2022 9:03 PM, Richard Damon wrote:
> On 3/25/22 9:47 PM, olcott wrote:
>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> A SHD computes the mapping from its input to its own accept or reject
>>>> state based on whether or not the pure simulation of its simulated
>>>> input could reach its own final state in a finite number of simulated
>>>> steps.
>>>>
>>>> The following simplifies the syntax for the definition of the Linz
>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>>> state.
>>>
>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>> final state.
>>>
>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ does not
>>> halt.
>>>
>>>> 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⟩...
>>>
>>> The ... is wrong for any Ĥ that meets Linz's definitions.  You can talk
>>> about a TM that acts like this, but since it's not what Linz is talking
>>> about any conclusions you draw don't apply the proof.
>>>
>>
>> Even Richard understands that unless embedded_H aborts its simulation
>> of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulation never stops.
>>
>> What Richard get get wrong:
>> He believes that aborting the simulation of the input causes this
>> aborted input to reach its final state.
>>
>
> It isn't 'this simulation' that reaches the final state, it is the
> CORRECT simulation that reaches the final state. Nobody (but you) cares
> about the results of an aborted simulation by H,

If the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its own final state
then the simulated input (by definition) specifies a non-halting
sequence of configurations.

--
Copyright 2022 Pete Olcott

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

On 3/25/2022 9:24 PM, Richard Damon wrote:
> On 3/25/22 10:07 PM, olcott wrote:
>> On 3/25/2022 9:03 PM, Richard Damon wrote:
>>> On 3/25/22 9:47 PM, olcott wrote:
>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A SHD computes the mapping from its input to its own accept or reject
>>>>>> state based on whether or not the pure simulation of its simulated
>>>>>> input could reach its own final state in a finite number of simulated
>>>>>> steps.
>>>>>>
>>>>>> The following simplifies the syntax for the definition of the Linz
>>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>>>>> state.
>>>>>
>>>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>> final state.
>>>>>
>>>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ does not
>>>>> halt.
>>>>>
>>>>>> 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⟩...
>>>>>
>>>>> The ... is wrong for any Ĥ that meets Linz's definitions.  You can
>>>>> talk
>>>>> about a TM that acts like this, but since it's not what Linz is
>>>>> talking
>>>>> about any conclusions you draw don't apply the proof.
>>>>>
>>>>
>>>> Even Richard understands that unless embedded_H aborts its
>>>> simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulation never stops.
>>>>
>>>> What Richard get get wrong:
>>>> He believes that aborting the simulation of the input causes this
>>>> aborted input to reach its final state.
>>>>
>>>
>>> It isn't 'this simulation' that reaches the final state, it is the
>>> CORRECT simulation that reaches the final state. Nobody (but you)
>>> cares about the results of an aborted simulation by H,
>>
>> If the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its own final
>> state then the simulated input (by definition) specifies a non-halting
>> sequence of configurations.
>>
>>
>
> The CORRECT simulation reaches the final state.
We are not talking about the simulation NITWIT!
We are talking about the simulated input !!!

When the entire recursive simulation chain is aborted
IT DOES NOT KEEP RUNNING NITWIT !!!

--
Copyright 2022 Pete Olcott

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

On 3/26/2022 8:24 AM, Richard Damon wrote:
>
> On 3/26/22 9:14 AM, olcott wrote:
>> On 3/26/2022 8:11 AM, Richard Damon wrote:
>>> On 3/26/22 9:04 AM, olcott wrote:
>>>> On 3/26/2022 5:18 AM, Richard Damon wrote:
>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>> On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> A SHD computes the mapping from its input to its own accept or
>>>>>>>>>> reject
>>>>>>>>>> state based on whether or not the pure simulation of its
>>>>>>>>>> simulated
>>>>>>>>>> input could reach its own final state in a finite number of
>>>>>>>>>> simulated
>>>>>>>>>> steps.
>>>>>>>>>>
>>>>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>>>>> Linz
>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>> its final
>>>>>>>>>> state.
>>>>>>>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>>
>>>>>>>> No it turns out to be the case that a halt decider is not
>>>>>>>> allowed to
>>>>>>>> report on its own behavior because itself is neither an input nor a
>>>>>>>> finite string.
>>>>>>>
>>>>>>> No.  Happy to answer questions about why this is wrong, but since
>>>>>>> you
>>>>>>> have not grasped what a halt decider is after 17 years, I don't
>>>>>>> think
>>>>>>> it's worth my while just writing it out yet again.
>>>>>>>
>>>>>>
>>>>>> You are agreed that a decider maps its input finite string input
>>>>>> to an accept or reject state.
>>>>>>
>>>>>> Now you are contradicting yourself by saying that a decider maps a
>>>>>> non-input non-finite string.
>>>>>>
>>>>>
>>>>> Nope, what it is mapping is the input <H^> <H^> which most
>>>>> definitely IS a finite string input.
>>>>>
>>>>> It is to map it to Qy (accept) or Qn (reject) based on if the
>>>>> machine H^   applied to <H^> Halts.
>>>>>
>>>>> The fact tha H^ applied to <H^> isn't exactly an input if fine,
>>>>
>>>> I am looking for white dogs in my kitchen by looking for black cats
>>>> in my living room.
>>>>
>>>
>>> Yes, EXACTLY. YOU ARE. This is because you aren't using the right
>>> definition of HALTING. (Halting is the white dog, your POOP is the
>>> black cats).
>>>
>>> Halting is DEFINED based on the behavoir of the TURING MACHINE that
>>> the input represents, NOT a simulation of the input by the decider.
>>
>> The only correct halt status criteria for a simulating halt decider is
>> whether or not the simulated input can possibly reach its own final
>> state. Every distraction away from this point is a dishonest dodge.
>>
>> The only correct halt status criteria for a simulating halt decider is
>> whether or not the simulated input can possibly reach its own final
>> state. Every distraction away from this point is a dishonest dodge.
>>
>> The only correct halt status criteria for a simulating halt decider is
>> whether or not the simulated input can possibly reach its own final
>> state. Every distraction away from this point is a dishonest dodge.
>>
>> The only correct halt status criteria for a simulating halt decider is
>> whether or not the simulated input can possibly reach its own final
>> state. Every distraction away from this point is a dishonest dodge.
>>
>
> Nope. THE DEFINITION of the right answer is what the ACTUAL TURING
> MACHINE the input represents does.
>

The actual behavior of the actual simulated input it what counts.

Your misunderstanding is the misunderstanding by someone that learns by
rote instead of having a deep understanding.

The only reason the term "represents" is used is because a Turing
machine description does not have any behavior unless it is simulated.

We cannot make the criteria the behavior of the Turing machine
description because it is only a finite string without behavior.

We can refer to the behavior that the finite string "represents",
"specifies" or we can simply say the behavior of the simulated finite
string. They all get around the fact that the finite string itself has
no behavior.

What we cannot do is refer to behavior that differs from the behavior of
the simulated finite string.

To make sure that we do not refer to behavior that differs from the
behavior of the simulated finite string we merely directly refer to the
behavior of the simulated finite string.

> Anything else, that isn't PROVABLY EXACTLY THE SAME, is WRONG.
>
> This is the plain meaning of the words.
>
> Your use of something different just PROVES that you whole arguement is
> a LIE.
>
> Your repeating it 4 times, just shows your maturing it that of a Toddler.
>
> FAIL.

--
Copyright 2022 Pete Olcott

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

On 3/26/2022 8:55 AM, Richard Damon wrote:
> On 3/26/22 9:44 AM, olcott wrote:
>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>
>>> On 3/26/22 9:14 AM, olcott wrote:
>>>> On 3/26/2022 8:11 AM, Richard Damon wrote:
>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>> On 3/26/2022 5:18 AM, Richard Damon wrote:
>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>> On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> A SHD computes the mapping from its input to its own accept
>>>>>>>>>>>> or reject
>>>>>>>>>>>> state based on whether or not the pure simulation of its
>>>>>>>>>>>> simulated
>>>>>>>>>>>> input could reach its own final state in a finite number of
>>>>>>>>>>>> simulated
>>>>>>>>>>>> steps.
>>>>>>>>>>>>
>>>>>>>>>>>> The following simplifies the syntax for the definition of
>>>>>>>>>>>> the Linz
>>>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a single
>>>>>>>>>>>> start
>>>>>>>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>> its final
>>>>>>>>>>>> state.
>>>>>>>>>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>> halts.
>>>>>>>>>>
>>>>>>>>>> No it turns out to be the case that a halt decider is not
>>>>>>>>>> allowed to
>>>>>>>>>> report on its own behavior because itself is neither an input
>>>>>>>>>> nor a
>>>>>>>>>> finite string.
>>>>>>>>>
>>>>>>>>> No.  Happy to answer questions about why this is wrong, but
>>>>>>>>> since you
>>>>>>>>> have not grasped what a halt decider is after 17 years, I don't
>>>>>>>>> think
>>>>>>>>> it's worth my while just writing it out yet again.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You are agreed that a decider maps its input finite string input
>>>>>>>> to an accept or reject state.
>>>>>>>>
>>>>>>>> Now you are contradicting yourself by saying that a decider maps
>>>>>>>> a non-input non-finite string.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, what it is mapping is the input <H^> <H^> which most
>>>>>>> definitely IS a finite string input.
>>>>>>>
>>>>>>> It is to map it to Qy (accept) or Qn (reject) based on if the
>>>>>>> machine H^   applied to <H^> Halts.
>>>>>>>
>>>>>>> The fact tha H^ applied to <H^> isn't exactly an input if fine,
>>>>>>
>>>>>> I am looking for white dogs in my kitchen by looking for black
>>>>>> cats in my living room.
>>>>>>
>>>>>
>>>>> Yes, EXACTLY. YOU ARE. This is because you aren't using the right
>>>>> definition of HALTING. (Halting is the white dog, your POOP is the
>>>>> black cats).
>>>>>
>>>>> Halting is DEFINED based on the behavoir of the TURING MACHINE that
>>>>> the input represents, NOT a simulation of the input by the decider.
>>>>
>>>> The only correct halt status criteria for a simulating halt decider
>>>> is whether or not the simulated input can possibly reach its own
>>>> final state. Every distraction away from this point is a dishonest
>>>> dodge.
>>>>
>>>> The only correct halt status criteria for a simulating halt decider
>>>> is whether or not the simulated input can possibly reach its own
>>>> final state. Every distraction away from this point is a dishonest
>>>> dodge.
>>>>
>>>> The only correct halt status criteria for a simulating halt decider
>>>> is whether or not the simulated input can possibly reach its own
>>>> final state. Every distraction away from this point is a dishonest
>>>> dodge.
>>>>
>>>> The only correct halt status criteria for a simulating halt decider
>>>> is whether or not the simulated input can possibly reach its own
>>>> final state. Every distraction away from this point is a dishonest
>>>> dodge.
>>>>
>>>
>>> Nope. THE DEFINITION of the right answer is what the ACTUAL TURING
>>> MACHINE the input represents does.
>>>
>>
>> The actual behavior of the actual simulated input it what counts.
>
> NOPE. READ THE DEFINITION!
>
> It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.

This only means that it is not the behavior of a finite string because
finite strings have no behavior.

The behavior referred to must be the same as the behavior of the
simulated Turing machine description otherwise you are denying the
computational equivalence of the direct execution of a Turing machine
and the UTM simulation of the machine description of this same machine.

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

If you can see that the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches its final state
and the executed Ĥ ⟨Ĥ⟩ does reach its final state then there must be
something about the different placement of Ĥ ⟨Ĥ⟩ at the beginning of Ĥ
and Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ in the middle of Ĥ that causes a difference in behavior.

What we cannot do is see that the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches its
final state and simply ignore this fact because it is not what we expect
to happen.

--
Copyright 2022 Pete Olcott

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

On 3/26/2022 9:56 AM, Richard Damon wrote:
>
> On 3/26/22 10:13 AM, olcott wrote:
>> On 3/26/2022 8:55 AM, Richard Damon wrote:
>>> On 3/26/22 9:44 AM, olcott wrote:
>>>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/26/22 9:14 AM, olcott wrote:
>>>>>> On 3/26/2022 8:11 AM, Richard Damon wrote:
>>>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon wrote:
>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>>>> On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A SHD computes the mapping from its input to its own
>>>>>>>>>>>>>> accept or reject
>>>>>>>>>>>>>> state based on whether or not the pure simulation of its
>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>> input could reach its own final state in a finite number
>>>>>>>>>>>>>> of simulated
>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The following simplifies the syntax for the definition of
>>>>>>>>>>>>>> the Linz
>>>>>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a single
>>>>>>>>>>>>>> start
>>>>>>>>>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>> state.
>>>>>>>>>>>>> Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> halts.
>>>>>>>>>>>>
>>>>>>>>>>>> No it turns out to be the case that a halt decider is not
>>>>>>>>>>>> allowed to
>>>>>>>>>>>> report on its own behavior because itself is neither an
>>>>>>>>>>>> input nor a
>>>>>>>>>>>> finite string.
>>>>>>>>>>>
>>>>>>>>>>> No.  Happy to answer questions about why this is wrong, but
>>>>>>>>>>> since you
>>>>>>>>>>> have not grasped what a halt decider is after 17 years, I
>>>>>>>>>>> don't think
>>>>>>>>>>> it's worth my while just writing it out yet again.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are agreed that a decider maps its input finite string
>>>>>>>>>> input to an accept or reject state.
>>>>>>>>>>
>>>>>>>>>> Now you are contradicting yourself by saying that a decider
>>>>>>>>>> maps a non-input non-finite string.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, what it is mapping is the input <H^> <H^> which most
>>>>>>>>> definitely IS a finite string input.
>>>>>>>>>
>>>>>>>>> It is to map it to Qy (accept) or Qn (reject) based on if the
>>>>>>>>> machine H^   applied to <H^> Halts.
>>>>>>>>>
>>>>>>>>> The fact tha H^ applied to <H^> isn't exactly an input if fine,
>>>>>>>>
>>>>>>>> I am looking for white dogs in my kitchen by looking for black
>>>>>>>> cats in my living room.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, EXACTLY. YOU ARE. This is because you aren't using the right
>>>>>>> definition of HALTING. (Halting is the white dog, your POOP is
>>>>>>> the black cats).
>>>>>>>
>>>>>>> Halting is DEFINED based on the behavoir of the TURING MACHINE
>>>>>>> that the input represents, NOT a simulation of the input by the
>>>>>>> decider.
>>>>>>
>>>>>> The only correct halt status criteria for a simulating halt
>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>> its own final state. Every distraction away from this point is a
>>>>>> dishonest dodge.
>>>>>>
>>>>>> The only correct halt status criteria for a simulating halt
>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>> its own final state. Every distraction away from this point is a
>>>>>> dishonest dodge.
>>>>>>
>>>>>> The only correct halt status criteria for a simulating halt
>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>> its own final state. Every distraction away from this point is a
>>>>>> dishonest dodge.
>>>>>>
>>>>>> The only correct halt status criteria for a simulating halt
>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>> its own final state. Every distraction away from this point is a
>>>>>> dishonest dodge.
>>>>>>
>>>>>
>>>>> Nope. THE DEFINITION of the right answer is what the ACTUAL TURING
>>>>> MACHINE the input represents does.
>>>>>
>>>>
>>>> The actual behavior of the actual simulated input it what counts.
>>>
>>> NOPE. READ THE DEFINITION!
>>>
>>> It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
>>
>> This only means that it is not the behavior of a finite string because
>> finite strings have no behavior.
>
> Right Finite strings have no behavior.
>
> The behavior the decider needs to decide on is the Turing Machine the
> input is a representation of.
>

The behavior of the UTM simulation of the input is the behavior that
this input specifies. That the input simulated by a UTM would never
reach its final state conclusively proves that this input specifies a
non-halting sequence of configurations.

>>
>> The behavior referred to must be the same as the behavior of the
>> simulated Turing machine description otherwise you are denying the
>> computational equivalence of the direct execution of a Turing machine
>> and the UTM simulation of the machine description of this same machine.
>
> Right, the behavior of the ACTUAL Turing Machine, which can also be
> obtained by the simulation with a UTM
>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>
> NOT 'by embedded_H' but by a UTM. Wrong Definition.
>

By the UTM aspect of embedded_H because the simulation must occur at the
same point (in the middle) of Ĥ where embedded_H is located.

>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>
> NOT 'by embedded_H' but by a UTM. Wrong Definition.
>

By the UTM aspect of embedded_H because the simulation must occur at the
same point (in the middle) of Ĥ where embedded_H is located.

> If embedded_H CAN meet the requirements of a UTM, then it can use
> itself, but if not, it can't. Note, one key point is for the second case
> (Qn) UTM not halting meens an unaborted simulation does not halt.
>

On 3/26/2022 10:50 AM, Richard Damon wrote:
> On 3/26/22 11:25 AM, olcott wrote:
>> On 3/26/2022 9:56 AM, Richard Damon wrote:
>>>
>>> On 3/26/22 10:13 AM, olcott wrote:
>>>> On 3/26/2022 8:55 AM, Richard Damon wrote:
>>>>> On 3/26/22 9:44 AM, olcott wrote:
>>>>>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/26/22 9:14 AM, olcott wrote:
>>>>>>>> On 3/26/2022 8:11 AM, Richard Damon wrote:
>>>>>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A SHD computes the mapping from its input to its own
>>>>>>>>>>>>>>>> accept or reject
>>>>>>>>>>>>>>>> state based on whether or not the pure simulation of its
>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>> input could reach its own final state in a finite number
>>>>>>>>>>>>>>>> of simulated
>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>> of the Linz
>>>>>>>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a
>>>>>>>>>>>>>>>> single start
>>>>>>>>>>>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>> Or, more simply, use Linz's condition: if Ĥ applied to
>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No it turns out to be the case that a halt decider is not
>>>>>>>>>>>>>> allowed to
>>>>>>>>>>>>>> report on its own behavior because itself is neither an
>>>>>>>>>>>>>> input nor a
>>>>>>>>>>>>>> finite string.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No.  Happy to answer questions about why this is wrong, but
>>>>>>>>>>>>> since you
>>>>>>>>>>>>> have not grasped what a halt decider is after 17 years, I
>>>>>>>>>>>>> don't think
>>>>>>>>>>>>> it's worth my while just writing it out yet again.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are agreed that a decider maps its input finite string
>>>>>>>>>>>> input to an accept or reject state.
>>>>>>>>>>>>
>>>>>>>>>>>> Now you are contradicting yourself by saying that a decider
>>>>>>>>>>>> maps a non-input non-finite string.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, what it is mapping is the input <H^> <H^> which most
>>>>>>>>>>> definitely IS a finite string input.
>>>>>>>>>>>
>>>>>>>>>>> It is to map it to Qy (accept) or Qn (reject) based on if the
>>>>>>>>>>> machine H^   applied to <H^> Halts.
>>>>>>>>>>>
>>>>>>>>>>> The fact tha H^ applied to <H^> isn't exactly an input if fine,
>>>>>>>>>>
>>>>>>>>>> I am looking for white dogs in my kitchen by looking for black
>>>>>>>>>> cats in my living room.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, EXACTLY. YOU ARE. This is because you aren't using the
>>>>>>>>> right definition of HALTING. (Halting is the white dog, your
>>>>>>>>> POOP is the black cats).
>>>>>>>>>
>>>>>>>>> Halting is DEFINED based on the behavoir of the TURING MACHINE
>>>>>>>>> that the input represents, NOT a simulation of the input by the
>>>>>>>>> decider.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>
>>>>>>> Nope. THE DEFINITION of the right answer is what the ACTUAL
>>>>>>> TURING MACHINE the input represents does.
>>>>>>>
>>>>>>
>>>>>> The actual behavior of the actual simulated input it what counts.
>>>>>
>>>>> NOPE. READ THE DEFINITION!
>>>>>
>>>>> It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
>>>>
>>>> This only means that it is not the behavior of a finite string
>>>> because finite strings have no behavior.
>>>
>>> Right Finite strings have no behavior.
>>>
>>> The behavior the decider needs to decide on is the Turing Machine the
>>> input is a representation of.
>>>
>>
>> The behavior of the UTM simulation of the input is the behavior that
>> this input specifies. That the input simulated by a UTM would never
>> reach its final state conclusively proves that this input specifies a
>> non-halting sequence of configurations.
>
> except that if H <H^> <H^> -> Qn, then H^ <H^> and UTM <H^> <H^> will
> also gp tp H^.Qn and halt, so your claim is a LIE.
>
> Eitehr you LIE that your deicder said its input was non-halting, or you
> LIE that simulation does not reach a final state.
>
> You can't use two different version of H/embedded_H here.
>>
>>>>
>>>> The behavior referred to must be the same as the behavior of the
>>>> simulated Turing machine description otherwise you are denying the
>>>> computational equivalence of the direct execution of a Turing
>>>> machine and the UTM simulation of the machine description of this
>>>> same machine.
>>>
>>> Right, the behavior of the ACTUAL Turing Machine, which can also be
>>> obtained by the simulation with a UTM
>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>> final state.
>>>
>>> NOT 'by embedded_H' but by a UTM. Wrong Definition.
>>>
>>
>> By the UTM aspect of embedded_H because the simulation must occur at
>> the same point (in the middle) of Ĥ where embedded_H is located.
>
> Nope!!!
>
> It is the INDEPENDENT running of UTM <H^> <H^>.
>

On 3/26/2022 11:35 AM, Richard Damon wrote:
>
> On 3/26/22 12:12 PM, olcott wrote:
>> On 3/26/2022 10:50 AM, Richard Damon wrote:
>>> On 3/26/22 11:25 AM, olcott wrote:
>>>> On 3/26/2022 9:56 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/26/22 10:13 AM, olcott wrote:
>>>>>> On 3/26/2022 8:55 AM, Richard Damon wrote:
>>>>>>> On 3/26/22 9:44 AM, olcott wrote:
>>>>>>>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 3/26/22 9:14 AM, olcott wrote:
>>>>>>>>>> On 3/26/2022 8:11 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A SHD computes the mapping from its input to its own
>>>>>>>>>>>>>>>>>> accept or reject
>>>>>>>>>>>>>>>>>> state based on whether or not the pure simulation of
>>>>>>>>>>>>>>>>>> its simulated
>>>>>>>>>>>>>>>>>> input could reach its own final state in a finite
>>>>>>>>>>>>>>>>>> number of simulated
>>>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>>>> of the Linz
>>>>>>>>>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a
>>>>>>>>>>>>>>>>>> single start
>>>>>>>>>>>>>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>> Or, more simply, use Linz's condition: if Ĥ applied to
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No it turns out to be the case that a halt decider is
>>>>>>>>>>>>>>>> not allowed to
>>>>>>>>>>>>>>>> report on its own behavior because itself is neither an
>>>>>>>>>>>>>>>> input nor a
>>>>>>>>>>>>>>>> finite string.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No.  Happy to answer questions about why this is wrong,
>>>>>>>>>>>>>>> but since you
>>>>>>>>>>>>>>> have not grasped what a halt decider is after 17 years, I
>>>>>>>>>>>>>>> don't think
>>>>>>>>>>>>>>> it's worth my while just writing it out yet again.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are agreed that a decider maps its input finite string
>>>>>>>>>>>>>> input to an accept or reject state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Now you are contradicting yourself by saying that a
>>>>>>>>>>>>>> decider maps a non-input non-finite string.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, what it is mapping is the input <H^> <H^> which most
>>>>>>>>>>>>> definitely IS a finite string input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is to map it to Qy (accept) or Qn (reject) based on if
>>>>>>>>>>>>> the machine H^   applied to <H^> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact tha H^ applied to <H^> isn't exactly an input if
>>>>>>>>>>>>> fine,
>>>>>>>>>>>>
>>>>>>>>>>>> I am looking for white dogs in my kitchen by looking for
>>>>>>>>>>>> black cats in my living room.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, EXACTLY. YOU ARE. This is because you aren't using the
>>>>>>>>>>> right definition of HALTING. (Halting is the white dog, your
>>>>>>>>>>> POOP is the black cats).
>>>>>>>>>>>
>>>>>>>>>>> Halting is DEFINED based on the behavoir of the TURING
>>>>>>>>>>> MACHINE that the input represents, NOT a simulation of the
>>>>>>>>>>> input by the decider.
>>>>>>>>>>
>>>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>>>> decider is whether or not the simulated input can possibly
>>>>>>>>>> reach its own final state. Every distraction away from this
>>>>>>>>>> point is a dishonest dodge.
>>>>>>>>>>
>>>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>>>> decider is whether or not the simulated input can possibly
>>>>>>>>>> reach its own final state. Every distraction away from this
>>>>>>>>>> point is a dishonest dodge.
>>>>>>>>>>
>>>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>>>> decider is whether or not the simulated input can possibly
>>>>>>>>>> reach its own final state. Every distraction away from this
>>>>>>>>>> point is a dishonest dodge.
>>>>>>>>>>
>>>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>>>> decider is whether or not the simulated input can possibly
>>>>>>>>>> reach its own final state. Every distraction away from this
>>>>>>>>>> point is a dishonest dodge.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope. THE DEFINITION of the right answer is what the ACTUAL
>>>>>>>>> TURING MACHINE the input represents does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The actual behavior of the actual simulated input it what counts.
>>>>>>>
>>>>>>> NOPE. READ THE DEFINITION!
>>>>>>>
>>>>>>> It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
>>>>>>
>>>>>> This only means that it is not the behavior of a finite string
>>>>>> because finite strings have no behavior.
>>>>>
>>>>> Right Finite strings have no behavior.
>>>>>
>>>>> The behavior the decider needs to decide on is the Turing Machine
>>>>> the input is a representation of.
>>>>>
>>>>
>>>> The behavior of the UTM simulation of the input is the behavior that
>>>> this input specifies. That the input simulated by a UTM would never
>>>> reach its final state conclusively proves that this input specifies
>>>> a non-halting sequence of configurations.
>>>
>>> except that if H <H^> <H^> -> Qn, then H^ <H^> and UTM <H^> <H^> will
>>> also gp tp H^.Qn and halt, so your claim is a LIE.
>>>
>>> Eitehr you LIE that your deicder said its input was non-halting, or
>>> you LIE that simulation does not reach a final state.
>>>
>>> You can't use two different version of H/embedded_H here.
>>>>
>>>>>>
>>>>>> The behavior referred to must be the same as the behavior of the
>>>>>> simulated Turing machine description otherwise you are denying the
>>>>>> computational equivalence of the direct execution of a Turing
>>>>>> machine and the UTM simulation of the machine description of this
>>>>>> same machine.
>>>>>
>>>>> Right, the behavior of the ACTUAL Turing Machine, which can also be
>>>>> obtained by the simulation with a UTM
>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>
>>>>> NOT 'by embedded_H' but by a UTM. Wrong Definition.
>>>>>
>>>>
>>>> By the UTM aspect of embedded_H because the simulation must occur at
>>>> the same point (in the middle) of Ĥ where embedded_H is located.
>>>
>>> Nope!!!
>>>
>>> It is the INDEPENDENT running of UTM <H^> <H^>.
>>>
>>
>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>
>> The invocation of Ĥ ⟨Ĥ⟩ is the first invocation in what would
>> otherwise be infinite recursion.
>>
>> Its normal behavior depends on a subsequent invocation being aborted.
>>
>> If a subsequent invocation is never aborted then the recursion remains
>> infinite.
>>
>> In any case the simulated input never reaches the final state of this
>> simulated input. The final state of the simulated input is ⟨Ĥ.qn⟩.
>>
>>
>
> Nope, ALL Copies of the same machine given the same input behave the same.
>

On 3/26/2022 7:30 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:

> what the correct answer for it is, is determined solely by whether or
> not Ĥ halts on input ⟨Ĥ⟩.

That is not true. This is true:

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.

--
Copyright 2022 Pete Olcott

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

On 3/26/2022 8:28 PM, Richard Damon wrote:
> On 3/26/22 9:05 PM, olcott wrote:
>> On 3/26/2022 7:39 PM, Richard Damon wrote:
>>> On 3/26/22 7:58 PM, olcott wrote:
>>>> On 3/26/2022 6:54 PM, Richard Damon wrote:
>>>>> On 3/26/22 7:40 PM, olcott wrote:
>>>>>> On 3/26/2022 6:32 PM, Richard Damon wrote:
>>>>>>> On 3/26/22 7:09 PM, olcott wrote:
>>>>>>>> On 3/26/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>> On 3/26/22 6:36 PM, olcott wrote:
>>>>>>>>>> On 3/26/2022 5:27 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/26/22 6:14 PM, olcott wrote:
>>>>>>>>>>>> On 3/26/2022 5:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/26/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/26/2022 4:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/26/22 5:21 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/26/2022 4:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/26/22 5:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/26/2022 3:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/26/22 4:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/26/2022 3:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/26/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 2:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 12:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 11:35 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 12:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 10:50 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 11:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 9:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 10:13 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:11 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2022 10:48 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A SHD computes the mapping
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its input to its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state based on whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input could reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state in a finite number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> syntax for the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine Ĥ, it is now a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single machine with a single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> start
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.  A copy of Linz H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Or, more simply, use Linz's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition: if Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it turns out to be the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a halt decider is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report on its own behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because itself is neither an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input nor a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No.  Happy to answer questions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about why this is wrong, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> since you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have not grasped what a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider is after 17 years, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it's worth my while just writing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it out yet again.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are agreed that a decider maps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input finite string input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Now you are contradicting yourself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by saying that a decider maps a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input non-finite string.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, what it is mapping is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input <H^> <H^> which most
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitely IS a finite string input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is to map it to Qy (accept) or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Qn (reject) based on if the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^   applied to <H^> Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact tha H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't exactly an input if fine,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am looking for white dogs in my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> kitchen by looking for black cats in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> my living room.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, EXACTLY. YOU ARE. This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because you aren't using the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of HALTING. (Halting is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the white dog, your POOP is the black
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cats).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting is DEFINED based on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavoir of the TURING MACHINE that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input represents, NOT a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input by the decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. THE DEFINITION of the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is what the ACTUAL TURING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE the input represents does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input it what counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOPE. READ THE DEFINITION!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the behavior of the ACTUAL TURING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE THE INPUT REPRESENT.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This only means that it is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a finite string because finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strings have no behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right Finite strings have no behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior the decider needs to decide on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the Turing Machine the input is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the UTM simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is the behavior that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies. That the input simulated by a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> except that if H <H^> <H^> -> Qn, then H^
>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> and UTM <H^> <H^> will also gp tp H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>> and halt, so your claim is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Eitehr you LIE that your deicder said its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input was non-halting, or you LIE that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not reach a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't use two different version of
>>>>>>>>>>>>>>>>>>>>>>>>>>> H/embedded_H here.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior referred to must be the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as the behavior of the simulated Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description otherwise you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> denying the computational equivalence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of a Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the UTM simulation of the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description of this same machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, the behavior of the ACTUAL Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine, which can also be obtained by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation with a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT 'by embedded_H' but by a UTM. Wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> By the UTM aspect of embedded_H because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation must occur at the same point (in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the middle) of Ĥ where embedded_H is located.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope!!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the INDEPENDENT running of UTM <H^> <H^>.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The invocation of Ĥ ⟨Ĥ⟩ is the first
>>>>>>>>>>>>>>>>>>>>>>>>>> invocation in what would otherwise be infinite
>>>>>>>>>>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Its normal behavior depends on a subsequent
>>>>>>>>>>>>>>>>>>>>>>>>>> invocation being aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If a subsequent invocation is never aborted
>>>>>>>>>>>>>>>>>>>>>>>>>> then the recursion remains infinite.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In any case the simulated input never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this simulated input. The
>>>>>>>>>>>>>>>>>>>>>>>>>> final state of the simulated input is ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, ALL Copies of the same machine given the
>>>>>>>>>>>>>>>>>>>>>>>>> same input behave the same.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is never any case where the simulated
>>>>>>>>>>>>>>>>>>>>>>>> input reaches its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If you want to refute that, provide and ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>> coded example.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^> -> H^.Qn and Halts and UTM
>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to <H^>.Qn and Halts if
>>>>>>>>>>>>>>>>>>>>>>>>> H/embedded_H -> Qn, and if H doesn't, it fails
>>>>>>>>>>>>>>>>>>>>>>>>> to be a decider, so is wrong either way.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ and embedded_H both reach their final
>>>>>>>>>>>>>>>>>>>>>>>> state of Ĥ.qn and halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
>>>>>>>>>>>>>>>>>>>>>>>> reaches its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope. The PROPERLY simulated <H^> <H^> will also
>>>>>>>>>>>>>>>>>>>>>>> go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I say I have no white dogs in my living room and
>>>>>>>>>>>>>>>>>>>>>> disagree on the basis that I have a black cat in
>>>>>>>>>>>>>>>>>>>>>> my kitchen.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
>>>>>>>>>>>>>>>>>>>>>> reaches its own final state of ⟨Ĥ.qn⟩ even though
>>>>>>>>>>>>>>>>>>>>>> the directly executed Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>>>>>>>>>>>>>> transition to its final state of Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the
>>>>>>>>>>>>>>>>>>>>>> first invocation of infinite recursion that only
>>>>>>>>>>>>>>>>>>>>>> terminates normally because of its one-way
>>>>>>>>>>>>>>>>>>>>>> dependency relationship on embedded_H aborting the
>>>>>>>>>>>>>>>>>>>>>> second invocation of this otherwise infinite
>>>>>>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And since it DOES Halt, the computation HA\LT.
>>>>>>>>>>>>>>>>>>>>> DEFINITION.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> As you were the first to point out the simulated
>>>>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H does not halt. To use
>>>>>>>>>>>>>>>>>>>> your own terms its execution has been suspended.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> YOU KNOW THIS IS TRUE YOU ARE JUST A LIAR
>>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
>>>>>>>>>>>>>>>>>>>> reaches its own final
>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ.qn⟩ even though the directly executed Ĥ
>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> does transition to its final state of Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The PARTIAL simulation of the input by embedded_H
>>>>>>>>>>>>>>>>>>> never reaches its final state, yes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since you already agreed that the complete simulation
>>>>>>>>>>>>>>>>>> of its input never stops running you already know that
>>>>>>>>>>>>>>>>>> the simulation of its input never reaches its final
>>>>>>>>>>>>>>>>>> state ⟨Ĥ.qn⟩ no matter what.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then that means your embedded_H NEVER aborts its
>>>>>>>>>>>>>>>>> simulation, and thus NEVER returns an annswer and thus
>>>>>>>>>>>>>>>>> FAILS to be a decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It also means that because the input never halts under
>>>>>>>>>>>>>>>> any circumstances that when embedded_H rejects this
>>>>>>>>>>>>>>>> input it is necessarily correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, that isn't what I agreed to.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sure it was.
>>>>>>>>>>>>>> It doesn't reach its final state if it is not aborted (it
>>>>>>>>>>>>>> keeps running) and it doesn't reach its final state if was
>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Bad use of pronouns.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by the UTM inside of embedded_H never
>>>>>>>>>>>> reaches its final state: ⟨Ĥ.qn⟩ no matter what.
>>>>>>>>>>>
>>>>>>>>>>> There IS NO UTM that is still a UTM inside embedded_H, or
>>>>>>>>>>> embedded_H doesn't ever answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You know that the simulated input to embedded_H never reaches
>>>>>>>>>> its final state of ⟨Ĥ.qn⟩ no matter what. Why don't you just
>>>>>>>>>> admit this so that I can escalate this to computer science
>>>>>>>>>> review?
>>>>>>>>>
>>>>>>>>> Because you are saying it wrong, because you are confusing two
>>>>>>>>> different 'simulations'
>>>>>>>>>
>>>>>>>>> The CORRECTLY Simulated input, done by the independent UTM,
>>>>>>>> Has never been what I am talking about and you know it.
>>>>>>>>
>>>>>>>
>>>>>>> So you admit that you are only talking about the INCORRECTLY
>>>>>>> Simulated Output?
>>>>>>
>>>>>> No nitwit I admit no such thing.
>>>>>
>>>>> Then why did you say it?
>>>>>
>>>>> I talked about the 'CORRECT Simulation' and you say that you aren't
>>>>> talking about that.
>>>>>
>>>>> What is the defintion of a simulation that isn't the correct
>>>>> simulation?
>>>>>
>>>>> You don't seem to understand the meaning of English words.
>>>>>
>>>>>>
>>>>>> The input simulated by the UTM contained within embedded_H cannot
>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ if simulated in an
>>>>>> infinite or finite number of steps or if the simulation is aborted
>>>>>> at any point along the way.
>>>>>>
>>>>>>
>>>>>
>>>>> As I have said, there IS NO UTM contained within embedded_H that is
>>>>> still a UTM if embedded_H EVER aborts its simulation.PERIOD.
>>>>
>>>> A music app can contain a complete C compiler that remains a
>>>> complete C compiler even if it is never uses.
>>>>
>>>>
>>>
>>> RED HERRING. Category error. (Since you claim embedded_H USES the
>>> UTM, your case in non-applicable).
>>>
>> If embedded_H uses its UTM to simulate one state transition at a time
>> of its input then each of these state transitions are simulated
>> correctly.
>>
>
> The step maybe, the MACHINE, NO.
>
> Definition of Correct Simulation, behaves IDENTICAL to the original
> machine.
>
> Means can not 'abort' the simulation.
>
> FAIL.

On 3/27/2022 11:20 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/26/2022 7:30 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>
>>> what the correct answer for it is, is determined solely by whether or
>>> not Ĥ halts on input ⟨Ĥ⟩.
>>
>> That is not true.
>
> You don't get to say what the halting problem is. It's already been
> specified.
>
> Every string either represents a halting computation or it does not.
> There is no context other than some prior agreed encoding about how a TM
> and an input should be represented. A halt decide must accept exactly
> those strings that represent halting computations.
>
> The fact that you need to reject the very definition of the problem is
> clear evidence that you know that no TM is a halt decider.
>
>> This is true:
>>
>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>> infinite recursion that only terminates normally because of its
>> one-way dependency relationship on embedded_H aborting the second
>> invocation of this otherwise infinite recursion.
>
> It does not matter why the computation represented a particular string
> halts. You've been trying to pull this "it only halts because" nonsense
> for years.
>

As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation then its
rejection of this input is necessarily correct and everything else in
the universe is totally irrelevant.

A halt decider must compute the mapping from its inputs (not anything
else in the universe besides it inputs) to its own accept or reject
state based on the actual behavior specified by these actual inputs (not
any behavior of anything else in the universe).

We also know that the actual behavior specified by these inputs must be
the same as the behavior of the simulation of N steps of this input by a
UTM. On this basis we know that any behavior that diverges from this
behavior is not the correct basis for the halt status decision.

> The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.

If it is simulated outside of Ĥ then it must have the same behavior as
Ĥ applied to ⟨Ĥ⟩.

If it is simulated inside of Ĥ then several steps of Ĥ have already been
executed when this simulation begins thus specifying a different
sequence of configurations then when Ĥ starts at its beginning.

> I assume you have not
> been deceiving us for years, and you know that the computation it
> represents is Ĥ applied to the string ⟨Ĥ⟩.

When Ĥ is simulated in the middle of Ĥ this is different than when Ĥ is
simulated at the beginning of Ĥ.

> That either is or is not a
> halting computation. There is no context-dependence (other than the

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

It is obvious that the above sequence is infinitely recursive.
If the halt decider aborts the second recursive call then the first
recursive call would halt. That the first recursive call halts does not
indicate that it is a halting computation.

> agreed encoding). There is no dispensation from "special" kinds of
> halting.
>
> Don't you think that having to have these sort of basic matter explained
> to you, year in, year out, indicates that maybe you should be doing
> something else?
>

YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.

As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation then its
rejection of this input is necessarily correct and everything else in
the universe is totally irrelevant.

--
Copyright 2022 Pete Olcott

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

On 3/27/2022 6:56 PM, Richard Damon wrote:
> On 3/27/22 7:37 PM, olcott wrote:
>> On 3/27/2022 6:34 PM, Dennis Bush wrote:
>>> On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
>>>> On 3/27/2022 6:22 PM, Richard Damon wrote:
>>>>>
>>>>> On 3/27/22 7:16 PM, olcott wrote:
>>>>>> On 3/27/2022 6:05 PM, Dennis Bush wrote:
>>>>>>> On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote:
>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:
>>>>>>>>> On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 1:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 7:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> what the correct answer for it is, is determined
>>>>>>>>>>>>>>>>>>>>>>>>>>> solely by
>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>> not Ĥ halts on input ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> That is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to say what the halting problem is.
>>>>>>>>>>>>>>>>>>>>>>>>> It's already
>>>>>>>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>>>>>>>> specified.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Every string either represents a halting
>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
>>>>>>>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>>>>>>> There is no context other than some prior agreed
>>>>>>>>>>>>>>>>>>>>>>>>> encoding about
>>>>>>>>>>>>>>>>>>>>>>>>> how a TM
>>>>>>>>>>>>>>>>>>>>>>>>> and an input should be represented. A halt decide
>>>>>>>>>>>>>>>>>>>>>>>>> must accept
>>>>>>>>>>>>>>>>>>>>>>>>> exactly
>>>>>>>>>>>>>>>>>>>>>>>>> those strings that represent halting computations.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The fact that you need to reject the very
>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
>>>>>>>>>>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>>>>>>>>>>> clear evidence that you know that no TM is a halt
>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This is true:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the
>>>>>>>>>>>>>>>>>>>>>>>>>> first invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion that only terminates normally
>>>>>>>>>>>>>>>>>>>>>>>>>> because of its
>>>>>>>>>>>>>>>>>>>>>>>>>> one-way dependency relationship on embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second
>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of this otherwise infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It does not matter why the computation represented
>>>>>>>>>>>>>>>>>>>>>>>>> a particular
>>>>>>>>>>>>>>>>>>>>>>>>> string
>>>>>>>>>>>>>>>>>>>>>>>>> halts. You've been trying to pull this "it only
>>>>>>>>>>>>>>>>>>>>>>>>> halts because"
>>>>>>>>>>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>>>>>>>>>>> for years.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could
>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its
>>>>>>>>>>>>>>>>>>>>>>>> inputs (not
>>>>>>>>>>>>>>>>>>>>>>>> anything else in the universe besides it inputs) to
>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state based on the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>> these actual inputs (not any behavior of anything
>>>>>>>>>>>>>>>>>>>>>>>> else in the
>>>>>>>>>>>>>>>>>>>>>>>> universe).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> We also know that the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>> these inputs
>>>>>>>>>>>>>>>>>>>>>>>> must be the same as the behavior of the simulation
>>>>>>>>>>>>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>>>>>>>>>>>>> this input by a UTM. On this basis we know that any
>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>> that diverges from this behavior is not the correct
>>>>>>>>>>>>>>>>>>>>>>>> basis for
>>>>>>>>>>>>>>>>>>>>>>>> the halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated outside of Ĥ then it must have
>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>> behavior as Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated inside of Ĥ then several
>>>>>>>>>>>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ have
>>>>>>>>>>>>>>>>>>>>>>>> already been executed when this simulation
>>>>>>>>>>>>>>>>>>>>>>>> begins thus
>>>>>>>>>>>>>>>>>>>>>>>> specifying a different sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
>>>>>>>>>>>>>>>>>>>>>>>> starts at its beginning.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I assume you have not
>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and you know that the
>>>>>>>>>>>>>>>>>>>>>>>>> computation it
>>>>>>>>>>>>>>>>>>>>>>>>> represents is Ĥ applied to the string ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is simulated in the middle of Ĥ this is
>>>>>>>>>>>>>>>>>>>>>>>> different than
>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ is simulated at the beginning of Ĥ.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That either is or is not a
>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no
>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
>>>>>>>>>>>>>>>>>>>>>>>>> (other
>>>>>>>>>>>>>>>>>>>>>>>>> than the
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is obvious that the above sequence is infinitely
>>>>>>>>>>>>>>>>>>>>>>>> recursive.
>>>>>>>>>>>>>>>>>>>>>>>> If the halt decider aborts the second recursive
>>>>>>>>>>>>>>>>>>>>>>>> call
>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>> first recursive call would halt. That the first
>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>> halts does not indicate that it is a halting
>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> agreed encoding). There is no dispensation from
>>>>>>>>>>>>>>>>>>>>>>>>> "special"
>>>>>>>>>>>>>>>>>>>>>>>>> kinds of
>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Don't you think that having to have these sort of
>>>>>>>>>>>>>>>>>>>>>>>>> basic matter
>>>>>>>>>>>>>>>>>>>>>>>>> explained
>>>>>>>>>>>>>>>>>>>>>>>>> to you, year in, year out, indicates that maybe
>>>>>>>>>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>>>>>>>>>> should be
>>>>>>>>>>>>>>>>>>>>>>>>> doing
>>>>>>>>>>>>>>>>>>>>>>>>> something else?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could
>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, YOU do not grasp that the definitions that were
>>>>>>>>>>>>>>>>>>>>>>> established
>>>>>>>>>>>>>>>>>>>>>>> ARE the definitions you need to use,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Because a halt decider must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>> finite strings based on the actual behavior specified
>>>>>>>>>>>>>>>>>>>>>> by these
>>>>>>>>>>>>>>>>>>>>>> strings which is correctly measured by a correct
>>>>>>>>>>>>>>>>>>>>>> simulation of N
>>>>>>>>>>>>>>>>>>>>>> steps of these strings you already know that I am
>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, wrong definition, wrong answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you have a reference for adding the 'of N steps'
>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>> definition?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> N = "simulating it for as many steps as it will take"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So might be infinite, and thus H fails to answer in
>>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You already that this is an infinite pattern:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note, the ... notation means that you intend the
>>>>>>>>>>>>>>>>> pattern to
>>>>>>>>>>>>>>>>> keep on
>>>>>>>>>>>>>>>>> repeating for ever, so you are SHOWING 3 steps, but
>>>>>>>>>>>>>>>>> stateing that more
>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What I said, was that pattern only repeats infinity if
>>>>>>>>>>>>>>>>> embedded_H never
>>>>>>>>>>>>>>>>> aborts its simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When embedded_H correctly computes the mapping from its
>>>>>>>>>>>>>>>> input finite
>>>>>>>>>>>>>>>> strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>> the behavior that embedded_H (and therefore H) is stipulated
>>>>>>>>>>>>>>> to answer about. So anything you say that follows doesn't
>>>>>>>>>>>>>>> matter.
>>>>>>>>>>>>>> That is a common misconception. Please read my paper.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I've read it, and it's bogus. It says nothing more than what
>>>>>>>>>>>>> you've been saying before.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To repeat:
>>>>>>>>>>>>>
>>>>>>>>>>>>> When H3 correctly computes the mapping from its input finite
>>>>>>>>>>>>> strings <N> <3> to its own final reject state
>>>>>>>>>>>>> on the basis that there is
>>>>>>>>>>>>> no finite number N of steps of correct simulation of this
>>>>>>>>>>>>> input
>>>>>>>>>>>>> by the
>>>>>>>>>>>>> UTM within H3 then H3 has correctly decided that its
>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>
>>>>>>>>>>>> There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩
>>>>>>>>>>>
>>>>>>>>>>> Sure there is, I defined them earlier. But just so there's no
>>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So Ha3 uses
>>>>>>>>>>> as its halt status criteria: simulate for 3 steps and abort.
>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>> You might as well define counting to ten: 1,2,3 DONE.
>>>>>>>>>
>>>>>>>>> So Ha3 is obviously wrong? What criteria do you use to
>>>>>>>>> determine that?
>>>>>>>> That is an intentionally stupid question.
>>>>>>>
>>>>>>> I want to hear your answer.  What criteria do you use to show that
>>>>>>> Ha3 applied to <N><5> reporting non-halting is incorrect?
>>>>>>
>>>>>> I take it that you want me to ignore everything you say.
>>>>>> This work is intended to be my legacy before I die.
>>>>>> If you just want to play head games go fornicate yourself.
>>>>>>
>>>>>>
>>>>>
>>>>> The fact you have trouble with these simple questions shows how bad
>>>>> your
>>>>> logic is.
>>>>>
>>>> I told him that his question was just liked counting to ten: 1,2,3
>>>> DONE.
>>>
>>> So in other words H3a is not simulating for enough steps?
>>>
>>
>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>> As long as the simulated input to embedded_H could never reach its
>> final state in any finite number of steps of correct simulation by
>> embedded_H then its rejection of this input is necessarily correct.
>
>
> Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED TO DO?
>
That is out-of-scope. You must find an error in my exact words and
explain why it is an error, otherwise we get stuck talking in circles
that are various shades of the strawman error.

On 3/27/2022 7:33 PM, Richard Damon wrote:
> On 3/27/22 8:22 PM, olcott wrote:
>> On 3/27/2022 6:56 PM, Richard Damon wrote:
>>> On 3/27/22 7:37 PM, olcott wrote:
>>>> On 3/27/2022 6:34 PM, Dennis Bush wrote:
>>>>> On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
>>>>>> On 3/27/2022 6:22 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/27/22 7:16 PM, olcott wrote:
>>>>>>>> On 3/27/2022 6:05 PM, Dennis Bush wrote:
>>>>>>>>> On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 7:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what the correct answer for it is, is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> solely by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Ĥ halts on input ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to say what the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>> It's already
>>>>>>>>>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>>>>>>>>>> specified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Every string either represents a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
>>>>>>>>>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>>>>>>>>> There is no context other than some prior agreed
>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding about
>>>>>>>>>>>>>>>>>>>>>>>>>>> how a TM
>>>>>>>>>>>>>>>>>>>>>>>>>>> and an input should be represented. A halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>>>>>>>>>> must accept
>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly
>>>>>>>>>>>>>>>>>>>>>>>>>>> those strings that represent halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> computations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that you need to reject the very
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>> clear evidence that you know that no TM is a
>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> first invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion that only terminates
>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally
>>>>>>>>>>>>>>>>>>>>>>>>>>>> because of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> one-way dependency relationship on embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second
>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of this otherwise infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It does not matter why the computation
>>>>>>>>>>>>>>>>>>>>>>>>>>> represented
>>>>>>>>>>>>>>>>>>>>>>>>>>> a particular
>>>>>>>>>>>>>>>>>>>>>>>>>>> string
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. You've been trying to pull this "it only
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts because"
>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>>>>>>>>>>>>> for years.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> could
>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (not
>>>>>>>>>>>>>>>>>>>>>>>>>> anything else in the universe besides it
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs) to
>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state based on the actual
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>> these actual inputs (not any behavior of anything
>>>>>>>>>>>>>>>>>>>>>>>>>> else in the
>>>>>>>>>>>>>>>>>>>>>>>>>> universe).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> We also know that the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>> these inputs
>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same as the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> this input by a UTM. On this basis we know
>>>>>>>>>>>>>>>>>>>>>>>>>> that any
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> that diverges from this behavior is not the
>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>> basis for
>>>>>>>>>>>>>>>>>>>>>>>>>> the halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated outside of Ĥ then it must have
>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior as Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated inside of Ĥ then several
>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ have
>>>>>>>>>>>>>>>>>>>>>>>>>> already been executed when this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> begins thus
>>>>>>>>>>>>>>>>>>>>>>>>>> specifying a different sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
>>>>>>>>>>>>>>>>>>>>>>>>>> starts at its beginning.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I assume you have not
>>>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and you know
>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation it
>>>>>>>>>>>>>>>>>>>>>>>>>>> represents is Ĥ applied to the string ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is simulated in the middle of Ĥ this is
>>>>>>>>>>>>>>>>>>>>>>>>>> different than
>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ is simulated at the beginning of Ĥ.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That either is or is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no
>>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
>>>>>>>>>>>>>>>>>>>>>>>>>>> (other
>>>>>>>>>>>>>>>>>>>>>>>>>>> than the
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is obvious that the above sequence is
>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>> If the halt decider aborts the second
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>>>> first recursive call would halt. That the first
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>> halts does not indicate that it is a halting
>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed encoding). There is no dispensation from
>>>>>>>>>>>>>>>>>>>>>>>>>>> "special"
>>>>>>>>>>>>>>>>>>>>>>>>>>> kinds of
>>>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't you think that having to have these
>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>> basic matter
>>>>>>>>>>>>>>>>>>>>>>>>>>> explained
>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, year in, year out, indicates that
>>>>>>>>>>>>>>>>>>>>>>>>>>> maybe you
>>>>>>>>>>>>>>>>>>>>>>>>>>> should be
>>>>>>>>>>>>>>>>>>>>>>>>>>> doing
>>>>>>>>>>>>>>>>>>>>>>>>>>> something else?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> could
>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, YOU do not grasp that the definitions that
>>>>>>>>>>>>>>>>>>>>>>>>> were
>>>>>>>>>>>>>>>>>>>>>>>>> established
>>>>>>>>>>>>>>>>>>>>>>>>> ARE the definitions you need to use,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Because a halt decider must compute the mapping
>>>>>>>>>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>> finite strings based on the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>> specified
>>>>>>>>>>>>>>>>>>>>>>>> by these
>>>>>>>>>>>>>>>>>>>>>>>> strings which is correctly measured by a correct
>>>>>>>>>>>>>>>>>>>>>>>> simulation of N
>>>>>>>>>>>>>>>>>>>>>>>> steps of these strings you already know that I am
>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope, wrong definition, wrong answer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Do you have a reference for adding the 'of N steps'
>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>> definition?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> N = "simulating it for as many steps as it will take"
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So might be infinite, and thus H fails to answer in
>>>>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You already that this is an infinite pattern:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Note, the ... notation means that you intend the
>>>>>>>>>>>>>>>>>>> pattern to
>>>>>>>>>>>>>>>>>>> keep on
>>>>>>>>>>>>>>>>>>> repeating for ever, so you are SHOWING 3 steps, but
>>>>>>>>>>>>>>>>>>> stateing that more
>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What I said, was that pattern only repeats infinity if
>>>>>>>>>>>>>>>>>>> embedded_H never
>>>>>>>>>>>>>>>>>>> aborts its simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When embedded_H correctly computes the mapping from its
>>>>>>>>>>>>>>>>>> input finite
>>>>>>>>>>>>>>>>>> strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>>>> the behavior that embedded_H (and therefore H) is
>>>>>>>>>>>>>>>>> stipulated
>>>>>>>>>>>>>>>>> to answer about. So anything you say that follows doesn't
>>>>>>>>>>>>>>>>> matter.
>>>>>>>>>>>>>>>> That is a common misconception. Please read my paper.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've read it, and it's bogus. It says nothing more than what
>>>>>>>>>>>>>>> you've been saying before.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To repeat:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When H3 correctly computes the mapping from its input finite
>>>>>>>>>>>>>>> strings <N> <3> to its own final reject state
>>>>>>>>>>>>>>> on the basis that there is
>>>>>>>>>>>>>>> no finite number N of steps of correct simulation of this
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>> UTM within H3 then H3 has correctly decided that its
>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sure there is, I defined them earlier. But just so there's no
>>>>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So Ha3
>>>>>>>>>>>>> uses
>>>>>>>>>>>>> as its halt status criteria: simulate for 3 steps and abort.
>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>> You might as well define counting to ten: 1,2,3 DONE.
>>>>>>>>>>>
>>>>>>>>>>> So Ha3 is obviously wrong? What criteria do you use to
>>>>>>>>>>> determine that?
>>>>>>>>>> That is an intentionally stupid question.
>>>>>>>>>
>>>>>>>>> I want to hear your answer.  What criteria do you use to show that
>>>>>>>>> Ha3 applied to <N><5> reporting non-halting is incorrect?
>>>>>>>>
>>>>>>>> I take it that you want me to ignore everything you say.
>>>>>>>> This work is intended to be my legacy before I die.
>>>>>>>> If you just want to play head games go fornicate yourself.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> The fact you have trouble with these simple questions shows how
>>>>>>> bad your
>>>>>>> logic is.
>>>>>>>
>>>>>> I told him that his question was just liked counting to ten: 1,2,3
>>>>>> DONE.
>>>>>
>>>>> So in other words H3a is not simulating for enough steps?
>>>>>
>>>>
>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>> As long as the simulated input to embedded_H could never reach its
>>>> final state in any finite number of steps of correct simulation by
>>>> embedded_H then its rejection of this input is necessarily correct.
>>>
>>>
>>> Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED TO DO?
>> That is out-of-scope. You must find an error in my exact words and
>> explain why it is an error, otherwise we get stuck talking in circles
>> that are various shades of the strawman error.
>>
>
> The error in your words is that you don't use the right defintion of
> Halting,

On 3/27/2022 7:51 PM, Richard Damon wrote:
> On 3/27/22 8:36 PM, olcott wrote:
>> On 3/27/2022 7:33 PM, Richard Damon wrote:
>>> On 3/27/22 8:22 PM, olcott wrote:
>>>> On 3/27/2022 6:56 PM, Richard Damon wrote:
>>>>> On 3/27/22 7:37 PM, olcott wrote:
>>>>>> On 3/27/2022 6:34 PM, Dennis Bush wrote:
>>>>>>> On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
>>>>>>>> On 3/27/2022 6:22 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 3/27/22 7:16 PM, olcott wrote:
>>>>>>>>>> On 3/27/2022 6:05 PM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 7:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what the correct answer for it is, is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> solely by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Ĥ halts on input ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to say what the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's already
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every string either represents a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is no context other than some prior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how a TM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and an input should be represented. A halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must accept
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> those strings that represent halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that you need to reject the very
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear evidence that you know that no TM is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion that only terminates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one-way dependency relationship on embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of this otherwise infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does not matter why the computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a particular
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> string
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. You've been trying to pull this "it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts because"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for years.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> could
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (not
>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything else in the universe besides it
>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs) to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state based on the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> these actual inputs (not any behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything
>>>>>>>>>>>>>>>>>>>>>>>>>>>> else in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> We also know that the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> these inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same as the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input by a UTM. On this basis we know
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that any
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that diverges from this behavior is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis for
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated outside of Ĥ then it must
>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior as Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated inside of Ĥ then several
>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> already been executed when this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> begins thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifying a different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
>>>>>>>>>>>>>>>>>>>>>>>>>>>> starts at its beginning.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I assume you have not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and you know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents is Ĥ applied to the string ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is simulated in the middle of Ĥ this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than
>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ is simulated at the beginning of Ĥ.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That either is or is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is obvious that the above sequence is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the halt decider aborts the second
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> first recursive call would halt. That the first
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts does not indicate that it is a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed encoding). There is no dispensation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "special"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> kinds of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't you think that having to have these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basic matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, year in, year out, indicates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> maybe you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something else?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> could
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, YOU do not grasp that the definitions
>>>>>>>>>>>>>>>>>>>>>>>>>>> that were
>>>>>>>>>>>>>>>>>>>>>>>>>>> established
>>>>>>>>>>>>>>>>>>>>>>>>>>> ARE the definitions you need to use,
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Because a halt decider must compute the
>>>>>>>>>>>>>>>>>>>>>>>>>> mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings based on the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> specified
>>>>>>>>>>>>>>>>>>>>>>>>>> by these
>>>>>>>>>>>>>>>>>>>>>>>>>> strings which is correctly measured by a correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N
>>>>>>>>>>>>>>>>>>>>>>>>>> steps of these strings you already know that I am
>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, wrong definition, wrong answer.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Do you have a reference for adding the 'of N
>>>>>>>>>>>>>>>>>>>>>>>>> steps'
>>>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>>>> definition?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> N = "simulating it for as many steps as it will
>>>>>>>>>>>>>>>>>>>>>>>> take"
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So might be infinite, and thus H fails to answer in
>>>>>>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You already that this is an infinite pattern:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Note, the ... notation means that you intend the
>>>>>>>>>>>>>>>>>>>>> pattern to
>>>>>>>>>>>>>>>>>>>>> keep on
>>>>>>>>>>>>>>>>>>>>> repeating for ever, so you are SHOWING 3 steps, but
>>>>>>>>>>>>>>>>>>>>> stateing that more
>>>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What I said, was that pattern only repeats infinity if
>>>>>>>>>>>>>>>>>>>>> embedded_H never
>>>>>>>>>>>>>>>>>>>>> aborts its simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When embedded_H correctly computes the mapping from its
>>>>>>>>>>>>>>>>>>>> input finite
>>>>>>>>>>>>>>>>>>>> strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>>>>>> the behavior that embedded_H (and therefore H) is
>>>>>>>>>>>>>>>>>>> stipulated
>>>>>>>>>>>>>>>>>>> to answer about. So anything you say that follows
>>>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>>>> matter.
>>>>>>>>>>>>>>>>>> That is a common misconception. Please read my paper.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I've read it, and it's bogus. It says nothing more than
>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>> you've been saying before.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> To repeat:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When H3 correctly computes the mapping from its input
>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>> strings <N> <3> to its own final reject state
>>>>>>>>>>>>>>>>> on the basis that there is
>>>>>>>>>>>>>>>>> no finite number N of steps of correct simulation of
>>>>>>>>>>>>>>>>> this input
>>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>>> UTM within H3 then H3 has correctly decided that its
>>>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sure there is, I defined them earlier. But just so
>>>>>>>>>>>>>>> there's no
>>>>>>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So
>>>>>>>>>>>>>>> Ha3 uses
>>>>>>>>>>>>>>> as its halt status criteria: simulate for 3 steps and abort.
>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>> You might as well define counting to ten: 1,2,3 DONE.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So Ha3 is obviously wrong? What criteria do you use to
>>>>>>>>>>>>> determine that?
>>>>>>>>>>>> That is an intentionally stupid question.
>>>>>>>>>>>
>>>>>>>>>>> I want to hear your answer.  What criteria do you use to show
>>>>>>>>>>> that
>>>>>>>>>>> Ha3 applied to <N><5> reporting non-halting is incorrect?
>>>>>>>>>>
>>>>>>>>>> I take it that you want me to ignore everything you say.
>>>>>>>>>> This work is intended to be my legacy before I die.
>>>>>>>>>> If you just want to play head games go fornicate yourself.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The fact you have trouble with these simple questions shows how
>>>>>>>>> bad your
>>>>>>>>> logic is.
>>>>>>>>>
>>>>>>>> I told him that his question was just liked counting to ten:
>>>>>>>> 1,2,3 DONE.
>>>>>>>
>>>>>>> So in other words H3a is not simulating for enough steps?
>>>>>>>
>>>>>>
>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>> As long as the simulated input to embedded_H could never reach its
>>>>>> final state in any finite number of steps of correct simulation by
>>>>>> embedded_H then its rejection of this input is necessarily correct.
>>>>>
>>>>>
>>>>> Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED
>>>>> TO DO?
>>>> That is out-of-scope. You must find an error in my exact words and
>>>> explain why it is an error, otherwise we get stuck talking in
>>>> circles that are various shades of the strawman error.
>>>>
>>>
>>> The error in your words is that you don't use the right defintion of
>>> Halting,
>>
>> So in other words you disagree with Linz:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>
> Nope, I agree with him, and he says look at the direct execution of the
> machine,

On 3/27/2022 8:02 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/27/2022 6:26 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/27/2022 1:25 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/27/2022 11:00 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> At least you seem to have dropped the notion of magic PO-machines. Is
>>>>>>> that the mistake you wouldn't tell me about?
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>
>>>>>> HERE IS WHY THAT IS CORRECT:
>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>>>> infinite recursion that only terminates normally because of its
>>>>>> one-way dependency relationship on embedded_H aborting the second
>>>>>> invocation of this otherwise infinite recursion.
>>>>> It terminates. You do see that you've said that again and again, yes?
>>>>> You can't hide a fact you keep stating explicitly.
>>>>> You saw this problem with your supposed solution a while back. That's
>>>>> why you invented magic PO-machines where H can behave differently to a
>>>>> copy of H. Why did you do that? Because you know that Ĥ applied to ⟨Ĥ⟩
>>>>> terminates and so H should accept ⟨Ĥ⟩ ⟨Ĥ⟩. > Now that you have ditched
>>>>
>>>> As long as the simulated input to embedded_H could never reach its
>>>> final state in any finite number of steps of correct simulation then
>>>> its rejection of this input is necessarily correct and everything else
>>>> in the universe is totally irrelevant.
>>>
>>> The definition of the problem is not irrelevant.
>>
>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>
> I see you are now in full-on cut and paste mode and don't want to
> discuss the points put to you. That's not a fun game. Just image that
> I put the same facts to you every time you paste the same text, ok?
>

When I require my exact words to be critiqued this makes the perpetual
strawman error impossible.

TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct.

Since there are no errors in the exact words of the above no one can
point them out. Every attempted rebuttal was the strawman error.

--
Copyright 2022 Pete Olcott

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

On 3/27/2022 8:47 PM, Dennis Bush wrote:
> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>> I don't even look at it because it is merely a terrible attempt at
>> trying to get away with the strawman error.
>
> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.

Frederick Brooks - ACM Awards Turing Award (1999)
I have always focused on Brooks advice of eliminating inessential
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet

Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible.

I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on.

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

TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct.

Halting problem undecidability and infinitely nested simulation (V4)

https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
Copyright 2022 Pete Olcott

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

On 3/27/2022 9:10 PM, Dennis Bush wrote:
> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>> I don't even look at it because it is merely a terrible attempt at
>>>> trying to get away with the strawman error.
>>>
>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>> Frederick Brooks - ACM Awards Turing Award (1999)
>> I have always focused on Brooks advice of eliminating inessential
>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>
>> Keeping analysis down to it minimal essence makes some otherwise
>> impossibly complex analysis feasible.
>>
>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>> what Linz bases his conclusion on.
>>
>> Ĥ.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.
>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>> As long as the simulated input to embedded_H could never reach its final
>> state in any finite number of steps of correct simulation by embedded_H
>> then its rejection of this input is necessarily correct.
>> Halting problem undecidability and infinitely nested simulation (V4)
>
> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>

I agree that I am only talking about embedded_H and Ha3 is not
embedded_H. I am also not talking about H because Linz does not use H as
the basis of his conclusion. We must stay focused on the simplest
possible essence.

It did take me many months writing and rewriting these words:

As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct.

It took thousands of hours from 2004 to 2016 just to get the gist of the
idea that those above words are based on. The last time that I looked
there were more than 12,000 posts by me in this forum since 2004.

> As long as the simulated input <N><5> to Ha3 could never reach its final
> state in any finite number of steps of correct simulation by Ha3
> then its rejection of this input is necessarily correct
>

--
Copyright 2022 Pete Olcott

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

On 3/27/2022 9:19 PM, Richard Damon wrote:
> On 3/27/22 10:04 PM, olcott wrote:

>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>> As long as the simulated input to embedded_H could never reach its
>> final state in any finite number of steps of correct simulation by
>> embedded_H then its rejection of this input is necessarily correct.
>>
> WRONG DEFINTION OF HALTING. FAIL.

You you still disagree with Linz:
computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

Halting problem undecidability and infinitely nested simulation (V4)

https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
Copyright 2022 Pete Olcott

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

On 3/27/2022 9:33 PM, Dennis Bush wrote:
> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>>>> I don't even look at it because it is merely a terrible attempt at
>>>>>> trying to get away with the strawman error.
>>>>>
>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>>>> Frederick Brooks - ACM Awards Turing Award (1999)
>>>> I have always focused on Brooks advice of eliminating inessential
>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>
>>>> Keeping analysis down to it minimal essence makes some otherwise
>>>> impossibly complex analysis feasible.
>>>>
>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>>>> what Linz bases his conclusion on.
>>>>
>>>> Ĥ.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.
>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>> As long as the simulated input to embedded_H could never reach its final
>>>> state in any finite number of steps of correct simulation by embedded_H
>>>> then its rejection of this input is necessarily correct.
>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>
>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>>>
>> I agree that I am only talking about embedded_H and Ha3 is not
>> embedded_H. I am also not talking about H because Linz does not use H as
>> the basis of his conclusion. We must stay focused on the simplest
>> possible essence.
>
> Yes you are talking about H (or more accurately Ha).

The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.

--
Copyright 2022 Pete Olcott

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

On 3/27/2022 10:04 PM, Dennis Bush wrote:
> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
>> On 3/27/2022 9:33 PM, Dennis Bush wrote:
>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>>>>>> I don't even look at it because it is merely a terrible attempt at
>>>>>>>> trying to get away with the strawman error.
>>>>>>>
>>>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>>>>>> Frederick Brooks - ACM Awards Turing Award (1999)
>>>>>> I have always focused on Brooks advice of eliminating inessential
>>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>
>>>>>> Keeping analysis down to it minimal essence makes some otherwise
>>>>>> impossibly complex analysis feasible.
>>>>>>
>>>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>>>>>> what Linz bases his conclusion on.
>>>>>>
>>>>>> Ĥ.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.
>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>> As long as the simulated input to embedded_H could never reach its final
>>>>>> state in any finite number of steps of correct simulation by embedded_H
>>>>>> then its rejection of this input is necessarily correct.
>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>>>
>>>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>>>>>
>>>> I agree that I am only talking about embedded_H and Ha3 is not
>>>> embedded_H. I am also not talking about H because Linz does not use H as
>>>> the basis of his conclusion. We must stay focused on the simplest
>>>> possible essence.
>>>
>>> Yes you are talking about H (or more accurately Ha).
>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
>> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:

>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>> infinite recursion that only terminates normally because of its one-way
>> dependency relationship on embedded_H aborting the second invocation of
>> this otherwise infinite recursion.
>
> That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.

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

embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
simulated input will never reach its own final state ⟨Ĥ.qn⟩.

--
Copyright 2022 Pete Olcott

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

On Sunday, March 27, 2022 at 10:18:06 PM UTC-5, olcott wrote:
> On 3/27/2022 10:04 PM, Dennis Bush wrote:
> > On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
> >> On 3/27/2022 9:33 PM, Dennis Bush wrote:
> >>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
> >>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
> >>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
> >>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
> >>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
> >>>>>>>> I don't even look at it because it is merely a terrible attempt at
> >>>>>>>> trying to get away with the strawman error.
> >>>>>>>
> >>>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
> >>>>>> Frederick Brooks - ACM Awards Turing Award (1999)
> >>>>>> I have always focused on Brooks advice of eliminating inessential
> >>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
> >>>>>>
> >>>>>> Keeping analysis down to it minimal essence makes some otherwise
> >>>>>> impossibly complex analysis feasible.
> >>>>>>
> >>>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
> >>>>>> what Linz bases his conclusion on.
> >>>>>>
> >>>>>> Ĥ.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.
> >>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
> >>>>>> As long as the simulated input to embedded_H could never reach its final
> >>>>>> state in any finite number of steps of correct simulation by embedded_H
> >>>>>> then its rejection of this input is necessarily correct.
> >>>>>> Halting problem undecidability and infinitely nested simulation (V4)
> >>>>>
> >>>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
> >>>>>
> >>>> I agree that I am only talking about embedded_H and Ha3 is not
> >>>> embedded_H. I am also not talking about H because Linz does not use H as
> >>>> the basis of his conclusion. We must stay focused on the simplest
> >>>> possible essence.
> >>>
> >>> Yes you are talking about H (or more accurately Ha).
> >> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
> >> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
> >> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:
>
> >> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
> >> infinite recursion that only terminates normally because of its one-way
> >> dependency relationship on embedded_H aborting the second invocation of
> >> this otherwise infinite recursion.
> >
> > That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
>
> A halt decider computes the mapping of its inputs to its own accept or
> reject state on the basis of the actual behavior specified by its input.
>
> embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
> simulated input will never reach its own final state ⟨Ĥ.qn⟩.
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

Pecan oil is highly polyunsaturated.

On 3/28/2022 6:33 AM, Richard Damon wrote:
> On 3/27/22 11:00 PM, olcott wrote:
>> On 3/27/2022 9:29 PM, Richard Damon wrote:
>>> On 3/27/22 10:07 PM, olcott wrote:
>>>> On 3/27/2022 8:52 PM, Richard Damon wrote:
>>>>> On 3/27/22 9:27 PM, olcott wrote:
>>>>>> On 3/27/2022 8:19 PM, Richard Damon wrote:
>>>>>>> On 3/27/22 9:00 PM, olcott wrote:
>>>>>>>> On 3/27/2022 7:51 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/22 8:36 PM, olcott wrote:
>>>>>>>>>> On 3/27/2022 7:33 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/27/22 8:22 PM, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 6:56 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/27/22 7:37 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 6:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 6:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/27/22 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 6:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:43:43 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:12:47 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 4:40:59 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 3:35:17 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 7:30 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what the correct answer for it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is, is determined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> solely by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Ĥ halts on input ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to say what the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's already
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every string either represents a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is no context other than some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prior agreed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how a TM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and an input should be represented.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must accept
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> those strings that represent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that you need to reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the very
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear evidence that you know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no TM is a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The directly executed Ĥ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion that only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminates normally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one-way dependency relationship on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of this otherwise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does not matter why the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation represented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a particular
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> string
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. You've been trying to pull
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this "it only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts because"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for years.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping from its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything else in the universe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> besides it inputs) to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state based on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these actual inputs (not any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of anything
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> else in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We also know that the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same as the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input by a UTM. On this basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that diverges from this behavior is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated outside of Ĥ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it must have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior as Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated inside of Ĥ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> several steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> already been executed when this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation begins thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifying a different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starts at its beginning.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I assume you have not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you know that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents is Ĥ applied to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> string ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is simulated in the middle of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ is simulated at the beginning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That either is or is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is obvious that the above
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sequence is infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the halt decider aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> second recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first recursive call would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That the first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts does not indicate that it is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed encoding). There is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dispensation from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "special"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> kinds of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't you think that having to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basic matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, year in, year out,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> indicates that maybe you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something else?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, YOU do not grasp that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions that were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> established
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARE the definitions you need to use,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because a halt decider must compute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings based on the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior specified
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strings which is correctly measured by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of these strings you already
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that I am
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, wrong definition, wrong answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you have a reference for adding the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'of N steps'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> N = "simulating it for as many steps as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will take"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So might be infinite, and thus H fails to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You already that this is an infinite pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, the ... notation means that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intend the pattern to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keep on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating for ever, so you are SHOWING 3
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stateing that more
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What I said, was that pattern only repeats
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinity if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H correctly computes the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping from its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Which it doesn't, because Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and that is
>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior that embedded_H (and therefore
>>>>>>>>>>>>>>>>>>>>>>>>>>> H) is stipulated
>>>>>>>>>>>>>>>>>>>>>>>>>>> to answer about. So anything you say that
>>>>>>>>>>>>>>>>>>>>>>>>>>> follows doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>> matter.
>>>>>>>>>>>>>>>>>>>>>>>>>> That is a common misconception. Please read my
>>>>>>>>>>>>>>>>>>>>>>>>>> paper.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I've read it, and it's bogus. It says nothing
>>>>>>>>>>>>>>>>>>>>>>>>> more than what
>>>>>>>>>>>>>>>>>>>>>>>>> you've been saying before.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> To repeat:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When H3 correctly computes the mapping from its
>>>>>>>>>>>>>>>>>>>>>>>>> input finite
>>>>>>>>>>>>>>>>>>>>>>>>> strings <N> <3> to its own final reject state
>>>>>>>>>>>>>>>>>>>>>>>>> on the basis that there is
>>>>>>>>>>>>>>>>>>>>>>>>> no finite number N of steps of correct
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input
>>>>>>>>>>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>>>>>>>>>>> UTM within H3 then H3 has correctly decided
>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Sure there is, I defined them earlier. But just
>>>>>>>>>>>>>>>>>>>>>>> so there's no
>>>>>>>>>>>>>>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3
>>>>>>>>>>>>>>>>>>>>>>> instead. So Ha3 uses
>>>>>>>>>>>>>>>>>>>>>>> as its halt status criteria: simulate for 3 steps
>>>>>>>>>>>>>>>>>>>>>>> and abort.
>>>>>>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>>>>>> You might as well define counting to ten: 1,2,3 DONE.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So Ha3 is obviously wrong? What criteria do you use
>>>>>>>>>>>>>>>>>>>>> to determine that?
>>>>>>>>>>>>>>>>>>>> That is an intentionally stupid question.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I want to hear your answer.  What criteria do you use
>>>>>>>>>>>>>>>>>>> to show that
>>>>>>>>>>>>>>>>>>> Ha3 applied to <N><5> reporting non-halting is
>>>>>>>>>>>>>>>>>>> incorrect?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I take it that you want me to ignore everything you say.
>>>>>>>>>>>>>>>>>> This work is intended to be my legacy before I die.
>>>>>>>>>>>>>>>>>> If you just want to play head games go fornicate
>>>>>>>>>>>>>>>>>> yourself.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The fact you have trouble with these simple questions
>>>>>>>>>>>>>>>>> shows how bad your
>>>>>>>>>>>>>>>>> logic is.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I told him that his question was just liked counting to
>>>>>>>>>>>>>>>> ten: 1,2,3 DONE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So in other words H3a is not simulating for enough steps?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>>>>>>>>>> As long as the simulated input to embedded_H could never
>>>>>>>>>>>>>> reach its final state in any finite number of steps of
>>>>>>>>>>>>>> correct simulation by embedded_H then its rejection of
>>>>>>>>>>>>>> this input is necessarily correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS
>>>>>>>>>>>>> SUPPOSED TO DO?
>>>>>>>>>>>> That is out-of-scope. You must find an error in my exact
>>>>>>>>>>>> words and explain why it is an error, otherwise we get stuck
>>>>>>>>>>>> talking in circles that are various shades of the strawman
>>>>>>>>>>>> error.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The error in your words is that you don't use the right
>>>>>>>>>>> defintion of Halting,
>>>>>>>>>>
>>>>>>>>>> So in other words you disagree with Linz:
>>>>>>>>>>
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, I agree with him, and he says look at the direct
>>>>>>>>> execution of the machine,
>>>>>>>>
>>>>>>>> Ah so you believe that Linz does not accept that the direct
>>>>>>>> execution of Turing machine is computationally equivalent to the
>>>>>>>> UTM simulation of the Turing machine description of this same
>>>>>>>> machine.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Computationally Equivalent, YES, but only by a REAL UTM.
>>>>>>
>>>>>> Go back to my words and find the error. Every error that you have
>>>>>> found is merely an error in the inaccurate paraphrase of what I said.
>>>>>>
>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>> As long as the simulated input to embedded_H could never reach its
>>>>>> final state in any finite number of steps of correct simulation by
>>>>>> embedded_H then its rejection of this input is necessarily correct.
>>>>>>
>>>>>
>>>>> embedded_H is NOT a UTM
>>>>
>>>> Bzzt you lose, I did not use the term "UTM" in my exact words above.
>>>>
>>>>
>>>
>>> BZZT BACK, LIAR.
>>>
>>> I Said:
>>>
>>>> embedded_H is NOT a UTM
>>
>> And I said the you are only allowed to critique my verbatim words that
>> have no "UTM".
>>
>
> Becasue you use the wrong definition of Halting. PERIOD.
>

On 3/28/2022 11:48 AM, Dennis Bush wrote:
> On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote:
>> On 3/28/2022 11:31 AM, Dennis Bush wrote:
>>> On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote:
>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:
>>>>> On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote:
>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:
>>>>>>> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:
>>>>>>>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> I don't even look at it because it is merely a terrible attempt at
>>>>>>>>>>>>>> trying to get away with the strawman error.
>>>>>>>>>>>>>
>>>>>>>>>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>>>>>>>>>>>> Frederick Brooks - ACM Awards Turing Award (1999)
>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessential
>>>>>>>>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>>>>>>>
>>>>>>>>>>>> Keeping analysis down to it minimal essence makes some otherwise
>>>>>>>>>>>> impossibly complex analysis feasible.
>>>>>>>>>>>>
>>>>>>>>>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>>>>>>>>>>>> what Linz bases his conclusion on.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.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.
>>>>>>>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>>>>>>>> As long as the simulated input to embedded_H could never reach its final
>>>>>>>>>>>> state in any finite number of steps of correct simulation by embedded_H
>>>>>>>>>>>> then its rejection of this input is necessarily correct.
>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>>>>>>>>>
>>>>>>>>>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>>>>>>>>>>>
>>>>>>>>>> I agree that I am only talking about embedded_H and Ha3 is not
>>>>>>>>>> embedded_H. I am also not talking about H because Linz does not use H as
>>>>>>>>>> the basis of his conclusion. We must stay focused on the simplest
>>>>>>>>>> possible essence.
>>>>>>>>>
>>>>>>>>> Yes you are talking about H (or more accurately Ha).
>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
>>>>>>>> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:
>>>>>>
>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>>>>>> infinite recursion that only terminates normally because of its one-way
>>>>>>>> dependency relationship on embedded_H aborting the second invocation of
>>>>>>>> this otherwise infinite recursion.
>>>>>>>
>>>>>>> That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
>>>>>> A halt decider computes the mapping of its inputs to its own accept or
>>>>>> reject state on the basis of the actual behavior specified by its input.
>>>>>>
>>>>>> embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
>>>>>> simulated input will never reach its own final state ⟨Ĥ.qn⟩.
>>>>>
>>>>> Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
>>>>>
>>>> You stipulated that <N><5> only has five iterations.
>>>> Ha3 is merely halt decider intentionally designed to get the wrong
>>>> answer. I really don't have time to spent on screwy ideas like this.
>>>
>>> By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
>>> any finite number of steps of correct simulation by Ha3.
>> You designed Ha3 to make sure that it cuts off simulation prematurely.
>> If you insist on playing these head games this will be the last response
>> I will provide.
>
> So in other words Ha3 is wrong because it didn't simulate long enough?
>