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.

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.

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.

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)

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.

*Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs*
https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs

--
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/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" since this H never does a
correct simulation of the sort that determines halting or not (that of
an ACTUAL UTM, which never aborts until it reaches the end).

Since H DOES abort its simulation, the changing of "H" to be a UTM
instead, is just saying that H doesn't actually process the input that
was given it, and thus it gets the wrong answer.

>
> *Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs*
> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>

Which is full of UNSOUND logic and Strawman.

You aren't allowed to change the input, so you can't change the H that D
uses.

You have been repeated told this, and yet you still repeat it. This
shows you have no capability of learning, and that you are totally
ignorant of the things you are talking about.

You have buried your reputation by all your lies and fabrications.

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.

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

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:

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.

/Flibble

On 4/18/23 11:58 AM, 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.
>

Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is shown
by the fact that D(D) does halt.

It might show that no possible H could simulate the input to a final
state, but that isn't the definition of Halting. Halting is strictly
about the behavior of the machine itself.

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

--
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/18/23 6: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.

Right, but not halting in N steps is not the same as not halting ever.
Remember, it is the actual machine described by the input that matters,
not the (partial) simulation done by H.

>
> *Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs*
> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs

Full of ERRORS.

On 4/18/2023 5:30 PM, Richard Damon wrote:
> On 4/18/23 11:58 AM, 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.
>>
>
> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is shown
> by the fact that D(D) does halt.
>
> It might show that no possible H could simulate the input to a final
> state, but that isn't the definition of Halting. Halting is strictly
> about the behavior of the machine itself.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

computation that halts… “the Turing machine will halt whenever it enters
a final state” (Linz:1990:234)

Non-halting behavior patterns can be matched in N steps
⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a finite
number of steps

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*

The above N steps proves that ⟨Ĥ⟩ correctly simulated by embedded_H
could not possibly reach the final state of ⟨Ĥ.q0⟩ in any finite number
of steps of correct simulation *because ⟨Ĥ⟩ is defined to have*
*a pathological relationship to embedded_H*

That a UTM applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts shows an entirely different sequence
*because UTM and ⟨Ĥ⟩ ⟨Ĥ⟩ do not have a pathological relationship*

--
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/18/23 7:13 PM, olcott wrote:
> On 4/18/2023 5:30 PM, Richard Damon wrote:
>> On 4/18/23 11:58 AM, 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.
>>>
>>
>> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is
>> shown by the fact that D(D) does halt.
>>
>> It might show that no possible H could simulate the input to a final
>> state, but that isn't the definition of Halting. Halting is strictly
>> about the behavior of the machine itself.
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> computation that halts… “the Turing machine will halt whenever it enters
> a final state” (Linz:1990:234)

Right and Ĥ (Ĥ) will reach Ĥ.qn and halt if H (Ĥ) (Ĥ) goes to qn, as it
must to be saying that its input is non-halting.

This is because embedded_H and H must be identical machines, and thus do
exactly the same thing when given the same input.

>
> Non-halting behavior patterns can be matched in N steps
> ⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a finite
> number of steps

Nope, Halting is the MACHINE Ĥ (Ĥ) reaching its final state Ĥ.qn in a
finite number of steps.

You can also use UTM (Ĥ) (Ĥ), which also reaches that final stste,
because it doesn't stop simulating until it reaches a final state, or it
just keeps simulating.

H / embedded_H are NOT a UTM, as they don't have that necessary property.

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

Except you have defined that H, and thus embeded_H doesn't do (c), but
when it sees the attempted to go into embedded_H with the same input
actually aborts its simulation and goes to Ĥ.qn which causes the machine
Ĥ to halt.

>
> The above N steps proves that ⟨Ĥ⟩ correctly simulated by embedded_H
> could not possibly reach the final state of ⟨Ĥ.q0⟩ in any finite number
> of steps of correct simulation *because ⟨Ĥ⟩ is defined to have*
> *a pathological relationship to embedded_H*

Nope, H is presuming INCORRECTLY that embedded_H is a UTM, and not a
copy of itself.

>
> That a UTM applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts shows an entirely different sequence
> *because UTM and ⟨Ĥ⟩ ⟨Ĥ⟩ do not have a pathological relationship*
>

Nope, the correct simulation of the input is the correct simulation of
the input and matches the actual behavior of the machine the input
represetns.

H does NOT do an actual "Correct Simulation" but only a PARTIAL
simulation of only N steps, which doesn't prove non-halting behavior.

You mind is stuck in a pathological loop, because you don't seem to
understand the actual basics of Turing Machines.

On 4/18/2023 9:31 PM, Richard Damon wrote:
> On 4/18/23 7:13 PM, olcott wrote:
>> On 4/18/2023 5:30 PM, Richard Damon wrote:
>>> On 4/18/23 11:58 AM, 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.
>>>>
>>>
>>> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is
>>> shown by the fact that D(D) does halt.
>>>
>>> It might show that no possible H could simulate the input to a final
>>> state, but that isn't the definition of Halting. Halting is strictly
>>> about the behavior of the machine itself.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> computation that halts… “the Turing machine will halt whenever it enters
>> a final state” (Linz:1990:234)
>
> Right and Ĥ (Ĥ) will reach Ĥ.qn and halt if H (Ĥ) (Ĥ) goes to qn, as it
> must to be saying that its input is non-halting.
>
> This is because embedded_H and H must be identical machines, and thus do
> exactly the same thing when given the same input.
>
>>
>> Non-halting behavior patterns can be matched in N steps
>> ⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a finite
>> number of steps
>
> Nope, Halting is the MACHINE Ĥ (Ĥ) reaching its final state Ĥ.qn in a
> finite number of steps.
>
> You can also use UTM (Ĥ) (Ĥ), which also reaches that final stste,
> because it doesn't stop simulating until it reaches a final state, or it
> just keeps simulating.
>
> H / embedded_H are NOT a UTM, as they don't have that necessary property.
>
>>
>> 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*
>
> Except you have defined that H, and thus embeded_H doesn't do (c), but
> when it sees the attempted to go into embedded_H with the same input
> actually aborts its simulation and goes to Ĥ.qn which causes the machine
> Ĥ to halt.
>

embedded_H could do (c) 10,000 times before aborting which would have to
be the actual behavior of the actual input because embedded_H remains in
pure UTM mode until it aborts.

How many times does it take for you to understand that ⟨Ĥ⟩ can't
possibly reach ⟨Ĥ.qn⟩ because of its pathological relationship to
embedded_H ?

--
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/18/23 10:57 PM, olcott wrote:
> On 4/18/2023 9:31 PM, Richard Damon wrote:
>> On 4/18/23 7:13 PM, olcott wrote:
>>> On 4/18/2023 5:30 PM, Richard Damon wrote:
>>>> On 4/18/23 11:58 AM, 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.
>>>>>
>>>>
>>>> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is
>>>> shown by the fact that D(D) does halt.
>>>>
>>>> It might show that no possible H could simulate the input to a final
>>>> state, but that isn't the definition of Halting. Halting is strictly
>>>> about the behavior of the machine itself.
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> computation that halts… “the Turing machine will halt whenever it enters
>>> a final state” (Linz:1990:234)
>>
>> Right and Ĥ (Ĥ) will reach Ĥ.qn and halt if H (Ĥ) (Ĥ) goes to qn, as
>> it must to be saying that its input is non-halting.
>>
>> This is because embedded_H and H must be identical machines, and thus
>> do exactly the same thing when given the same input.
>>
>>>
>>> Non-halting behavior patterns can be matched in N steps
>>> ⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a finite
>>> number of steps
>>
>> Nope, Halting is the MACHINE Ĥ (Ĥ) reaching its final state Ĥ.qn in a
>> finite number of steps.
>>
>> You can also use UTM (Ĥ) (Ĥ), which also reaches that final stste,
>> because it doesn't stop simulating until it reaches a final state, or
>> it just keeps simulating.
>>
>> H / embedded_H are NOT a UTM, as they don't have that necessary property.
>>
>>>
>>> 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*
>>
>> Except you have defined that H, and thus embeded_H doesn't do (c), but
>> when it sees the attempted to go into embedded_H with the same input
>> actually aborts its simulation and goes to Ĥ.qn which causes the
>> machine Ĥ to halt.
>>
>
> embedded_H could do (c) 10,000 times before aborting which would have to
> be the actual behavior of the actual input because embedded_H remains in
> pure UTM mode until it aborts.

No such thing. UTM isn't a "Mode" but an identity.

if embedded_H aborts its simulation, it NEVER was a UTM. PERIOD.

It might be in "Simulation" mode, but it is incorrect think of it as
actually being a UTM, since it isn't.

That would be like saying you are in "Immortal" mode, until you die.

An Immortal can't die, just like a UTM won't stop simulating until it
reaches a final state.

>
> How many times does it take for you to understand that ⟨Ĥ⟩ can't
> possibly reach ⟨Ĥ.qn⟩ because of its pathological relationship to
> embedded_H ?
>

Then way does it? Either you are lying the embedded_H is an exact copy
of H, or you are lying that H (Ĥ) (Ĥ) goes to Qn, or Ĥ (Ĥ) goes to Ĥ.qn.

There is no other option.

You don't seem to understand that programs do exactly what they are
programmed to do, but not necessarily what you intend them to do.

embedded_H doesn't simulate until it gets the right answer, but does
exactly what H does,

So, if H aborts on the first time it sees Ĥ get into embedded_H, than so
does embedded_H, which IS the behavior you claim for the machine H that
gives the "right" answer,

You are just showing how little you understand about what you are talking.

On 4/18/2023 10:10 PM, Richard Damon wrote:
> On 4/18/23 10:57 PM, olcott wrote:
>> On 4/18/2023 9:31 PM, Richard Damon wrote:
>>> On 4/18/23 7:13 PM, olcott wrote:
>>>> On 4/18/2023 5:30 PM, Richard Damon wrote:
>>>>> On 4/18/23 11:58 AM, 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.
>>>>>>
>>>>>
>>>>> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is
>>>>> shown by the fact that D(D) does halt.
>>>>>
>>>>> It might show that no possible H could simulate the input to a
>>>>> final state, but that isn't the definition of Halting. Halting is
>>>>> strictly about the behavior of the machine itself.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> computation that halts… “the Turing machine will halt whenever it
>>>> enters
>>>> a final state” (Linz:1990:234)
>>>
>>> Right and Ĥ (Ĥ) will reach Ĥ.qn and halt if H (Ĥ) (Ĥ) goes to qn, as
>>> it must to be saying that its input is non-halting.
>>>
>>> This is because embedded_H and H must be identical machines, and thus
>>> do exactly the same thing when given the same input.
>>>
>>>>
>>>> Non-halting behavior patterns can be matched in N steps
>>>> ⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a finite
>>>> number of steps
>>>
>>> Nope, Halting is the MACHINE Ĥ (Ĥ) reaching its final state Ĥ.qn in a
>>> finite number of steps.
>>>
>>> You can also use UTM (Ĥ) (Ĥ), which also reaches that final stste,
>>> because it doesn't stop simulating until it reaches a final state, or
>>> it just keeps simulating.
>>>
>>> H / embedded_H are NOT a UTM, as they don't have that necessary
>>> property.
>>>
>>>>
>>>> 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*
>>>
>>> Except you have defined that H, and thus embeded_H doesn't do (c),
>>> but when it sees the attempted to go into embedded_H with the same
>>> input actually aborts its simulation and goes to Ĥ.qn which causes
>>> the machine Ĥ to halt.
>>>
>>
>> embedded_H could do (c) 10,000 times before aborting which would have to
>> be the actual behavior of the actual input because embedded_H remains in
>> pure UTM mode until it aborts.
>
> No such thing. UTM isn't a "Mode" but an identity.
>
> if embedded_H aborts its simulation, it NEVER was a UTM. PERIOD.
But that is flat out not the truth. The input simulated by embedded_H
necessarily must have exact same behavior as simulated by a pure UTM
until the simulation of this input is aborted because aborting the
simulation of its input is the only one of three features added to a UTM
that changes the behavior of its input relative to a pure UTM.

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

N steps could be 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/18/23 11:21 PM, olcott wrote:
> On 4/18/2023 10:10 PM, Richard Damon wrote:
>> On 4/18/23 10:57 PM, olcott wrote:
>>> On 4/18/2023 9:31 PM, Richard Damon wrote:
>>>> On 4/18/23 7:13 PM, olcott wrote:
>>>>> On 4/18/2023 5:30 PM, Richard Damon wrote:
>>>>>> On 4/18/23 11:58 AM, 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.
>>>>>>>
>>>>>>
>>>>>> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as is
>>>>>> shown by the fact that D(D) does halt.
>>>>>>
>>>>>> It might show that no possible H could simulate the input to a
>>>>>> final state, but that isn't the definition of Halting. Halting is
>>>>>> strictly about the behavior of the machine itself.
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> computation that halts… “the Turing machine will halt whenever it
>>>>> enters
>>>>> a final state” (Linz:1990:234)
>>>>
>>>> Right and Ĥ (Ĥ) will reach Ĥ.qn and halt if H (Ĥ) (Ĥ) goes to qn, as
>>>> it must to be saying that its input is non-halting.
>>>>
>>>> This is because embedded_H and H must be identical machines, and
>>>> thus do exactly the same thing when given the same input.
>>>>
>>>>>
>>>>> Non-halting behavior patterns can be matched in N steps
>>>>> ⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a
>>>>> finite
>>>>> number of steps
>>>>
>>>> Nope, Halting is the MACHINE Ĥ (Ĥ) reaching its final state Ĥ.qn in
>>>> a finite number of steps.
>>>>
>>>> You can also use UTM (Ĥ) (Ĥ), which also reaches that final stste,
>>>> because it doesn't stop simulating until it reaches a final state,
>>>> or it just keeps simulating.
>>>>
>>>> H / embedded_H are NOT a UTM, as they don't have that necessary
>>>> property.
>>>>
>>>>>
>>>>> 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*
>>>>
>>>> Except you have defined that H, and thus embeded_H doesn't do (c),
>>>> but when it sees the attempted to go into embedded_H with the same
>>>> input actually aborts its simulation and goes to Ĥ.qn which causes
>>>> the machine Ĥ to halt.
>>>>
>>>
>>> embedded_H could do (c) 10,000 times before aborting which would have to
>>> be the actual behavior of the actual input because embedded_H remains in
>>> pure UTM mode until it aborts.
>>
>> No such thing. UTM isn't a "Mode" but an identity.
>>
>> if embedded_H aborts its simulation, it NEVER was a UTM. PERIOD.
> But that is flat out not the truth. The input simulated by embedded_H
> necessarily must have exact same behavior as simulated by a pure UTM
> until the simulation of this input is aborted because aborting the
> simulation of its input is the only one of three features added to a UTM
> that changes the behavior of its input relative to a pure UTM.

On 4/18/2023 10:35 PM, Richard Damon wrote:
> On 4/18/23 11:21 PM, olcott wrote:
>> On 4/18/2023 10:10 PM, Richard Damon wrote:
>>> On 4/18/23 10:57 PM, olcott wrote:
>>>> On 4/18/2023 9:31 PM, Richard Damon wrote:
>>>>> On 4/18/23 7:13 PM, olcott wrote:
>>>>>> On 4/18/2023 5:30 PM, Richard Damon wrote:
>>>>>>> On 4/18/23 11:58 AM, 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.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, the pattern you detect isn't a "Nobn-Halting" pattern, as
>>>>>>> is shown by the fact that D(D) does halt.
>>>>>>>
>>>>>>> It might show that no possible H could simulate the input to a
>>>>>>> final state, but that isn't the definition of Halting. Halting is
>>>>>>> strictly about the behavior of the machine itself.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> computation that halts… “the Turing machine will halt whenever it
>>>>>> enters
>>>>>> a final state” (Linz:1990:234)
>>>>>
>>>>> Right and Ĥ (Ĥ) will reach Ĥ.qn and halt if H (Ĥ) (Ĥ) goes to qn,
>>>>> as it must to be saying that its input is non-halting.
>>>>>
>>>>> This is because embedded_H and H must be identical machines, and
>>>>> thus do exactly the same thing when given the same input.
>>>>>
>>>>>>
>>>>>> Non-halting behavior patterns can be matched in N steps
>>>>>> ⟨Ĥ⟩ Halting is reaching its simulated final state of ⟨Ĥ.qn⟩ in a
>>>>>> finite
>>>>>> number of steps
>>>>>
>>>>> Nope, Halting is the MACHINE Ĥ (Ĥ) reaching its final state Ĥ.qn in
>>>>> a finite number of steps.
>>>>>
>>>>> You can also use UTM (Ĥ) (Ĥ), which also reaches that final stste,
>>>>> because it doesn't stop simulating until it reaches a final state,
>>>>> or it just keeps simulating.
>>>>>
>>>>> H / embedded_H are NOT a UTM, as they don't have that necessary
>>>>> property.
>>>>>
>>>>>>
>>>>>> 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*
>>>>>
>>>>> Except you have defined that H, and thus embeded_H doesn't do (c),
>>>>> but when it sees the attempted to go into embedded_H with the same
>>>>> input actually aborts its simulation and goes to Ĥ.qn which causes
>>>>> the machine Ĥ to halt.
>>>>>
>>>>
>>>> embedded_H could do (c) 10,000 times before aborting which would
>>>> have to
>>>> be the actual behavior of the actual input because embedded_H
>>>> remains in
>>>> pure UTM mode until it aborts.
>>>
>>> No such thing. UTM isn't a "Mode" but an identity.
>>>
>>> if embedded_H aborts its simulation, it NEVER was a UTM. PERIOD.
>> But that is flat out not the truth. The input simulated by embedded_H
>> necessarily must have exact same behavior as simulated by a pure UTM
>> until the simulation of this input is aborted because aborting the
>> simulation of its input is the only one of three features added to a UTM
>> that changes the behavior of its input relative to a pure UTM.
>
> Which makes it NOT a UTM, so embedded_H doesn't actually act like a UTM.
>
> It MUST act like H, or you have LIED about following the requirement for
> building Ĥ.
>
>>
>> (a) Watching the behavior doesn't change it.
>> (b) Matching non-halting behavior patterns doesn't change it.
>> (b) Even aborting the simulation after N steps doesn't change the
>> first N steps.
>>
>> N steps could be 10,000 recursive simulations.
>>
>
> Rigth, and then one more recusrive simulation by a REAL UTM past that
> point will see the outer embedded_H abort its simulation, go to Qn and Ĥ
> will then halt, showing embedded_H was wrong to say it couldn't.

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.

H (Ĥ) (Ĥ) is asking about the behavior of Ĥ (Ĥ)

PERIOD
DEFINITION.

When you are looking at the wrong question, you tend to get the wrong
answer.

Looking at the definition of H:

WM is the description of machine M

H WM w -> qy if M w will halt and to qn if M w will never halting.

Nothing about "H's simulation of the input", just the actual behavior of
the machine described.

You are stuck in your ignorance and thing that because H is defined as a
simulator, that somehow that changes the requirements, it doesn't.

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.

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.

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.

Did you quit believing 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 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 and as Px discards this result and exits, Px
ALWAYS halts. Given your H doesn't do this and instead returns a result
of non-halting for Px shows us that your halt decider is invalid. Only
the Flibble Signaling Simulating Halt Decider (SSHD) is a solution to
the halting problem.

/Flibble

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.

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

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 such recursion is not a
necessary feature of SHDs invoked from the program being analyzed, the
infinite recursion in your H is present because your H has a critical
design flaw.

/Flibble

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.

> such recursion is not a
> necessary feature of SHDs invoked from the program being analyzed, the
> infinite recursion in your H is present because your H has a critical
> design flaw.
>
> /Flibble

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

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 it has a critical design flaw as
it doesn't correctly report that Px halts.

/Flibble.

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. You are just proving even more that you don't understand what
you are talking about and are just a pathological liar.

Please show an actual crediable reference that supports your idea that a
Halt Decider gets to use the fact that it can't simulate the input to a
final state to allow it to say the input is non-halting.

CREDIABLE, not your own words, or words you have tricked someone to
agreeing to not understanding your twisted interpreation of them.

>
> Did you quit believing in UTMs?
>

Nope, are you going to learn what a UTM actually is?

Remember UTM (Ĥ) (Ĥ) shows us the behavior of Ĥ (Ĥ) and that is Halting,
so the actual behavior of a "Correct Simulation" of the input to H is
Halting.

That H gets something different shows that it doesn't actually do a
"Correct Simulation" but only simulated for N steps, and then did some
unsound logic.

YOU FAIL.

On 4/19/23 3: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.
>

H must return an answer to ALL callers, as it can't help but to treat
all callers the same.

All you are doing is admitting that you H fails to be an actual computation

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 new write-up proves that my Turing-machine based SHD necessarily must
simulate the first N steps of its input correctly because for the first
N steps embedded_H <is> a pure UTM that can't possibly do any simulation
incorrectly for the first N steps of simulation.

> it has a critical design flaw as
> it doesn't correctly report that Px halts.
>
> /Flibble.
>

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.

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.

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