On 8/12/2022 7:03 AM, Dennis Bush wrote:
> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
>>>>>>>>>> ...
>>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
>>>>>>>>>> its call to H(P,P).
>>>>>>>>>
>>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
>>>>>>>> I have never even implied that my criteria is incorrect.
>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
>>>>>>>>
>>>>>>>> Example 02:
>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
>>>>>>>
>>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
>>>>>>>
>>>>>>> Let's test that logic on Ha3,
>>>>>> In other words you are saying let's dishonestly change the subject using
>>>>>> the straw man deception.
>>>>>
>>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
>>>
>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer.
>> That is a stupid thing to say there is no luck in correct algorithm design.
>
> When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
>
>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
>> Yes it does. Every time that the pattern is correctly matched the
>> behavior is non-terminating.
>
> Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
>
> And from there it follows what I said below:
>
>>>
>>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
>>>
>>> Agreed?
>> It is ridiculously stupid (or flat out dishonest) of you to compare an
>> intentionally broken halt decider with one that is correct.
>
> But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
>

The criteria has been extensively reviewed and validated.

> And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
>
> Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
>

If H(P,P) waits any fixed number of recursive invocations before
aborting it is still the outermost H that aborts. If H waits for an
inner H to abort then each inner H waits for its inner H to abort and
the simulation never stops.

> So anything you use to prove Ha is correct can be used to prove that Ha3 is correct.
Not at all H3 is intentionally defined to get the wrong answer.

--
Copyright 2022 Pete Olcott

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

On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
> On 8/12/2022 7:03 AM, Dennis Bush wrote:
> > On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
> >> On 8/11/2022 12:10 PM, Dennis Bush wrote:
> >>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
> >>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
> >>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
> >>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
> >>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
> >>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
> >>>>>>>>>> ...
> >>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
> >>>>>>>>>> its call to H(P,P).
> >>>>>>>>>
> >>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
> >>>>>>>> I have never even implied that my criteria is incorrect.
> >>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
> >>>>>>>>
> >>>>>>>> Example 02:
> >>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
> >>>>>>>
> >>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
> >>>>>>>
> >>>>>>> Let's test that logic on Ha3,
> >>>>>> In other words you are saying let's dishonestly change the subject using
> >>>>>> the straw man deception.
> >>>>>
> >>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
> >>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
> >>>
> >>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer..
> >> That is a stupid thing to say there is no luck in correct algorithm design.
> >
> > When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
> >
> >>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
> >> Yes it does. Every time that the pattern is correctly matched the
> >> behavior is non-terminating.
> >
> > Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
> >
> > And from there it follows what I said below:
> >
> >>>
> >>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
> >>>
> >>> Agreed?
> >> It is ridiculously stupid (or flat out dishonest) of you to compare an
> >> intentionally broken halt decider with one that is correct.
> >
> > But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
> >
> The criteria has been extensively reviewed and validated.

FALSE. You *claim* it is correct but it is not, as several people pointed out several times the problem with your criteria 3 which you have *still* failed to respond to. The criteria is proved incorrect by Ha(Pa,Pa)==0 when Pa(Pa) halts.

> > And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
> >
> > Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
> >

Deceptive use of "H" and "P" coming to refer to multiple unrelated computations:

> If H(P,P) waits any fixed number of recursive invocations before
> aborting it is still the outermost H that aborts.

And the inner Ha's would also abort in a correct simulation. Assuming Ha is a pure function if its inputs (otherwise it's disqualified from being a halt decider), *all* instances of Ha(Pa,Pa) will return 0. That the simulation Ha performs is stopped before it gets there doesn't change that.

> If H waits for an
> inner H to abort then each inner H waits for its inner H to abort and
> the simulation never stops.

Yes, because Hn does not abort, Pn(Pn) will not halt but then neither will Hn(Pn,Pn) so it fails to be a decider.

> > So anything you use to prove Ha is correct can be used to prove that Ha3 is correct.
> Not at all H3 is intentionally defined to get the wrong answer.

Intentional doesn't matter. What matters is that both abort too soon. So yes.

On 8/12/2022 9:55 AM, Dennis Bush wrote:
> On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
>> On 8/12/2022 7:03 AM, Dennis Bush wrote:
>>> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
>>>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
>>>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
>>>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
>>>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
>>>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
>>>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
>>>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
>>>>>>>>>>>> ...
>>>>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
>>>>>>>>>>>> its call to H(P,P).
>>>>>>>>>>>
>>>>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
>>>>>>>>>> I have never even implied that my criteria is incorrect.
>>>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
>>>>>>>>>>
>>>>>>>>>> Example 02:
>>>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
>>>>>>>>>
>>>>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
>>>>>>>>>
>>>>>>>>> Let's test that logic on Ha3,
>>>>>>>> In other words you are saying let's dishonestly change the subject using
>>>>>>>> the straw man deception.
>>>>>>>
>>>>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
>>>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
>>>>>
>>>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer.
>>>> That is a stupid thing to say there is no luck in correct algorithm design.
>>>
>>> When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
>>>
>>>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
>>>> Yes it does. Every time that the pattern is correctly matched the
>>>> behavior is non-terminating.
>>>
>>> Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
>>>
>>> And from there it follows what I said below:
>>>
>>>>>
>>>>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
>>>>>
>>>>> Agreed?
>>>> It is ridiculously stupid (or flat out dishonest) of you to compare an
>>>> intentionally broken halt decider with one that is correct.
>>>
>>> But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
>>>
>> The criteria has been extensively reviewed and validated.
>
> FALSE. You *claim* it is correct but it is not, as several people pointed out several times the problem with your criteria 3 which you have *still* failed to respond to. The criteria is proved incorrect by Ha(Pa,Pa)==0 when Pa(Pa) halts.
>
>>> And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
>>>
>>> Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
>>>
>
> Deceptive use of "H" and "P" coming to refer to multiple unrelated computations:
>

H(P,P) correctly predicts that a correct and complete simulation of its
input never halts. All correct simulating halt deciders work this same way.

H0 does not report that Infinite_Loop() halts on the basis that H0 knows
that it will abort its simulation of Infinite_Loop(). H0 correctly
predicts that a correct and complete simulation of Infinite_Loop() would
never halt.

void Infinite_Loop()
{ HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H0((u32)Infinite_Loop));
}

_Infinite_Loop()
[00001102](01) 55 push ebp
[00001103](02) 8bec mov ebp,esp
[00001105](02) ebfe jmp 00001105
[00001107](01) 5d pop ebp
[00001108](01) c3 ret
Size in bytes:(0007) [00001108]

>> If H(P,P) waits any fixed number of recursive invocations before
>> aborting it is still the outermost H that aborts.
>
> And the inner Ha's would also abort in a correct simulation.

The outermost H always sees a longer execution trace than any inner H,
thus always meets its abort criteria sooner.

> Assuming Ha is a pure function if its inputs (otherwise it's disqualified from being a halt decider), *all* instances of Ha(Pa,Pa) will return 0.

All invoked instances of H return 0. The pure function version of H
aborts its inner H before it is invoked.

> That the simulation Ha performs is stopped before it gets there doesn't change that.
>
>> If H waits for an
>> inner H to abort then each inner H waits for its inner H to abort and
>> the simulation never stops.
>
> Yes, because Hn does not abort, Pn(Pn) will not halt but then neither will Hn(Pn,Pn) so it fails to be a decider.
>

Therefore a correct halt decider aborts its simulation as soon as it
correctly matches a non-halting behavior pattern.

>>> So anything you use to prove Ha is correct can be used to prove that Ha3 is correct.
>> Not at all H3 is intentionally defined to get the wrong answer.
>
> Intentional doesn't matter. What matters is that both abort too soon. So yes.

I said STF up about that. I will not play those head games.

A correct simulating halt decider always continues to simulate its input
until:
(a) It correctly matches a non-halting behavior pattern.
(b) Its input halts on its own.

Because you know this and you know that Ha3 does not do this
STF up about Ha3.

--
Copyright 2022 Pete Olcott

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

On Friday, August 12, 2022 at 11:44:37 AM UTC-4, olcott wrote:
> On 8/12/2022 9:55 AM, Dennis Bush wrote:
> > On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
> >> On 8/12/2022 7:03 AM, Dennis Bush wrote:
> >>> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
> >>>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
> >>>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
> >>>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
> >>>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
> >>>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> ...
> >>>>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
> >>>>>>>>>>>> its call to H(P,P).
> >>>>>>>>>>>
> >>>>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
> >>>>>>>>>> I have never even implied that my criteria is incorrect.
> >>>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
> >>>>>>>>>>
> >>>>>>>>>> Example 02:
> >>>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
> >>>>>>>>>
> >>>>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
> >>>>>>>>>
> >>>>>>>>> Let's test that logic on Ha3,
> >>>>>>>> In other words you are saying let's dishonestly change the subject using
> >>>>>>>> the straw man deception.
> >>>>>>>
> >>>>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
> >>>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
> >>>>>
> >>>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer.
> >>>> That is a stupid thing to say there is no luck in correct algorithm design.
> >>>
> >>> When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
> >>>
> >>>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
> >>>> Yes it does. Every time that the pattern is correctly matched the
> >>>> behavior is non-terminating.
> >>>
> >>> Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
> >>>
> >>> And from there it follows what I said below:
> >>>
> >>>>>
> >>>>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
> >>>>>
> >>>>> Agreed?
> >>>> It is ridiculously stupid (or flat out dishonest) of you to compare an
> >>>> intentionally broken halt decider with one that is correct.
> >>>
> >>> But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
> >>>
> >> The criteria has been extensively reviewed and validated.
> >
> > FALSE. You *claim* it is correct but it is not, as several people pointed out several times the problem with your criteria 3 which you have *still* failed to respond to. The criteria is proved incorrect by Ha(Pa,Pa)==0 when Pa(Pa) halts.
> >
> >>> And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
> >>>
> >>> Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
> >>>
> >
> > Deceptive use of "H" and "P" coming to refer to multiple unrelated computations:
> >
> H(P,P) correctly predicts that a correct and complete simulation of its
> input never halts. All correct simulating halt deciders work this same way.

FALSE, because a correct and complete simulation of the input to Ha(Pa,Pa), i.e. UTM(Pa,Pa) halts, therefore Ha(Pa,Pa)==0 is wrong.

So Ha is not a correct simulating halt decider.

>
> H0 does not report that Infinite_Loop() halts on the basis that H0 knows
> that it will abort its simulation of Infinite_Loop(). H0 correctly
> predicts that a correct and complete simulation of Infinite_Loop() would
> never halt.

And it uses an invalid criteria that happens to get the right answer, just as Ha3 does.

>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
> _Infinite_Loop()
> [00001102](01) 55 push ebp
> [00001103](02) 8bec mov ebp,esp
> [00001105](02) ebfe jmp 00001105
> [00001107](01) 5d pop ebp
> [00001108](01) c3 ret
> Size in bytes:(0007) [00001108]
> >> If H(P,P) waits any fixed number of recursive invocations before
> >> aborting it is still the outermost H that aborts.
> >
> > And the inner Ha's would also abort in a correct simulation.
> The outermost H always sees a longer execution trace than any inner H,
> thus always meets its abort criteria sooner.

Which doesn't change that the criteria is incorrect as demonstrated by Pa(Pa) halting.

> > Assuming Ha is a pure function if its inputs (otherwise it's disqualified from being a halt decider), *all* instances of Ha(Pa,Pa) will return 0.
> All invoked instances of H return 0. The pure function version of H
> aborts its inner H before it is invoked.

And in doing so incorrectly concludes that the inner Ha wouldn't return when in fact it will because Ha is a pure function.

> > That the simulation Ha performs is stopped before it gets there doesn't change that.
> >
> >> If H waits for an
> >> inner H to abort then each inner H waits for its inner H to abort and
> >> the simulation never stops.
> >
> > Yes, because Hn does not abort, Pn(Pn) will not halt but then neither will Hn(Pn,Pn) so it fails to be a decider.
> >
> Therefore a correct halt decider aborts its simulation as soon as it
> correctly matches a non-halting behavior pattern.

And the behavior pattern used by Ha is not correct as demonstrated by Pa(Pa) halting.

> >>> So anything you use to prove Ha is correct can be used to prove that Ha3 is correct.
> >> Not at all H3 is intentionally defined to get the wrong answer.
> >
> > Intentional doesn't matter. What matters is that both abort too soon. So yes.
> I said STF up about that. I will not play those head games.

The only head game is the one you played on yourself where you convinced yourself that Ha(Pa,Pa)==0 is correct even though Pa(Pa) halts, contrary to the requirements of a halt decider:

For *any* algorithm X and input Y:
H(X,Y)==1 if and only if X(Y) halts, and
H(X,Y)==0 if and only if X(Y) does not halt

>
> A correct simulating halt decider always continues to simulate its input
> until:
> (a) It correctly matches a non-halting behavior pattern.

Which Ha fails to do as demonstrated by Pa(Pa) halting

> (b) Its input halts on its own.

>
> Because you know this and you know that Ha3 does not do this
> STF up about Ha3.

And neither does Ha for the same reason.

On 8/12/2022 11:09 AM, Dennis Bush wrote:
> On Friday, August 12, 2022 at 11:44:37 AM UTC-4, olcott wrote:
>> On 8/12/2022 9:55 AM, Dennis Bush wrote:
>>> On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
>>>> On 8/12/2022 7:03 AM, Dennis Bush wrote:
>>>>> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
>>>>>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
>>>>>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
>>>>>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
>>>>>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
>>>>>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
>>>>>>>>>>>>>> its call to H(P,P).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
>>>>>>>>>>>> I have never even implied that my criteria is incorrect.
>>>>>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
>>>>>>>>>>>>
>>>>>>>>>>>> Example 02:
>>>>>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
>>>>>>>>>>>
>>>>>>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
>>>>>>>>>>>
>>>>>>>>>>> Let's test that logic on Ha3,
>>>>>>>>>> In other words you are saying let's dishonestly change the subject using
>>>>>>>>>> the straw man deception.
>>>>>>>>>
>>>>>>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
>>>>>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
>>>>>>>
>>>>>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer.
>>>>>> That is a stupid thing to say there is no luck in correct algorithm design.
>>>>>
>>>>> When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
>>>>>
>>>>>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
>>>>>> Yes it does. Every time that the pattern is correctly matched the
>>>>>> behavior is non-terminating.
>>>>>
>>>>> Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
>>>>>
>>>>> And from there it follows what I said below:
>>>>>
>>>>>>>
>>>>>>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
>>>>>>>
>>>>>>> Agreed?
>>>>>> It is ridiculously stupid (or flat out dishonest) of you to compare an
>>>>>> intentionally broken halt decider with one that is correct.
>>>>>
>>>>> But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
>>>>>
>>>> The criteria has been extensively reviewed and validated.
>>>
>>> FALSE. You *claim* it is correct but it is not, as several people pointed out several times the problem with your criteria 3 which you have *still* failed to respond to. The criteria is proved incorrect by Ha(Pa,Pa)==0 when Pa(Pa) halts.
>>>
>>>>> And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
>>>>>
>>>>> Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
>>>>>
>>>
>>> Deceptive use of "H" and "P" coming to refer to multiple unrelated computations:
>>>
>> H(P,P) correctly predicts that a correct and complete simulation of its
>> input never halts. All correct simulating halt deciders work this same way.
>
> FALSE, because a correct and complete simulation of the input to Ha(Pa,Pa), i.e. UTM(Pa,Pa) halts, therefore Ha(Pa,Pa)==0 is wrong.
>

H(P,P) correctly predicts that a correct and complete simulation of its
input never halts:

void P(ptr x)
{ // this right here:
int Halt_Status = Simulate(x, x);

if (Halt_Status)
HERE: goto HERE;
return;
}

UTM(P,P) is not a correct simulation of the input to H(P,P) because it
is at an incorrect placement in the execution trace.

P is intentionally designed to make its have different behavior
depending on where it is invoked.

--
Copyright 2022 Pete Olcott

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

On Friday, August 12, 2022 at 7:45:29 PM UTC-4, olcott wrote:
> On 8/12/2022 11:09 AM, Dennis Bush wrote:
> > On Friday, August 12, 2022 at 11:44:37 AM UTC-4, olcott wrote:
> >> On 8/12/2022 9:55 AM, Dennis Bush wrote:
> >>> On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
> >>>> On 8/12/2022 7:03 AM, Dennis Bush wrote:
> >>>>> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
> >>>>>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
> >>>>>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
> >>>>>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> ...
> >>>>>>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
> >>>>>>>>>>>>>> its call to H(P,P).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
> >>>>>>>>>>>> I have never even implied that my criteria is incorrect.
> >>>>>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
> >>>>>>>>>>>>
> >>>>>>>>>>>> Example 02:
> >>>>>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
> >>>>>>>>>>>
> >>>>>>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
> >>>>>>>>>>>
> >>>>>>>>>>> Let's test that logic on Ha3,
> >>>>>>>>>> In other words you are saying let's dishonestly change the subject using
> >>>>>>>>>> the straw man deception.
> >>>>>>>>>
> >>>>>>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
> >>>>>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
> >>>>>>>
> >>>>>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer.
> >>>>>> That is a stupid thing to say there is no luck in correct algorithm design.
> >>>>>
> >>>>> When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
> >>>>>
> >>>>>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
> >>>>>> Yes it does. Every time that the pattern is correctly matched the
> >>>>>> behavior is non-terminating.
> >>>>>
> >>>>> Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
> >>>>>
> >>>>> And from there it follows what I said below:
> >>>>>
> >>>>>>>
> >>>>>>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
> >>>>>>>
> >>>>>>> Agreed?
> >>>>>> It is ridiculously stupid (or flat out dishonest) of you to compare an
> >>>>>> intentionally broken halt decider with one that is correct.
> >>>>>
> >>>>> But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
> >>>>>
> >>>> The criteria has been extensively reviewed and validated.
> >>>
> >>> FALSE. You *claim* it is correct but it is not, as several people pointed out several times the problem with your criteria 3 which you have *still* failed to respond to. The criteria is proved incorrect by Ha(Pa,Pa)==0 when Pa(Pa) halts.
> >>>
> >>>>> And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
> >>>>>
> >>>>> Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
> >>>>>
> >>>
> >>> Deceptive use of "H" and "P" coming to refer to multiple unrelated computations:
> >>>
> >> H(P,P) correctly predicts that a correct and complete simulation of its
> >> input never halts. All correct simulating halt deciders work this same way.
> >
> > FALSE, because a correct and complete simulation of the input to Ha(Pa,Pa), i.e. UTM(Pa,Pa) halts, therefore Ha(Pa,Pa)==0 is wrong.
> >
>

Incoming: deceptive use of "H" and "P" to refer to multiple unrelated computations.

> H(P,P) correctly predicts that a correct and complete simulation of its
> input never halts:
>
> void P(ptr x)
> {
> // this right here:
> int Halt_Status = Simulate(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }

Correct, Ha(Pn,Pn) correct predicts that a correct complete simulation of its input never halts. However, this isn't the case Ha needs to get right to refute the halting problem proof.

> UTM(P,P) is not a correct simulation of the input to H(P,P) because it
> is at an incorrect placement in the execution trace.

Algorithms don't have an "execution trace".

>
> P is intentionally designed to make its have different behavior
> depending on where it is invoked.

If Pa does that, then it's not a computation (i.e. not a pure function of its input). And the only way that can be the case is if Ha is not a computation, which means that Ha is disqualified from being a halt decider.

On 8/12/2022 6:51 PM, Dennis Bush wrote:
> On Friday, August 12, 2022 at 7:45:29 PM UTC-4, olcott wrote:
>> On 8/12/2022 11:09 AM, Dennis Bush wrote:
>>> On Friday, August 12, 2022 at 11:44:37 AM UTC-4, olcott wrote:
>>>> On 8/12/2022 9:55 AM, Dennis Bush wrote:
>>>>> On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
>>>>>> On 8/12/2022 7:03 AM, Dennis Bush wrote:
>>>>>>> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
>>>>>>>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
>>>>>>>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>> (3) With no control flow instructions between the invocation of P() and
>>>>>>>>>>>>>>>> its call to H(P,P).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Still actively lying about your results by using a criteria you've implicitly agreed is incorrect by your failure to respond to countless explanations of why this criteria is wrong, I see.
>>>>>>>>>>>>>> I have never even implied that my criteria is incorrect.
>>>>>>>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Example 02:
>>>>>>>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you claim that the criteria that Ha uses is correct because it can correctly detect that Infinite_Recursion does not halt?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Let's test that logic on Ha3,
>>>>>>>>>>>> In other words you are saying let's dishonestly change the subject using
>>>>>>>>>>>> the straw man deception.
>>>>>>>>>>>
>>>>>>>>>>> It's not my problem that you don't understand explanations as to why your criteria is wrong.
>>>>>>>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
>>>>>>>>>
>>>>>>>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right answer.
>>>>>>>> That is a stupid thing to say there is no luck in correct algorithm design.
>>>>>>>
>>>>>>> When I say "luck", I mean a case where an incorrect criteria happened give the correct answer in one case, such as this one.
>>>>>>>
>>>>>>>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
>>>>>>>> Yes it does. Every time that the pattern is correctly matched the
>>>>>>>> behavior is non-terminating.
>>>>>>>
>>>>>>> Which means you're saying that any decider D that answers D(Infinite_Recursion)==0 has a correct pattern.
>>>>>>>
>>>>>>> And from there it follows what I said below:
>>>>>>>
>>>>>>>>>
>>>>>>>>> If you think that a decider correctly determining that Infinite_Recursion means that its halt criteria is correct, then according to you the fact that Ha3(Infinite_Recursion)==0 is correct proves its halt criteria correct, making Ha3(N,5)==0 correct.
>>>>>>>>>
>>>>>>>>> Agreed?
>>>>>>>> It is ridiculously stupid (or flat out dishonest) of you to compare an
>>>>>>>> intentionally broken halt decider with one that is correct.
>>>>>>>
>>>>>>> But you said that any decider D that answers D(Infinite_Recursion)==0 is correct. And since Ha3(Infinite_Recursion)==0 then according to you it's criteria is correct and therefore Ha3(N,5)==0 is correct.
>>>>>>>
>>>>>> The criteria has been extensively reviewed and validated.
>>>>>
>>>>> FALSE. You *claim* it is correct but it is not, as several people pointed out several times the problem with your criteria 3 which you have *still* failed to respond to. The criteria is proved incorrect by Ha(Pa,Pa)==0 when Pa(Pa) halts.
>>>>>
>>>>>>> And since you don't agree that Ha3 is correct, than mean it is NOT true that any decider D that answers D(Infinite_Recursion)==0 is correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT proof that its criteria is correct.
>>>>>>>
>>>>>>> Your Ha and my Ha3 are both broken in exactly the same way: they both abort too soon and report some halting computations as non-halting. It's just more obvious that Ha3 is wrong.
>>>>>>>
>>>>>
>>>>> Deceptive use of "H" and "P" coming to refer to multiple unrelated computations:
>>>>>
>>>> H(P,P) correctly predicts that a correct and complete simulation of its
>>>> input never halts. All correct simulating halt deciders work this same way.
>>>
>>> FALSE, because a correct and complete simulation of the input to Ha(Pa,Pa), i.e. UTM(Pa,Pa) halts, therefore Ha(Pa,Pa)==0 is wrong.
>>>
>>
>
> Incoming: deceptive use of "H" and "P" to refer to multiple unrelated computations.
>
>> H(P,P) correctly predicts that a correct and complete simulation of its
>> input never halts:
>>
>> void P(ptr x)
>> {
>> // this right here:
>> int Halt_Status = Simulate(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>
> Correct, Ha(Pn,Pn) correct predicts that a correct complete simulation of its input never halts. However, this isn't the case Ha needs to get right to refute the halting problem proof.

By changing the names it is not clear what you Are referring to.

H is always correct to reject any input that it correctly predicts
would never stop running if it were to perform a correct and complete
simulation on its input.

It can do this by performing a correct partial simulation of this input
on the basis of correctly matching behavior patterns that are known
to never halt.

>
>> UTM(P,P) is not a correct simulation of the input to H(P,P) because it
>> is at an incorrect placement in the execution trace.
>
> Algorithms don't have an "execution trace".

When any algorithm is implemented as a TM it has a sequence of moves:
state transitions and and movements of its tape head.

>
>>
>> P is intentionally designed to make its have different behavior
>> depending on where it is invoked.
>
> If Pa does that, then it's not a computation (i.e. not a pure function of its input).

That is the whole point. Only H must be a computation, its non-halting
input cannot be a computation because it is non-halting.

> And the only way that can be the case is if Ha is not a computation,
> which means that Ha is disqualified from being a halt decider.

That the input to a halt decider is non-halting does not freaking
prevent the halt decider itself from being a computation, how dumb can
you get?

--
Copyright 2022 Pete Olcott

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

On 8/12/22 7:45 PM, olcott wrote:
> On 8/12/2022 11:09 AM, Dennis Bush wrote:
>> On Friday, August 12, 2022 at 11:44:37 AM UTC-4, olcott wrote:
>>> On 8/12/2022 9:55 AM, Dennis Bush wrote:
>>>> On Friday, August 12, 2022 at 10:40:25 AM UTC-4, olcott wrote:
>>>>> On 8/12/2022 7:03 AM, Dennis Bush wrote:
>>>>>> On Friday, August 12, 2022 at 2:21:52 AM UTC-4, olcott wrote:
>>>>>>> On 8/11/2022 12:10 PM, Dennis Bush wrote:
>>>>>>>> On Thursday, August 11, 2022 at 12:53:54 PM UTC-4, olcott wrote:
>>>>>>>>> On 8/11/2022 11:42 AM, Dennis Bush wrote:
>>>>>>>>>> On Thursday, August 11, 2022 at 10:47:33 AM UTC-4, olcott wrote:
>>>>>>>>>>> On 8/11/2022 9:22 AM, Dennis Bush wrote:
>>>>>>>>>>>> On Thursday, August 11, 2022 at 10:11:56 AM UTC-4, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 8/11/2022 8:55 AM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Thursday, August 11, 2022 at 9:35:32 AM UTC-4, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>> (3) With no control flow instructions between the
>>>>>>>>>>>>>>> invocation of P() and
>>>>>>>>>>>>>>> its call to H(P,P).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Still actively lying about your results by using a
>>>>>>>>>>>>>> criteria you've implicitly agreed is incorrect by your
>>>>>>>>>>>>>> failure to respond to countless explanations of why this
>>>>>>>>>>>>>> criteria is wrong, I see.
>>>>>>>>>>>>> I have never even implied that my criteria is incorrect.
>>>>>>>>>>>>> *HERE IS PROOF THAT THE SAME CRITERIA IS CORRECT*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Example 02:
>>>>>>>>>>>>> *H correctly determines that Infinite_Recursion() never halts*
>>>>>>>>>>>>
>>>>>>>>>>>> So you claim that the criteria that Ha uses is correct
>>>>>>>>>>>> because it can correctly detect that Infinite_Recursion does
>>>>>>>>>>>> not halt?
>>>>>>>>>>>>
>>>>>>>>>>>> Let's test that logic on Ha3,
>>>>>>>>>>> In other words you are saying let's dishonestly change the
>>>>>>>>>>> subject using
>>>>>>>>>>> the straw man deception.
>>>>>>>>>>
>>>>>>>>>> It's not my problem that you don't understand explanations as
>>>>>>>>>> to why your criteria is wrong.
>>>>>>>>> Try to point out any error with: H(Infinite_Recursion, 0x777);
>>>>>>>>
>>>>>>>> Ha(Infinite_Recursion, 0x777) got lucky with getting the right
>>>>>>>> answer.
>>>>>>> That is a stupid thing to say there is no luck in correct
>>>>>>> algorithm design.
>>>>>>
>>>>>> When I say "luck", I mean a case where an incorrect criteria
>>>>>> happened give the correct answer in one case, such as this one.
>>>>>>
>>>>>>>> The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.
>>>>>>> Yes it does. Every time that the pattern is correctly matched the
>>>>>>> behavior is non-terminating.
>>>>>>
>>>>>> Which means you're saying that any decider D that answers
>>>>>> D(Infinite_Recursion)==0 has a correct pattern.
>>>>>>
>>>>>> And from there it follows what I said below:
>>>>>>
>>>>>>>>
>>>>>>>> If you think that a decider correctly determining that
>>>>>>>> Infinite_Recursion means that its halt criteria is correct, then
>>>>>>>> according to you the fact that Ha3(Infinite_Recursion)==0 is
>>>>>>>> correct proves its halt criteria correct, making Ha3(N,5)==0
>>>>>>>> correct.
>>>>>>>>
>>>>>>>> Agreed?
>>>>>>> It is ridiculously stupid (or flat out dishonest) of you to
>>>>>>> compare an
>>>>>>> intentionally broken halt decider with one that is correct.
>>>>>>
>>>>>> But you said that any decider D that answers
>>>>>> D(Infinite_Recursion)==0 is correct. And since
>>>>>> Ha3(Infinite_Recursion)==0 then according to you it's criteria is
>>>>>> correct and therefore Ha3(N,5)==0 is correct.
>>>>>>
>>>>> The criteria has been extensively reviewed and validated.
>>>>
>>>> FALSE. You *claim* it is correct but it is not, as several people
>>>> pointed out several times the problem with your criteria 3 which you
>>>> have *still* failed to respond to. The criteria is proved incorrect
>>>> by Ha(Pa,Pa)==0 when Pa(Pa) halts.
>>>>
>>>>>> And since you don't agree that Ha3 is correct, than mean it is NOT
>>>>>> true that any decider D that answers D(Infinite_Recursion)==0 is
>>>>>> correct, and therefore Ha(Infinite_Recursion, 0x777)==0 is NOT
>>>>>> proof that its criteria is correct.
>>>>>>
>>>>>> Your Ha and my Ha3 are both broken in exactly the same way: they
>>>>>> both abort too soon and report some halting computations as
>>>>>> non-halting. It's just more obvious that Ha3 is wrong.
>>>>>>
>>>>
>>>> Deceptive use of "H" and "P" coming to refer to multiple unrelated
>>>> computations:
>>>>
>>> H(P,P) correctly predicts that a correct and complete simulation of its
>>> input never halts. All correct simulating halt deciders work this
>>> same way.
>>
>> FALSE, because a correct and complete simulation of the input to
>> Ha(Pa,Pa), i.e. UTM(Pa,Pa) halts, therefore Ha(Pa,Pa)==0 is wrong.
>>
>
> H(P,P) correctly predicts that a correct and complete simulation of its
> input never halts:

Nope, UTM(P,P) does, and that shows P(P) Halts, unless of course, you H
isn't actually a computation, and thus not a Decider.

>
> void P(ptr x)
> {
> // this right here:
>   int Halt_Status = Simulate(x, x);
>
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> UTM(P,P) is not a correct simulation of the input to H(P,P) because it
> is at an incorrect placement in the execution trace.

Then H isn't a decider, because it isn't a "Computation" because it
doesn't depend on just its input.

So, you are admitting FAILURE.

>
> P is intentionally designed to make its have different behavior
> depending on where it is invoked.
>

Nope. P CAN'T have different behavior depending on where it is invoked,
if H is a Pure Function, as P has no way to even KNOW how it was invoked.

Thus, if P does depend on how it was invoked, you just admitted that H
depends on how it was invoked, which mean that it isn't a Computation,
because its output in not just a function of its input, the
representation of P and P.

Thus, you H isn't a Decider, so can't be a Halt Decider.

There you go wasting 18 years of your life down the drain.

Maybe if you understood the requirements to be a Computation, you might
not have wasted your life on a lie.

olcott <NoOne@NoWhere.com> wrote:

> On 8/12/2022 6:26 AM, Otto J. Makela wrote:
>> Just to understand how you define this to be a working H(), when
>> void P(ptr x) {
>> return;
>> }
>> What does H(H,P) return?
>
> It returns 1. for halting.

I am somewhat surprised by this.
H(P,P) returning "halting" I can understand.

How does H(H,P) end up returning "halting" since it simulates itself and
you said "every case that has conditional branches is excluded from my
implementation" — conditional branches surely do come up here, or did I
misunderstand what this means?

--
/* * * Otto J. Makela <om@iki.fi> * * * * * * * * * */
/* Phone: +358 40 765 5772, ICBM: N 60 10' E 24 55' */
/* Mail: Mechelininkatu 26 B 27, FI-00100 Helsinki */
/* * * Computers Rule 01001111 01001011 * * * * * * */

On 8/15/2022 8:36 AM, Otto J. Makela wrote:
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/12/2022 6:26 AM, Otto J. Makela wrote:
>>> Just to understand how you define this to be a working H(), when
>>> void P(ptr x) {
>>> return;
>>> }
>>> What does H(H,P) return?
>>

This is semantically incorrect, P does not have its argument.

>> It returns 1. for halting.
>
> I am somewhat surprised by this.
> H(P,P) returning "halting" I can understand.
>
> How does H(H,P) end up returning "halting" since it simulates itself and
> you said "every case that has conditional branches is excluded from my
> implementation" — conditional branches surely do come up here, or did I
> misunderstand what this means?
>

--
Copyright 2022 Pete Olcott

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