On 4/19/23 7:16 PM, olcott wrote:
> On 4/19/2023 5:49 PM, Richard Damon wrote:
>> On 4/19/23 11:05 AM, olcott wrote:
>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>
>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute its
>>>>> mapping
>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even after
>>>>> 10,000
>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is defined to
>>>>> have
>>>>> a pathological relationship to embedded_H.
>>>>
>>>>
>>>> An YOU keep on falling into your Strawman error. The question is NOT
>>>> what does the "simulation by H" show, but what is the actual
>>>> behavior of the actual machine the input represents.
>>>>
>>>>
>>>
>>> When a simulating halt decider correctly simulates N steps of its input
>>> it derives the exact same N steps that a pure UTM would derive because
>>> it is itself a UTM with extra features.
>>>
>>
>> No, it ISN'T a UTM because if fails to meeet the definition of a UTM.
>>
>> You are just proving that you are a pathological liar that doesn't
>> know what he is talking about.
>>
>>> My reviewers cannot show that any of the extra features added to the UTM
>>> change the behavior of the simulated input for the first N steps of
>>> simulation:
>>> (a) Watching the behavior doesn't change it.
>>> (b) Matching non-halting behavior patterns doesn't change it
>>> (c) Even aborting the simulation after N steps doesn't change the
>>> first N steps.
>>
>> Which don't matter, as the question
>>
>>>
>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>> behavior of the simulation of N steps by embedded_H because embedded_H
>>> has the exact same behavior as a UTM for these first N steps, and you
>>> already agreed with this.
>>
>> No, the actual behavior of the input is what the MACHINE Ĥ applied to
>> (Ĥ) does.
> Because embedded_H is a UTM that has been augmented with three features
> that cannot possibly cause its simulation of its input to diverge from
> the simulation of a pure UTM for the first N steps of simulation we know
> that it necessarily does provide the actual behavior specified by this
> input for these N steps.

And is no longer a UTM, since if fails to meet the requirement of a UTM

You are just showing you don't understand what a "UTM" actually is.

Note, that UTM isn't just a fancy word for "Simulator", but a very
specific type of simulator, and since some of your "additions" break
those requiremnts, your H isn't actually a UTM.

You are just proving your stupidity.

>
> Because these N steps can include 10,000 recursive simulations of ⟨Ĥ⟩ by
> embedded_H, these recursive simulations <are> the actual behavior
> specified by this input.
>

And no matter how many steps (N) you design your H / embedded_H to
simulate Ĥ (Ĥ), there will always be a slightly larger (but still
finite) number, which if the same input is given to an ACTUAL UTM, that
simulation will reach the point that the top level embedded_H decides to
abort its simulation, transition to Qn, and Ĥ Halts.

Since you MUST chose your "N" when you design your H, it is a SINGLE
DEFINED VALUE, and always to small to determine the actual behavior of
the Ĥ[n] built on that H[n].

The only Ĥ[n] that is non-halting is when N becomes infinite, but for
that N, H never answers.

In fact, your flawed logic is based on the LIE that embedded_H can have
a different N than H does, which just means you LIED when you said you
built Ĥ by the requirements.

On 4/19/2023 7:07 PM, Richard Damon wrote:
> On 4/19/23 7:16 PM, olcott wrote:
>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>> On 4/19/23 11:05 AM, olcott wrote:
>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>
>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute its
>>>>>> mapping
>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even after
>>>>>> 10,000
>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is defined
>>>>>> to have
>>>>>> a pathological relationship to embedded_H.
>>>>>
>>>>>
>>>>> An YOU keep on falling into your Strawman error. The question is
>>>>> NOT what does the "simulation by H" show, but what is the actual
>>>>> behavior of the actual machine the input represents.
>>>>>
>>>>>
>>>>
>>>> When a simulating halt decider correctly simulates N steps of its input
>>>> it derives the exact same N steps that a pure UTM would derive because
>>>> it is itself a UTM with extra features.
>>>>
>>>
>>> No, it ISN'T a UTM because if fails to meeet the definition of a UTM.
>>>
>>> You are just proving that you are a pathological liar that doesn't
>>> know what he is talking about.
>>>
>>>> My reviewers cannot show that any of the extra features added to the
>>>> UTM
>>>> change the behavior of the simulated input for the first N steps of
>>>> simulation:
>>>> (a) Watching the behavior doesn't change it.
>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>> first N steps.
>>>
>>> Which don't matter, as the question
>>>
>>>>
>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>> behavior of the simulation of N steps by embedded_H because embedded_H
>>>> has the exact same behavior as a UTM for these first N steps, and you
>>>> already agreed with this.
>>>
>>> No, the actual behavior of the input is what the MACHINE Ĥ applied to
>>> (Ĥ) does.
>> Because embedded_H is a UTM that has been augmented with three features
>> that cannot possibly cause its simulation of its input to diverge from
>> the simulation of a pure UTM for the first N steps of simulation we know
>> that it necessarily does provide the actual behavior specified by this
>> input for these N steps.
>
> And is no longer a UTM, since if fails to meet the requirement of a UTM
>
As you already agreed:
The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are the
actual behavior of these N steps because

(a) Watching the behavior doesn't change it.
(b) Matching non-halting behavior patterns doesn't change it
(c) Even aborting the simulation after N steps doesn't change the
first N steps.

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

On 4/19/23 8:31 PM, olcott wrote:
> On 4/19/2023 7:07 PM, Richard Damon wrote:
>> On 4/19/23 7:16 PM, olcott wrote:
>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>
>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute its
>>>>>>> mapping
>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even after
>>>>>>> 10,000
>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is defined
>>>>>>> to have
>>>>>>> a pathological relationship to embedded_H.
>>>>>>
>>>>>>
>>>>>> An YOU keep on falling into your Strawman error. The question is
>>>>>> NOT what does the "simulation by H" show, but what is the actual
>>>>>> behavior of the actual machine the input represents.
>>>>>>
>>>>>>
>>>>>
>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>> input
>>>>> it derives the exact same N steps that a pure UTM would derive because
>>>>> it is itself a UTM with extra features.
>>>>>
>>>>
>>>> No, it ISN'T a UTM because if fails to meeet the definition of a UTM.
>>>>
>>>> You are just proving that you are a pathological liar that doesn't
>>>> know what he is talking about.
>>>>
>>>>> My reviewers cannot show that any of the extra features added to
>>>>> the UTM
>>>>> change the behavior of the simulated input for the first N steps of
>>>>> simulation:
>>>>> (a) Watching the behavior doesn't change it.
>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>> first N steps.
>>>>
>>>> Which don't matter, as the question
>>>>
>>>>>
>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>> behavior of the simulation of N steps by embedded_H because embedded_H
>>>>> has the exact same behavior as a UTM for these first N steps, and you
>>>>> already agreed with this.
>>>>
>>>> No, the actual behavior of the input is what the MACHINE Ĥ applied
>>>> to (Ĥ) does.
>>> Because embedded_H is a UTM that has been augmented with three features
>>> that cannot possibly cause its simulation of its input to diverge from
>>> the simulation of a pure UTM for the first N steps of simulation we know
>>> that it necessarily does provide the actual behavior specified by this
>>> input for these N steps.
>>
>> And is no longer a UTM, since if fails to meet the requirement of a UTM
>>
> As you already agreed:
> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are the
> actual behavior of these N steps because
>
> (a) Watching the behavior doesn't change it.
> (b) Matching non-halting behavior patterns doesn't change it
> (c) Even aborting the simulation after N steps doesn't change the
> first N steps.
>
>
>

But a UTM doesn't simulate just "N" steps of its input, but ALL of them.

Anything less and it isn't a UTM. DEFINITION.

Your basically claiming that your immortal since you haven't died, YET.

You are just PROVING that you don't understand what you are talking about.

Since you don't seem to want to hold to correct definitions, everything
you say needs to be treated as a likely LIE or DECEPTION.

You are just proving your incompetence.

On 4/19/2023 7:45 PM, Richard Damon wrote:
> On 4/19/23 8:31 PM, olcott wrote:
>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>> On 4/19/23 7:16 PM, olcott wrote:
>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>
>>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute its
>>>>>>>> mapping
>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even
>>>>>>>> after 10,000
>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is defined
>>>>>>>> to have
>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>
>>>>>>>
>>>>>>> An YOU keep on falling into your Strawman error. The question is
>>>>>>> NOT what does the "simulation by H" show, but what is the actual
>>>>>>> behavior of the actual machine the input represents.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>>> input
>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>> because
>>>>>> it is itself a UTM with extra features.
>>>>>>
>>>>>
>>>>> No, it ISN'T a UTM because if fails to meeet the definition of a UTM.
>>>>>
>>>>> You are just proving that you are a pathological liar that doesn't
>>>>> know what he is talking about.
>>>>>
>>>>>> My reviewers cannot show that any of the extra features added to
>>>>>> the UTM
>>>>>> change the behavior of the simulated input for the first N steps of
>>>>>> simulation:
>>>>>> (a) Watching the behavior doesn't change it.
>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>> first N steps.
>>>>>
>>>>> Which don't matter, as the question
>>>>>
>>>>>>
>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>> embedded_H
>>>>>> has the exact same behavior as a UTM for these first N steps, and you
>>>>>> already agreed with this.
>>>>>
>>>>> No, the actual behavior of the input is what the MACHINE Ĥ applied
>>>>> to (Ĥ) does.
>>>> Because embedded_H is a UTM that has been augmented with three features
>>>> that cannot possibly cause its simulation of its input to diverge from
>>>> the simulation of a pure UTM for the first N steps of simulation we
>>>> know
>>>> that it necessarily does provide the actual behavior specified by this
>>>> input for these N steps.
>>>
>>> And is no longer a UTM, since if fails to meet the requirement of a UTM
>>>
>> As you already agreed:
>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are the
>> actual behavior of these N steps because
>>
>> (a) Watching the behavior doesn't change it.
>> (b) Matching non-halting behavior patterns doesn't change it
>> (c) Even aborting the simulation after N steps doesn't change the
>> first N steps.
>>
>>
>>
>
> But a UTM doesn't simulate just "N" steps of its input, but ALL of them.
>

Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual behavior
of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
recursive simulations these are the actual behavior of ⟨Ĥ⟩.

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

On 4/19/23 8:52 PM, olcott wrote:
> On 4/19/2023 7:45 PM, Richard Damon wrote:
>> On 4/19/23 8:31 PM, olcott wrote:
>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>
>>>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute
>>>>>>>>> its mapping
>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even
>>>>>>>>> after 10,000
>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>> defined to have
>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>
>>>>>>>>
>>>>>>>> An YOU keep on falling into your Strawman error. The question is
>>>>>>>> NOT what does the "simulation by H" show, but what is the actual
>>>>>>>> behavior of the actual machine the input represents.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>>>> input
>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>> because
>>>>>>> it is itself a UTM with extra features.
>>>>>>>
>>>>>>
>>>>>> No, it ISN'T a UTM because if fails to meeet the definition of a UTM.
>>>>>>
>>>>>> You are just proving that you are a pathological liar that doesn't
>>>>>> know what he is talking about.
>>>>>>
>>>>>>> My reviewers cannot show that any of the extra features added to
>>>>>>> the UTM
>>>>>>> change the behavior of the simulated input for the first N steps of
>>>>>>> simulation:
>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>>> first N steps.
>>>>>>
>>>>>> Which don't matter, as the question
>>>>>>
>>>>>>>
>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>> embedded_H
>>>>>>> has the exact same behavior as a UTM for these first N steps, and
>>>>>>> you
>>>>>>> already agreed with this.
>>>>>>
>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ applied
>>>>>> to (Ĥ) does.
>>>>> Because embedded_H is a UTM that has been augmented with three
>>>>> features
>>>>> that cannot possibly cause its simulation of its input to diverge from
>>>>> the simulation of a pure UTM for the first N steps of simulation we
>>>>> know
>>>>> that it necessarily does provide the actual behavior specified by this
>>>>> input for these N steps.
>>>>
>>>> And is no longer a UTM, since if fails to meet the requirement of a UTM
>>>>
>>> As you already agreed:
>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are the
>>> actual behavior of these N steps because
>>>
>>> (a) Watching the behavior doesn't change it.
>>> (b) Matching non-halting behavior patterns doesn't change it
>>> (c) Even aborting the simulation after N steps doesn't change the
>>> first N steps.
>>>
>>>
>>>
>>
>> But a UTM doesn't simulate just "N" steps of its input, but ALL of them.
>>
>
> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual behavior
> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>
>

Yes, but doesn't actually show the ACTUAL behavior of the input as
defined, since that would be what the ACTUAL MACHINE does, or the
COMPLETE SIMULATION done by a UTM, not the PARTIAL simulation done by H.

You are using a STRAWMAN criteria, so you get the wrong answer.

That is like drive 10 miles on a road, then getting off, and say they
all looked the same, so this road must go on forever.

Note, embedded_H simulates for the EXACT SAME number of steps as H, so
gets the exact same answer, because it INCORRECTLY aborts at the exact
same point and decides its input is non-halting, returning that answer
to its caller, which makes the ACTUAL BEHAVIOR that input represents to
be Halting.

You are just proving that you don't understand the simple basic of the
theory, and are proving yourself to be a ignorant liar.

On 4/19/2023 8:08 PM, Richard Damon wrote:
> On 4/19/23 8:52 PM, olcott wrote:
>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>> On 4/19/23 8:31 PM, olcott wrote:
>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute
>>>>>>>>>> its mapping
>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even
>>>>>>>>>> after 10,000
>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>> defined to have
>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> An YOU keep on falling into your Strawman error. The question
>>>>>>>>> is NOT what does the "simulation by H" show, but what is the
>>>>>>>>> actual behavior of the actual machine the input represents.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>> its input
>>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>>> because
>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>
>>>>>>>
>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition of a
>>>>>>> UTM.
>>>>>>>
>>>>>>> You are just proving that you are a pathological liar that
>>>>>>> doesn't know what he is talking about.
>>>>>>>
>>>>>>>> My reviewers cannot show that any of the extra features added to
>>>>>>>> the UTM
>>>>>>>> change the behavior of the simulated input for the first N steps of
>>>>>>>> simulation:
>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>> (c) Even aborting the simulation after N steps doesn't change
>>>>>>>> the first N steps.
>>>>>>>
>>>>>>> Which don't matter, as the question
>>>>>>>
>>>>>>>>
>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>>> embedded_H
>>>>>>>> has the exact same behavior as a UTM for these first N steps,
>>>>>>>> and you
>>>>>>>> already agreed with this.
>>>>>>>
>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>> applied to (Ĥ) does.
>>>>>> Because embedded_H is a UTM that has been augmented with three
>>>>>> features
>>>>>> that cannot possibly cause its simulation of its input to diverge
>>>>>> from
>>>>>> the simulation of a pure UTM for the first N steps of simulation
>>>>>> we know
>>>>>> that it necessarily does provide the actual behavior specified by
>>>>>> this
>>>>>> input for these N steps.
>>>>>
>>>>> And is no longer a UTM, since if fails to meet the requirement of a
>>>>> UTM
>>>>>
>>>> As you already agreed:
>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are the
>>>> actual behavior of these N steps because
>>>>
>>>> (a) Watching the behavior doesn't change it.
>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>> first N steps.
>>>>
>>>>
>>>>
>>>
>>> But a UTM doesn't simulate just "N" steps of its input, but ALL of them.
>>>
>>
>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual behavior
>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>
>>
>
> Yes, but doesn't actually show the ACTUAL behavior of the input as
> defined,
There is only one actual behavior of the actual input and this behavior
is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.

If you simply don't "believe in" UTMs then you might not see this
correctly.

If you fully comprehend UTMs then you understand that 10,000 recursive
simulations of ⟨Ĥ⟩ by embedded_H are the actual behavior of ⟨Ĥ⟩.

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

On 4/19/23 9:25 PM, olcott wrote:
> On 4/19/2023 8:08 PM, Richard Damon wrote:
>> On 4/19/23 8:52 PM, olcott wrote:
>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute
>>>>>>>>>>> its mapping
>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even
>>>>>>>>>>> after 10,000
>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>>> defined to have
>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> An YOU keep on falling into your Strawman error. The question
>>>>>>>>>> is NOT what does the "simulation by H" show, but what is the
>>>>>>>>>> actual behavior of the actual machine the input represents.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>> its input
>>>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>>>> because
>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition of a
>>>>>>>> UTM.
>>>>>>>>
>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>> doesn't know what he is talking about.
>>>>>>>>
>>>>>>>>> My reviewers cannot show that any of the extra features added
>>>>>>>>> to the UTM
>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>> steps of
>>>>>>>>> simulation:
>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change
>>>>>>>>> the first N steps.
>>>>>>>>
>>>>>>>> Which don't matter, as the question
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>>>> embedded_H
>>>>>>>>> has the exact same behavior as a UTM for these first N steps,
>>>>>>>>> and you
>>>>>>>>> already agreed with this.
>>>>>>>>
>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>> applied to (Ĥ) does.
>>>>>>> Because embedded_H is a UTM that has been augmented with three
>>>>>>> features
>>>>>>> that cannot possibly cause its simulation of its input to diverge
>>>>>>> from
>>>>>>> the simulation of a pure UTM for the first N steps of simulation
>>>>>>> we know
>>>>>>> that it necessarily does provide the actual behavior specified by
>>>>>>> this
>>>>>>> input for these N steps.
>>>>>>
>>>>>> And is no longer a UTM, since if fails to meet the requirement of
>>>>>> a UTM
>>>>>>
>>>>> As you already agreed:
>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are the
>>>>> actual behavior of these N steps because
>>>>>
>>>>> (a) Watching the behavior doesn't change it.
>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>> first N steps.
>>>>>
>>>>>
>>>>>
>>>>
>>>> But a UTM doesn't simulate just "N" steps of its input, but ALL of
>>>> them.
>>>>
>>>
>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual behavior
>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>
>>>
>>
>> Yes, but doesn't actually show the ACTUAL behavior of the input as
>> defined,
> There is only one actual behavior of the actual input and this behavior
> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.

Nope, Read the problem definition.

The behavior to be decided by a Halt Decider is the behavior of the
ACTUAL MACHINE which is decribed by the input.

You are just trying to pass a DECIETFULL LIE about what your H is
supposed to do, because you just don't understand the theory, because
you are just too ignorant.

>
> If you simply don't "believe in" UTMs then you might not see this
> correctly.

No, you are the one that doesn't seem to "believe" in UTMs. You don't
seem to understand that a UTM ALWAYS recreates the behavior of the
machine it is given the description of, because it NEVER stops until it
is done.

Anything less is NOT a UTM, and you LIE when you claim your H is one.

>
> If you fully comprehend UTMs then you understand that 10,000 recursive
> simulations of ⟨Ĥ⟩ by embedded_H are the actual behavior of ⟨Ĥ⟩.
>
>

Nope, ALL the steps of Ĥ (Ĥ) is the behavior of the input, which is also
what happens when you give a REAL UTM (one the doesn't stop) the input
UTM (Ĥ) (Ĥ)

You are just stuck in using INCORRECT definitions, so you get wrong
answers. This shows that you really don't understand the very basics of
what Truth is, because Truth is base on using the RIGHT definitions, the
definition defined by the field.

Thus, YOU LIE when you make your claims, because you are too igno

On 4/19/2023 8:38 PM, Richard Damon wrote:
> On 4/19/23 9:25 PM, olcott wrote:
>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>> On 4/19/23 8:52 PM, olcott wrote:
>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must compute
>>>>>>>>>>>> its mapping
>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even
>>>>>>>>>>>> after 10,000
>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>>>> defined to have
>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> An YOU keep on falling into your Strawman error. The question
>>>>>>>>>>> is NOT what does the "simulation by H" show, but what is the
>>>>>>>>>>> actual behavior of the actual machine the input represents.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>>> its input
>>>>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>>>>> because
>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition of
>>>>>>>>> a UTM.
>>>>>>>>>
>>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>>> doesn't know what he is talking about.
>>>>>>>>>
>>>>>>>>>> My reviewers cannot show that any of the extra features added
>>>>>>>>>> to the UTM
>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>> steps of
>>>>>>>>>> simulation:
>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change
>>>>>>>>>> the first N steps.
>>>>>>>>>
>>>>>>>>> Which don't matter, as the question
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>>>>> embedded_H
>>>>>>>>>> has the exact same behavior as a UTM for these first N steps,
>>>>>>>>>> and you
>>>>>>>>>> already agreed with this.
>>>>>>>>>
>>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>>> applied to (Ĥ) does.
>>>>>>>> Because embedded_H is a UTM that has been augmented with three
>>>>>>>> features
>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>> diverge from
>>>>>>>> the simulation of a pure UTM for the first N steps of simulation
>>>>>>>> we know
>>>>>>>> that it necessarily does provide the actual behavior specified
>>>>>>>> by this
>>>>>>>> input for these N steps.
>>>>>>>
>>>>>>> And is no longer a UTM, since if fails to meet the requirement of
>>>>>>> a UTM
>>>>>>>
>>>>>> As you already agreed:
>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are
>>>>>> the actual behavior of these N steps because
>>>>>>
>>>>>> (a) Watching the behavior doesn't change it.
>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>> first N steps.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> But a UTM doesn't simulate just "N" steps of its input, but ALL of
>>>>> them.
>>>>>
>>>>
>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual
>>>> behavior
>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>
>>>>
>>>
>>> Yes, but doesn't actually show the ACTUAL behavior of the input as
>>> defined,
>> There is only one actual behavior of the actual input and this behavior
>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.
>
> Nope, Read the problem definition.
>
> The behavior to be decided by a Halt Decider is the behavior of the
> ACTUAL MACHINE which is decribed by the input.

No matter what the problem definition says the actual behavior of the
actual input must necessarily be the N steps simulated by embedded_H.

The only alternative is to simply disbelieve in UTMs.

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

On 4/19/23 9:59 PM, olcott wrote:
> On 4/19/2023 8:38 PM, Richard Damon wrote:
>> On 4/19/23 9:25 PM, olcott wrote:
>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation error*
>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩ even
>>>>>>>>>>>>> after 10,000
>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>>>>> defined to have
>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>> question is NOT what does the "simulation by H" show, but
>>>>>>>>>>>> what is the actual behavior of the actual machine the input
>>>>>>>>>>>> represents.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>>>> its input
>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>> derive because
>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition of
>>>>>>>>>> a UTM.
>>>>>>>>>>
>>>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>>>> doesn't know what he is talking about.
>>>>>>>>>>
>>>>>>>>>>> My reviewers cannot show that any of the extra features added
>>>>>>>>>>> to the UTM
>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>> steps of
>>>>>>>>>>> simulation:
>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change
>>>>>>>>>>> the first N steps.
>>>>>>>>>>
>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is the
>>>>>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>>>>>> embedded_H
>>>>>>>>>>> has the exact same behavior as a UTM for these first N steps,
>>>>>>>>>>> and you
>>>>>>>>>>> already agreed with this.
>>>>>>>>>>
>>>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>>>> applied to (Ĥ) does.
>>>>>>>>> Because embedded_H is a UTM that has been augmented with three
>>>>>>>>> features
>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>> diverge from
>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>> simulation we know
>>>>>>>>> that it necessarily does provide the actual behavior specified
>>>>>>>>> by this
>>>>>>>>> input for these N steps.
>>>>>>>>
>>>>>>>> And is no longer a UTM, since if fails to meet the requirement
>>>>>>>> of a UTM
>>>>>>>>
>>>>>>> As you already agreed:
>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are
>>>>>>> the actual behavior of these N steps because
>>>>>>>
>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>>> first N steps.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But a UTM doesn't simulate just "N" steps of its input, but ALL of
>>>>>> them.
>>>>>>
>>>>>
>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual
>>>>> behavior
>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>
>>>>>
>>>>
>>>> Yes, but doesn't actually show the ACTUAL behavior of the input as
>>>> defined,
>>> There is only one actual behavior of the actual input and this behavior
>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.
>>
>> Nope, Read the problem definition.
>>
>> The behavior to be decided by a Halt Decider is the behavior of the
>> ACTUAL MACHINE which is decribed by the input.
>
> No matter what the problem definition says the actual behavior of the
> actual input must necessarily be the N steps simulated by embedded_H.
>
> The only alternative is to simply disbelieve in UTMs.
>

NOPE, Since H isn't a UTM, because it doesn't meet the REQUIREMENTS of a
UTM, the statement is meaningless.

A UTM is defined as a simulator whose behavior DOES match the behavior
of the input. MATCHING is the criteria that determines that it IS one,
not a result of just calling a machine one.

By your logic, I could change my cat into a dog my just calling it one.

Calling your machine a UTM, doesn't make it one, you need to make it
meet the requirements to earn the title. Your doesn't.

What happens if you decide to call the color "Red" to be "Green", and
run through a traffic light when the top light is on. A traffic ticket
for running a "Red Light", because just because you called it a Green
Light doesn't make it one.

YOU FAIL.

You are showing you don't understand the basics of logic, so your ideas
are just failures.

On 4/19/2023 9:16 PM, Richard Damon wrote:
> On 4/19/23 9:59 PM, olcott wrote:
>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>> On 4/19/23 9:25 PM, olcott wrote:
>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation
>>>>>>>>>>>>>> error*
>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩
>>>>>>>>>>>>>> even after 10,000
>>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>>>>>> defined to have
>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>> question is NOT what does the "simulation by H" show, but
>>>>>>>>>>>>> what is the actual behavior of the actual machine the input
>>>>>>>>>>>>> represents.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>> of its input
>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>> derive because
>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition
>>>>>>>>>>> of a UTM.
>>>>>>>>>>>
>>>>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>>>>> doesn't know what he is talking about.
>>>>>>>>>>>
>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>>> steps of
>>>>>>>>>>>> simulation:
>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>
>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents is
>>>>>>>>>>>> the
>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>>>>>>> embedded_H
>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>> steps, and you
>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>
>>>>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>>>>> applied to (Ĥ) does.
>>>>>>>>>> Because embedded_H is a UTM that has been augmented with three
>>>>>>>>>> features
>>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>>> diverge from
>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>> simulation we know
>>>>>>>>>> that it necessarily does provide the actual behavior specified
>>>>>>>>>> by this
>>>>>>>>>> input for these N steps.
>>>>>>>>>
>>>>>>>>> And is no longer a UTM, since if fails to meet the requirement
>>>>>>>>> of a UTM
>>>>>>>>>
>>>>>>>> As you already agreed:
>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are
>>>>>>>> the actual behavior of these N steps because
>>>>>>>>
>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>>>> first N steps.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but ALL
>>>>>>> of them.
>>>>>>>
>>>>>>
>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual
>>>>>> behavior
>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but doesn't actually show the ACTUAL behavior of the input as
>>>>> defined,
>>>> There is only one actual behavior of the actual input and this behavior
>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.
>>>
>>> Nope, Read the problem definition.
>>>
>>> The behavior to be decided by a Halt Decider is the behavior of the
>>> ACTUAL MACHINE which is decribed by the input.
>>
>> No matter what the problem definition says the actual behavior of the
>> actual input must necessarily be the N steps simulated by embedded_H.
>>
>> The only alternative is to simply disbelieve in UTMs.
>>
>
> NOPE, Since H isn't a UTM, because it doesn't meet the REQUIREMENTS of a
> UTM, the statement is meaningless.
It <is> equivalent to a UTM for the first N steps that can include
10,000 recursive simulations.

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

On 4/19/23 11:29 PM, olcott wrote:
> On 4/19/2023 9:16 PM, Richard Damon wrote:
>> On 4/19/23 9:59 PM, olcott wrote:
>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation
>>>>>>>>>>>>>>> error*
>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩
>>>>>>>>>>>>>>> even after 10,000
>>>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>>>>>>> defined to have
>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>> question is NOT what does the "simulation by H" show, but
>>>>>>>>>>>>>> what is the actual behavior of the actual machine the
>>>>>>>>>>>>>> input represents.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>>> of its input
>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>> derive because
>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition
>>>>>>>>>>>> of a UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>>>>>> doesn't know what he is talking about.
>>>>>>>>>>>>
>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>>>> steps of
>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>
>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents
>>>>>>>>>>>>> is the
>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H because
>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>>> steps, and you
>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>
>>>>>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>>>>>> applied to (Ĥ) does.
>>>>>>>>>>> Because embedded_H is a UTM that has been augmented with
>>>>>>>>>>> three features
>>>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>>>> diverge from
>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>> simulation we know
>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>> specified by this
>>>>>>>>>>> input for these N steps.
>>>>>>>>>>
>>>>>>>>>> And is no longer a UTM, since if fails to meet the requirement
>>>>>>>>>> of a UTM
>>>>>>>>>>
>>>>>>>>> As you already agreed:
>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must are
>>>>>>>>> the actual behavior of these N steps because
>>>>>>>>>
>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>>>>> first N steps.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but ALL
>>>>>>>> of them.
>>>>>>>>
>>>>>>>
>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual
>>>>>>> behavior
>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the input as
>>>>>> defined,
>>>>> There is only one actual behavior of the actual input and this
>>>>> behavior
>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.
>>>>
>>>> Nope, Read the problem definition.
>>>>
>>>> The behavior to be decided by a Halt Decider is the behavior of the
>>>> ACTUAL MACHINE which is decribed by the input.
>>>
>>> No matter what the problem definition says the actual behavior of the
>>> actual input must necessarily be the N steps simulated by embedded_H.
>>>
>>> The only alternative is to simply disbelieve in UTMs.
>>>
>>
>> NOPE, Since H isn't a UTM, because it doesn't meet the REQUIREMENTS of
>> a UTM, the statement is meaningless.
> It <is> equivalent to a UTM for the first N steps that can include
> 10,000 recursive simulations.
>

Which means it ISN'T the Equivalent of a UTM. PERIOD.

The numbers from 1 to 10 are not the equivalent of the numbers from 1 to
a hundred.

NOT EQUIVALENT is NOT EQUIVALENT.

It might correctly simulate the first N steps, but that doesn't make it
a UTM.

On 4/19/2023 10:41 PM, Richard Damon wrote:
> On 4/19/23 11:29 PM, olcott wrote:
>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>> On 4/19/23 9:59 PM, olcott wrote:
>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation
>>>>>>>>>>>>>>>> error*
>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩
>>>>>>>>>>>>>>>> even after 10,000
>>>>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>> defined to have
>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>>> question is NOT what does the "simulation by H" show, but
>>>>>>>>>>>>>>> what is the actual behavior of the actual machine the
>>>>>>>>>>>>>>> input represents.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>>>> of its input
>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the definition
>>>>>>>>>>>>> of a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>>>>>>> doesn't know what he is talking about.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents
>>>>>>>>>>>>>> is the
>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>>>> steps, and you
>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>>>>>>> applied to (Ĥ) does.
>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented with
>>>>>>>>>>>> three features
>>>>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>>>>> diverge from
>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>> simulation we know
>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>> specified by this
>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>
>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>
>>>>>>>>>> As you already agreed:
>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must
>>>>>>>>>> are the actual behavior of these N steps because
>>>>>>>>>>
>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>>>>>> first N steps.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but ALL
>>>>>>>>> of them.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual
>>>>>>>> behavior
>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the input
>>>>>>> as defined,
>>>>>> There is only one actual behavior of the actual input and this
>>>>>> behavior
>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.
>>>>>
>>>>> Nope, Read the problem definition.
>>>>>
>>>>> The behavior to be decided by a Halt Decider is the behavior of the
>>>>> ACTUAL MACHINE which is decribed by the input.
>>>>
>>>> No matter what the problem definition says the actual behavior of the
>>>> actual input must necessarily be the N steps simulated by embedded_H.
>>>>
>>>> The only alternative is to simply disbelieve in UTMs.
>>>>
>>>
>>> NOPE, Since H isn't a UTM, because it doesn't meet the REQUIREMENTS
>>> of a UTM, the statement is meaningless.
>> It <is> equivalent to a UTM for the first N steps that can include
>> 10,000 recursive simulations.
>>
>
> Which means it ISN'T the Equivalent of a UTM. PERIOD.

On 4/20/23 12:04 AM, olcott wrote:
> On 4/19/2023 10:41 PM, Richard Damon wrote:
>> On 4/19/23 11:29 PM, olcott wrote:
>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of equivocation
>>>>>>>>>>>>>>>>> error*
>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩
>>>>>>>>>>>>>>>>> even after 10,000
>>>>>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> is defined to have
>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>>>> question is NOT what does the "simulation by H" show,
>>>>>>>>>>>>>>>> but what is the actual behavior of the actual machine
>>>>>>>>>>>>>>>> the input represents.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are just proving that you are a pathological liar that
>>>>>>>>>>>>>> doesn't know what he is talking about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>>> change the behavior of the simulated input for the first
>>>>>>>>>>>>>>> N steps of
>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩ represents
>>>>>>>>>>>>>>> is the
>>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>>>>> steps, and you
>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, the actual behavior of the input is what the MACHINE Ĥ
>>>>>>>>>>>>>> applied to (Ĥ) does.
>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented with
>>>>>>>>>>>>> three features
>>>>>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>>>>>> diverge from
>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>>> simulation we know
>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>
>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>
>>>>>>>>>>> As you already agreed:
>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must
>>>>>>>>>>> are the actual behavior of these N steps because
>>>>>>>>>>>
>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change
>>>>>>>>>>> the
>>>>>>>>>>> first N steps.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but
>>>>>>>>>> ALL of them.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the actual
>>>>>>>>> behavior
>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the input
>>>>>>>> as defined,
>>>>>>> There is only one actual behavior of the actual input and this
>>>>>>> behavior
>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by embedded_H.
>>>>>>
>>>>>> Nope, Read the problem definition.
>>>>>>
>>>>>> The behavior to be decided by a Halt Decider is the behavior of
>>>>>> the ACTUAL MACHINE which is decribed by the input.
>>>>>
>>>>> No matter what the problem definition says the actual behavior of the
>>>>> actual input must necessarily be the N steps simulated by embedded_H.
>>>>>
>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>
>>>>
>>>> NOPE, Since H isn't a UTM, because it doesn't meet the REQUIREMENTS
>>>> of a UTM, the statement is meaningless.
>>> It <is> equivalent to a UTM for the first N steps that can include
>>> 10,000 recursive simulations.
>>>
>>
>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>
> Why are you playing head games with this?
>
> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these first N
> steps.
>

On 4/20/2023 6:23 AM, Richard Damon wrote:
> On 4/20/23 12:04 AM, olcott wrote:
>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>> On 4/19/23 11:29 PM, olcott wrote:
>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of ⟨Ĥ.qn⟩
>>>>>>>>>>>>>>>>>> even after 10,000
>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> is defined to have
>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>>>>> question is NOT what does the "simulation by H" show,
>>>>>>>>>>>>>>>>> but what is the actual behavior of the actual machine
>>>>>>>>>>>>>>>>> the input represents.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are just proving that you are a pathological liar
>>>>>>>>>>>>>>> that doesn't know what he is talking about.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>>>> change the behavior of the simulated input for the first
>>>>>>>>>>>>>>>> N steps of
>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>>>>>> steps, and you
>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, the actual behavior of the input is what the MACHINE
>>>>>>>>>>>>>>> Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented with
>>>>>>>>>>>>>> three features
>>>>>>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>>>>>>> diverge from
>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>>>> simulation we know
>>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>
>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must
>>>>>>>>>>>> are the actual behavior of these N steps because
>>>>>>>>>>>>
>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>> change the
>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but
>>>>>>>>>>> ALL of them.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the
>>>>>>>>>> actual behavior
>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the input
>>>>>>>>> as defined,
>>>>>>>> There is only one actual behavior of the actual input and this
>>>>>>>> behavior
>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>> embedded_H.
>>>>>>>
>>>>>>> Nope, Read the problem definition.
>>>>>>>
>>>>>>> The behavior to be decided by a Halt Decider is the behavior of
>>>>>>> the ACTUAL MACHINE which is decribed by the input.
>>>>>>
>>>>>> No matter what the problem definition says the actual behavior of the
>>>>>> actual input must necessarily be the N steps simulated by embedded_H.
>>>>>>
>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>
>>>>>
>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the REQUIREMENTS
>>>>> of a UTM, the statement is meaningless.
>>>> It <is> equivalent to a UTM for the first N steps that can include
>>>> 10,000 recursive simulations.
>>>>
>>>
>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>
>> Why are you playing head games with this?
>>
>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these first N
>> steps.
>>
>
> Right, but we don't care about that. We care about the TOTAL behavior of
> the input, which H never gets to see, because it gives up.
>

On 4/20/23 7:56 AM, olcott wrote:
> On 4/20/2023 6:23 AM, Richard Damon wrote:
>> On 4/20/23 12:04 AM, olcott wrote:
>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations because ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> is defined to have
>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>>>>>> question is NOT what does the "simulation by H" show,
>>>>>>>>>>>>>>>>>> but what is the actual behavior of the actual machine
>>>>>>>>>>>>>>>>>> the input represents.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are just proving that you are a pathological liar
>>>>>>>>>>>>>>>> that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>> first N steps of
>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>>>>>>> steps, and you
>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the MACHINE
>>>>>>>>>>>>>>>> Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented with
>>>>>>>>>>>>>>> three features
>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its input to
>>>>>>>>>>>>>>> diverge from
>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>>>>> simulation we know
>>>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>
>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H must
>>>>>>>>>>>>> are the actual behavior of these N steps because
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>> change the
>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but
>>>>>>>>>>>> ALL of them.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the
>>>>>>>>>>> actual behavior
>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the
>>>>>>>>>> input as defined,
>>>>>>>>> There is only one actual behavior of the actual input and this
>>>>>>>>> behavior
>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>> embedded_H.
>>>>>>>>
>>>>>>>> Nope, Read the problem definition.
>>>>>>>>
>>>>>>>> The behavior to be decided by a Halt Decider is the behavior of
>>>>>>>> the ACTUAL MACHINE which is decribed by the input.
>>>>>>>
>>>>>>> No matter what the problem definition says the actual behavior of
>>>>>>> the
>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>> embedded_H.
>>>>>>>
>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>
>>>>>>
>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>> It <is> equivalent to a UTM for the first N steps that can include
>>>>> 10,000 recursive simulations.
>>>>>
>>>>
>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>
>>> Why are you playing head games with this?
>>>
>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these first N
>>> steps.
>>>
>>
>> Right, but we don't care about that. We care about the TOTAL behavior
>> of the input, which H never gets to see, because it gives up.
>>
>
>
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual behavior
> of this input:
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which simulates
> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*

On 4/20/2023 7:06 AM, Richard Damon wrote:
> On 4/20/23 7:56 AM, olcott wrote:
>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>> On 4/20/23 12:04 AM, olcott wrote:
>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H must
>>>>>>>>>>>>>>>>>>>> compute its mapping
>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations because
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>>>>>>> question is NOT what does the "simulation by H" show,
>>>>>>>>>>>>>>>>>>> but what is the actual behavior of the actual machine
>>>>>>>>>>>>>>>>>>> the input represents.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just proving that you are a pathological liar
>>>>>>>>>>>>>>>>> that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>> first N steps of
>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first N
>>>>>>>>>>>>>>>>>> steps, and you
>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented with
>>>>>>>>>>>>>>>> three features
>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its input
>>>>>>>>>>>>>>>> to diverge from
>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>>>>>> simulation we know
>>>>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H
>>>>>>>>>>>>>> must are the actual behavior of these N steps because
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>> change the
>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input, but
>>>>>>>>>>>>> ALL of them.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the
>>>>>>>>>>>> actual behavior
>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates 10,000
>>>>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the
>>>>>>>>>>> input as defined,
>>>>>>>>>> There is only one actual behavior of the actual input and this
>>>>>>>>>> behavior
>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>
>>>>>>>>> The behavior to be decided by a Halt Decider is the behavior of
>>>>>>>>> the ACTUAL MACHINE which is decribed by the input.
>>>>>>>>
>>>>>>>> No matter what the problem definition says the actual behavior
>>>>>>>> of the
>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>> embedded_H.
>>>>>>>>
>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>
>>>>>>>
>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>> It <is> equivalent to a UTM for the first N steps that can include
>>>>>> 10,000 recursive simulations.
>>>>>>
>>>>>
>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>
>>>> Why are you playing head games with this?
>>>>
>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these
>>>> first N
>>>> steps.
>>>>
>>>
>>> Right, but we don't care about that. We care about the TOTAL behavior
>>> of the input, which H never gets to see, because it gives up.
>>>
>>
>>
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>> behavior of this input:
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which simulates
>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>
> Until the outer embedded_H used by Ĥ reaches the point that it decides
> to stop its simulation, and the whole simulation ends with just partial
> results and it decides to go to qn and Ĥ Halts.
>

On 19/04/2023 11:52 pm, olcott wrote:
> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>> On 19/04/2023 10:10 pm, olcott wrote:
>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>> A simulating halt decider correctly predicts whether or not its
>>>>>>>>>>> correctly simulated input can possibly reach its own final
>>>>>>>>>>> state and
>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>> non-halting behavior
>>>>>>>>>>> patterns in a finite number of steps of correct simulation.
>>>>>>>>>>> Inputs that
>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>
>>>>>>>>>> The "Pathological Program" when built on such a Decider that
>>>>>>>>>> does give an answer, which you say will be non-halting, and
>>>>>>>>>> then "Correctly Simulated" by giving it representation to a
>>>>>>>>>> UTM, we see that the simulation reaches a final state.
>>>>>>>>>>
>>>>>>>>>> Thus, your H was WRONG t make the answer. And the problem is
>>>>>>>>>> you have added a pattern that isn't always non-halting.
>>>>>>>>>>
>>>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>>>> its input
>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>> derive because
>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>
>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the features
>>>>>>>>>> you added have removed essential features needed for it to be
>>>>>>>>>> an actual UTM. That you make this claim shows you don't
>>>>>>>>>> actually know what a UTM is.
>>>>>>>>>>
>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street Legal
>>>>>>>>>> vehicle, since it started as one and just had some extra
>>>>>>>>>> features axded.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> My reviewers cannot show that any of the extra features added
>>>>>>>>>>> to the UTM
>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>> steps of simulation:
>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't change
>>>>>>>>>>> the first N steps.
>>>>>>>>>>
>>>>>>>>>> No one claims that it doesn't correctly reproduce the first N
>>>>>>>>>> steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because of all this we can know that the first N steps of
>>>>>>>>>>> input D
>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>> behavior that D
>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>
>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>
>>>>>>>>>> Right, so we are concerned about the behavior of the ACTUAL
>>>>>>>>>> machine, not a partial simulation of it.
>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer is
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When we see (after N steps) that D correctly simulated by H
>>>>>>>>>>> cannot
>>>>>>>>>>> possibly reach its simulated final state in any finite number
>>>>>>>>>>> of steps
>>>>>>>>>>> of correct simulation then we have conclusive proof that D
>>>>>>>>>>> presents non-
>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>
>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>
>>>>>>>>> It turns out that the non-halting behavior pattern is correctly
>>>>>>>>> recognized in the first N steps.
>>>>>>>>
>>>>>>>> Your assumption that a program that calls H is non-halting is
>>>>>>>> erroneous:
>>>>>>>>
>>>>>>>
>>>>>>> My new paper anchors its ideas in actual Turing machines so it is
>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>> machine based proof.
>>>>>>>
>>>>>>> The H/D material is now on a single page and all reference
>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>> analysis entirely in C.
>>>>>>>
>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>> UTM based simulated by a simulating halt decider are necessarily the
>>>>>>> actual behavior of these N steps.
>>>>>>>
>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting Problem
>>>>>>> Proofs*
>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>
>>>>>>>> void Px(void (*x)())
>>>>>>>> {
>>>>>>>>      (void) H(x, x);
>>>>>>>>      return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Px halts (it discards the result that H returns); your decider
>>>>>>>> thinks that Px is non-halting which is an obvious error due to a
>>>>>>>> design flaw in the architecture of your decider.  Only the
>>>>>>>> Flibble Signaling Simulating Halt Decider (SSHD) correctly
>>>>>>>> handles this case.
>>>>>>
>>>>>> Nope. For H to be a halt decider it must return a halt decision to
>>>>>> its caller in finite time
>>>>>
>>>>> Although H must always return to some caller H is not allowed to
>>>>> return
>>>>> to any caller that essentially calls H in infinite recursion.
>>>>
>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not have
>>>> any infinite recursion thereby proving that
>>>
>>> It overrode that behavior that was specified by the machine code for Px.
>>
>> Nope. You SHD is not a halt decider as
>
> I was not even talking about my SHD, I was talking about how your
> program does its simulation incorrectly.

On 19/04/2023 8:39 pm, olcott wrote:
> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>> On 18/04/2023 11:39 pm, olcott wrote:
>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>> A simulating halt decider correctly predicts whether or not its
>>>>>>> correctly simulated input can possibly reach its own final state and
>>>>>>> halt. It does this by correctly recognizing several non-halting
>>>>>>> behavior
>>>>>>> patterns in a finite number of steps of correct simulation.
>>>>>>> Inputs that
>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>
>>>>>> The "Pathological Program" when built on such a Decider that does
>>>>>> give an answer, which you say will be non-halting, and then
>>>>>> "Correctly Simulated" by giving it representation to a UTM, we see
>>>>>> that the simulation reaches a final state.
>>>>>>
>>>>>> Thus, your H was WRONG t make the answer. And the problem is you
>>>>>> have added a pattern that isn't always non-halting.
>>>>>>
>>>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>>>> input
>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>> because
>>>>>>> it is itself a UTM with extra features.
>>>>>>
>>>>>> But if ISN'T a "UTM" any more, because some of the features you
>>>>>> added have removed essential features needed for it to be an
>>>>>> actual UTM. That you make this claim shows you don't actually know
>>>>>> what a UTM is.
>>>>>>
>>>>>> This is like saying a NASCAR Racing Car is a Street Legal vehicle,
>>>>>> since it started as one and just had some extra features axded.
>>>>>>
>>>>>>>
>>>>>>> My reviewers cannot show that any of the extra features added to
>>>>>>> the UTM
>>>>>>> change the behavior of the simulated input for the first N steps
>>>>>>> of simulation:
>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>> (c) Even aborting the simulation after N steps doesn't change the
>>>>>>> first N steps.
>>>>>>
>>>>>> No one claims that it doesn't correctly reproduce the first N
>>>>>> steps of the behavior, that is a Strawman argumen.
>>>>>>
>>>>>>>
>>>>>>> Because of all this we can know that the first N steps of input D
>>>>>>> simulated by simulating halt decider H are the actual behavior
>>>>>>> that D
>>>>>>> presents to H for these same N steps.
>>>>>>>
>>>>>>> *computation that halts*… “the Turing machine will halt whenever
>>>>>>> it enters a final state” (Linz:1990:234)rrr
>>>>>>
>>>>>> Right, so we are concerned about the behavior of the ACTUAL
>>>>>> machine, not a partial simulation of it.
>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer is wrong.
>>>>>>
>>>>>>>
>>>>>>> When we see (after N steps) that D correctly simulated by H cannot
>>>>>>> possibly reach its simulated final state in any finite number of
>>>>>>> steps
>>>>>>> of correct simulation then we have conclusive proof that D
>>>>>>> presents non-
>>>>>>> halting behavior to H.
>>>>>>
>>>>>> But it isn't "Correctly Simulated by H"
>>>>> You agreed that the first N steps are correctly simulated.
>>>>>
>>>>> It turns out that the non-halting behavior pattern is correctly
>>>>> recognized in the first N steps.
>>>>
>>>> Your assumption that a program that calls H is non-halting is
>>>> erroneous:
>>>>
>>>
>>> My new paper anchors its ideas in actual Turing machines so it is
>>> unequivocal. The first two pages re only about the Linz Turing
>>> machine based proof.
>>>
>>> The H/D material is now on a single page and all reference
>>> to the x86 language has been stripped and replaced with
>>> analysis entirely in C.
>>>
>>> With this new paper even Richard admits that the first N steps
>>> UTM based simulated by a simulating halt decider are necessarily the
>>> actual behavior of these N steps.
>>>
>>> *Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs*
>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>
>>>> void Px(void (*x)())
>>>> {
>>>>      (void) H(x, x);
>>>>      return;
>>>> }
>>>>
>>>> Px halts (it discards the result that H returns); your decider
>>>> thinks that Px is non-halting which is an obvious error due to a
>>>> design flaw in the architecture of your decider.  Only the Flibble
>>>> Signaling Simulating Halt Decider (SSHD) correctly handles this case.
>>
>> Nope. For H to be a halt decider it must return a halt decision to its
>> caller in finite time
>
> Although H must always return to some caller H is not allowed to return
> to any caller that essentially calls H in infinite recursion.

That is a contradiction: either H MUST ALWAYS return to its caller or
MUST NOT; your mistake is in thinking that there is some "get out"
clause for SHDs.

/Flibble

On 4/20/2023 12:32 PM, Mr Flibble wrote:
> On 19/04/2023 11:52 pm, olcott wrote:
>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>> A simulating halt decider correctly predicts whether or not its
>>>>>>>>>>>> correctly simulated input can possibly reach its own final
>>>>>>>>>>>> state and
>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>> patterns in a finite number of steps of correct simulation.
>>>>>>>>>>>> Inputs that
>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>
>>>>>>>>>>> The "Pathological Program" when built on such a Decider that
>>>>>>>>>>> does give an answer, which you say will be non-halting, and
>>>>>>>>>>> then "Correctly Simulated" by giving it representation to a
>>>>>>>>>>> UTM, we see that the simulation reaches a final state.
>>>>>>>>>>>
>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the problem is
>>>>>>>>>>> you have added a pattern that isn't always non-halting.
>>>>>>>>>>>
>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>> of its input
>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>> derive because
>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>
>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the features
>>>>>>>>>>> you added have removed essential features needed for it to be
>>>>>>>>>>> an actual UTM. That you make this claim shows you don't
>>>>>>>>>>> actually know what a UTM is.
>>>>>>>>>>>
>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street Legal
>>>>>>>>>>> vehicle, since it started as one and just had some extra
>>>>>>>>>>> features axded.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>>> steps of simulation:
>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>
>>>>>>>>>>> No one claims that it doesn't correctly reproduce the first N
>>>>>>>>>>> steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because of all this we can know that the first N steps of
>>>>>>>>>>>> input D
>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>> behavior that D
>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>
>>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>
>>>>>>>>>>> Right, so we are concerned about the behavior of the ACTUAL
>>>>>>>>>>> machine, not a partial simulation of it.
>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer is
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When we see (after N steps) that D correctly simulated by H
>>>>>>>>>>>> cannot
>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>> number of steps
>>>>>>>>>>>> of correct simulation then we have conclusive proof that D
>>>>>>>>>>>> presents non-
>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>
>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>
>>>>>>>>>> It turns out that the non-halting behavior pattern is correctly
>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>
>>>>>>>>> Your assumption that a program that calls H is non-halting is
>>>>>>>>> erroneous:
>>>>>>>>>
>>>>>>>>
>>>>>>>> My new paper anchors its ideas in actual Turing machines so it is
>>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>>> machine based proof.
>>>>>>>>
>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>> analysis entirely in C.
>>>>>>>>
>>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>>> UTM based simulated by a simulating halt decider are necessarily
>>>>>>>> the
>>>>>>>> actual behavior of these N steps.
>>>>>>>>
>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting Problem
>>>>>>>> Proofs*
>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>
>>>>>>>>> void Px(void (*x)())
>>>>>>>>> {
>>>>>>>>>      (void) H(x, x);
>>>>>>>>>      return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Px halts (it discards the result that H returns); your decider
>>>>>>>>> thinks that Px is non-halting which is an obvious error due to
>>>>>>>>> a design flaw in the architecture of your decider.  Only the
>>>>>>>>> Flibble Signaling Simulating Halt Decider (SSHD) correctly
>>>>>>>>> handles this case.
>>>>>>>
>>>>>>> Nope. For H to be a halt decider it must return a halt decision
>>>>>>> to its caller in finite time
>>>>>>
>>>>>> Although H must always return to some caller H is not allowed to
>>>>>> return
>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>
>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not have
>>>>> any infinite recursion thereby proving that
>>>>
>>>> It overrode that behavior that was specified by the machine code for
>>>> Px.
>>>
>>> Nope. You SHD is not a halt decider as
>>
>> I was not even talking about my SHD, I was talking about how your
>> program does its simulation incorrectly.
>
> My SSHD does not do its simulation incorrectly: it does its simulation
> just like I have defined it as evidenced by the fact that it returns a
> correct halting decision for Px; something your broken SHD gets wrong.
>

On 20/04/2023 6:49 pm, olcott wrote:
> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>> On 19/04/2023 11:52 pm, olcott wrote:
>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>> A simulating halt decider correctly predicts whether or not
>>>>>>>>>>>>> its
>>>>>>>>>>>>> correctly simulated input can possibly reach its own final
>>>>>>>>>>>>> state and
>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>> patterns in a finite number of steps of correct simulation.
>>>>>>>>>>>>> Inputs that
>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>
>>>>>>>>>>>> The "Pathological Program" when built on such a Decider that
>>>>>>>>>>>> does give an answer, which you say will be non-halting, and
>>>>>>>>>>>> then "Correctly Simulated" by giving it representation to a
>>>>>>>>>>>> UTM, we see that the simulation reaches a final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the problem is
>>>>>>>>>>>> you have added a pattern that isn't always non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>>> of its input
>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>> derive because
>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>
>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the features
>>>>>>>>>>>> you added have removed essential features needed for it to
>>>>>>>>>>>> be an actual UTM. That you make this claim shows you don't
>>>>>>>>>>>> actually know what a UTM is.
>>>>>>>>>>>>
>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street Legal
>>>>>>>>>>>> vehicle, since it started as one and just had some extra
>>>>>>>>>>>> features axded.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>>>> steps of simulation:
>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>
>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the first
>>>>>>>>>>>> N steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because of all this we can know that the first N steps of
>>>>>>>>>>>>> input D
>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>>
>>>>>>>>>>>> Right, so we are concerned about the behavior of the ACTUAL
>>>>>>>>>>>> machine, not a partial simulation of it.
>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer is
>>>>>>>>>>>> wrong.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When we see (after N steps) that D correctly simulated by H
>>>>>>>>>>>>> cannot
>>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>>> number of steps
>>>>>>>>>>>>> of correct simulation then we have conclusive proof that D
>>>>>>>>>>>>> presents non-
>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>
>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>
>>>>>>>>>>> It turns out that the non-halting behavior pattern is correctly
>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>
>>>>>>>>>> Your assumption that a program that calls H is non-halting is
>>>>>>>>>> erroneous:
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> My new paper anchors its ideas in actual Turing machines so it is
>>>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>>>> machine based proof.
>>>>>>>>>
>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>> analysis entirely in C.
>>>>>>>>>
>>>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>> necessarily the
>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>
>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting Problem
>>>>>>>>> Proofs*
>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>
>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>      return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Px halts (it discards the result that H returns); your decider
>>>>>>>>>> thinks that Px is non-halting which is an obvious error due to
>>>>>>>>>> a design flaw in the architecture of your decider.  Only the
>>>>>>>>>> Flibble Signaling Simulating Halt Decider (SSHD) correctly
>>>>>>>>>> handles this case.
>>>>>>>>
>>>>>>>> Nope. For H to be a halt decider it must return a halt decision
>>>>>>>> to its caller in finite time
>>>>>>>
>>>>>>> Although H must always return to some caller H is not allowed to
>>>>>>> return
>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>
>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not have
>>>>>> any infinite recursion thereby proving that
>>>>>
>>>>> It overrode that behavior that was specified by the machine code
>>>>> for Px.
>>>>
>>>> Nope. You SHD is not a halt decider as
>>>
>>> I was not even talking about my SHD, I was talking about how your
>>> program does its simulation incorrectly.
>>
>> My SSHD does not do its simulation incorrectly: it does its simulation
>> just like I have defined it as evidenced by the fact that it returns a
>> correct halting decision for Px; something your broken SHD gets wrong.
>>
>
> In order for you to have Px simulated by H terminate normally you must
> change the behavior of Px away from the behavior that its x86 code
> specifies.

On 4/20/2023 2:08 PM, Mr Flibble wrote:
> On 20/04/2023 6:49 pm, olcott wrote:
>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether or
>>>>>>>>>>>>>> not its
>>>>>>>>>>>>>> correctly simulated input can possibly reach its own final
>>>>>>>>>>>>>> state and
>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The "Pathological Program" when built on such a Decider
>>>>>>>>>>>>> that does give an answer, which you say will be
>>>>>>>>>>>>> non-halting, and then "Correctly Simulated" by giving it
>>>>>>>>>>>>> representation to a UTM, we see that the simulation reaches
>>>>>>>>>>>>> a final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the problem
>>>>>>>>>>>>> is you have added a pattern that isn't always non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>>>> of its input
>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the features
>>>>>>>>>>>>> you added have removed essential features needed for it to
>>>>>>>>>>>>> be an actual UTM. That you make this claim shows you don't
>>>>>>>>>>>>> actually know what a UTM is.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street Legal
>>>>>>>>>>>>> vehicle, since it started as one and just had some extra
>>>>>>>>>>>>> features axded.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>> change the behavior of the simulated input for the first N
>>>>>>>>>>>>>> steps of simulation:
>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the first
>>>>>>>>>>>>> N steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because of all this we can know that the first N steps of
>>>>>>>>>>>>>> input D
>>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, so we are concerned about the behavior of the ACTUAL
>>>>>>>>>>>>> machine, not a partial simulation of it.
>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer
>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When we see (after N steps) that D correctly simulated by
>>>>>>>>>>>>>> H cannot
>>>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>>>> number of steps
>>>>>>>>>>>>>> of correct simulation then we have conclusive proof that D
>>>>>>>>>>>>>> presents non-
>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>>
>>>>>>>>>>>> It turns out that the non-halting behavior pattern is correctly
>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>
>>>>>>>>>>> Your assumption that a program that calls H is non-halting is
>>>>>>>>>>> erroneous:
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> My new paper anchors its ideas in actual Turing machines so it is
>>>>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>>>>> machine based proof.
>>>>>>>>>>
>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>
>>>>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>> necessarily the
>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>
>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting Problem
>>>>>>>>>> Proofs*
>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>
>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>      return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>> decider thinks that Px is non-halting which is an obvious
>>>>>>>>>>> error due to a design flaw in the architecture of your
>>>>>>>>>>> decider.  Only the Flibble Signaling Simulating Halt Decider
>>>>>>>>>>> (SSHD) correctly handles this case.
>>>>>>>>>
>>>>>>>>> Nope. For H to be a halt decider it must return a halt decision
>>>>>>>>> to its caller in finite time
>>>>>>>>
>>>>>>>> Although H must always return to some caller H is not allowed to
>>>>>>>> return
>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>
>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not
>>>>>>> have any infinite recursion thereby proving that
>>>>>>
>>>>>> It overrode that behavior that was specified by the machine code
>>>>>> for Px.
>>>>>
>>>>> Nope. You SHD is not a halt decider as
>>>>
>>>> I was not even talking about my SHD, I was talking about how your
>>>> program does its simulation incorrectly.
>>>
>>> My SSHD does not do its simulation incorrectly: it does its
>>> simulation just like I have defined it as evidenced by the fact that
>>> it returns a correct halting decision for Px; something your broken
>>> SHD gets wrong.
>>>
>>
>> In order for you to have Px simulated by H terminate normally you must
>> change the behavior of Px away from the behavior that its x86 code
>> specifies.
>
> Your "x86 code" has nothing to do with how my halt decider works; I am
> using an entirely different simulation method, one that actually works.
>
>>
>> void Px(void (*x)())
>> {
>>    (void) H(x, x);
>>    return;
>> }
>>
>> Px correctly simulated by H cannot possibly reach past its machine
>> address of: [00001b3d].
>>
>> _Px()
>> [00001b32] 55         push ebp
>> [00001b33] 8bec       mov ebp,esp
>> [00001b35] 8b4508     mov eax,[ebp+08]
>> [00001b38] 50         push eax      // push address of Px
>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>> [00001b3c] 51         push ecx      // push address of Px
>> [00001b3d] e800faffff call 00001542 // Call H
>> [00001b42] 83c408     add esp,+08
>> [00001b45] 5d         pop ebp
>> [00001b46] c3         ret
>> Size in bytes:(0021) [00001b46]
>>
>> What you are doing is the the same as recognizing that _Infinite_Loop()
>> never halts, forcing it to break out of its infinite loop and jump to
>> its "ret" instruction
>>
>> _Infinite_Loop()
>> [00001c62] 55         push ebp
>> [00001c63] 8bec       mov ebp,esp
>> [00001c65] ebfe       jmp 00001c65
>> [00001c67] 5d         pop ebp
>> [00001c68] c3         ret
>> Size in bytes:(0007) [00001c68]
>
> No I am not: there is no infinite loop in Px above; forking the
> simulation into two branches and returning a different halt decision to
> each branch is a perfectly valid SHD design; again a design, unlike
> yours, that actually works.

On 4/20/23 10:59 AM, olcott wrote:
> On 4/20/2023 7:06 AM, Richard Damon wrote:
>> On 4/20/23 7:56 AM, olcott wrote:
>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H
>>>>>>>>>>>>>>>>>>>>> must compute its mapping
>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations because
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error. The
>>>>>>>>>>>>>>>>>>>> question is NOT what does the "simulation by H"
>>>>>>>>>>>>>>>>>>>> show, but what is the actual behavior of the actual
>>>>>>>>>>>>>>>>>>>> machine the input represents.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological liar
>>>>>>>>>>>>>>>>>> that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>> first N steps of
>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first
>>>>>>>>>>>>>>>>>>> N steps, and you
>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented
>>>>>>>>>>>>>>>>> with three features
>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its input
>>>>>>>>>>>>>>>>> to diverge from
>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>>>>>>> simulation we know
>>>>>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H
>>>>>>>>>>>>>>> must are the actual behavior of these N steps because
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>> change the
>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input,
>>>>>>>>>>>>>> but ALL of them.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the
>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates
>>>>>>>>>>>>> 10,000
>>>>>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the
>>>>>>>>>>>> input as defined,
>>>>>>>>>>> There is only one actual behavior of the actual input and
>>>>>>>>>>> this behavior
>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>> embedded_H.
>>>>>>>>>>
>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>
>>>>>>>>>> The behavior to be decided by a Halt Decider is the behavior
>>>>>>>>>> of the ACTUAL MACHINE which is decribed by the input.
>>>>>>>>>
>>>>>>>>> No matter what the problem definition says the actual behavior
>>>>>>>>> of the
>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>> include 10,000 recursive simulations.
>>>>>>>
>>>>>>
>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>
>>>>> Why are you playing head games with this?
>>>>>
>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these
>>>>> first N
>>>>> steps.
>>>>>
>>>>
>>>> Right, but we don't care about that. We care about the TOTAL
>>>> behavior of the input, which H never gets to see, because it gives up.
>>>>
>>>
>>>
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>> behavior of this input:
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which simulates
>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>
>> Until the outer embedded_H used by Ĥ reaches the point that it decides
>> to stop its simulation, and the whole simulation ends with just
>> partial results and it decides to go to qn and Ĥ Halts.
>>
>
> You keep dodging the key truth when N steps of embedded_H are correctly
> simulated by embedded_H and N = 30000 then we know that the actual
> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never reached
> their final state of ⟨Ĥ.qn⟩.
>

On 4/20/2023 5:40 PM, Richard Damon wrote:
> On 4/20/23 10:59 AM, olcott wrote:
>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>> On 4/20/23 7:56 AM, olcott wrote:
>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H
>>>>>>>>>>>>>>>>>>>>>> must compute its mapping
>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations because
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error.
>>>>>>>>>>>>>>>>>>>>> The question is NOT what does the "simulation by H"
>>>>>>>>>>>>>>>>>>>>> show, but what is the actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>> machine the input represents.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological liar
>>>>>>>>>>>>>>>>>>> that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>>> first N steps of
>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by embedded_H
>>>>>>>>>>>>>>>>>>>> because embedded_H
>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these first
>>>>>>>>>>>>>>>>>>>> N steps, and you
>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented
>>>>>>>>>>>>>>>>>> with three features
>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its input
>>>>>>>>>>>>>>>>>> to diverge from
>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps of
>>>>>>>>>>>>>>>>>> simulation we know
>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H
>>>>>>>>>>>>>>>> must are the actual behavior of these N steps because
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>> change the
>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input,
>>>>>>>>>>>>>>> but ALL of them.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the
>>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates
>>>>>>>>>>>>>> 10,000
>>>>>>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the
>>>>>>>>>>>>> input as defined,
>>>>>>>>>>>> There is only one actual behavior of the actual input and
>>>>>>>>>>>> this behavior
>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>
>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>
>>>>>>>>>>> The behavior to be decided by a Halt Decider is the behavior
>>>>>>>>>>> of the ACTUAL MACHINE which is decribed by the input.
>>>>>>>>>>
>>>>>>>>>> No matter what the problem definition says the actual behavior
>>>>>>>>>> of the
>>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>>> embedded_H.
>>>>>>>>>>
>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>
>>>>>>>
>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>
>>>>>> Why are you playing head games with this?
>>>>>>
>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these
>>>>>> first N
>>>>>> steps.
>>>>>>
>>>>>
>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>> behavior of the input, which H never gets to see, because it gives up.
>>>>>
>>>>
>>>>
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>>> behavior of this input:
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>>
>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>> decides to stop its simulation, and the whole simulation ends with
>>> just partial results and it decides to go to qn and Ĥ Halts.
>>>
>>
>> You keep dodging the key truth when N steps of embedded_H are correctly
>> simulated by embedded_H and N = 30000 then we know that the actual
>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never reached
>> their final state of ⟨Ĥ.qn⟩.
>>
>
> No, it has been shown that if N = 3000, then