Whenever the pure simulation of the input to simulating halt decider
H(x,y) never stops running unless H aborts its simulation H correctly
aborts this simulation and returns 0 for not halting.

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 12/3/21 7:18 PM, olcott wrote:
> Whenever the pure simulation of the input to simulating halt decider
> H(x,y) never stops running unless H aborts its simulation H correctly
> aborts this simulation and returns 0 for not halting.
>
> Halting problem undecidability and infinitely nested simulation (V2)
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>

Maybe the problem is that YOU don't understand that SINCE H does abort
its simulation of P(P), that the P that calls this H does Halt by
itself, and it is the P that is actually being run, and not the aborted
simulation buried in H that actually matters.

Since the ACTUAL Computation P(P) does halt, then the right answer to
the question does P(P) Halt is Yes.

If H(P,P) doesn't actually ask this question, then you claim that your H
is supposed to be a halt decider is just a LIE, and your whole 'proof'
is just a dishonest deception.

The 'input' to H(P,P) is the representation of P applied to P which is
the representation of the computation P(P). That Computation does Halt,
at least if H(P,P) answers 0 (Non-Halting). We don't care that H's
simulation of P applied to P doesn't reach the halting state, as that
ISN'T the behavior of its INPUT, that it the (sub) behavior of H on that
input, which isn't what we are asking about.

Yes, P(P) is non-halting for the one case where H(P,P) doesn't answer,
but that H is still wrong because it doesn't answer.

You are just to studip to understand that EVERY H gets its own H^/P, and
you need to pair your H with the RIGHT one of those, and it needs to
give the answer that matches THAT machines behavior.

On 12/3/2021 7:01 PM, Richard Damon wrote:
> On 12/3/21 7:18 PM, olcott wrote:
>> Whenever the pure simulation of the input to simulating halt decider
>> H(x,y) never stops running unless H aborts its simulation H correctly
>> aborts this simulation and returns 0 for not halting.
>>
>> Halting problem undecidability and infinitely nested simulation (V2)
>>
>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>
>>
>
> Maybe the problem is that YOU don't understand that SINCE H does abort
> its simulation of P(P), that the P that calls this H does Halt by
> itself, and it is the P that is actually being run, and not the aborted
> simulation buried in H that actually matters.
>

int main() { P(P) } calls H(P,P) simulates P(P) never halts even when
aborted dumbbell

> Since the ACTUAL Computation P(P) does halt, then the right answer to
> the question does P(P) Halt is Yes.
>
> If H(P,P) doesn't actually ask this question, then you claim that your H
> is supposed to be a halt decider is just a LIE, and your whole 'proof'
> is just a dishonest deception.
>
> The 'input' to H(P,P) is the representation of P applied to P which is
> the representation of the computation P(P). That Computation does Halt,
> at least if H(P,P) answers 0 (Non-Halting). We don't care that H's
> simulation of P applied to P doesn't reach the halting state, as that
> ISN'T the behavior of its INPUT, that it the (sub) behavior of H on that
> input, which isn't what we are asking about.
>
> Yes, P(P) is non-halting for the one case where H(P,P) doesn't answer,
> but that H is still wrong because it doesn't answer.
>
> You are just to studip to understand that EVERY H gets its own H^/P, and
> you need to pair your H with the RIGHT one of those, and it needs to
> give the answer that matches THAT machines behavior.

--
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 12/3/21 8:36 PM, olcott wrote:
> On 12/3/2021 7:01 PM, Richard Damon wrote:
>> On 12/3/21 7:18 PM, olcott wrote:
>>> Whenever the pure simulation of the input to simulating halt decider
>>> H(x,y) never stops running unless H aborts its simulation H correctly
>>> aborts this simulation and returns 0 for not halting.
>>>
>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>
>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>
>>>
>>
>> Maybe the problem is that YOU don't understand that SINCE H does abort
>> its simulation of P(P), that the P that calls this H does Halt by
>> itself, and it is the P that is actually being run, and not the
>> aborted simulation buried in H that actually matters.
>>
>
> int main() { P(P) } calls H(P,P) simulates P(P) never halts even when
> aborted dumbbell

Then your H(P,P) never returns 0, or you are just a bad liar.

Now, if you are going into double-speak, and trying to use the fact that
the SIMULATED copy of P(P) that H is doing never got to an end state,
then you are just being a cheating liar.

The P(P) that we care about is the one that main calls.

If the H that it calls never returns, then H fails to be a decider. PERIOD.

If that H does return the value 0, then this P(P) will halt. PERIOD.

Thus, you NEVER have an H that is a correct Halt Decider, and have
FAILED at your goal and WASTED over a decade of you life.

>
>> Since the ACTUAL Computation P(P) does halt, then the right answer to
>> the question does P(P) Halt is Yes.
>>
>> If H(P,P) doesn't actually ask this question, then you claim that your
>> H is supposed to be a halt decider is just a LIE, and your whole
>> 'proof' is just a dishonest deception.
>>
>> The 'input' to H(P,P) is the representation of P applied to P which is
>> the representation of the computation P(P). That Computation does
>> Halt, at least if H(P,P) answers 0 (Non-Halting). We don't care that
>> H's simulation of P applied to P doesn't reach the halting state, as
>> that ISN'T the behavior of its INPUT, that it the (sub) behavior of H
>> on that input, which isn't what we are asking about.
>>
>> Yes, P(P) is non-halting for the one case where H(P,P) doesn't answer,
>> but that H is still wrong because it doesn't answer.
>>
>> You are just to studip to understand that EVERY H gets its own H^/P,
>> and you need to pair your H with the RIGHT one of those, and it needs
>> to give the answer that matches THAT machines behavior.
>
>

On 12/3/2021 10:15 PM, Richard Damon wrote:
> On 12/3/21 8:36 PM, olcott wrote:
>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>> On 12/3/21 7:18 PM, olcott wrote:
>>>> Whenever the pure simulation of the input to simulating halt decider
>>>> H(x,y) never stops running unless H aborts its simulation H
>>>> correctly aborts this simulation and returns 0 for not halting.
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>>
>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>
>>>>
>>>
>>> Maybe the problem is that YOU don't understand that SINCE H does
>>> abort its simulation of P(P), that the P that calls this H does Halt
>>> by itself, and it is the P that is actually being run, and not the
>>> aborted simulation buried in H that actually matters.
>>>
>>
>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even when
>> aborted dumbbell
>
> Then your H(P,P) never returns 0, or you are just a bad liar.
>
Here is what I said and you already "forgot" one sentence ago:
>>>> H(x,y) never stops running unless H aborts its simulation H
>>>> correctly aborts this simulation and returns 0 for 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 12/3/2021 10:15 PM, Richard Damon wrote:
> On 12/3/21 8:36 PM, olcott wrote:
>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>> On 12/3/21 7:18 PM, olcott wrote:
>>>> Whenever the pure simulation of the input to simulating halt decider
>>>> H(x,y) never stops running unless H aborts its simulation H
>>>> correctly aborts this simulation and returns 0 for not halting.
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>>
>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>
>>>>
>>>
>>> Maybe the problem is that YOU don't understand that SINCE H does
>>> abort its simulation of P(P), that the P that calls this H does Halt
>>> by itself, and it is the P that is actually being run, and not the
>>> aborted simulation buried in H that actually matters.
>>>
>>
>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even when
>> aborted dumbbell
>
> Then your H(P,P) never returns 0, or you are just a bad liar.
>
> Now, if you are going into double-speak, and trying to use the fact that
> the SIMULATED copy of P(P) that H is doing never got to an end state,
> then you are just being a cheating liar.
>
> The P(P) that we care about is the one that main calls.
>
> If the H that it calls never returns, then H fails to be a decider. PERIOD.
>
> If that H does return the value 0, then this P(P) will halt. PERIOD.
>

Here is what I said and you already "forgot" one sentence ago:
>>>> Whenever the pure simulation of the input to
>>>> simulating halt decider H(x,y) never stops running
>>>> unless H aborts its simulation H correctly aborts
>>>> this simulation and returns 0 for not halting.

returns 0 for not halting.
returns 0 for not halting.
returns 0 for not halting.
returns 0 for not halting.
returns 0 for 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 12/3/21 11:31 PM, olcott wrote:
> On 12/3/2021 10:15 PM, Richard Damon wrote:
>> On 12/3/21 8:36 PM, olcott wrote:
>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>> Whenever the pure simulation of the input to simulating halt
>>>>> decider H(x,y) never stops running unless H aborts its simulation H
>>>>> correctly aborts this simulation and returns 0 for not halting.
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>>>
>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>
>>>>>
>>>>
>>>> Maybe the problem is that YOU don't understand that SINCE H does
>>>> abort its simulation of P(P), that the P that calls this H does Halt
>>>> by itself, and it is the P that is actually being run, and not the
>>>> aborted simulation buried in H that actually matters.
>>>>
>>>
>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even when
>>> aborted dumbbell
>>
>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>
> Here is what I said and you already "forgot" one sentence ago:
> >>>> H(x,y) never stops running unless H aborts its simulation H
> >>>> correctly aborts this simulation and returns 0 for not halting.
>

So, does H(P,P) abort this simulation, or not.

YOU have defined its algorithm, it MUST have an answer.

'Get the Right Answer' is NOT an algorithm.

If H decides (incorrectly) that it needs to abort, it will be wrong.

If H waits until it can PROVE that it will be non-halting, it will never
abort and be wrong for never answering.

Which way is your H wrong?

You make the fault of assuming it can be right.

On 12/3/21 11:43 PM, olcott wrote:
> On 12/3/2021 10:15 PM, Richard Damon wrote:
>> On 12/3/21 8:36 PM, olcott wrote:
>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>> Whenever the pure simulation of the input to simulating halt
>>>>> decider H(x,y) never stops running unless H aborts its simulation H
>>>>> correctly aborts this simulation and returns 0 for not halting.
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>>>
>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>
>>>>>
>>>>
>>>> Maybe the problem is that YOU don't understand that SINCE H does
>>>> abort its simulation of P(P), that the P that calls this H does Halt
>>>> by itself, and it is the P that is actually being run, and not the
>>>> aborted simulation buried in H that actually matters.
>>>>
>>>
>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even when
>>> aborted dumbbell
>>
>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>
>> Now, if you are going into double-speak, and trying to use the fact
>> that the SIMULATED copy of P(P) that H is doing never got to an end
>> state, then you are just being a cheating liar.
>>
>> The P(P) that we care about is the one that main calls.
>>
>> If the H that it calls never returns, then H fails to be a decider.
>> PERIOD.
>>
>> If that H does return the value 0, then this P(P) will halt. PERIOD.
>>
>
> Here is what I said and you already "forgot" one sentence ago:
> >>>> Whenever the pure simulation of the input to
> >>>> simulating halt decider H(x,y) never stops running
> >>>> unless H aborts its simulation H correctly aborts
> >>>> this simulation and returns 0 for not halting.
>
> returns 0 for not halting.
> returns 0 for not halting.
> returns 0 for not halting.
> returns 0 for not halting.
> returns 0 for not halting.
>

IF H returns 0, then it is BY DEFINITION wrong, because if H returns 0
to the P(P) that called it, that will Halt and thus show H was incorrect
in aborting.

You can't just 'define' H to be correct, you need to figure out how to
make it correct, which is impossible.

You have just proved that you don't understand what truth is.

FAIL.

On 12/3/2021 10:53 PM, Richard Damon wrote:
> On 12/3/21 11:43 PM, olcott wrote:
>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>> On 12/3/21 8:36 PM, olcott wrote:
>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>> decider H(x,y) never stops running unless H aborts its simulation
>>>>>> H correctly aborts this simulation and returns 0 for not halting.
>>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>>>>
>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>
>>>>>>
>>>>>
>>>>> Maybe the problem is that YOU don't understand that SINCE H does
>>>>> abort its simulation of P(P), that the P that calls this H does
>>>>> Halt by itself, and it is the P that is actually being run, and not
>>>>> the aborted simulation buried in H that actually matters.
>>>>>
>>>>
>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even
>>>> when aborted dumbbell
>>>
>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>
>>> Now, if you are going into double-speak, and trying to use the fact
>>> that the SIMULATED copy of P(P) that H is doing never got to an end
>>> state, then you are just being a cheating liar.
>>>
>>> The P(P) that we care about is the one that main calls.
>>>
>>> If the H that it calls never returns, then H fails to be a decider.
>>> PERIOD.
>>>
>>> If that H does return the value 0, then this P(P) will halt. PERIOD.
>>>
>>
>> Here is what I said and you already "forgot" one sentence ago:
>>  >>>> Whenever the pure simulation of the input to
>>  >>>> simulating halt decider H(x,y) never stops running
>>  >>>> unless H aborts its simulation H correctly aborts
>>  >>>> this simulation and returns 0 for not halting.
>>
>> returns 0 for not halting.
>> returns 0 for not halting.
>> returns 0 for not halting.
>> returns 0 for not halting.
>> returns 0 for not halting.
>>
>
> IF H returns 0, then it is BY DEFINITION wrong,

The problem may be that you actually lack the capacity to hold two
sentence in your mind at once:

>>>> Whenever the pure simulation of the input to
>>>> simulating halt decider H(x,y) never stops running
>>>> unless H aborts its simulation H correctly aborts
>>>> this simulation and returns 0 for not halting.

>>> because if H returns 0
> to the P(P) that called it, that will Halt and thus show H was incorrect
> in aborting.
>
> You can't just 'define' H to be correct, you need to figure out how to
> make it correct, which is impossible.
>
> You have just proved that you don't understand what truth is.
>
> FAIL.
>

--
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 12/4/21 12:10 AM, olcott wrote:
> On 12/3/2021 10:53 PM, Richard Damon wrote:
>> On 12/3/21 11:43 PM, olcott wrote:
>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>> decider H(x,y) never stops running unless H aborts its simulation
>>>>>>> H correctly aborts this simulation and returns 0 for not halting.
>>>>>>>
>>>>>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Maybe the problem is that YOU don't understand that SINCE H does
>>>>>> abort its simulation of P(P), that the P that calls this H does
>>>>>> Halt by itself, and it is the P that is actually being run, and
>>>>>> not the aborted simulation buried in H that actually matters.
>>>>>>
>>>>>
>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even
>>>>> when aborted dumbbell
>>>>
>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>
>>>> Now, if you are going into double-speak, and trying to use the fact
>>>> that the SIMULATED copy of P(P) that H is doing never got to an end
>>>> state, then you are just being a cheating liar.
>>>>
>>>> The P(P) that we care about is the one that main calls.
>>>>
>>>> If the H that it calls never returns, then H fails to be a decider.
>>>> PERIOD.
>>>>
>>>> If that H does return the value 0, then this P(P) will halt. PERIOD.
>>>>
>>>
>>> Here is what I said and you already "forgot" one sentence ago:
>>>  >>>> Whenever the pure simulation of the input to
>>>  >>>> simulating halt decider H(x,y) never stops running
>>>  >>>> unless H aborts its simulation H correctly aborts
>>>  >>>> this simulation and returns 0 for not halting.
>>>
>>> returns 0 for not halting.
>>> returns 0 for not halting.
>>> returns 0 for not halting.
>>> returns 0 for not halting.
>>> returns 0 for not halting.
>>>
>>
>> IF H returns 0, then it is BY DEFINITION wrong,
>
>
> The problem may be that you actually lack the capacity to hold two
> sentence in your mind at once:
>
> >>>> Whenever the pure simulation of the input to
> >>>> simulating halt decider H(x,y) never stops running
> >>>> unless H aborts its simulation H correctly aborts
> >>>> this simulation and returns 0 for not halting.

I guess you just have a recursive problem then, to actually build your
halt decider H, someone needs to give you a working Halt Decider for it
to use. Since no one can do that, As Turing proved (and restated by
Linz), the answer is that you just can't build the machine you want.

For the proper definition of H^ (which used to be your P), it is clear
that if H returns 0, then H^ will make it wrong by Halting and if H
returns 1, then H^ will make it wrong by Looping forever, so if H only
acts when the answer it gives will be right, its only possible response
is to not respond, which also makes it wrong, and thus H fails by not
answering.

You seem to be mentally incapable of understanding that H has not
'correctly proved' that P(P) is non-halting, since when H returns 0,
P(P) is Halting, so it can't be non-halting.

>
>>>> because if H returns 0
>> to the P(P) that called it, that will Halt and thus show H was
>> incorrect in aborting.
>>
>> You can't just 'define' H to be correct, you need to figure out how to
>> make it correct, which is impossible.
>>
>> You have just proved that you don't understand what truth is.
>>
>> FAIL.
>>
>
>

On 12/4/2021 5:58 AM, Richard Damon wrote:
> On 12/4/21 12:10 AM, olcott wrote:
>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>> On 12/3/21 11:43 PM, olcott wrote:
>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>> simulation H correctly aborts this simulation and returns 0 for
>>>>>>>> not halting.
>>>>>>>>
>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>> (V2)
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Maybe the problem is that YOU don't understand that SINCE H does
>>>>>>> abort its simulation of P(P), that the P that calls this H does
>>>>>>> Halt by itself, and it is the P that is actually being run, and
>>>>>>> not the aborted simulation buried in H that actually matters.
>>>>>>>
>>>>>>
>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even
>>>>>> when aborted dumbbell
>>>>>
>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>
>>>>> Now, if you are going into double-speak, and trying to use the fact
>>>>> that the SIMULATED copy of P(P) that H is doing never got to an end
>>>>> state, then you are just being a cheating liar.
>>>>>
>>>>> The P(P) that we care about is the one that main calls.
>>>>>
>>>>> If the H that it calls never returns, then H fails to be a decider.
>>>>> PERIOD.
>>>>>
>>>>> If that H does return the value 0, then this P(P) will halt. PERIOD.
>>>>>
>>>>
>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>  >>>> Whenever the pure simulation of the input to
>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>  >>>> this simulation and returns 0 for not halting.
>>>>
>>>> returns 0 for not halting.
>>>> returns 0 for not halting.
>>>> returns 0 for not halting.
>>>> returns 0 for not halting.
>>>> returns 0 for not halting.
>>>>
>>>
>>> IF H returns 0, then it is BY DEFINITION wrong,
>>
>>
>> The problem may be that you actually lack the capacity to hold two
>> sentence in your mind at once:
>>
>>  >>>> Whenever the pure simulation of the input to
>>  >>>> simulating halt decider H(x,y) never stops running
>>  >>>> unless H aborts its simulation H correctly aborts
>>  >>>> this simulation and returns 0 for not halting.
>
> I guess you just have a recursive problem then, to actually build your
> halt decider H, someone needs to give you a working Halt Decider for it
> to use.

I have had a working halt decider since 2021-06-08.

>>>> Whenever the pure simulation of the input to
>>>> simulating halt decider H(x,y) never stops running
>>>> unless H aborts its simulation H correctly aborts
>>>> this simulation and returns 0 for not halting.

H(P,P) detects when its simulated input is about to call H again with
the same parameters, aborts it simulation at this point and returns 0.

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

> Since no one can do that, As Turing proved (and restated by
> Linz), the answer is that you just can't build the machine you want.
>
> For the proper definition of H^ (which used to be your P), it is clear
> that if H returns 0, then H^ will make it wrong by Halting and if H
> returns 1, then H^ will make it wrong by Looping forever, so if H only
> acts when the answer it gives will be right, its only possible response
> is to not respond, which also makes it wrong, and thus H fails by not
> answering.
>
> You seem to be mentally incapable of understanding that H has not
> 'correctly proved' that P(P) is non-halting, since when H returns 0,
> P(P) is Halting, so it can't be non-halting.
>
>
>>
>>>>> because if H returns 0
>>> to the P(P) that called it, that will Halt and thus show H was
>>> incorrect in aborting.
>>>
>>> You can't just 'define' H to be correct, you need to figure out how
>>> to make it correct, which is impossible.
>>>
>>> You have just proved that you don't understand what truth is.
>>>
>>> FAIL.
>>>
>>
>>
>

--
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 12/4/21 8:53 AM, olcott wrote:
> On 12/4/2021 5:58 AM, Richard Damon wrote:
>> On 12/4/21 12:10 AM, olcott wrote:
>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>>> simulation H correctly aborts this simulation and returns 0 for
>>>>>>>>> not halting.
>>>>>>>>>
>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>> (V2)
>>>>>>>>>
>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H does
>>>>>>>> abort its simulation of P(P), that the P that calls this H does
>>>>>>>> Halt by itself, and it is the P that is actually being run, and
>>>>>>>> not the aborted simulation buried in H that actually matters.
>>>>>>>>
>>>>>>>
>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even
>>>>>>> when aborted dumbbell
>>>>>>
>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>
>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got to
>>>>>> an end state, then you are just being a cheating liar.
>>>>>>
>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>
>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>> decider. PERIOD.
>>>>>>
>>>>>> If that H does return the value 0, then this P(P) will halt. PERIOD.
>>>>>>
>>>>>
>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>
>>>>> returns 0 for not halting.
>>>>> returns 0 for not halting.
>>>>> returns 0 for not halting.
>>>>> returns 0 for not halting.
>>>>> returns 0 for not halting.
>>>>>
>>>>
>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>
>>>
>>> The problem may be that you actually lack the capacity to hold two
>>> sentence in your mind at once:
>>>
>>>  >>>> Whenever the pure simulation of the input to
>>>  >>>> simulating halt decider H(x,y) never stops running
>>>  >>>> unless H aborts its simulation H correctly aborts
>>>  >>>> this simulation and returns 0 for not halting.
>>
>> I guess you just have a recursive problem then, to actually build your
>> halt decider H, someone needs to give you a working Halt Decider for
>> it to use.
>
> I have had a working halt decider since 2021-06-08.

You can't have, as it gives the wrong answer to the problem.

Since P(P) Halts, H(P,P) must say Halting, but it says Non-Halting

QED, you claim is false.

What you have is a working POOP detector, not a Halt Decider.

>
> >>>> Whenever the pure simulation of the input to
> >>>> simulating halt decider H(x,y) never stops running
> >>>> unless H aborts its simulation H correctly aborts
> >>>> this simulation and returns 0 for not halting.
>
> H(P,P) detects when its simulated input is about to call H again with
> the same parameters, aborts it simulation at this point and returns 0.

Which is NOT a definite infinite pattern, as H is conditional.

Your H assumes that the H in P will never abort its own simulation, but
it will, so your logic is unsound.

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

Right.

Remember, if H(x,y) is supposed to be a Halting Decider then H(x,y) is
supposed to answer on whether x(y) will halt in finite time or not, and
must ALWAYS answer in finite time.

H needs to be an actual 'Computation', which means that all copies of it
will ALWAYS return the same value for the same inputs.

THAT IS THE DEFINITION.

Given we run P(P) from above

If H(P,P) returns 1, then P(P) will loop forever, so H was wrong to
return 1 and say P(P) will halt.

If H(P,P) returns 0, then P(P) will return immediately, so H was wrong
to return 0 and say P(P) will never halt.

Thus, H can't return any correct answer.

Your 'Logic' tries to redefine different parts of the requirements, but
that means that H isn't actually claiming to be a Halt Decider.

>
>> Since no one can do that, As Turing proved (and restated by Linz), the
>> answer is that you just can't build the machine you want.
>>
>> For the proper definition of H^ (which used to be your P), it is clear
>> that if H returns 0, then H^ will make it wrong by Halting and if H
>> returns 1, then H^ will make it wrong by Looping forever, so if H only
>> acts when the answer it gives will be right, its only possible
>> response is to not respond, which also makes it wrong, and thus H
>> fails by not answering.
>>
>> You seem to be mentally incapable of understanding that H has not
>> 'correctly proved' that P(P) is non-halting, since when H returns 0,
>> P(P) is Halting, so it can't be non-halting.
>>
>>
>>>
>>>>>> because if H returns 0
>>>> to the P(P) that called it, that will Halt and thus show H was
>>>> incorrect in aborting.
>>>>
>>>> You can't just 'define' H to be correct, you need to figure out how
>>>> to make it correct, which is impossible.
>>>>
>>>> You have just proved that you don't understand what truth is.
>>>>
>>>> FAIL.
>>>>
>>>
>>>
>>
>
>

On 12/4/2021 8:38 AM, Richard Damon wrote:
> On 12/4/21 8:53 AM, olcott wrote:
>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>> On 12/4/21 12:10 AM, olcott wrote:
>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
>>>>>>>>>> for not halting.
>>>>>>>>>>
>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>> simulation (V2)
>>>>>>>>>>
>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>> does abort its simulation of P(P), that the P that calls this H
>>>>>>>>> does Halt by itself, and it is the P that is actually being
>>>>>>>>> run, and not the aborted simulation buried in H that actually
>>>>>>>>> matters.
>>>>>>>>>
>>>>>>>>
>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts even
>>>>>>>> when aborted dumbbell
>>>>>>>
>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>
>>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got to
>>>>>>> an end state, then you are just being a cheating liar.
>>>>>>>
>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>
>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>> decider. PERIOD.
>>>>>>>
>>>>>>> If that H does return the value 0, then this P(P) will halt. PERIOD.
>>>>>>>
>>>>>>
>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>
>>>>>> returns 0 for not halting.
>>>>>> returns 0 for not halting.
>>>>>> returns 0 for not halting.
>>>>>> returns 0 for not halting.
>>>>>> returns 0 for not halting.
>>>>>>
>>>>>
>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>
>>>>
>>>> The problem may be that you actually lack the capacity to hold two
>>>> sentence in your mind at once:
>>>>
>>>>  >>>> Whenever the pure simulation of the input to
>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>  >>>> this simulation and returns 0 for not halting.
>>>
>>> I guess you just have a recursive problem then, to actually build
>>> your halt decider H, someone needs to give you a working Halt Decider
>>> for it to use.
>>
>> I have had a working halt decider since 2021-06-08.
>
> You can't have, as it gives the wrong answer to the problem.
On 12/3/2021 6:18 PM, olcott wrote:
> Whenever the pure simulation of the input to simulating halt decider
> H(x,y) never stops running unless H aborts its simulation H correctly
> aborts this simulation and returns 0 for not halting.
>

H does correctly decide the pure simulation of the input to simulating
halt decider H(x,y) never stops running unless H aborts its simulation.

--
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 12/4/21 9:52 AM, olcott wrote:
> On 12/4/2021 8:38 AM, Richard Damon wrote:
>> On 12/4/21 8:53 AM, olcott wrote:
>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
>>>>>>>>>>> for not halting.
>>>>>>>>>>>
>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>
>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>>> does abort its simulation of P(P), that the P that calls this
>>>>>>>>>> H does Halt by itself, and it is the P that is actually being
>>>>>>>>>> run, and not the aborted simulation buried in H that actually
>>>>>>>>>> matters.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>> even when aborted dumbbell
>>>>>>>>
>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>
>>>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got
>>>>>>>> to an end state, then you are just being a cheating liar.
>>>>>>>>
>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>
>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>> decider. PERIOD.
>>>>>>>>
>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>> PERIOD.
>>>>>>>>
>>>>>>>
>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>
>>>>>>> returns 0 for not halting.
>>>>>>> returns 0 for not halting.
>>>>>>> returns 0 for not halting.
>>>>>>> returns 0 for not halting.
>>>>>>> returns 0 for not halting.
>>>>>>>
>>>>>>
>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>
>>>>>
>>>>> The problem may be that you actually lack the capacity to hold two
>>>>> sentence in your mind at once:
>>>>>
>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>
>>>> I guess you just have a recursive problem then, to actually build
>>>> your halt decider H, someone needs to give you a working Halt
>>>> Decider for it to use.
>>>
>>> I have had a working halt decider since 2021-06-08.
>>
>> You can't have, as it gives the wrong answer to the problem.
> On 12/3/2021 6:18 PM, olcott wrote:
> > Whenever the pure simulation of the input to simulating halt decider
> > H(x,y) never stops running unless H aborts its simulation H correctly
> > aborts this simulation and returns 0 for not halting.
> >
>
> H does correctly decide the pure simulation of the input to simulating
> halt decider H(x,y) never stops running unless H aborts its simulation.
>

WRONG.

Since the direct running of P(P) Halts, the pure simulation of P(P) by
UTM(P,P) will Halt, thus H saying that the input to H(P,P) will never
halt is an incorrect statement.

What you are actually saying is that there is no H that can simulate for
itself that P(P) will reach a halting state, which is true, but does't
prove that P is non-halting, only that H can not prove that P is Halting.

Absence of Proof is not proof of Absence, so you fail.

You seem to not understand what a computation actually is, and that H
needs to be the SAME through out an arguement about the behavior of
something that depends on it.

FAIL.

On 12/4/2021 10:18 AM, Richard Damon wrote:
> On 12/4/21 9:52 AM, olcott wrote:
>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>> On 12/4/21 8:53 AM, olcott wrote:
>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
>>>>>>>>>>>> for not halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>>>> does abort its simulation of P(P), that the P that calls this
>>>>>>>>>>> H does Halt by itself, and it is the P that is actually being
>>>>>>>>>>> run, and not the aborted simulation buried in H that actually
>>>>>>>>>>> matters.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>>> even when aborted dumbbell
>>>>>>>>>
>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>
>>>>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got
>>>>>>>>> to an end state, then you are just being a cheating liar.
>>>>>>>>>
>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>
>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>> decider. PERIOD.
>>>>>>>>>
>>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>>> PERIOD.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>
>>>>>>>> returns 0 for not halting.
>>>>>>>> returns 0 for not halting.
>>>>>>>> returns 0 for not halting.
>>>>>>>> returns 0 for not halting.
>>>>>>>> returns 0 for not halting.
>>>>>>>>
>>>>>>>
>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>
>>>>>>
>>>>>> The problem may be that you actually lack the capacity to hold two
>>>>>> sentence in your mind at once:
>>>>>>
>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>
>>>>> I guess you just have a recursive problem then, to actually build
>>>>> your halt decider H, someone needs to give you a working Halt
>>>>> Decider for it to use.
>>>>
>>>> I have had a working halt decider since 2021-06-08.
>>>
>>> You can't have, as it gives the wrong answer to the problem.
>> On 12/3/2021 6:18 PM, olcott wrote:
>>  > Whenever the pure simulation of the input to simulating halt decider
>>  > H(x,y) never stops running unless H aborts its simulation H correctly
>>  > aborts this simulation and returns 0 for not halting.
>>  >
>>
>> H does correctly decide the pure simulation of the input to simulating
>> halt decider H(x,y) never stops running unless H aborts its simulation.
>>
>
> WRONG.
>
> Since the direct running of P(P) Halts,

#include <stdint.h>
typedef void (*ptr)();

int H(ptr x, ptr y)
{ x(y);
return 1;
}

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

int main(void)
{ P(P);
}

You know that you are a liar.
The above is the direct execution of P(P).

> the pure simulation of P(P) by
> UTM(P,P) will Halt, thus H saying that the input to H(P,P) will never
> halt is an incorrect statement.
>
> What you are actually saying is that there is no H that can simulate for
> itself that P(P) will reach a halting state, which is true, but does't
> prove that P is non-halting, only that H can not prove that P is Halting.
>
> Absence of Proof is not proof of Absence, so you fail.
>
> You seem to not understand what a computation actually is, and that H
> needs to be the SAME through out an arguement about the behavior of
> something that depends on it.
>
> FAIL.

--
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 Sunday, 5 December 2021 at 00:39:56 UTC+8, olcott wrote:
> On 12/4/2021 10:18 AM, Richard Damon wrote:
> > On 12/4/21 9:52 AM, olcott wrote:
> >> On 12/4/2021 8:38 AM, Richard Damon wrote:
> >>> On 12/4/21 8:53 AM, olcott wrote:
> >>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
> >>>>> On 12/4/21 12:10 AM, olcott wrote:
> >>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
> >>>>>>> On 12/3/21 11:43 PM, olcott wrote:
> >>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
> >>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
> >>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
> >>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
> >>>>>>>>>>>> Whenever the pure simulation of the input to simulating halt
> >>>>>>>>>>>> decider H(x,y) never stops running unless H aborts its
> >>>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
> >>>>>>>>>>>> for not halting.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Halting problem undecidability and infinitely nested
> >>>>>>>>>>>> simulation (V2)
> >>>>>>>>>>>>
> >>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
> >>>>>>>>>>> does abort its simulation of P(P), that the P that calls this
> >>>>>>>>>>> H does Halt by itself, and it is the P that is actually being
> >>>>>>>>>>> run, and not the aborted simulation buried in H that actually
> >>>>>>>>>>> matters.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
> >>>>>>>>>> even when aborted dumbbell
> >>>>>>>>>
> >>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
> >>>>>>>>>
> >>>>>>>>> Now, if you are going into double-speak, and trying to use the
> >>>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got
> >>>>>>>>> to an end state, then you are just being a cheating liar.
> >>>>>>>>>
> >>>>>>>>> The P(P) that we care about is the one that main calls.
> >>>>>>>>>
> >>>>>>>>> If the H that it calls never returns, then H fails to be a
> >>>>>>>>> decider. PERIOD.
> >>>>>>>>>
> >>>>>>>>> If that H does return the value 0, then this P(P) will halt.
> >>>>>>>>> PERIOD.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Here is what I said and you already "forgot" one sentence ago:
> >>>>>>>> >>>> Whenever the pure simulation of the input to
> >>>>>>>> >>>> simulating halt decider H(x,y) never stops running
> >>>>>>>> >>>> unless H aborts its simulation H correctly aborts
> >>>>>>>> >>>> this simulation and returns 0 for not halting.
> >>>>>>>>
> >>>>>>>> returns 0 for not halting.
> >>>>>>>> returns 0 for not halting.
> >>>>>>>> returns 0 for not halting.
> >>>>>>>> returns 0 for not halting.
> >>>>>>>> returns 0 for not halting.
> >>>>>>>>
> >>>>>>>
> >>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
> >>>>>>
> >>>>>>
> >>>>>> The problem may be that you actually lack the capacity to hold two
> >>>>>> sentence in your mind at once:
> >>>>>>
> >>>>>> >>>> Whenever the pure simulation of the input to
> >>>>>> >>>> simulating halt decider H(x,y) never stops running
> >>>>>> >>>> unless H aborts its simulation H correctly aborts
> >>>>>> >>>> this simulation and returns 0 for not halting.
> >>>>>
> >>>>> I guess you just have a recursive problem then, to actually build
> >>>>> your halt decider H, someone needs to give you a working Halt
> >>>>> Decider for it to use.
> >>>>
> >>>> I have had a working halt decider since 2021-06-08.
> >>>
> >>> You can't have, as it gives the wrong answer to the problem.
> >> On 12/3/2021 6:18 PM, olcott wrote:
> >> > Whenever the pure simulation of the input to simulating halt decider
> >> > H(x,y) never stops running unless H aborts its simulation H correctly
> >> > aborts this simulation and returns 0 for not halting.
> >> >
> >>
> >> H does correctly decide the pure simulation of the input to simulating
> >> halt decider H(x,y) never stops running unless H aborts its simulation..
> >>
> >
> > WRONG.
> >
> > Since the direct running of P(P) Halts,
> #include <stdint.h>
> typedef void (*ptr)();
>
> int H(ptr x, ptr y)
> {
> x(y);
> return 1;
> }
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
> int main(void)
> {
> P(P);
> }
>
> You know that you are a liar.
> The above is the direct execution of P(P).
> > the pure simulation of P(P) by
> > UTM(P,P) will Halt, thus H saying that the input to H(P,P) will never
> > halt is an incorrect statement.
> >
> > What you are actually saying is that there is no H that can simulate for
> > itself that P(P) will reach a halting state, which is true, but does't
> > prove that P is non-halting, only that H can not prove that P is Halting.
> >
> > Absence of Proof is not proof of Absence, so you fail.
> >
> > You seem to not understand what a computation actually is, and that H
> > needs to be the SAME through out an arguement about the behavior of
> > something that depends on it.
> >
> > FAIL.
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

int H(ptr x, ptr y)
{ x(y);
return 1;
}

H can only return 1 or never returns. Do you agree?
I had asked the same question, you did not answer.

On 12/4/21 11:39 AM, olcott wrote:
> On 12/4/2021 10:18 AM, Richard Damon wrote:
>> On 12/4/21 9:52 AM, olcott wrote:
>>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>>> On 12/4/21 8:53 AM, olcott wrote:
>>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>>> Whenever the pure simulation of the input to simulating
>>>>>>>>>>>>> halt decider H(x,y) never stops running unless H aborts its
>>>>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
>>>>>>>>>>>>> for not halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>>>>> does abort its simulation of P(P), that the P that calls
>>>>>>>>>>>> this H does Halt by itself, and it is the P that is actually
>>>>>>>>>>>> being run, and not the aborted simulation buried in H that
>>>>>>>>>>>> actually matters.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>>>> even when aborted dumbbell
>>>>>>>>>>
>>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>>
>>>>>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got
>>>>>>>>>> to an end state, then you are just being a cheating liar.
>>>>>>>>>>
>>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>>
>>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>>> decider. PERIOD.
>>>>>>>>>>
>>>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>>>> PERIOD.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>>
>>>>>>>>> returns 0 for not halting.
>>>>>>>>> returns 0 for not halting.
>>>>>>>>> returns 0 for not halting.
>>>>>>>>> returns 0 for not halting.
>>>>>>>>> returns 0 for not halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>>
>>>>>>>
>>>>>>> The problem may be that you actually lack the capacity to hold
>>>>>>> two sentence in your mind at once:
>>>>>>>
>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>
>>>>>> I guess you just have a recursive problem then, to actually build
>>>>>> your halt decider H, someone needs to give you a working Halt
>>>>>> Decider for it to use.
>>>>>
>>>>> I have had a working halt decider since 2021-06-08.
>>>>
>>>> You can't have, as it gives the wrong answer to the problem.
>>> On 12/3/2021 6:18 PM, olcott wrote:
>>>  > Whenever the pure simulation of the input to simulating halt decider
>>>  > H(x,y) never stops running unless H aborts its simulation H correctly
>>>  > aborts this simulation and returns 0 for not halting.
>>>  >
>>>
>>> H does correctly decide the pure simulation of the input to
>>> simulating halt decider H(x,y) never stops running unless H aborts
>>> its simulation.
>>>
>>
>> WRONG.
>>
>> Since the direct running of P(P) Halts,
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y);
>   return 1;
> }
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> int main(void)
> {
>   P(P);
> }
>
> You know that you are a liar.
> The above is the direct execution of P(P).

Right, and the above H doesn't meet the requirements as it doesn't
answer H(P,P), thus this H never 'correctly answers'.

YOU ARE THE LIAR.

Remember your quote from Revelations.

>
>
>> the pure simulation of P(P) by UTM(P,P) will Halt, thus H saying that
>> the input to H(P,P) will never halt is an incorrect statement.
>>
>> What you are actually saying is that there is no H that can simulate
>> for itself that P(P) will reach a halting state, which is true, but
>> does't prove that P is non-halting, only that H can not prove that P
>> is Halting.
>>
>> Absence of Proof is not proof of Absence, so you fail.
>>
>> You seem to not understand what a computation actually is, and that H
>> needs to be the SAME through out an arguement about the behavior of
>> something that depends on it.
>>
>> FAIL.
>
>

On 12/4/2021 11:51 AM, wij wrote:
> On Sunday, 5 December 2021 at 00:39:56 UTC+8, olcott wrote:
>> On 12/4/2021 10:18 AM, Richard Damon wrote:
>>> On 12/4/21 9:52 AM, olcott wrote:
>>>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>>>> On 12/4/21 8:53 AM, olcott wrote:
>>>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
>>>>>>>>>>>>>> for not halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>>>>>> does abort its simulation of P(P), that the P that calls this
>>>>>>>>>>>>> H does Halt by itself, and it is the P that is actually being
>>>>>>>>>>>>> run, and not the aborted simulation buried in H that actually
>>>>>>>>>>>>> matters.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>>>>> even when aborted dumbbell
>>>>>>>>>>>
>>>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>>>
>>>>>>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got
>>>>>>>>>>> to an end state, then you are just being a cheating liar.
>>>>>>>>>>>
>>>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>>>
>>>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>>>> decider. PERIOD.
>>>>>>>>>>>
>>>>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>>>>> PERIOD.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>>> >>>> Whenever the pure simulation of the input to
>>>>>>>>>> >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>> >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>> >>>> this simulation and returns 0 for not halting.
>>>>>>>>>>
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>>>
>>>>>>>>
>>>>>>>> The problem may be that you actually lack the capacity to hold two
>>>>>>>> sentence in your mind at once:
>>>>>>>>
>>>>>>>> >>>> Whenever the pure simulation of the input to
>>>>>>>> >>>> simulating halt decider H(x,y) never stops running
>>>>>>>> >>>> unless H aborts its simulation H correctly aborts
>>>>>>>> >>>> this simulation and returns 0 for not halting.
>>>>>>>
>>>>>>> I guess you just have a recursive problem then, to actually build
>>>>>>> your halt decider H, someone needs to give you a working Halt
>>>>>>> Decider for it to use.
>>>>>>
>>>>>> I have had a working halt decider since 2021-06-08.
>>>>>
>>>>> You can't have, as it gives the wrong answer to the problem.
>>>> On 12/3/2021 6:18 PM, olcott wrote:
>>>> > Whenever the pure simulation of the input to simulating halt decider
>>>> > H(x,y) never stops running unless H aborts its simulation H correctly
>>>> > aborts this simulation and returns 0 for not halting.
>>>> >
>>>>
>>>> H does correctly decide the pure simulation of the input to simulating
>>>> halt decider H(x,y) never stops running unless H aborts its simulation.
>>>>
>>>
>>> WRONG.
>>>
>>> Since the direct running of P(P) Halts,
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> int H(ptr x, ptr y)
>> {
>> x(y);
>> return 1;
>> }
>>
>> // Simplified Linz(1990) Ĥ
>> // and Strachey(1965) P
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>> int main(void)
>> {
>> P(P);
>> }
>>
>> You know that you are a liar.
>> The above is the direct execution of P(P).
>>> the pure simulation of P(P) by
>>> UTM(P,P) will Halt, thus H saying that the input to H(P,P) will never
>>> halt is an incorrect statement.
>>>
>>> What you are actually saying is that there is no H that can simulate for
>>> itself that P(P) will reach a halting state, which is true, but does't
>>> prove that P is non-halting, only that H can not prove that P is Halting.
>>>
>>> Absence of Proof is not proof of Absence, so you fail.
>>>
>>> You seem to not understand what a computation actually is, and that H
>>> needs to be the SAME through out an arguement about the behavior of
>>> something that depends on it.
>>>
>>> FAIL.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> int H(ptr x, ptr y)
> {
> x(y);
> return 1;
> }
>
> H can only return 1 or never returns. Do you agree?
> I had asked the same question, you did not answer.
>

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

When that H has (P,P) as input it can only never return.

This H(P,P) correctly decides that its input never stops running:
On 12/3/2021 6:18 PM, olcott wrote:
> Whenever the pure simulation of the input to simulating halt decider
> H(x,y) never stops running unless H aborts its simulation H correctly
> aborts this simulation and returns 0 for not halting.

On the basis of the infinite_recursion behavior pattern.

--
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 12/4/2021 11:57 AM, Richard Damon wrote:
> On 12/4/21 11:39 AM, olcott wrote:
>> On 12/4/2021 10:18 AM, Richard Damon wrote:
>>> On 12/4/21 9:52 AM, olcott wrote:
>>>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>>>> On 12/4/21 8:53 AM, olcott wrote:
>>>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>>>> Whenever the pure simulation of the input to simulating
>>>>>>>>>>>>>> halt decider H(x,y) never stops running unless H aborts
>>>>>>>>>>>>>> its simulation H correctly aborts this simulation and
>>>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>>>>>> does abort its simulation of P(P), that the P that calls
>>>>>>>>>>>>> this H does Halt by itself, and it is the P that is
>>>>>>>>>>>>> actually being run, and not the aborted simulation buried
>>>>>>>>>>>>> in H that actually matters.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>>>>> even when aborted dumbbell
>>>>>>>>>>>
>>>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>>>
>>>>>>>>>>> Now, if you are going into double-speak, and trying to use
>>>>>>>>>>> the fact that the SIMULATED copy of P(P) that H is doing
>>>>>>>>>>> never got to an end state, then you are just being a cheating
>>>>>>>>>>> liar.
>>>>>>>>>>>
>>>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>>>
>>>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>>>> decider. PERIOD.
>>>>>>>>>>>
>>>>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>>>>> PERIOD.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>>>
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>>>
>>>>>>>>
>>>>>>>> The problem may be that you actually lack the capacity to hold
>>>>>>>> two sentence in your mind at once:
>>>>>>>>
>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>
>>>>>>> I guess you just have a recursive problem then, to actually build
>>>>>>> your halt decider H, someone needs to give you a working Halt
>>>>>>> Decider for it to use.
>>>>>>
>>>>>> I have had a working halt decider since 2021-06-08.
>>>>>
>>>>> You can't have, as it gives the wrong answer to the problem.
>>>> On 12/3/2021 6:18 PM, olcott wrote:
>>>>  > Whenever the pure simulation of the input to simulating halt decider
>>>>  > H(x,y) never stops running unless H aborts its simulation H
>>>> correctly
>>>>  > aborts this simulation and returns 0 for not halting.
>>>>  >
>>>>
>>>> H does correctly decide the pure simulation of the input to
>>>> simulating halt decider H(x,y) never stops running unless H aborts
>>>> its simulation.
>>>>
>>>
>>> WRONG.
>>>
>>> Since the direct running of P(P) Halts,
>>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> int H(ptr x, ptr y)
>> {
>>    x(y);
>>    return 1;
>> }
>>
>> // Simplified Linz(1990) Ĥ
>> // and Strachey(1965) P
>> void P(ptr x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>> }
>>
>> int main(void)
>> {
>>    P(P);
>> }
>>
>> You know that you are a liar.
>> The above is the direct execution of P(P).
>
> Right, and the above H doesn't meet the requirements as it doesn't
> answer H(P,P), thus this H never 'correctly answers'.
>

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

When that H has (P,P) as input it can only never return.

This H(P,P) correctly decides that its input never stops running:
On 12/3/2021 6:18 PM, olcott wrote:
> Whenever the pure simulation of the input to simulating halt decider
> H(x,y) never stops running unless H aborts its simulation H correctly
> aborts this simulation and returns 0 for not halting.

On the basis of the infinite_recursion behavior pattern.

> YOU ARE THE LIAR.
>
> Remember your quote from Revelations.
>
>>
>>
>>> the pure simulation of P(P) by UTM(P,P) will Halt, thus H saying that
>>> the input to H(P,P) will never halt is an incorrect statement.
>>>
>>> What you are actually saying is that there is no H that can simulate
>>> for itself that P(P) will reach a halting state, which is true, but
>>> does't prove that P is non-halting, only that H can not prove that P
>>> is Halting.
>>>
>>> Absence of Proof is not proof of Absence, so you fail.
>>>
>>> You seem to not understand what a computation actually is, and that H
>>> needs to be the SAME through out an arguement about the behavior of
>>> something that depends on it.
>>>
>>> FAIL.
>>
>>
>

--
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 12/4/21 1:07 PM, olcott wrote:
> On 12/4/2021 11:51 AM, wij wrote:
>> On Sunday, 5 December 2021 at 00:39:56 UTC+8, olcott wrote:
>>> On 12/4/2021 10:18 AM, Richard Damon wrote:
>>>> On 12/4/21 9:52 AM, olcott wrote:
>>>>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>>>>> On 12/4/21 8:53 AM, olcott wrote:
>>>>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>>>>> Whenever the pure simulation of the input to simulating halt
>>>>>>>>>>>>>>> decider H(x,y) never stops running unless H aborts its
>>>>>>>>>>>>>>> simulation H correctly aborts this simulation and returns 0
>>>>>>>>>>>>>>> for not halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE H
>>>>>>>>>>>>>> does abort its simulation of P(P), that the P that calls this
>>>>>>>>>>>>>> H does Halt by itself, and it is the P that is actually being
>>>>>>>>>>>>>> run, and not the aborted simulation buried in H that actually
>>>>>>>>>>>>>> matters.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>>>>>> even when aborted dumbbell
>>>>>>>>>>>>
>>>>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>>>>
>>>>>>>>>>>> Now, if you are going into double-speak, and trying to use the
>>>>>>>>>>>> fact that the SIMULATED copy of P(P) that H is doing never got
>>>>>>>>>>>> to an end state, then you are just being a cheating liar.
>>>>>>>>>>>>
>>>>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>>>>
>>>>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>>>>> decider. PERIOD.
>>>>>>>>>>>>
>>>>>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>>>>>> PERIOD.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>>>>   >>>> Whenever the pure simulation of the input to
>>>>>>>>>>>   >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>>>   >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>>>   >>>> this simulation and returns 0 for not halting.
>>>>>>>>>>>
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The problem may be that you actually lack the capacity to hold two
>>>>>>>>> sentence in your mind at once:
>>>>>>>>>
>>>>>>>>>   >>>> Whenever the pure simulation of the input to
>>>>>>>>>   >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>   >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>   >>>> this simulation and returns 0 for not halting.
>>>>>>>>
>>>>>>>> I guess you just have a recursive problem then, to actually build
>>>>>>>> your halt decider H, someone needs to give you a working Halt
>>>>>>>> Decider for it to use.
>>>>>>>
>>>>>>> I have had a working halt decider since 2021-06-08.
>>>>>>
>>>>>> You can't have, as it gives the wrong answer to the problem.
>>>>> On 12/3/2021 6:18 PM, olcott wrote:
>>>>>   > Whenever the pure simulation of the input to simulating halt
>>>>> decider
>>>>>   > H(x,y) never stops running unless H aborts its simulation H
>>>>> correctly
>>>>>   > aborts this simulation and returns 0 for not halting.
>>>>>   >
>>>>>
>>>>> H does correctly decide the pure simulation of the input to simulating
>>>>> halt decider H(x,y) never stops running unless H aborts its
>>>>> simulation.
>>>>>
>>>>
>>>> WRONG.
>>>>
>>>> Since the direct running of P(P) Halts,
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> int H(ptr x, ptr y)
>>> {
>>> x(y);
>>> return 1;
>>> }
>>>
>>> // Simplified Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> void P(ptr x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>> int main(void)
>>> {
>>> P(P);
>>> }
>>>
>>> You know that you are a liar.
>>> The above is the direct execution of P(P).
>>>> the pure simulation of P(P) by
>>>> UTM(P,P) will Halt, thus H saying that the input to H(P,P) will never
>>>> halt is an incorrect statement.
>>>>
>>>> What you are actually saying is that there is no H that can simulate
>>>> for
>>>> itself that P(P) will reach a halting state, which is true, but does't
>>>> prove that P is non-halting, only that H can not prove that P is
>>>> Halting.
>>>>
>>>> Absence of Proof is not proof of Absence, so you fail.
>>>>
>>>> You seem to not understand what a computation actually is, and that H
>>>> needs to be the SAME through out an arguement about the behavior of
>>>> something that depends on it.
>>>>
>>>> FAIL.
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> int H(ptr x, ptr y)
>> {
>>     x(y);
>>     return 1;
>> }
>>
>> H can only return 1 or never returns. Do you agree?
>> I had asked the same question, you did not answer.
>>
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> When that H has (P,P) as input it can only never return.
>
> This H(P,P) correctly decides that its input never stops running:
> On 12/3/2021 6:18 PM, olcott wrote:
> > Whenever the pure simulation of the input to simulating halt decider
> > H(x,y) never stops running unless H aborts its simulation H correctly
> > aborts this simulation and returns 0 for not halting.
>
> On the basis of the infinite_recursion behavior pattern.
>

On 12/4/21 1:09 PM, olcott wrote:
> On 12/4/2021 11:57 AM, Richard Damon wrote:
>> On 12/4/21 11:39 AM, olcott wrote:
>>> On 12/4/2021 10:18 AM, Richard Damon wrote:
>>>> On 12/4/21 9:52 AM, olcott wrote:
>>>>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>>>>> On 12/4/21 8:53 AM, olcott wrote:
>>>>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>>>>> Whenever the pure simulation of the input to simulating
>>>>>>>>>>>>>>> halt decider H(x,y) never stops running unless H aborts
>>>>>>>>>>>>>>> its simulation H correctly aborts this simulation and
>>>>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE
>>>>>>>>>>>>>> H does abort its simulation of P(P), that the P that calls
>>>>>>>>>>>>>> this H does Halt by itself, and it is the P that is
>>>>>>>>>>>>>> actually being run, and not the aborted simulation buried
>>>>>>>>>>>>>> in H that actually matters.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never halts
>>>>>>>>>>>>> even when aborted dumbbell
>>>>>>>>>>>>
>>>>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>>>>
>>>>>>>>>>>> Now, if you are going into double-speak, and trying to use
>>>>>>>>>>>> the fact that the SIMULATED copy of P(P) that H is doing
>>>>>>>>>>>> never got to an end state, then you are just being a
>>>>>>>>>>>> cheating liar.
>>>>>>>>>>>>
>>>>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>>>>
>>>>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>>>>> decider. PERIOD.
>>>>>>>>>>>>
>>>>>>>>>>>> If that H does return the value 0, then this P(P) will halt.
>>>>>>>>>>>> PERIOD.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>>>>
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The problem may be that you actually lack the capacity to hold
>>>>>>>>> two sentence in your mind at once:
>>>>>>>>>
>>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>
>>>>>>>> I guess you just have a recursive problem then, to actually
>>>>>>>> build your halt decider H, someone needs to give you a working
>>>>>>>> Halt Decider for it to use.
>>>>>>>
>>>>>>> I have had a working halt decider since 2021-06-08.
>>>>>>
>>>>>> You can't have, as it gives the wrong answer to the problem.
>>>>> On 12/3/2021 6:18 PM, olcott wrote:
>>>>>  > Whenever the pure simulation of the input to simulating halt
>>>>> decider
>>>>>  > H(x,y) never stops running unless H aborts its simulation H
>>>>> correctly
>>>>>  > aborts this simulation and returns 0 for not halting.
>>>>>  >
>>>>>
>>>>> H does correctly decide the pure simulation of the input to
>>>>> simulating halt decider H(x,y) never stops running unless H aborts
>>>>> its simulation.
>>>>>
>>>>
>>>> WRONG.
>>>>
>>>> Since the direct running of P(P) Halts,
>>>
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> int H(ptr x, ptr y)
>>> {
>>>    x(y);
>>>    return 1;
>>> }
>>>
>>> // Simplified Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> void P(ptr x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>> }
>>>
>>> int main(void)
>>> {
>>>    P(P);
>>> }
>>>
>>> You know that you are a liar.
>>> The above is the direct execution of P(P).
>>
>> Right, and the above H doesn't meet the requirements as it doesn't
>> answer H(P,P), thus this H never 'correctly answers'.
>>
>
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> When that H has (P,P) as input it can only never return.
>
> This H(P,P) correctly decides that its input never stops running:
> On 12/3/2021 6:18 PM, olcott wrote:
> > Whenever the pure simulation of the input to simulating halt decider
> > H(x,y) never stops running unless H aborts its simulation H correctly
> > aborts this simulation and returns 0 for not halting.
>
> On the basis of the infinite_recursion behavior pattern.

WRONG, LIE, see other post.

>
>
>> YOU ARE THE LIAR.
>>
>> Remember your quote from Revelations.
>>
>>>
>>>
>>>> the pure simulation of P(P) by UTM(P,P) will Halt, thus H saying
>>>> that the input to H(P,P) will never halt is an incorrect statement.
>>>>
>>>> What you are actually saying is that there is no H that can simulate
>>>> for itself that P(P) will reach a halting state, which is true, but
>>>> does't prove that P is non-halting, only that H can not prove that P
>>>> is Halting.
>>>>
>>>> Absence of Proof is not proof of Absence, so you fail.
>>>>
>>>> You seem to not understand what a computation actually is, and that
>>>> H needs to be the SAME through out an arguement about the behavior
>>>> of something that depends on it.
>>>>
>>>> FAIL.
>>>
>>>
>>
>
>

On 12/4/2021 12:20 PM, Richard Damon wrote:
> On 12/4/21 1:09 PM, olcott wrote:
>> On 12/4/2021 11:57 AM, Richard Damon wrote:
>>> On 12/4/21 11:39 AM, olcott wrote:
>>>> On 12/4/2021 10:18 AM, Richard Damon wrote:
>>>>> On 12/4/21 9:52 AM, olcott wrote:
>>>>>> On 12/4/2021 8:38 AM, Richard Damon wrote:
>>>>>>> On 12/4/21 8:53 AM, olcott wrote:
>>>>>>>> On 12/4/2021 5:58 AM, Richard Damon wrote:
>>>>>>>>> On 12/4/21 12:10 AM, olcott wrote:
>>>>>>>>>> On 12/3/2021 10:53 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/3/21 11:43 PM, olcott wrote:
>>>>>>>>>>>> On 12/3/2021 10:15 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/3/21 8:36 PM, olcott wrote:
>>>>>>>>>>>>>> On 12/3/2021 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 12/3/21 7:18 PM, olcott wrote:
>>>>>>>>>>>>>>>> Whenever the pure simulation of the input to simulating
>>>>>>>>>>>>>>>> halt decider H(x,y) never stops running unless H aborts
>>>>>>>>>>>>>>>> its simulation H correctly aborts this simulation and
>>>>>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>> simulation (V2)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Maybe the problem is that YOU don't understand that SINCE
>>>>>>>>>>>>>>> H does abort its simulation of P(P), that the P that
>>>>>>>>>>>>>>> calls this H does Halt by itself, and it is the P that is
>>>>>>>>>>>>>>> actually being run, and not the aborted simulation buried
>>>>>>>>>>>>>>> in H that actually matters.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main() { P(P) } calls H(P,P) simulates P(P) never
>>>>>>>>>>>>>> halts even when aborted dumbbell
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then your H(P,P) never returns 0, or you are just a bad liar.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Now, if you are going into double-speak, and trying to use
>>>>>>>>>>>>> the fact that the SIMULATED copy of P(P) that H is doing
>>>>>>>>>>>>> never got to an end state, then you are just being a
>>>>>>>>>>>>> cheating liar.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The P(P) that we care about is the one that main calls.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the H that it calls never returns, then H fails to be a
>>>>>>>>>>>>> decider. PERIOD.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If that H does return the value 0, then this P(P) will
>>>>>>>>>>>>> halt. PERIOD.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Here is what I said and you already "forgot" one sentence ago:
>>>>>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>>>>>
>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>> returns 0 for not halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> IF H returns 0, then it is BY DEFINITION wrong,
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The problem may be that you actually lack the capacity to hold
>>>>>>>>>> two sentence in your mind at once:
>>>>>>>>>>
>>>>>>>>>>  >>>> Whenever the pure simulation of the input to
>>>>>>>>>>  >>>> simulating halt decider H(x,y) never stops running
>>>>>>>>>>  >>>> unless H aborts its simulation H correctly aborts
>>>>>>>>>>  >>>> this simulation and returns 0 for not halting.
>>>>>>>>>
>>>>>>>>> I guess you just have a recursive problem then, to actually
>>>>>>>>> build your halt decider H, someone needs to give you a working
>>>>>>>>> Halt Decider for it to use.
>>>>>>>>
>>>>>>>> I have had a working halt decider since 2021-06-08.
>>>>>>>
>>>>>>> You can't have, as it gives the wrong answer to the problem.
>>>>>> On 12/3/2021 6:18 PM, olcott wrote:
>>>>>>  > Whenever the pure simulation of the input to simulating halt
>>>>>> decider
>>>>>>  > H(x,y) never stops running unless H aborts its simulation H
>>>>>> correctly
>>>>>>  > aborts this simulation and returns 0 for not halting.
>>>>>>  >
>>>>>>
>>>>>> H does correctly decide the pure simulation of the input to
>>>>>> simulating halt decider H(x,y) never stops running unless H aborts
>>>>>> its simulation.
>>>>>>
>>>>>
>>>>> WRONG.
>>>>>
>>>>> Since the direct running of P(P) Halts,
>>>>
>>>> #include <stdint.h>
>>>> typedef void (*ptr)();
>>>>
>>>> int H(ptr x, ptr y)
>>>> {
>>>>    x(y);
>>>>    return 1;
>>>> }
>>>>
>>>> // Simplified Linz(1990) Ĥ
>>>> // and Strachey(1965) P
>>>> void P(ptr x)
>>>> {
>>>>    if (H(x, x))
>>>>      HERE: goto HERE;
>>>> }
>>>>
>>>> int main(void)
>>>> {
>>>>    P(P);
>>>> }
>>>>
>>>> You know that you are a liar.
>>>> The above is the direct execution of P(P).
>>>
>>> Right, and the above H doesn't meet the requirements as it doesn't
>>> answer H(P,P), thus this H never 'correctly answers'.
>>>
>>
>>
>> // Simplified Linz(1990) Ĥ
>> // and Strachey(1965) P
>> void P(ptr x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>> }
>>
>> When that H has (P,P) as input it can only never return.
>>
>> This H(P,P) correctly decides that its input never stops running:
>> On 12/3/2021 6:18 PM, olcott wrote:
>>  > Whenever the pure simulation of the input to simulating halt decider
>>  > H(x,y) never stops running unless H aborts its simulation H correctly
>>  > aborts this simulation and returns 0 for not halting.
>>
>> On the basis of the infinite_recursion behavior pattern.
>
> WRONG, LIE, see other post.
>
>

On Sunday, 5 December 2021 at 02:07:53 UTC+8, olcott wrote:
>...
> > int H(ptr x, ptr y)
> > {
> > x(y);
> > return 1;
> > }
> >
> > H can only return 1 or never returns. Do you agree?
> > I had asked the same question, you did not answer.
> >
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
> When that H has (P,P) as input it can only never return.
>

https://en.wikipedia.org/wiki/Halting_problem

Halting decider H has to return {0,1} (or reject, accept) for the given inputs.
Your H clearly can only return 1, not a halting decider.

----
GUR(v4) https://groups.google.com/g/comp.theory/c/_tbCYyMox9M
....
No function f can decide the property of another function g that g can defy..
....

On 12/4/2021 12:37 PM, wij wrote:
> On Sunday, 5 December 2021 at 02:07:53 UTC+8, olcott wrote:
>> ...
>>> int H(ptr x, ptr y)
>>> {
>>> x(y);
>>> return 1;
>>> }
>>>
>>> H can only return 1 or never returns. Do you agree?
>>> I had asked the same question, you did not answer.
>>>
>>
>> // Simplified Linz(1990) Ĥ
>> // and Strachey(1965) P
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>> When that H has (P,P) as input it can only never return.
>>
>
> https://en.wikipedia.org/wiki/Halting_problem
>
> Halting decider H has to return {0,1} (or reject, accept) for the given inputs.
> Your H clearly can only return 1, not a halting decider.
>

ARE YOU BRAIN-DEAD ???

Whenever the pure simulation of the input to simulating halt decider
H(x,y) never stops running unless H aborts its simulation H correctly
aborts this simulation and returns 0 for not halting.

> ----
> GUR(v4) https://groups.google.com/g/comp.theory/c/_tbCYyMox9M
> ...
> No function f can decide the property of another function g that g can defy.
> ...
>

--
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 12/4/2021 12:45 PM, olcott wrote:
> On 12/4/2021 12:37 PM, wij wrote:
>> On Sunday, 5 December 2021 at 02:07:53 UTC+8, olcott wrote:
>>> ...
>>>> int H(ptr x, ptr y)
>>>> {
>>>> x(y);
>>>> return 1;
>>>> }
>>>>
>>>> H can only return 1 or never returns. Do you agree?
>>>> I had asked the same question, you did not answer.
>>>>
>>>
>>> // Simplified Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> void P(ptr x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>> When that H has (P,P) as input it can only never return.
>>>
>>
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> Halting decider H has to return {0,1} (or reject, accept) for the
>> given inputs.
>> Your H clearly can only return 1, not a halting decider.
>>
>
> ARE YOU BRAIN-DEAD ???
>
> Whenever the pure simulation of the input to simulating halt decider
> H(x,y) never stops running unless H aborts its simulation H correctly
> aborts this simulation and returns 0 for not halting.
>

THIS IS A GENERAL PRINCIPLE:
Whenever the pure simulation of [ANY] input to [ANY] simulating halt
decider H(x,y) never stops running unless H aborts its simulation H
correctly aborts this simulation and returns 0 for not halting.

>
>> ----
>> GUR(v4) https://groups.google.com/g/comp.theory/c/_tbCYyMox9M
>> ...
>> No function f can decide the property of another function g that g can
>> defy.
>> ...
>>
>
>

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