// Simplified Linz(1990) Ĥ
// and Strachey(1965) P
void P(ptr x)
{ if (H(x, y))
HERE: goto HERE;
}

H and P are defined according to the standard HP counter-example
template shown above.

H bases its halt status decision on the behavior of the simulation of
its input.

Then P demonstrates an infinitely repeating pattern that cannot possibly
ever reach its final state.

This conclusively proves that the input to H meets the Linz definition
of non-halting:

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

thus the sufficiency condition for H to report that its input specifies
a non-halting computation.

Halting problem undecidability and infinitely nested simulation V2
https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

--
Copyright 2021 Pete Olcott

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

On 1/8/22 8:41 PM, olcott wrote:
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   if (H(x, y))
>     HERE: goto HERE;
> }
>
> H and P are defined according to the standard HP counter-example
> template shown above.
>
> H bases its halt status decision on the behavior of the simulation of
> its input.

Ok, presumably it will abort this simulation if it thinks the input is
non-haltng, otherwise, as has been proven, a non-aborting decider will
naver answer, and thus be wrong.

If you want to claim that our H IS such an non-aborting decider, then
say so and it fails that way.

Otherwise, we will assume that H DOES abort its simulation if it thinks
the input is non-halting and returns 0.
>
> Then P demonstrates an infinitely repeating pattern that cannot possibly
> ever reach its final state.

WRONG. IF H aborts is simulation and returns a zero to its caller, then
P will Halt.

>
> This conclusively proves that the input to H meets the Linz definition
> of non-halting:

Wrong.

Since if H(P,P) returns 0, then P() will reach its final state, P(P) is
halting if H(P,P) returns 0.

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

Which it does. (If H(P,P) returns 0)

>
> thus the sufficiency condition for H to report that its input specifies
> a non-halting computation.
>

WRONG.

> Halting problem undecidability and infinitely nested simulation V2
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>
>

Note:

H can not do BOTH be non-aborting and also aborting, it must be one or
the other, unless you want to provide a proof that a specific algorithm
can do two different things for the same input.

Non-Aborting H fails to give an answer.

Aborting H gives the wrong answer, as P will Halt if H returns
non-halting in finite time.

On 1/8/22 8:41 PM, olcott wrote:
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   if (H(x, y))
>     HERE: goto HERE;
> }
>
> H and P are defined according to the standard HP counter-example
> template shown above.
>
> H bases its halt status decision on the behavior of the simulation of
> its input.
>
> Then P demonstrates an infinitely repeating pattern that cannot possibly
> ever reach its final state.
>
> This conclusively proves that the input to H meets the Linz definition
> of non-halting:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> thus the sufficiency condition for H to report that its input specifies
> a non-halting computation.
>
> Halting problem undecidability and infinitely nested simulation V2
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>
>

Full Proof with Request for Rebuttal
We have gone around the circle of this MANY times, and you keep just
rearranging things and not every answering the refutation.

The following as a fairly formal step by step refutation of your arguements.

FAIR WARNING.
Failure to make a SPECIFIC refutation, indicating exactly which item is
incorrect and how it is wrong, will be taken as an admission that this
proof is correct, and your whole argument is invalid.

1) The standard rules of Logic apply. This means things like if we can
show that the truth of proposition A implies the truth of proposition B,
and we can show that proposition A is actually true, then Propsition B
MUST be true.

If you don’t claim this, then you aren’t working with the required logic
system to talk about Computation Theory.

2) All copies of a given Turing Machine (like H) given the exact same
input (like <H^> <H^>) will ALWAYS give the exact same output EVERY TIME.

This is a fundamental property of Computation Theory.

To claim this to be incorrect, you need to provide at least one example
of an ACTUAL Turing Machine and an Input, and show how it can give two
different outputs.

3) Your H claims to follow the requirements of a Halt Decider, meaning
that H(<X>,y) to be correct returns 1 if X(y) will Halt and 0 if X(y)
will NEVER Halt, which can be equivalently stated as UTM(<x>, y)
Halts/will NEVER Hal

Formal Notation:
H <X> y -> H.Qy iff X y will Halt and
H <X> y -> H.Qn iff X y will NEVER Halt

IF you don’t claim this, then you aren’t working on the Halting Problem

4) H^ (which you sometimes call P) is build EXACTLY per the Linz
specification which means that H^(x) will use a copy of H to perform
H(x,x) and if that returns 1 (Halting) will go into an infinite loop,
and if H returns 0 (Non_Halting) will immediately Halt.

The H that we base H^ on is EXACTLY the same H that we are testing with.

Formal Notation:
H^ x -> H^.Qy -> Infinite Loop iff H x x -> H.Qy and
H^ x -> H^.Qn & Halt iff H x x -> H.Qn

If you don’t claim this, then your H^/P is not needed one for countering
Linz.

5) Your claim is that H is correctly deciding that H^ is non-halting,
therefore you are claiming that H <H^> <H^> -> H.Qn

If not, then you H isn’t giving the answer you claim is correct.

6) By 2 & 5, this means that the copy of H inside H^ goes to H.Qn, and
thus by 4, H^ <H^> -> H^.Qn and Halts.

7) By Substitution of X = H^, and y = <H^> requirement 3 becomes, for H
to be correct:

H <H^> <H^> -> H.Qy iff H^ <H^> will Halt and
H <H^> <H^> -> H.Qn iff H^ <H^> will NEVER Halt

8) By 6, we have that H^ <H^> will Halt, so the correct answer for the
question H <H^> <H^> must be H.Qy

9) This is NOT the answer H gave, so H is wrong.

Remember, you must point out WHAT is wrong, not just claim you have a
'proof' that shows the contrary.

The specific error in YOUR arguement HAVE been pointed out and you have
ignored them, showing you don't really have grounds to defend them.

On 1/8/2022 8:55 PM, Richard Damon wrote:
> On 1/8/22 8:41 PM, olcott wrote:
>> // Simplified Linz(1990) Ĥ
>> // and Strachey(1965) P
>> void P(ptr x)
>> {
>>    if (H(x, y))
>>      HERE: goto HERE;
>> }
>>
>> H and P are defined according to the standard HP counter-example
>> template shown above.
>>
>> H bases its halt status decision on the behavior of the simulation of
>> its input.
>>
>> Then P demonstrates an infinitely repeating pattern that cannot
>> possibly ever reach its final state.
>>
>> This conclusively proves that the input to H meets the Linz definition
>> of non-halting:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> thus the sufficiency condition for H to report that its input
>> specifies a non-halting computation.
>>
>> Halting problem undecidability and infinitely nested simulation V2
>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>
>>
>>
>
> Full Proof with Request for Rebuttal
> We have gone around the circle of this MANY times, and you keep just
> rearranging things and not every answering the refutation.

The problem is that you are simply too stupid to ever understand that P
specifies a sequence of configurations that never reach its final state
and thus is correctly determined to be a non-halting computation
according to Linz.

Malcolm, Kaz and Flibble are not too stupid to understand this.

Ben, André and Mike are not interested in understanding what I say they
are only interested in finding some basis for rebuttal. If there is at
least one minor point that I have not proven completely they count
everything that I say as incorrect on the basis of this minor point.

--
Copyright 2021 Pete Olcott

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

On Saturday, January 8, 2022 at 8:41:34 PM UTC-5, olcott wrote:
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
> if (H(x, y))
> HERE: goto HERE;
> }
>
> H and P are defined according to the standard HP counter-example
> template shown above.
>
> H bases its halt status decision on the behavior of the simulation of
> its input.
>
> Then P demonstrates an infinitely repeating pattern that cannot possibly
> ever reach its final state.
>
> This conclusively proves that the input to H meets the Linz definition
> of non-halting:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> thus the sufficiency condition for H to report that its input specifies
> a non-halting computation.
>
> Halting problem undecidability and infinitely nested simulation V2
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

It just occurred to me that your thought experiment (?) regarding the halting problem might be a sort of "chess fork"--either one participates in your thought experiment, or one declines to participate and discusses objections to the thought experiment (whether perceiving it or not), or one merely spectates.

Is this itself a form of "innuendo about the nature of human consciousness?" I.e., are you subtly asking the question, "Do humans make choices, is the human mind strictly a Turing machine?"

In case you are wondering about that, I don't mind sharing a "safely publishable subset" of sorts of my physics theory of everything. The answer, according to my theory, is that the human mind is not a Turing machine, because conscious entities can make choices that are *mathematically unmodelable.* These choices (of one conscious entity) are thus in a precise sense completely unpredictable (even "undecidable" in a precise sense), especially without the consent of the predicted, in spite of possible illusions to the contrary.

In case you doubt that, consider this halting-problem-related experiment: I have a certain mental process for making decision X between choice A and choice B. Perhaps my process is simple, and involves a sort of set of coinflips that leads to an 80% chance of A and a 20% chance of B, every time.

One day, while consciously perceiving things, I note that an adversary is researching me and has identified my simple process completely. My adversary knows my exact probability for choosing A and B. Thus, being aware of this based on comparable analytical processes of my own, I choose to quickly modify my "mental computer program" to change the probability distribution, throwing my adversary off completely--now my probabilities are 65% for A and 35% for B, and my adversary hasn't "hacked into" my new process yet, and thus cannot predict me accurately.

That is my argument, which you'll note is similar to the halting problem (a "halt-solver TM" could give rise to a "halts on self TM" that would, quite similarly, fail to compete with a comparable TM that does the same thing--the first machine can't "beat" the second machine in the sense of fully analyzing or "understanding it"), for why humans are definitely conscious and not just TMs. It is quite related to physics, in ways I refuse to discuss at this time.

I have no idea if that's what you're wondering. The idea I've proposed above is not specific to any one religious paradigm--atheists and Christians/Jews/Muslims/Buddhists/etc. should all accept my argument, based on the idea that a conscious entity should be able to modify its "choice-making process" faster than an adversary can learn such a process, once possibly successful adversary research efforts have been detected by the target.

Even if that wasn't what you were looking for, I hope my post is at least a little bit interesting! I suppose I was wondering if I should do a little more to react helpfully to your posts myself, given that you've been kind enough to interact with me appropriately in the past when most others weren't willing to.

Feel free to ignore this if it bores you or if you would prefer to discuss other things.

Best regards,
Philip White

On 1/8/22 10:20 PM, olcott wrote:
> On 1/8/2022 8:55 PM, Richard Damon wrote:
>> On 1/8/22 8:41 PM, olcott wrote:
>>> // Simplified Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> void P(ptr x)
>>> {
>>>    if (H(x, y))
>>>      HERE: goto HERE;
>>> }
>>>
>>> H and P are defined according to the standard HP counter-example
>>> template shown above.
>>>
>>> H bases its halt status decision on the behavior of the simulation of
>>> its input.
>>>
>>> Then P demonstrates an infinitely repeating pattern that cannot
>>> possibly ever reach its final state.
>>>
>>> This conclusively proves that the input to H meets the Linz
>>> definition of non-halting:
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> thus the sufficiency condition for H to report that its input
>>> specifies a non-halting computation.
>>>
>>> Halting problem undecidability and infinitely nested simulation V2
>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>
>>>
>>>
>>
>> Full Proof with Request for Rebuttal
>> We have gone around the circle of this MANY times, and you keep just
>> rearranging things and not every answering the refutation.
>
> The problem is that you are simply too stupid to ever understand that P
> specifies a sequence of configurations that never reach its final state
> and thus is correctly determined to be a non-halting computation
> according to Linz.

And you are too stupid to see that it doesn't if H(P,P) returns 0, as
this just proved.

Your failure to point out an error will be taken as an admission that
you accept that your logic is incorrect.

FAIR WARNING.

>
> Malcolm, Kaz and Flibble are not too stupid to understand this.
>
> Ben, André and Mike are not interested in understanding what I say they
> are only interested in finding some basis for rebuttal. If there is at
> least one minor point that I have not proven completely they count
> everything that I say as incorrect on the basis of this minor point.
>

On 1/8/2022 9:59 PM, Richard Damon wrote:
> On 1/8/22 10:20 PM, olcott wrote:
>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>> On 1/8/22 8:41 PM, olcott wrote:
>>>> // Simplified Linz(1990) Ĥ
>>>> // and Strachey(1965) P
>>>> void P(ptr x)
>>>> {
>>>>    if (H(x, y))
>>>>      HERE: goto HERE;
>>>> }
>>>>
>>>> H and P are defined according to the standard HP counter-example
>>>> template shown above.
>>>>
>>>> H bases its halt status decision on the behavior of the simulation
>>>> of its input.
>>>>
>>>> Then P demonstrates an infinitely repeating pattern that cannot
>>>> possibly ever reach its final state.
>>>>
>>>> This conclusively proves that the input to H meets the Linz
>>>> definition of non-halting:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> thus the sufficiency condition for H to report that its input
>>>> specifies a non-halting computation.
>>>>
>>>> Halting problem undecidability and infinitely nested simulation V2
>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>
>>>>
>>>>
>>>
>>> Full Proof with Request for Rebuttal
>>> We have gone around the circle of this MANY times, and you keep just
>>> rearranging things and not every answering the refutation.
>>
>> The problem is that you are simply too stupid to ever understand that
>> P specifies a sequence of configurations that never reach its final
>> state and thus is correctly determined to be a non-halting computation
>> according to Linz.
>
> And you are too stupid to see that it doesn't if H(P,P) returns 0, as
> this just proved.
>

It is always correct for H to report on what the behavior of its input
would be if H did not interfere with the behavior of this input.
H is an objective observer.

It is never correct for H to report on what the behavior of its input
would be if H did interfere with the behavior of this input.
H is not an objective observer.

> Your failure to point out an error will be taken as an admission that
> you accept that your logic is incorrect.
>
> FAIR WARNING.
>
>>
>> Malcolm, Kaz and Flibble are not too stupid to understand this.
>>
>> Ben, André and Mike are not interested in understanding what I say
>> they are only interested in finding some basis for rebuttal. If there
>> is at least one minor point that I have not proven completely they
>> count everything that I say as incorrect on the basis of this minor
>> point.
>>
>

--
Copyright 2021 Pete Olcott

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

On 1/9/22 11:40 AM, olcott wrote:
> On 1/8/2022 9:59 PM, Richard Damon wrote:
>> On 1/8/22 10:20 PM, olcott wrote:
>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>> // Simplified Linz(1990) Ĥ
>>>>> // and Strachey(1965) P
>>>>> void P(ptr x)
>>>>> {
>>>>>    if (H(x, y))
>>>>>      HERE: goto HERE;
>>>>> }
>>>>>
>>>>> H and P are defined according to the standard HP counter-example
>>>>> template shown above.
>>>>>
>>>>> H bases its halt status decision on the behavior of the simulation
>>>>> of its input.
>>>>>
>>>>> Then P demonstrates an infinitely repeating pattern that cannot
>>>>> possibly ever reach its final state.
>>>>>
>>>>> This conclusively proves that the input to H meets the Linz
>>>>> definition of non-halting:
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> thus the sufficiency condition for H to report that its input
>>>>> specifies a non-halting computation.
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation V2
>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>
>>>>>
>>>>>
>>>>
>>>> Full Proof with Request for Rebuttal
>>>> We have gone around the circle of this MANY times, and you keep just
>>>> rearranging things and not every answering the refutation.
>>>
>>> The problem is that you are simply too stupid to ever understand that
>>> P specifies a sequence of configurations that never reach its final
>>> state and thus is correctly determined to be a non-halting
>>> computation according to Linz.
>>
>> And you are too stupid to see that it doesn't if H(P,P) returns 0, as
>> this just proved.
>>
>
> It is always correct for H to report on what the behavior of its input
> would be if H did not interfere with the behavior of this input.
> H is an objective observer.
>
> It is never correct for H to report on what the behavior of its input
> would be if H did interfere with the behavior of this input.
> H is not an objective observer.

IMPROPERLY PHRASED, H must report on what the machine that its input
represents will do, even if that includes a copy of itself. That is not
H 'interfering' with the behavior of that machine.

It is Impossible for the copy of a decider doing the deciding to
'interfere' with the behavior of a machine, as that behavior is defined
independent of the decider.

Yes, the aborting of a simulation by the copy of the decider doing the
deciding doesn't affect the behavior of the machine it is deciding on, a
copy of it IN the machine it is trying to decide on, DOES, as it IS part
of the machine it is deciding on.

FAIL.

The fact that you can't keep the different copies of H separate shows
your lack of reasoning ability.

>
>
>> Your failure to point out an error will be taken as an admission that
>> you accept that your logic is incorrect.
>>
>> FAIR WARNING.
>>
>>>
>>> Malcolm, Kaz and Flibble are not too stupid to understand this.
>>>
>>> Ben, André and Mike are not interested in understanding what I say
>>> they are only interested in finding some basis for rebuttal. If there
>>> is at least one minor point that I have not proven completely they
>>> count everything that I say as incorrect on the basis of this minor
>>> point.
>>>
>>
>
>

On 1/9/2022 11:43 AM, Richard Damon wrote:
> On 1/9/22 11:40 AM, olcott wrote:
>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>> On 1/8/22 10:20 PM, olcott wrote:
>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>> // Simplified Linz(1990) Ĥ
>>>>>> // and Strachey(1965) P
>>>>>> void P(ptr x)
>>>>>> {
>>>>>>    if (H(x, y))
>>>>>>      HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> H and P are defined according to the standard HP counter-example
>>>>>> template shown above.
>>>>>>
>>>>>> H bases its halt status decision on the behavior of the simulation
>>>>>> of its input.
>>>>>>
>>>>>> Then P demonstrates an infinitely repeating pattern that cannot
>>>>>> possibly ever reach its final state.
>>>>>>
>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>> definition of non-halting:
>>>>>>
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters a final state. (Linz:1990:234)
>>>>>>
>>>>>> thus the sufficiency condition for H to report that its input
>>>>>> specifies a non-halting computation.
>>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation V2
>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Full Proof with Request for Rebuttal
>>>>> We have gone around the circle of this MANY times, and you keep
>>>>> just rearranging things and not every answering the refutation.
>>>>
>>>> The problem is that you are simply too stupid to ever understand
>>>> that P specifies a sequence of configurations that never reach its
>>>> final state and thus is correctly determined to be a non-halting
>>>> computation according to Linz.
>>>
>>> And you are too stupid to see that it doesn't if H(P,P) returns 0, as
>>> this just proved.
>>>
>>
>> It is always correct for H to report on what the behavior of its input
>> would be if H did not interfere with the behavior of this input.
>> H is an objective observer.
>>
>> It is never correct for H to report on what the behavior of its input
>> would be if H did interfere with the behavior of this input.
>> H is not an objective observer.
>
> IMPROPERLY PHRASED, H must report on what the machine that its input
> represents will do, even if that includes a copy of itself. That is not
> H 'interfering' with the behavior of that machine.
>
> It is Impossible for the copy of a decider doing the deciding to
> 'interfere' with the behavior of a machine, as that behavior is defined
> independent of the decider.
>
> Yes, the aborting of a simulation by the copy of the decider doing the
> deciding doesn't affect the behavior of the machine it is deciding on, a
> copy of it IN the machine it is trying to decide on, DOES, as it IS part
> of the machine it is deciding on.
>
> FAIL.
>
>
> The fact that you can't keep the different copies of H separate shows
> your lack of reasoning ability.
>

When H reports on what the behavior of its simulated input would be if H
did not interfere, it is the same for P, infinite loops, or infinite
recursion, H must only reject its input as non-halting.

>>
>>
>>> Your failure to point out an error will be taken as an admission that
>>> you accept that your logic is incorrect.
>>>
>>> FAIR WARNING.
>>>
>>>>
>>>> Malcolm, Kaz and Flibble are not too stupid to understand this.
>>>>
>>>> Ben, André and Mike are not interested in understanding what I say
>>>> they are only interested in finding some basis for rebuttal. If
>>>> there is at least one minor point that I have not proven completely
>>>> they count everything that I say as incorrect on the basis of this
>>>> minor point.
>>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

On 1/9/22 12:57 PM, olcott wrote:
> On 1/9/2022 11:43 AM, Richard Damon wrote:
>> On 1/9/22 11:40 AM, olcott wrote:
>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>> // and Strachey(1965) P
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>>    if (H(x, y))
>>>>>>>      HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> H and P are defined according to the standard HP counter-example
>>>>>>> template shown above.
>>>>>>>
>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>> simulation of its input.
>>>>>>>
>>>>>>> Then P demonstrates an infinitely repeating pattern that cannot
>>>>>>> possibly ever reach its final state.
>>>>>>>
>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>> definition of non-halting:
>>>>>>>
>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>
>>>>>>> thus the sufficiency condition for H to report that its input
>>>>>>> specifies a non-halting computation.
>>>>>>>
>>>>>>> Halting problem undecidability and infinitely nested simulation V2
>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Full Proof with Request for Rebuttal
>>>>>> We have gone around the circle of this MANY times, and you keep
>>>>>> just rearranging things and not every answering the refutation.
>>>>>
>>>>> The problem is that you are simply too stupid to ever understand
>>>>> that P specifies a sequence of configurations that never reach its
>>>>> final state and thus is correctly determined to be a non-halting
>>>>> computation according to Linz.
>>>>
>>>> And you are too stupid to see that it doesn't if H(P,P) returns 0,
>>>> as this just proved.
>>>>
>>>
>>> It is always correct for H to report on what the behavior of its
>>> input would be if H did not interfere with the behavior of this input.
>>> H is an objective observer.
>>>
>>> It is never correct for H to report on what the behavior of its input
>>> would be if H did interfere with the behavior of this input.
>>> H is not an objective observer.
>>
>> IMPROPERLY PHRASED, H must report on what the machine that its input
>> represents will do, even if that includes a copy of itself. That is
>> not H 'interfering' with the behavior of that machine.
>>
>> It is Impossible for the copy of a decider doing the deciding to
>> 'interfere' with the behavior of a machine, as that behavior is
>> defined independent of the decider.
>>
>> Yes, the aborting of a simulation by the copy of the decider doing the
>> deciding doesn't affect the behavior of the machine it is deciding on,
>> a copy of it IN the machine it is trying to decide on, DOES, as it IS
>> part of the machine it is deciding on.
>>
>> FAIL.
>>
>>
>> The fact that you can't keep the different copies of H separate shows
>> your lack of reasoning ability.
>>
>
> When H reports on what the behavior of its simulated input would be if H
> did not interfere, it is the same for P, infinite loops, or infinite
> recursion, H must only reject its input as non-halting.
>

Except it isn't 'interference' for the copy of H in the input to do what
it is programmed to do.

In fact, it is interference for the H that is deciding to NOT let the
copy of H inside P to do that that H is programmed to do.

DEFINITIONS, you know, The correct answer for H(<X>, y) is basd on what
X(y) would do when run.

The behavior of 'the input' is what that program would do when run
'without outside interference', that means that copy of H inside P does
what it will do.

Since H(P,P) returns 0, ALL Copies of H(P,P) return 0, so the copy
inside P does thins, and P(P) will Halt.

FAIL.

This has been PROVEN and no actual rebuttal provided, so you have
conceded the point.

>>>
>>>
>>>> Your failure to point out an error will be taken as an admission
>>>> that you accept that your logic is incorrect.
>>>>
>>>> FAIR WARNING.
>>>>
>>>>>
>>>>> Malcolm, Kaz and Flibble are not too stupid to understand this.
>>>>>
>>>>> Ben, André and Mike are not interested in understanding what I say
>>>>> they are only interested in finding some basis for rebuttal. If
>>>>> there is at least one minor point that I have not proven completely
>>>>> they count everything that I say as incorrect on the basis of this
>>>>> minor point.
>>>>>
>>>>
>>>
>>>
>>
>
>

On 1/9/2022 12:06 PM, Richard Damon wrote:
> On 1/9/22 12:57 PM, olcott wrote:
>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>> On 1/9/22 11:40 AM, olcott wrote:
>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>> // and Strachey(1965) P
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>>    if (H(x, y))
>>>>>>>>      HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> H and P are defined according to the standard HP counter-example
>>>>>>>> template shown above.
>>>>>>>>
>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>> simulation of its input.
>>>>>>>>
>>>>>>>> Then P demonstrates an infinitely repeating pattern that cannot
>>>>>>>> possibly ever reach its final state.
>>>>>>>>
>>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>>> definition of non-halting:
>>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>> thus the sufficiency condition for H to report that its input
>>>>>>>> specifies a non-halting computation.
>>>>>>>>
>>>>>>>> Halting problem undecidability and infinitely nested simulation V2
>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Full Proof with Request for Rebuttal
>>>>>>> We have gone around the circle of this MANY times, and you keep
>>>>>>> just rearranging things and not every answering the refutation.
>>>>>>
>>>>>> The problem is that you are simply too stupid to ever understand
>>>>>> that P specifies a sequence of configurations that never reach its
>>>>>> final state and thus is correctly determined to be a non-halting
>>>>>> computation according to Linz.
>>>>>
>>>>> And you are too stupid to see that it doesn't if H(P,P) returns 0,
>>>>> as this just proved.
>>>>>
>>>>
>>>> It is always correct for H to report on what the behavior of its
>>>> input would be if H did not interfere with the behavior of this input.
>>>> H is an objective observer.
>>>>
>>>> It is never correct for H to report on what the behavior of its
>>>> input would be if H did interfere with the behavior of this input.
>>>> H is not an objective observer.
>>>
>>> IMPROPERLY PHRASED, H must report on what the machine that its input
>>> represents will do, even if that includes a copy of itself. That is
>>> not H 'interfering' with the behavior of that machine.
>>>
>>> It is Impossible for the copy of a decider doing the deciding to
>>> 'interfere' with the behavior of a machine, as that behavior is
>>> defined independent of the decider.
>>>
>>> Yes, the aborting of a simulation by the copy of the decider doing
>>> the deciding doesn't affect the behavior of the machine it is
>>> deciding on, a copy of it IN the machine it is trying to decide on,
>>> DOES, as it IS part of the machine it is deciding on.
>>>
>>> FAIL.
>>>
>>>
>>> The fact that you can't keep the different copies of H separate shows
>>> your lack of reasoning ability.
>>>
>>
>> When H reports on what the behavior of its simulated input would be if
>> H did not interfere, it is the same for P, infinite loops, or infinite
>> recursion, H must only reject its input as non-halting.
>>
>
> Except it isn't 'interference' for the copy of H in the input to do what
> it is programmed to do.
>

It is the job of H to determine what the behavior of the input would be
if H did not interfere with this behavior.

Alternatively H could correctly recognize inputs that would never stop
running if H did not interfere and then report that every input does
halt when H does interfere.

Such an H could simply accept every input in that some of its inputs
halt on their own and the other inputs must be aborted. In this case It
would be impossible to create an input that H would not correctly decide.

> In fact, it is interference for the H that is deciding to NOT let the
> copy of H inside P to do that that H is programmed to do.
>
> DEFINITIONS, you know, The correct answer for H(<X>, y) is basd on what
> X(y) would do when run.
>
> The behavior of 'the input' is what that program would do when run
> 'without outside interference', that means that copy of H inside P does
> what it will do.
>
> Since H(P,P) returns 0, ALL Copies of H(P,P) return 0, so the copy
> inside P does thins, and P(P) will Halt.
>
> FAIL.
>
> This has been PROVEN and no actual rebuttal provided, so you have
> conceded the point.
>
>>>>
>>>>
>>>>> Your failure to point out an error will be taken as an admission
>>>>> that you accept that your logic is incorrect.
>>>>>
>>>>> FAIR WARNING.
>>>>>
>>>>>>
>>>>>> Malcolm, Kaz and Flibble are not too stupid to understand this.
>>>>>>
>>>>>> Ben, André and Mike are not interested in understanding what I say
>>>>>> they are only interested in finding some basis for rebuttal. If
>>>>>> there is at least one minor point that I have not proven
>>>>>> completely they count everything that I say as incorrect on the
>>>>>> basis of this minor point.
>>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

On 1/9/22 2:11 PM, olcott wrote:
> On 1/9/2022 12:06 PM, Richard Damon wrote:
>> On 1/9/22 12:57 PM, olcott wrote:
>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>> // and Strachey(1965) P
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>>    if (H(x, y))
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>> counter-example template shown above.
>>>>>>>>>
>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>> simulation of its input.
>>>>>>>>>
>>>>>>>>> Then P demonstrates an infinitely repeating pattern that cannot
>>>>>>>>> possibly ever reach its final state.
>>>>>>>>>
>>>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>>>> definition of non-halting:
>>>>>>>>>
>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> thus the sufficiency condition for H to report that its input
>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>
>>>>>>>>> Halting problem undecidability and infinitely nested simulation V2
>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>> We have gone around the circle of this MANY times, and you keep
>>>>>>>> just rearranging things and not every answering the refutation.
>>>>>>>
>>>>>>> The problem is that you are simply too stupid to ever understand
>>>>>>> that P specifies a sequence of configurations that never reach
>>>>>>> its final state and thus is correctly determined to be a
>>>>>>> non-halting computation according to Linz.
>>>>>>
>>>>>> And you are too stupid to see that it doesn't if H(P,P) returns 0,
>>>>>> as this just proved.
>>>>>>
>>>>>
>>>>> It is always correct for H to report on what the behavior of its
>>>>> input would be if H did not interfere with the behavior of this input.
>>>>> H is an objective observer.
>>>>>
>>>>> It is never correct for H to report on what the behavior of its
>>>>> input would be if H did interfere with the behavior of this input.
>>>>> H is not an objective observer.
>>>>
>>>> IMPROPERLY PHRASED, H must report on what the machine that its input
>>>> represents will do, even if that includes a copy of itself. That is
>>>> not H 'interfering' with the behavior of that machine.
>>>>
>>>> It is Impossible for the copy of a decider doing the deciding to
>>>> 'interfere' with the behavior of a machine, as that behavior is
>>>> defined independent of the decider.
>>>>
>>>> Yes, the aborting of a simulation by the copy of the decider doing
>>>> the deciding doesn't affect the behavior of the machine it is
>>>> deciding on, a copy of it IN the machine it is trying to decide on,
>>>> DOES, as it IS part of the machine it is deciding on.
>>>>
>>>> FAIL.
>>>>
>>>>
>>>> The fact that you can't keep the different copies of H separate
>>>> shows your lack of reasoning ability.
>>>>
>>>
>>> When H reports on what the behavior of its simulated input would be
>>> if H did not interfere, it is the same for P, infinite loops, or
>>> infinite recursion, H must only reject its input as non-halting.
>>>
>>
>> Except it isn't 'interference' for the copy of H in the input to do
>> what it is programmed to do.
>>
>
> It is the job of H to determine what the behavior of the input would be
> if H did not interfere with this behavior.
>
> Alternatively H could correctly recognize inputs that would never stop
> running if H did not interfere and then report that every input does
> halt when H does interfere.
>
> Such an H could simply accept every input in that some of its inputs
> halt on their own and the other inputs must be aborted. In this case It
> would be impossible to create an input that H would not correctly decide.

WRONG.

H needs to determine what the machine represented by its input will DO.

PERIOD.

It is impossible for H to change that behavior by it trying to decide on
it, as H has been FIXED in definition before that input existed, and the
DEEFINITION of the behavior isn't affected by asking H about it.

FAIL.

The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y) does.

If X uses a copy of H, that copy needs to behave exactly like H behaves,
as that is what H does.

Please provide an ACTUAL REFERENCE from someone who actually know
something about this that uses words anything about this 'interference'
that you talk about.

This seems to be some figment of your imagination because you just don't
understand.

With out an actual reference, repeating this claim will just be a LIE,
since the actual definition doesn't use such words.

FAIL.

>
>> In fact, it is interference for the H that is deciding to NOT let the
>> copy of H inside P to do that that H is programmed to do.
>>
>> DEFINITIONS, you know, The correct answer for H(<X>, y) is basd on
>> what X(y) would do when run.
>>
>> The behavior of 'the input' is what that program would do when run
>> 'without outside interference', that means that copy of H inside P
>> does what it will do.
>>
>> Since H(P,P) returns 0, ALL Copies of H(P,P) return 0, so the copy
>> inside P does thins, and P(P) will Halt.
>>
>> FAIL.
>>
>> This has been PROVEN and no actual rebuttal provided, so you have
>> conceded the point.
>>
>>>>>
>>>>>
>>>>>> Your failure to point out an error will be taken as an admission
>>>>>> that you accept that your logic is incorrect.
>>>>>>
>>>>>> FAIR WARNING.
>>>>>>
>>>>>>>
>>>>>>> Malcolm, Kaz and Flibble are not too stupid to understand this.
>>>>>>>
>>>>>>> Ben, André and Mike are not interested in understanding what I
>>>>>>> say they are only interested in finding some basis for rebuttal.
>>>>>>> If there is at least one minor point that I have not proven
>>>>>>> completely they count everything that I say as incorrect on the
>>>>>>> basis of this minor point.
>>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
>
>

On 1/9/2022 1:29 PM, Richard Damon wrote:
> On 1/9/22 2:11 PM, olcott wrote:
>> On 1/9/2022 12:06 PM, Richard Damon wrote:
>>> On 1/9/22 12:57 PM, olcott wrote:
>>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>>    if (H(x, y))
>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>>> counter-example template shown above.
>>>>>>>>>>
>>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>>> simulation of its input.
>>>>>>>>>>
>>>>>>>>>> Then P demonstrates an infinitely repeating pattern that
>>>>>>>>>> cannot possibly ever reach its final state.
>>>>>>>>>>
>>>>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>>>>> definition of non-halting:
>>>>>>>>>>
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> thus the sufficiency condition for H to report that its input
>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>
>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>> simulation V2
>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>>> We have gone around the circle of this MANY times, and you keep
>>>>>>>>> just rearranging things and not every answering the refutation.
>>>>>>>>
>>>>>>>> The problem is that you are simply too stupid to ever understand
>>>>>>>> that P specifies a sequence of configurations that never reach
>>>>>>>> its final state and thus is correctly determined to be a
>>>>>>>> non-halting computation according to Linz.
>>>>>>>
>>>>>>> And you are too stupid to see that it doesn't if H(P,P) returns
>>>>>>> 0, as this just proved.
>>>>>>>
>>>>>>
>>>>>> It is always correct for H to report on what the behavior of its
>>>>>> input would be if H did not interfere with the behavior of this
>>>>>> input.
>>>>>> H is an objective observer.
>>>>>>
>>>>>> It is never correct for H to report on what the behavior of its
>>>>>> input would be if H did interfere with the behavior of this input.
>>>>>> H is not an objective observer.
>>>>>
>>>>> IMPROPERLY PHRASED, H must report on what the machine that its
>>>>> input represents will do, even if that includes a copy of itself.
>>>>> That is not H 'interfering' with the behavior of that machine.
>>>>>
>>>>> It is Impossible for the copy of a decider doing the deciding to
>>>>> 'interfere' with the behavior of a machine, as that behavior is
>>>>> defined independent of the decider.
>>>>>
>>>>> Yes, the aborting of a simulation by the copy of the decider doing
>>>>> the deciding doesn't affect the behavior of the machine it is
>>>>> deciding on, a copy of it IN the machine it is trying to decide on,
>>>>> DOES, as it IS part of the machine it is deciding on.
>>>>>
>>>>> FAIL.
>>>>>
>>>>>
>>>>> The fact that you can't keep the different copies of H separate
>>>>> shows your lack of reasoning ability.
>>>>>
>>>>
>>>> When H reports on what the behavior of its simulated input would be
>>>> if H did not interfere, it is the same for P, infinite loops, or
>>>> infinite recursion, H must only reject its input as non-halting.
>>>>
>>>
>>> Except it isn't 'interference' for the copy of H in the input to do
>>> what it is programmed to do.
>>>
>>
>> It is the job of H to determine what the behavior of the input would
>> be if H did not interfere with this behavior.
>>
>> Alternatively H could correctly recognize inputs that would never stop
>> running if H did not interfere and then report that every input does
>> halt when H does interfere.
>>
>> Such an H could simply accept every input in that some of its inputs
>> halt on their own and the other inputs must be aborted. In this case
>> It would be impossible to create an input that H would not correctly
>> decide.
>
> WRONG.
>
> H needs to determine what the machine represented by its input will DO.
>
> PERIOD.
>
> It is impossible for H to change that behavior by it trying to decide on
> it, as H has been FIXED in definition before that input existed, and the
> DEEFINITION of the behavior isn't affected by asking H about it.
>
> FAIL.
>
> The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y) does.
>
> If X uses a copy of H, that copy needs to behave exactly like H behaves,
> as that is what H does.
>
> Please provide an ACTUAL REFERENCE from someone who actually know
> something about this that uses words anything about this 'interference'
> that you talk about.
>
> This seems to be some figment of your imagination because you just don't
> understand.
>
> With out an actual reference, repeating this claim will just be a LIE,
> since the actual definition doesn't use such words.
>
> FAIL.
>

You simply ignored and erased the important part.

(1) H must report on what the behavior of its input would be without any
interference by H.

OTHERWISE

(2) H would be correct to simply accept every input as halting on the
basis that the input halts on its own or was aborted by H.

--
Copyright 2021 Pete Olcott

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

On 1/9/22 2:53 PM, olcott wrote:
> On 1/9/2022 1:29 PM, Richard Damon wrote:
>> On 1/9/22 2:11 PM, olcott wrote:
>>> On 1/9/2022 12:06 PM, Richard Damon wrote:
>>>> On 1/9/22 12:57 PM, olcott wrote:
>>>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>    if (H(x, y))
>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>>>> counter-example template shown above.
>>>>>>>>>>>
>>>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>> Then P demonstrates an infinitely repeating pattern that
>>>>>>>>>>> cannot possibly ever reach its final state.
>>>>>>>>>>>
>>>>>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>>>>>> definition of non-halting:
>>>>>>>>>>>
>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> thus the sufficiency condition for H to report that its input
>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>
>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>> simulation V2
>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>>>> We have gone around the circle of this MANY times, and you
>>>>>>>>>> keep just rearranging things and not every answering the
>>>>>>>>>> refutation.
>>>>>>>>>
>>>>>>>>> The problem is that you are simply too stupid to ever
>>>>>>>>> understand that P specifies a sequence of configurations that
>>>>>>>>> never reach its final state and thus is correctly determined to
>>>>>>>>> be a non-halting computation according to Linz.
>>>>>>>>
>>>>>>>> And you are too stupid to see that it doesn't if H(P,P) returns
>>>>>>>> 0, as this just proved.
>>>>>>>>
>>>>>>>
>>>>>>> It is always correct for H to report on what the behavior of its
>>>>>>> input would be if H did not interfere with the behavior of this
>>>>>>> input.
>>>>>>> H is an objective observer.
>>>>>>>
>>>>>>> It is never correct for H to report on what the behavior of its
>>>>>>> input would be if H did interfere with the behavior of this input.
>>>>>>> H is not an objective observer.
>>>>>>
>>>>>> IMPROPERLY PHRASED, H must report on what the machine that its
>>>>>> input represents will do, even if that includes a copy of itself.
>>>>>> That is not H 'interfering' with the behavior of that machine.
>>>>>>
>>>>>> It is Impossible for the copy of a decider doing the deciding to
>>>>>> 'interfere' with the behavior of a machine, as that behavior is
>>>>>> defined independent of the decider.
>>>>>>
>>>>>> Yes, the aborting of a simulation by the copy of the decider doing
>>>>>> the deciding doesn't affect the behavior of the machine it is
>>>>>> deciding on, a copy of it IN the machine it is trying to decide
>>>>>> on, DOES, as it IS part of the machine it is deciding on.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>
>>>>>> The fact that you can't keep the different copies of H separate
>>>>>> shows your lack of reasoning ability.
>>>>>>
>>>>>
>>>>> When H reports on what the behavior of its simulated input would be
>>>>> if H did not interfere, it is the same for P, infinite loops, or
>>>>> infinite recursion, H must only reject its input as non-halting.
>>>>>
>>>>
>>>> Except it isn't 'interference' for the copy of H in the input to do
>>>> what it is programmed to do.
>>>>
>>>
>>> It is the job of H to determine what the behavior of the input would
>>> be if H did not interfere with this behavior.
>>>
>>> Alternatively H could correctly recognize inputs that would never
>>> stop running if H did not interfere and then report that every input
>>> does halt when H does interfere.
>>>
>>> Such an H could simply accept every input in that some of its inputs
>>> halt on their own and the other inputs must be aborted. In this case
>>> It would be impossible to create an input that H would not correctly
>>> decide.
>>
>> WRONG.
>>
>> H needs to determine what the machine represented by its input will DO.
>>
>> PERIOD.
>>
>> It is impossible for H to change that behavior by it trying to decide
>> on it, as H has been FIXED in definition before that input existed,
>> and the DEEFINITION of the behavior isn't affected by asking H about it.
>>
>> FAIL.
>>
>> The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y) does.
>>
>> If X uses a copy of H, that copy needs to behave exactly like H
>> behaves, as that is what H does.
>>
>> Please provide an ACTUAL REFERENCE from someone who actually know
>> something about this that uses words anything about this
>> 'interference' that you talk about.
>>
>> This seems to be some figment of your imagination because you just
>> don't understand.
>>
>> With out an actual reference, repeating this claim will just be a LIE,
>> since the actual definition doesn't use such words.
>>
>> FAIL.
>>
>
> You simply ignored and erased the important part.
>

I didn't erase anything.

> (1) H must report on what the behavior of its input would be without any
> interference by H.

No, it must reprot on what the behavior of its input IS. It CAN'T
interfere with it by the definition of what that behavior is.

>
> OTHERWISE
>
> (2) H would be correct to simply accept every input as halting on the
> basis that the input halts on its own or was aborted by H.
>

FAIL.

Since you have failed to provide a reference for the source of your
incorrect definition, it just proves that you are making up a LIE.

FAIL.

You have just proved that you are incapable of understanding what you
are talking about.

The RIGHT answer, for ANY Halt Decider H(<X>, y) is baseed on that
behavior of X(y). PERIOD.

Given your claim that H(P,P) returns 0 (Non-Halting) we KNOW from the
definition of P that P(P), which is the compuation that H(P,P) is asking
about, DOES HALT, thus we have PROVED that your H is WRONG.

PERIOD.

DEFINITION.

On 1/9/2022 2:04 PM, Richard Damon wrote:
>
> On 1/9/22 2:53 PM, olcott wrote:
>> On 1/9/2022 1:29 PM, Richard Damon wrote:
>>> On 1/9/22 2:11 PM, olcott wrote:
>>>> On 1/9/2022 12:06 PM, Richard Damon wrote:
>>>>> On 1/9/22 12:57 PM, olcott wrote:
>>>>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>    if (H(x, y))
>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>>>>> counter-example template shown above.
>>>>>>>>>>>>
>>>>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Then P demonstrates an infinitely repeating pattern that
>>>>>>>>>>>> cannot possibly ever reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>>>>>>> definition of non-halting:
>>>>>>>>>>>>
>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>> thus the sufficiency condition for H to report that its
>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>
>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>> simulation V2
>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>>>>> We have gone around the circle of this MANY times, and you
>>>>>>>>>>> keep just rearranging things and not every answering the
>>>>>>>>>>> refutation.
>>>>>>>>>>
>>>>>>>>>> The problem is that you are simply too stupid to ever
>>>>>>>>>> understand that P specifies a sequence of configurations that
>>>>>>>>>> never reach its final state and thus is correctly determined
>>>>>>>>>> to be a non-halting computation according to Linz.
>>>>>>>>>
>>>>>>>>> And you are too stupid to see that it doesn't if H(P,P) returns
>>>>>>>>> 0, as this just proved.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is always correct for H to report on what the behavior of its
>>>>>>>> input would be if H did not interfere with the behavior of this
>>>>>>>> input.
>>>>>>>> H is an objective observer.
>>>>>>>>
>>>>>>>> It is never correct for H to report on what the behavior of its
>>>>>>>> input would be if H did interfere with the behavior of this input.
>>>>>>>> H is not an objective observer.
>>>>>>>
>>>>>>> IMPROPERLY PHRASED, H must report on what the machine that its
>>>>>>> input represents will do, even if that includes a copy of itself.
>>>>>>> That is not H 'interfering' with the behavior of that machine.
>>>>>>>
>>>>>>> It is Impossible for the copy of a decider doing the deciding to
>>>>>>> 'interfere' with the behavior of a machine, as that behavior is
>>>>>>> defined independent of the decider.
>>>>>>>
>>>>>>> Yes, the aborting of a simulation by the copy of the decider
>>>>>>> doing the deciding doesn't affect the behavior of the machine it
>>>>>>> is deciding on, a copy of it IN the machine it is trying to
>>>>>>> decide on, DOES, as it IS part of the machine it is deciding on.
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>>
>>>>>>> The fact that you can't keep the different copies of H separate
>>>>>>> shows your lack of reasoning ability.
>>>>>>>
>>>>>>
>>>>>> When H reports on what the behavior of its simulated input would
>>>>>> be if H did not interfere, it is the same for P, infinite loops,
>>>>>> or infinite recursion, H must only reject its input as non-halting.
>>>>>>
>>>>>
>>>>> Except it isn't 'interference' for the copy of H in the input to do
>>>>> what it is programmed to do.
>>>>>
>>>>
>>>> It is the job of H to determine what the behavior of the input would
>>>> be if H did not interfere with this behavior.
>>>>
>>>> Alternatively H could correctly recognize inputs that would never
>>>> stop running if H did not interfere and then report that every input
>>>> does halt when H does interfere.
>>>>
>>>> Such an H could simply accept every input in that some of its inputs
>>>> halt on their own and the other inputs must be aborted. In this case
>>>> It would be impossible to create an input that H would not correctly
>>>> decide.
>>>
>>> WRONG.
>>>
>>> H needs to determine what the machine represented by its input will DO.
>>>
>>> PERIOD.
>>>
>>> It is impossible for H to change that behavior by it trying to decide
>>> on it, as H has been FIXED in definition before that input existed,
>>> and the DEEFINITION of the behavior isn't affected by asking H about it.
>>>
>>> FAIL.
>>>
>>> The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y) does.
>>>
>>> If X uses a copy of H, that copy needs to behave exactly like H
>>> behaves, as that is what H does.
>>>
>>> Please provide an ACTUAL REFERENCE from someone who actually know
>>> something about this that uses words anything about this
>>> 'interference' that you talk about.
>>>
>>> This seems to be some figment of your imagination because you just
>>> don't understand.
>>>
>>> With out an actual reference, repeating this claim will just be a
>>> LIE, since the actual definition doesn't use such words.
>>>
>>> FAIL.
>>>
>>
>> You simply ignored and erased the important part.
>>
>
> I didn't erase anything.
>
>> (1) H must report on what the behavior of its input would be without
>> any interference by H.
>
> No, it must reprot on what the behavior of its input IS. It CAN'T
> interfere with it by the definition of what that behavior is.
>
>>
>> OTHERWISE
>>
>> (2) H would be correct to simply accept every input as halting on the
>> basis that the input halts on its own or was aborted by H.
>>
>
> FAIL.
>
> Since you have failed to provide a reference for the source of your
> incorrect definition, it just proves that you are making up a LIE.
>

On 1/9/22 3:17 PM, olcott wrote:
> On 1/9/2022 2:04 PM, Richard Damon wrote:
>>
>> On 1/9/22 2:53 PM, olcott wrote:
>>> On 1/9/2022 1:29 PM, Richard Damon wrote:
>>>> On 1/9/22 2:11 PM, olcott wrote:
>>>>> On 1/9/2022 12:06 PM, Richard Damon wrote:
>>>>>> On 1/9/22 12:57 PM, olcott wrote:
>>>>>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>>>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    if (H(x, y))
>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>>>>>> counter-example template shown above.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then P demonstrates an infinitely repeating pattern that
>>>>>>>>>>>>> cannot possibly ever reach its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This conclusively proves that the input to H meets the Linz
>>>>>>>>>>>>> definition of non-halting:
>>>>>>>>>>>>>
>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>> thus the sufficiency condition for H to report that its
>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>> simulation V2
>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>>>>>> We have gone around the circle of this MANY times, and you
>>>>>>>>>>>> keep just rearranging things and not every answering the
>>>>>>>>>>>> refutation.
>>>>>>>>>>>
>>>>>>>>>>> The problem is that you are simply too stupid to ever
>>>>>>>>>>> understand that P specifies a sequence of configurations that
>>>>>>>>>>> never reach its final state and thus is correctly determined
>>>>>>>>>>> to be a non-halting computation according to Linz.
>>>>>>>>>>
>>>>>>>>>> And you are too stupid to see that it doesn't if H(P,P)
>>>>>>>>>> returns 0, as this just proved.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is always correct for H to report on what the behavior of
>>>>>>>>> its input would be if H did not interfere with the behavior of
>>>>>>>>> this input.
>>>>>>>>> H is an objective observer.
>>>>>>>>>
>>>>>>>>> It is never correct for H to report on what the behavior of its
>>>>>>>>> input would be if H did interfere with the behavior of this input.
>>>>>>>>> H is not an objective observer.
>>>>>>>>
>>>>>>>> IMPROPERLY PHRASED, H must report on what the machine that its
>>>>>>>> input represents will do, even if that includes a copy of
>>>>>>>> itself. That is not H 'interfering' with the behavior of that
>>>>>>>> machine.
>>>>>>>>
>>>>>>>> It is Impossible for the copy of a decider doing the deciding to
>>>>>>>> 'interfere' with the behavior of a machine, as that behavior is
>>>>>>>> defined independent of the decider.
>>>>>>>>
>>>>>>>> Yes, the aborting of a simulation by the copy of the decider
>>>>>>>> doing the deciding doesn't affect the behavior of the machine it
>>>>>>>> is deciding on, a copy of it IN the machine it is trying to
>>>>>>>> decide on, DOES, as it IS part of the machine it is deciding on.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>>
>>>>>>>> The fact that you can't keep the different copies of H separate
>>>>>>>> shows your lack of reasoning ability.
>>>>>>>>
>>>>>>>
>>>>>>> When H reports on what the behavior of its simulated input would
>>>>>>> be if H did not interfere, it is the same for P, infinite loops,
>>>>>>> or infinite recursion, H must only reject its input as non-halting.
>>>>>>>
>>>>>>
>>>>>> Except it isn't 'interference' for the copy of H in the input to
>>>>>> do what it is programmed to do.
>>>>>>
>>>>>
>>>>> It is the job of H to determine what the behavior of the input
>>>>> would be if H did not interfere with this behavior.
>>>>>
>>>>> Alternatively H could correctly recognize inputs that would never
>>>>> stop running if H did not interfere and then report that every
>>>>> input does halt when H does interfere.
>>>>>
>>>>> Such an H could simply accept every input in that some of its
>>>>> inputs halt on their own and the other inputs must be aborted. In
>>>>> this case It would be impossible to create an input that H would
>>>>> not correctly decide.
>>>>
>>>> WRONG.
>>>>
>>>> H needs to determine what the machine represented by its input will DO.
>>>>
>>>> PERIOD.
>>>>
>>>> It is impossible for H to change that behavior by it trying to
>>>> decide on it, as H has been FIXED in definition before that input
>>>> existed, and the DEEFINITION of the behavior isn't affected by
>>>> asking H about it.
>>>>
>>>> FAIL.
>>>>
>>>> The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y) does.
>>>>
>>>> If X uses a copy of H, that copy needs to behave exactly like H
>>>> behaves, as that is what H does.
>>>>
>>>> Please provide an ACTUAL REFERENCE from someone who actually know
>>>> something about this that uses words anything about this
>>>> 'interference' that you talk about.
>>>>
>>>> This seems to be some figment of your imagination because you just
>>>> don't understand.
>>>>
>>>> With out an actual reference, repeating this claim will just be a
>>>> LIE, since the actual definition doesn't use such words.
>>>>
>>>> FAIL.
>>>>
>>>
>>> You simply ignored and erased the important part.
>>>
>>
>> I didn't erase anything.
>>
>>> (1) H must report on what the behavior of its input would be without
>>> any interference by H.
>>
>> No, it must reprot on what the behavior of its input IS. It CAN'T
>> interfere with it by the definition of what that behavior is.
>>
>>>
>>> OTHERWISE
>>>
>>> (2) H would be correct to simply accept every input as halting on the
>>> basis that the input halts on its own or was aborted by H.
>>>
>>
>> FAIL.
>>
>> Since you have failed to provide a reference for the source of your
>> incorrect definition, it just proves that you are making up a LIE.
>>
>
>
> H reports on what the behavior of its input would be:
>  X = if H did not interfere with this behavior
> ~X = if H interferes with this behavior
> There is only X and ~X.

On 1/9/2022 2:29 PM, Richard Damon wrote:
> On 1/9/22 3:17 PM, olcott wrote:
>> On 1/9/2022 2:04 PM, Richard Damon wrote:
>>>
>>> On 1/9/22 2:53 PM, olcott wrote:
>>>> On 1/9/2022 1:29 PM, Richard Damon wrote:
>>>>> On 1/9/22 2:11 PM, olcott wrote:
>>>>>> On 1/9/2022 12:06 PM, Richard Damon wrote:
>>>>>>> On 1/9/22 12:57 PM, olcott wrote:
>>>>>>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>>>>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>>>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    if (H(x, y))
>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>>>>>>> counter-example template shown above.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then P demonstrates an infinitely repeating pattern that
>>>>>>>>>>>>>> cannot possibly ever reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This conclusively proves that the input to H meets the
>>>>>>>>>>>>>> Linz definition of non-halting:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> thus the sufficiency condition for H to report that its
>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation V2
>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>>>>>>> We have gone around the circle of this MANY times, and you
>>>>>>>>>>>>> keep just rearranging things and not every answering the
>>>>>>>>>>>>> refutation.
>>>>>>>>>>>>
>>>>>>>>>>>> The problem is that you are simply too stupid to ever
>>>>>>>>>>>> understand that P specifies a sequence of configurations
>>>>>>>>>>>> that never reach its final state and thus is correctly
>>>>>>>>>>>> determined to be a non-halting computation according to Linz.
>>>>>>>>>>>
>>>>>>>>>>> And you are too stupid to see that it doesn't if H(P,P)
>>>>>>>>>>> returns 0, as this just proved.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is always correct for H to report on what the behavior of
>>>>>>>>>> its input would be if H did not interfere with the behavior of
>>>>>>>>>> this input.
>>>>>>>>>> H is an objective observer.
>>>>>>>>>>
>>>>>>>>>> It is never correct for H to report on what the behavior of
>>>>>>>>>> its input would be if H did interfere with the behavior of
>>>>>>>>>> this input.
>>>>>>>>>> H is not an objective observer.
>>>>>>>>>
>>>>>>>>> IMPROPERLY PHRASED, H must report on what the machine that its
>>>>>>>>> input represents will do, even if that includes a copy of
>>>>>>>>> itself. That is not H 'interfering' with the behavior of that
>>>>>>>>> machine.
>>>>>>>>>
>>>>>>>>> It is Impossible for the copy of a decider doing the deciding
>>>>>>>>> to 'interfere' with the behavior of a machine, as that behavior
>>>>>>>>> is defined independent of the decider.
>>>>>>>>>
>>>>>>>>> Yes, the aborting of a simulation by the copy of the decider
>>>>>>>>> doing the deciding doesn't affect the behavior of the machine
>>>>>>>>> it is deciding on, a copy of it IN the machine it is trying to
>>>>>>>>> decide on, DOES, as it IS part of the machine it is deciding on.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The fact that you can't keep the different copies of H separate
>>>>>>>>> shows your lack of reasoning ability.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When H reports on what the behavior of its simulated input would
>>>>>>>> be if H did not interfere, it is the same for P, infinite loops,
>>>>>>>> or infinite recursion, H must only reject its input as non-halting.
>>>>>>>>
>>>>>>>
>>>>>>> Except it isn't 'interference' for the copy of H in the input to
>>>>>>> do what it is programmed to do.
>>>>>>>
>>>>>>
>>>>>> It is the job of H to determine what the behavior of the input
>>>>>> would be if H did not interfere with this behavior.
>>>>>>
>>>>>> Alternatively H could correctly recognize inputs that would never
>>>>>> stop running if H did not interfere and then report that every
>>>>>> input does halt when H does interfere.
>>>>>>
>>>>>> Such an H could simply accept every input in that some of its
>>>>>> inputs halt on their own and the other inputs must be aborted. In
>>>>>> this case It would be impossible to create an input that H would
>>>>>> not correctly decide.
>>>>>
>>>>> WRONG.
>>>>>
>>>>> H needs to determine what the machine represented by its input will
>>>>> DO.
>>>>>
>>>>> PERIOD.
>>>>>
>>>>> It is impossible for H to change that behavior by it trying to
>>>>> decide on it, as H has been FIXED in definition before that input
>>>>> existed, and the DEEFINITION of the behavior isn't affected by
>>>>> asking H about it.
>>>>>
>>>>> FAIL.
>>>>>
>>>>> The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y) does.
>>>>>
>>>>> If X uses a copy of H, that copy needs to behave exactly like H
>>>>> behaves, as that is what H does.
>>>>>
>>>>> Please provide an ACTUAL REFERENCE from someone who actually know
>>>>> something about this that uses words anything about this
>>>>> 'interference' that you talk about.
>>>>>
>>>>> This seems to be some figment of your imagination because you just
>>>>> don't understand.
>>>>>
>>>>> With out an actual reference, repeating this claim will just be a
>>>>> LIE, since the actual definition doesn't use such words.
>>>>>
>>>>> FAIL.
>>>>>
>>>>
>>>> You simply ignored and erased the important part.
>>>>
>>>
>>> I didn't erase anything.
>>>
>>>> (1) H must report on what the behavior of its input would be without
>>>> any interference by H.
>>>
>>> No, it must reprot on what the behavior of its input IS. It CAN'T
>>> interfere with it by the definition of what that behavior is.
>>>
>>>>
>>>> OTHERWISE
>>>>
>>>> (2) H would be correct to simply accept every input as halting on
>>>> the basis that the input halts on its own or was aborted by H.
>>>>
>>>
>>> FAIL.
>>>
>>> Since you have failed to provide a reference for the source of your
>>> incorrect definition, it just proves that you are making up a LIE.
>>>
>>
>>
>> H reports on what the behavior of its input would be:
>>   X = if H did not interfere with this behavior
>> ~X = if H interferes with this behavior
>> There is only X and ~X.
>
> But H CAN'T 'interfere' with the behavior of P(P), because it is PART of
> the behavior of P(P), so it isn't interference.
>
> Boy are you so dumb.
>
> We have 3 possibilities.
>

On 1/9/22 3:34 PM, olcott wrote:
> On 1/9/2022 2:29 PM, Richard Damon wrote:
>> On 1/9/22 3:17 PM, olcott wrote:
>>> On 1/9/2022 2:04 PM, Richard Damon wrote:
>>>>
>>>> On 1/9/22 2:53 PM, olcott wrote:
>>>>> On 1/9/2022 1:29 PM, Richard Damon wrote:
>>>>>> On 1/9/22 2:11 PM, olcott wrote:
>>>>>>> On 1/9/2022 12:06 PM, Richard Damon wrote:
>>>>>>>> On 1/9/22 12:57 PM, olcott wrote:
>>>>>>>>> On 1/9/2022 11:43 AM, Richard Damon wrote:
>>>>>>>>>> On 1/9/22 11:40 AM, olcott wrote:
>>>>>>>>>>> On 1/8/2022 9:59 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/8/22 10:20 PM, olcott wrote:
>>>>>>>>>>>>> On 1/8/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/8/22 8:41 PM, olcott wrote:
>>>>>>>>>>>>>>> // Simplified Linz(1990) Ĥ
>>>>>>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    if (H(x, y))
>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H and P are defined according to the standard HP
>>>>>>>>>>>>>>> counter-example template shown above.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H bases its halt status decision on the behavior of the
>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then P demonstrates an infinitely repeating pattern that
>>>>>>>>>>>>>>> cannot possibly ever reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This conclusively proves that the input to H meets the
>>>>>>>>>>>>>>> Linz definition of non-halting:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> thus the sufficiency condition for H to report that its
>>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>> simulation V2
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Full Proof with Request for Rebuttal
>>>>>>>>>>>>>> We have gone around the circle of this MANY times, and you
>>>>>>>>>>>>>> keep just rearranging things and not every answering the
>>>>>>>>>>>>>> refutation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The problem is that you are simply too stupid to ever
>>>>>>>>>>>>> understand that P specifies a sequence of configurations
>>>>>>>>>>>>> that never reach its final state and thus is correctly
>>>>>>>>>>>>> determined to be a non-halting computation according to Linz.
>>>>>>>>>>>>
>>>>>>>>>>>> And you are too stupid to see that it doesn't if H(P,P)
>>>>>>>>>>>> returns 0, as this just proved.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is always correct for H to report on what the behavior of
>>>>>>>>>>> its input would be if H did not interfere with the behavior
>>>>>>>>>>> of this input.
>>>>>>>>>>> H is an objective observer.
>>>>>>>>>>>
>>>>>>>>>>> It is never correct for H to report on what the behavior of
>>>>>>>>>>> its input would be if H did interfere with the behavior of
>>>>>>>>>>> this input.
>>>>>>>>>>> H is not an objective observer.
>>>>>>>>>>
>>>>>>>>>> IMPROPERLY PHRASED, H must report on what the machine that its
>>>>>>>>>> input represents will do, even if that includes a copy of
>>>>>>>>>> itself. That is not H 'interfering' with the behavior of that
>>>>>>>>>> machine.
>>>>>>>>>>
>>>>>>>>>> It is Impossible for the copy of a decider doing the deciding
>>>>>>>>>> to 'interfere' with the behavior of a machine, as that
>>>>>>>>>> behavior is defined independent of the decider.
>>>>>>>>>>
>>>>>>>>>> Yes, the aborting of a simulation by the copy of the decider
>>>>>>>>>> doing the deciding doesn't affect the behavior of the machine
>>>>>>>>>> it is deciding on, a copy of it IN the machine it is trying to
>>>>>>>>>> decide on, DOES, as it IS part of the machine it is deciding on.
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The fact that you can't keep the different copies of H
>>>>>>>>>> separate shows your lack of reasoning ability.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When H reports on what the behavior of its simulated input
>>>>>>>>> would be if H did not interfere, it is the same for P, infinite
>>>>>>>>> loops, or infinite recursion, H must only reject its input as
>>>>>>>>> non-halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except it isn't 'interference' for the copy of H in the input to
>>>>>>>> do what it is programmed to do.
>>>>>>>>
>>>>>>>
>>>>>>> It is the job of H to determine what the behavior of the input
>>>>>>> would be if H did not interfere with this behavior.
>>>>>>>
>>>>>>> Alternatively H could correctly recognize inputs that would never
>>>>>>> stop running if H did not interfere and then report that every
>>>>>>> input does halt when H does interfere.
>>>>>>>
>>>>>>> Such an H could simply accept every input in that some of its
>>>>>>> inputs halt on their own and the other inputs must be aborted. In
>>>>>>> this case It would be impossible to create an input that H would
>>>>>>> not correctly decide.
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>> H needs to determine what the machine represented by its input
>>>>>> will DO.
>>>>>>
>>>>>> PERIOD.
>>>>>>
>>>>>> It is impossible for H to change that behavior by it trying to
>>>>>> decide on it, as H has been FIXED in definition before that input
>>>>>> existed, and the DEEFINITION of the behavior isn't affected by
>>>>>> asking H about it.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>> The ONLY right answer for H(<X>,y) is based on EXACTLY what X(y)
>>>>>> does.
>>>>>>
>>>>>> If X uses a copy of H, that copy needs to behave exactly like H
>>>>>> behaves, as that is what H does.
>>>>>>
>>>>>> Please provide an ACTUAL REFERENCE from someone who actually know
>>>>>> something about this that uses words anything about this
>>>>>> 'interference' that you talk about.
>>>>>>
>>>>>> This seems to be some figment of your imagination because you just
>>>>>> don't understand.
>>>>>>
>>>>>> With out an actual reference, repeating this claim will just be a
>>>>>> LIE, since the actual definition doesn't use such words.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>
>>>>> You simply ignored and erased the important part.
>>>>>
>>>>
>>>> I didn't erase anything.
>>>>
>>>>> (1) H must report on what the behavior of its input would be
>>>>> without any interference by H.
>>>>
>>>> No, it must reprot on what the behavior of its input IS. It CAN'T
>>>> interfere with it by the definition of what that behavior is.
>>>>
>>>>>
>>>>> OTHERWISE
>>>>>
>>>>> (2) H would be correct to simply accept every input as halting on
>>>>> the basis that the input halts on its own or was aborted by H.
>>>>>
>>>>
>>>> FAIL.
>>>>
>>>> Since you have failed to provide a reference for the source of your
>>>> incorrect definition, it just proves that you are making up a LIE.
>>>>
>>>
>>>
>>> H reports on what the behavior of its input would be:
>>>   X = if H did not interfere with this behavior
>>> ~X = if H interferes with this behavior
>>> There is only X and ~X.
>>
>> But H CAN'T 'interfere' with the behavior of P(P), because it is PART
>> of the behavior of P(P), so it isn't interference.
>>
>> Boy are you so dumb.
>>
>> We have 3 possibilities.
>>
>
> H can interfere with the behavior of  all of its inputs is stupid.
> H can interfere with the behavior of some of its inputs is stupid.
> H can interfere with the behavior of none of its inputs is correct.

On 2022-01-09 16:40:09 +0000, olcott wrote:

> It is always correct for H to report on what the behavior of its input
> would be if H did not interfere with the behavior of this input.
> H is an objective observer.
>
> It is never correct for H to report on what the behavior of its input
> would be if H did interfere with the behavior of this input.
> H is not an objective observer.

The halting problem does not specify whether H is an objective observer,
a non-objective observer, or no observer. It only specifies that H shall
predict correctly whether the computation represented by the input will
halt or not.

Mikko

On 1/10/22 4:13 AM, Mikko wrote:
> On 2022-01-09 16:40:09 +0000, olcott wrote:
>
>> It is always correct for H to report on what the behavior of its input
>> would be if H did not interfere with the behavior of this input.
>> H is an objective observer.
>>
>> It is never correct for H to report on what the behavior of its input
>> would be if H did interfere with the behavior of this input.
>> H is not an objective observer.
>
> The halting problem does not specify whether H is an objective observer,
> a non-objective observer, or no observer. It only specifies that H shall
> predict correctly whether the computation represented by the input will
> halt or not.
>
> Mikko
>
>

Thinking about it, 'Objective' isn't even an appropriate sort of
modifier in this sense for a Turing Machine. The term objective implies
the thing has the capability of volition, of having feelings or
opinions. Turing Machines are deterministic, they will ALWAYS do the
same thing in the same situation.

If you want to try to use the term, they can't be anything BUT objective
as they have no feelings or opinions to get in their way, they will
ALWAYS just give the answer that they will give.

On 1/10/2022 3:13 AM, Mikko wrote:
> On 2022-01-09 16:40:09 +0000, olcott wrote:
>
>> It is always correct for H to report on what the behavior of its input
>> would be if H did not interfere with the behavior of this input.
>> H is an objective observer.
>>
>> It is never correct for H to report on what the behavior of its input
>> would be if H did interfere with the behavior of this input.
>> H is not an objective observer.
>
> The halting problem does not specify whether H is an objective observer,
> a non-objective observer, or no observer. It only specifies that H shall
> predict correctly whether the computation represented by the input will
> halt or not.
>
> Mikko
>
>

If H is not an objective observer it could simply abort the execution of
every input and report that this input halts.

My H recognizes that all the conventional Halting Problem
counter-examples specify infinitely nested simulation to every
simulating halt decider. H correctly aborts this otherwise infinite
simulation and rejects its input as not halting.

--
Copyright 2021 Pete Olcott

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

On 1/10/22 9:44 AM, olcott wrote:
> On 1/10/2022 3:13 AM, Mikko wrote:
>> On 2022-01-09 16:40:09 +0000, olcott wrote:
>>
>>> It is always correct for H to report on what the behavior of its
>>> input would be if H did not interfere with the behavior of this input.
>>> H is an objective observer.
>>>
>>> It is never correct for H to report on what the behavior of its input
>>> would be if H did interfere with the behavior of this input.
>>> H is not an objective observer.
>>
>> The halting problem does not specify whether H is an objective observer,
>> a non-objective observer, or no observer. It only specifies that H shall
>> predict correctly whether the computation represented by the input will
>> halt or not.
>>
>> Mikko
>>
>>
>
> If H is not an objective observer it could simply abort the execution of
> every input and report that this input halts.

Except that then it would be wrong, since the definition of Halting
ISN'T based on the simulation (if any) done by the decider, but what the
machine actually does (or the equivalent, what happens when the input is
applied to a real UTM).

>
> My H recognizes that all the conventional Halting Problem
> counter-examples specify infinitely nested simulation to every
> simulating halt decider. H correctly aborts this otherwise infinite
> simulation and rejects its input as not halting.
>

And is thus WRONG, as it has been shown that if the H that H^ is built
on returns non-halting, that H^ is then Halting.

FAIL.

The key point is that the determination of Halting is done by the ACTUAL
'objective observer', the UTM, not the decider.

The problem is that in one sense H CAN'T be totally objective, as it
can't actually see that execution by the UTM, but only an partial
recreation that it does itself.

Also, H doesn't really get to make a 'decision', as it is required to
act according to its programming, even if it can determine that this
would be wrong.

On 1/10/2022 5:58 PM, Richard Damon wrote:
>
> On 1/10/22 9:44 AM, olcott wrote:
>> On 1/10/2022 3:13 AM, Mikko wrote:
>>> On 2022-01-09 16:40:09 +0000, olcott wrote:
>>>
>>>> It is always correct for H to report on what the behavior of its
>>>> input would be if H did not interfere with the behavior of this input.
>>>> H is an objective observer.
>>>>
>>>> It is never correct for H to report on what the behavior of its
>>>> input would be if H did interfere with the behavior of this input.
>>>> H is not an objective observer.
>>>
>>> The halting problem does not specify whether H is an objective observer,
>>> a non-objective observer, or no observer. It only specifies that H shall
>>> predict correctly whether the computation represented by the input will
>>> halt or not.
>>>
>>> Mikko
>>>
>>>
>>
>> If H is not an objective observer it could simply abort the execution
>> of every input and report that this input halts.
>
> Except that then it would be wrong, since the definition of Halting
> ISN'T based on the simulation (if any) done by the decider, but what the
> machine actually does (or the equivalent, what happens when the input is
> applied to a real UTM).
>
>>
>> My H recognizes that all the conventional Halting Problem
>> counter-examples specify infinitely nested simulation to every
>> simulating halt decider. H correctly aborts this otherwise infinite
>> simulation and rejects its input as not halting.
>>
>
> And is thus WRONG, as it has been shown that if the H that H^ is built
> on returns non-halting, that H^ is then Halting.
>
> FAIL.
>
>
> The key point is that the determination of Halting is done by the ACTUAL
> 'objective observer', the UTM, not the decider.
>
> The problem is that in one sense H CAN'T be totally objective, as it
> can't actually see that execution by the UTM, but only an partial
> recreation that it does itself.
>
> Also, H doesn't really get to make a 'decision', as it is required to
> act according to its programming, even if it can determine that this
> would be wrong.

Every case where the input to a simulating halt decider would never stop
running unless the simulating halt decider aborted its simulation of
this input is a case where this input is correctly determined to be non
halting.

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

On 1/13/22 10:40 AM, olcott wrote:
> On 1/10/2022 5:58 PM, Richard Damon wrote:
>>
>> On 1/10/22 9:44 AM, olcott wrote:
>>> On 1/10/2022 3:13 AM, Mikko wrote:
>>>> On 2022-01-09 16:40:09 +0000, olcott wrote:
>>>>
>>>>> It is always correct for H to report on what the behavior of its
>>>>> input would be if H did not interfere with the behavior of this input.
>>>>> H is an objective observer.
>>>>>
>>>>> It is never correct for H to report on what the behavior of its
>>>>> input would be if H did interfere with the behavior of this input.
>>>>> H is not an objective observer.
>>>>
>>>> The halting problem does not specify whether H is an objective
>>>> observer,
>>>> a non-objective observer, or no observer. It only specifies that H
>>>> shall
>>>> predict correctly whether the computation represented by the input will
>>>> halt or not.
>>>>
>>>> Mikko
>>>>
>>>>
>>>
>>> If H is not an objective observer it could simply abort the execution
>>> of every input and report that this input halts.
>>
>> Except that then it would be wrong, since the definition of Halting
>> ISN'T based on the simulation (if any) done by the decider, but what
>> the machine actually does (or the equivalent, what happens when the
>> input is applied to a real UTM).
>>
>>>
>>> My H recognizes that all the conventional Halting Problem
>>> counter-examples specify infinitely nested simulation to every
>>> simulating halt decider. H correctly aborts this otherwise infinite
>>> simulation and rejects its input as not halting.
>>>
>>
>> And is thus WRONG, as it has been shown that if the H that H^ is built
>> on returns non-halting, that H^ is then Halting.
>>
>> FAIL.
>>
>>
>> The key point is that the determination of Halting is done by the
>> ACTUAL 'objective observer', the UTM, not the decider.
>>
>> The problem is that in one sense H CAN'T be totally objective, as it
>> can't actually see that execution by the UTM, but only an partial
>> recreation that it does itself.
>>
>> Also, H doesn't really get to make a 'decision', as it is required to
>> act according to its programming, even if it can determine that this
>> would be wrong.
>
> Every case where the input to a simulating halt decider would never stop
> running unless the simulating halt decider aborted its simulation of
> this input is a case where this input is correctly determined to be non
> halting.
>

WRONG DEFINITION. THAT IS YOUR POOP.

The ONLY definition of the correct answer is AFTER you have determined
the answer that H WILL give (since it MUST be a fixed algorithm), will
the machine the input represents Halt or Not when run with the input the
input represents being given to it.

Equivalently, what happens when the same input to the decider is given
to a UTM, will that UTM halt or not.

Given that your H returns Non-Halting for H(<H^>.<H^>) it is easy to see
by inspection that H^(<H^>) and UTM(<H^>,<H^>) wil both halt and thus
Halting is the correct answer, so H was WRONG.

All you have proven is that no H built by your method can ever get a
correct Halting decision for an input like H^.