On 8/10/2022 4:42 PM, dklei...@gmail.com wrote:
> On Wednesday, August 10, 2022 at 1:55:17 PM UTC-7, olcott wrote:
>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>>> olcott <No...@NoWhere.com> wrote:
>>>
>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>>>>>>> I assume also a direct call of H(H,H) will produce the same
>>>>>>> "non-halting" result?
>>>>>> That is not in the domain of H.
>>>>> Your halting decider H() will only work for a subset of halting
>>>>> problems, any cases including itself (or programs using similar
>>>>> methodology) are excluded?
>>>>
>>>> Every case that has conditional branches is excluded from my
>>>> implementation, yet not excluded from my underlying theory. It simply
>>>> takes too much more time to correctly handle conditional branches in
>>>> working code.
>>>
>>> I see.
>>>
>>> Why don't you get back to us once you've implemented also this part,
>>> because without it, this is not even a toy implementation?
>>>
>> Because it is moot. I have proven that H does correctly determine the
>> halt status of the HP's impossible input, thus correctly refuted these
>> proofs.
>
> Once again - just exactly what are you trying to prove?

You must be brain dead.

--
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/10/22 4:55 PM, olcott wrote:
> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>>>>>> I assume also a direct call of H(H,H) will produce the same
>>>>>> "non-halting" result?
>>>>> That is not in the domain of H.
>>>> Your halting decider H() will only work for a subset of halting
>>>> problems, any cases including itself (or programs using similar
>>>> methodology) are excluded?
>>>
>>> Every case that has conditional branches is excluded from my
>>> implementation, yet not excluded from my underlying theory. It simply
>>> takes too much more time to correctly handle conditional branches in
>>> working code.
>>
>> I see.
>>
>> Why don't you get back to us once you've implemented also this part,
>> because without it, this is not even a toy implementation?
>>
>
> Because it is moot. I have proven that H does correctly determine the
> halt status of the HP's impossible input, thus correctly refuted these
> proofs.
>

No, because P(P) Hslts, so H(P,P) MUST return 1 to be correct, but it
returns 0.

If you say that the input to H(P,P) is not the representaiton of P(P),
then you are just admitting you have been lying this whole time about
working on the Halting Problem, as P calls H(P,P) to ask that question.

You hav been caught in your lie, and your only out is to plead ignorance.

On 8/10/22 9:33 AM, olcott wrote:
> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/9/2022 7:27 AM, Otto J. Makela wrote:
>>>> What is the result of H(P,P) with the following definition of P?
>>>> ----
>>>> void P(ptr x) {
>>>>      int Halt_Status = H(x, x);
>>>>      return;
>>>> }
>>>
>>> Same result as detailed below. This version of H detects what is
>>> essentially infinite recursion with itself as the first call of this
>>> recursive sequence.
>>
>> I assume also a direct call of H(H,H) will produce the same
>> "non-halting" result?
>>
>
> That is not in the domain of H.
>
>> The fact that your halting detector H() detects itself as infinitely
>> recursive
>
> H(P,P) is not detecting itself as infinitely recursive, it is detecting
> the P is called it in infinite recursion.
>
> < (although it under normal circumstances produce a result,
>
> No function called in infinite recursion ever returns to its caller.

And no pure function that is part of an infinite recursion returns to
ANY caller.

If P -> H -> P -> H -> P ... forms an infinite recursion, and H is a
pure function then any call to H like A -> H must proceed as

A -> H -> P -> H -> P ... in infinite recursion.

If it doesn't, then H is shown to NOT be a pure function.

That is your problem.

Note, your arguement also fails because it has been demonstrated that:
(note -> is a call, => is a simulation)

main -> H(P,P) => P(P) -> H(P,P) and the simulation is aborts and
returns 0 to main, and that

main -> P(P) -> H(P,P) => P(P) -> H(P,P) also triggers the first called
H to abort its simulation and returns 0 to P(P) which returns to main,
showing that P(P) Halts.

The only case that shows the infinite recrusion is that H *THINKS* that
its simulation would be:

H(P,P) => P(P) -> H(P,P) => P(P) -> H(P,P) => P(P) ...

but that is an INCORRECT determination as we have shown that a CORRECT
simulation of the input would be:

UTM(P,P) => P(P) -> H(P,P) => P(P) -> H(P,P) and the first H(P,P), the
one being simulated by the UTM decides (incorrectly) that it will be
caught in the above (incorrect) loop and aborts its simulation,
returning to the first simulated P(P) which reaches its final state and
halts.

>
>> without infinite recursion) would seem to indicate it does not always
>> produce correct results as originally defined.
>>
>
> H1(P,P) returns 1.
>
>> I believe I understand the halting problem sufficiently to claim this is
>> one aspect of the impossibilty of creating a true halting detector.
>>
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
>    For any program H that might determine if programs halt, a
>    "pathological" program P, called with some input, can pass
>    its own source and its input to H and then specifically do the
>    opposite of what H predicts P will do.
>    *No H can exist that handles this case*
>    https://en.wikipedia.org/wiki/Halting_problem
>
> H and P implement the exact pathological relationship to each
> other as described above. Because H(P,P) does handle this
> case the above halting problem undecidable input template has
> been refuted.
>
>

But it DOESN'T, since P(P) HALTS, but H(P,P) says it doesn't

On 8/10/22 4:55 PM, olcott wrote:
> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>>>>>> I assume also a direct call of H(H,H) will produce the same
>>>>>> "non-halting" result?
>>>>> That is not in the domain of H.
>>>> Your halting decider H() will only work for a subset of halting
>>>> problems, any cases including itself (or programs using similar
>>>> methodology) are excluded?
>>>
>>> Every case that has conditional branches is excluded from my
>>> implementation, yet not excluded from my underlying theory. It simply
>>> takes too much more time to correctly handle conditional branches in
>>> working code.
>>
>> I see.
>>
>> Why don't you get back to us once you've implemented also this part,
>> because without it, this is not even a toy implementation?
>>
>
> Because it is moot. I have proven that H does correctly determine the
> halt status of the HP's impossible input, thus correctly refuted these
> proofs.
>

No, you haven't, since its answer doesn't agree with the behavior of the
machine its input represents.

On Wednesday, August 10, 2022 at 2:50:12 PM UTC-7, olcott wrote:
> On 8/10/2022 4:42 PM, dklei...@gmail.com wrote:
> > On Wednesday, August 10, 2022 at 1:55:17 PM UTC-7, olcott wrote:
> >> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
> >>> olcott <No...@NoWhere.com> wrote:
> >>>
> >>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
> >>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
> >>>>>>> I assume also a direct call of H(H,H) will produce the same
> >>>>>>> "non-halting" result?
> >>>>>> That is not in the domain of H.
> >>>>> Your halting decider H() will only work for a subset of halting
> >>>>> problems, any cases including itself (or programs using similar
> >>>>> methodology) are excluded?
> >>>>
> >>>> Every case that has conditional branches is excluded from my
> >>>> implementation, yet not excluded from my underlying theory. It simply
> >>>> takes too much more time to correctly handle conditional branches in
> >>>> working code.
> >>>
> >>> I see.
> >>>
> >>> Why don't you get back to us once you've implemented also this part,
> >>> because without it, this is not even a toy implementation?
> >>>
> >> Because it is moot. I have proven that H does correctly determine the
> >> halt status of the HP's impossible input, thus correctly refuted these
> >> proofs.
> >
> > Once again - just exactly what are you trying to prove?
> You must be brain dead.
>
I'm old but still living.
>
Do you imagine that the paragraph I questioned is a statement than might
be proven or disproven?

On 8/10/2022 11:19 PM, dklei...@gmail.com wrote:
> On Wednesday, August 10, 2022 at 2:50:12 PM UTC-7, olcott wrote:
>> On 8/10/2022 4:42 PM, dklei...@gmail.com wrote:
>>> On Wednesday, August 10, 2022 at 1:55:17 PM UTC-7, olcott wrote:
>>>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>>>>>>>>> I assume also a direct call of H(H,H) will produce the same
>>>>>>>>> "non-halting" result?
>>>>>>>> That is not in the domain of H.
>>>>>>> Your halting decider H() will only work for a subset of halting
>>>>>>> problems, any cases including itself (or programs using similar
>>>>>>> methodology) are excluded?
>>>>>>
>>>>>> Every case that has conditional branches is excluded from my
>>>>>> implementation, yet not excluded from my underlying theory. It simply
>>>>>> takes too much more time to correctly handle conditional branches in
>>>>>> working code.
>>>>>
>>>>> I see.
>>>>>
>>>>> Why don't you get back to us once you've implemented also this part,
>>>>> because without it, this is not even a toy implementation?
>>>>>
>>>> Because it is moot. I have proven that H does correctly determine the
>>>> halt status of the HP's impossible input, thus correctly refuted these
>>>> proofs.
>>>
>>> Once again - just exactly what are you trying to prove?
>> You must be brain dead.
>>
> I'm old but still living.
>>
> Do you imagine that the paragraph I questioned is a statement than might
> be proven or disproven?

I spent thousands of hours on it, it is proven.
H(P,P) correctly maps the behavior of its first argument to its own
reject state on the basis that the correct simulation that H(P,P)
performs on its first argument:

(a) Would never reach its "return" instruction (final state).
or

(b) on the basis the its simulation only stops running when it had been
aborted by H.

*This is the proof even if no one here besides me understands it*

Example 03: H(P,P) correctly determines that its input never halts

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

_P()

machine machine assembly
address code language
======== ======== ======================
[000013c6](01) 55 push ebp // Save Base Pointer
register onto the stack
[000013c7](02) 8bec mov ebp,esp // Load Base Pointer
with Stack Pointer
[000013c9](01) 51 push ecx // Save the value of
ecx on the stack
[000013ca](03) 8b4508 mov eax,[ebp+08] // Load eax with
argument to P
[000013cd](01) 50 push eax // push 2nd argument
to H onto the stack
[000013ce](03) 8b4d08 mov ecx,[ebp+08] // Load ecx with with
argument to P
[000013d1](01) 51 push ecx // push 1st argument
to H onto the stack
[000013d2](05) e82ffdffff call 00001106 // push return address
on the stack; call simulated H
[000013d7](03) 83c408 add esp,+08 // remove call
arguments from stack
[000013da](03) 8945fc mov [ebp-04],eax // load Halt_Status
with return value from H
[000013dd](04) 837dfc00 cmp dword [ebp-04],+00 // compare Halt_Status
to 0
[000013e1](02) 7402 jz 000013e5 // if Halt_Status == 0
goto 000013e5
[000013e3](02) ebfe jmp 000013e3 // goto 13e3
[000013e5](02) 8be5 mov esp,ebp // Load Stack Pointer
with Base Pointer
[000013e7](01) 5d pop ebp // Restore Base
Pointer value from stack
[000013e8](01) c3 ret // return to caller
Size in bytes:(0035) [000013e8]

_main()
[000013f6](01) 55 push ebp // Save Base Pointer register
onto the stack
[000013f7](02) 8bec mov ebp,esp // Load Base Pointer with Stack
Pointer
[000013f9](05) 68c6130000 push 000013c6 // Push P (2nd argument to H)
onto the stack
[000013fe](05) 68c6130000 push 000013c6 // Push P (1nd argument to H)
onto the stack
[00001403](05) e8fefcffff call 00001106 // push return address onto the
stack and call executed H
[00001408](03) 83c408 add esp,+08 // remove call arguments from
stack frame
[0000140b](01) 50 push eax // Push return value from H
onto the stack
[0000140c](05) 6837050000 push 00000537 // Push address of "Input_Halts
= " onto the stack
[00001411](05) e870f1ffff call 00000586 // call Output with its pushed
arguments.
[00001416](03) 83c408 add esp,+08 // remove call arguments from
stack frame
[00001419](02) 33c0 xor eax,eax // set eax to 0
[0000141b](01) 5d pop ebp // Restore Base Pointer
register from stack
[0000141c](01) c3 ret // return to 0 operating system
Size in bytes:(0039) [0000141c]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000013f6][0010235f][00000000] 55 push ebp
[000013f7][0010235f][00000000] 8bec mov ebp,esp
[000013f9][0010235b][000013c6] 68c6130000 push 000013c6 // Push P (2nd
argument to H) onto the stack
[000013fe][00102357][000013c6] 68c6130000 push 000013c6 // Push P (1nd
argument to H) onto the stack
[00001403][00102353][00001408] e8fefcffff call 00001106 // push return
address; call executed H

H: Begin Simulation Execution Trace Stored at:11240b
Address_of_H:1106
[000013c6][001123f7][001123fb] 55 push ebp
[000013c7][001123f7][001123fb] 8bec mov ebp,esp
[000013c9][001123f3][001023c7] 51 push ecx // Save the
value of ecx on the stack
[000013ca][001123f3][001023c7] 8b4508 mov eax,[ebp+08] // Load eax
with argument to P
[000013cd][001123ef][000013c6] 50 push eax // push 2nd
argument to H onto the stack
[000013ce][001123ef][000013c6] 8b4d08 mov ecx,[ebp+08] // Load ecx
with with argument to P
[000013d1][001123eb][000013c6] 51 push ecx // push 1st
argument to H onto the stack
[000013d2][001123e7][000013d7] e82ffdffff call 00001106 // push
return address; call simulated H
H: Infinitely Recursive Simulation Detected Simulation Stopped

(1) Function H() is called from P().
(2) With the same arguments to H().
(3) With no control flow instructions in P preceding its invocation of
H(P,P) that could escape repeated simulations.

[00001408][0010235f][00000000] 83c408 add esp,+08
[0000140b][0010235b][00000000] 50 push eax // Push return
value from H onto the stack
[0000140c][00102357][00000537] 6837050000 push 00000537 // Push address
of "Input_Halts = " onto stack
[00001411][00102357][00000537] e870f1ffff call 00000586 // call Output
with its pushed arguments
Input_Halts = 0
[00001416][0010235f][00000000] 83c408 add esp,+08
[00001419][0010235f][00000000] 33c0 xor eax,eax // set eax to 0
[0000141b][00102363][00000018] 5d pop ebp
[0000141c][00102367][00000000] c3 ret // return to 0
operating system
Number of Instructions Executed(987) == 15 Pages

--
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/11/22 12:30 AM, olcott wrote:
> On 8/10/2022 11:19 PM, dklei...@gmail.com wrote:
>> On Wednesday, August 10, 2022 at 2:50:12 PM UTC-7, olcott wrote:
>>> On 8/10/2022 4:42 PM, dklei...@gmail.com wrote:
>>>> On Wednesday, August 10, 2022 at 1:55:17 PM UTC-7, olcott wrote:
>>>>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>>>>>>>>>> I assume also a direct call of H(H,H) will produce the same
>>>>>>>>>> "non-halting" result?
>>>>>>>>> That is not in the domain of H.
>>>>>>>> Your halting decider H() will only work for a subset of halting
>>>>>>>> problems, any cases including itself (or programs using similar
>>>>>>>> methodology) are excluded?
>>>>>>>
>>>>>>> Every case that has conditional branches is excluded from my
>>>>>>> implementation, yet not excluded from my underlying theory. It
>>>>>>> simply
>>>>>>> takes too much more time to correctly handle conditional branches in
>>>>>>> working code.
>>>>>>
>>>>>> I see.
>>>>>>
>>>>>> Why don't you get back to us once you've implemented also this part,
>>>>>> because without it, this is not even a toy implementation?
>>>>>>
>>>>> Because it is moot. I have proven that H does correctly determine the
>>>>> halt status of the HP's impossible input, thus correctly refuted these
>>>>> proofs.
>>>>
>>>> Once again - just exactly what are you trying to prove?
>>> You must be brain dead.
>>>
>> I'm old but still living.
>>>
>> Do you imagine that the paragraph I questioned is a statement than might
>> be proven or disproven?
>
> I spent thousands of hours on it, it is proven.

You have WASTED Thousands of Hours.

> H(P,P) correctly maps the behavior of its first argument to its own
> reject state on the basis that the correct simulation that H(P,P)
> performs on its first argument:

Which is incorrect, as even YOU have proven that a CORRECT and COMPLETE
simulation of the input to H(P,P) [by an actual UTM, not H] will reach
that final state for the H you have provided that returns 0 for H(P,P)

THe fact that H can't do the

>
> (a) Would never reach its "return" instruction (final state).
> or
>
> (b) on the basis the its simulation only stops running when it had been
> aborted by H.
>
> *This is the proof even if no one here besides me understands it*

You don't understand what you proof is says because you don't know the
meaning of the words.

What you have proved is that you can't design an H that can PROVE that
the P(P) built on it will halt, not that this P(P) doesn't Halt.

>
> Example 03:     H(P,P) correctly determines that its input never halts
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ",  H(P, P));
> }
>
> _P()
>
>  machine        machine   assembly
>  address        code      language
>  ========       ========  ======================
> [000013c6](01)  55         push ebp               // Save Base Pointer
> register onto the stack
> [000013c7](02)  8bec       mov ebp,esp            // Load Base Pointer
> with Stack Pointer
> [000013c9](01)  51         push ecx               // Save the value of
> ecx on the stack
> [000013ca](03)  8b4508     mov eax,[ebp+08]       // Load eax with
> argument to P
> [000013cd](01)  50         push eax               // push 2nd argument
> to H onto the stack
> [000013ce](03)  8b4d08     mov ecx,[ebp+08]       // Load ecx with with
> argument to P
> [000013d1](01)  51         push ecx               // push 1st argument
> to H onto the stack
> [000013d2](05)  e82ffdffff call 00001106          // push return address
> on the stack; call simulated H
> [000013d7](03)  83c408     add esp,+08            // remove call
> arguments from stack
> [000013da](03)  8945fc     mov [ebp-04],eax       // load Halt_Status
> with return value from H
> [000013dd](04)  837dfc00   cmp dword [ebp-04],+00 // compare Halt_Status
> to 0
> [000013e1](02)  7402       jz 000013e5            // if Halt_Status == 0
> goto 000013e5
> [000013e3](02)  ebfe       jmp 000013e3           // goto 13e3
> [000013e5](02)  8be5       mov esp,ebp            // Load Stack Pointer
> with Base Pointer
> [000013e7](01)  5d         pop ebp                // Restore Base
> Pointer value from stack
> [000013e8](01)  c3         ret                    // return to caller
> Size in bytes:(0035) [000013e8]
>
> _main()
> [000013f6](01)  55         push ebp      // Save Base Pointer register
> onto the stack
> [000013f7](02)  8bec       mov ebp,esp   // Load Base Pointer with Stack
> Pointer
> [000013f9](05)  68c6130000 push 000013c6 // Push P (2nd argument to H)
> onto the stack
> [000013fe](05)  68c6130000 push 000013c6 // Push P (1nd argument to H)
> onto the stack
> [00001403](05)  e8fefcffff call 00001106 // push return address onto the
> stack and call executed H
> [00001408](03)  83c408     add esp,+08   // remove call arguments from
> stack frame
> [0000140b](01)  50         push eax      // Push return value from H
> onto the stack
> [0000140c](05)  6837050000 push 00000537 // Push address of "Input_Halts
> = " onto the stack
> [00001411](05)  e870f1ffff call 00000586 // call Output with its pushed
> arguments.
> [00001416](03)  83c408     add esp,+08   // remove call arguments from
> stack frame
> [00001419](02)  33c0       xor eax,eax   // set eax to 0
> [0000141b](01)  5d         pop ebp       // Restore Base Pointer
> register from stack
> [0000141c](01)  c3         ret           // return to 0 operating system
> Size in bytes:(0039) [0000141c]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [000013f6][0010235f][00000000] 55         push ebp
> [000013f7][0010235f][00000000] 8bec       mov ebp,esp
> [000013f9][0010235b][000013c6] 68c6130000 push 000013c6 // Push P (2nd
> argument to H) onto the stack
> [000013fe][00102357][000013c6] 68c6130000 push 000013c6 // Push P (1nd
> argument to H) onto the stack
> [00001403][00102353][00001408] e8fefcffff call 00001106 // push return
> address; call executed H
>
> H: Begin Simulation   Execution Trace Stored at:11240b
> Address_of_H:1106
> [000013c6][001123f7][001123fb] 55         push ebp
> [000013c7][001123f7][001123fb] 8bec       mov ebp,esp
> [000013c9][001123f3][001023c7] 51         push ecx         // Save the
> value of ecx on the stack
> [000013ca][001123f3][001023c7] 8b4508     mov eax,[ebp+08] // Load eax
> with argument to P
> [000013cd][001123ef][000013c6] 50         push eax         // push 2nd
> argument to H onto the stack
> [000013ce][001123ef][000013c6] 8b4d08     mov ecx,[ebp+08] // Load ecx
> with with argument to P
> [000013d1][001123eb][000013c6] 51         push ecx         // push 1st
> argument to H onto the stack
> [000013d2][001123e7][000013d7] e82ffdffff call 00001106    // push
> return address; call simulated H
> H: Infinitely Recursive Simulation Detected Simulation Stopped
>
> (1) Function H() is called from P().
> (2) With the same arguments to H().
> (3) With no control flow instructions in P preceding its invocation of
> H(P,P) that could escape repeated simulations.

Which is a FALSE Premise, proving you are ignorant, or a liar, or both.

olcott <NoOne@NoWhere.com> wrote:

> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>> olcott <NoOne@NoWhere.com> wrote:
>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>> Your halting decider H() will only work for a subset of halting
>>>> problems, any cases including itself (or programs using similar
>>>> methodology) are excluded?
>>> Every case that has conditional branches is excluded from my
>>> implementation, yet not excluded from my underlying theory. It
>>> simply takes too much more time to correctly handle conditional
>>> branches in working code.
>> I see.
>> Why don't you get back to us once you've implemented also this part,
>> because without it, this is not even a toy implementation?
>
> Because it is moot. I have proven that H does correctly determine the
> halt status of the HP's impossible input, thus correctly refuted these
> proofs.

A halting detector which purports to work for just this single case
(in part because it IMHO incorrectly reports its own halting status)
and fails in the majority of other cases is not really much of a
halting detector. As I said, not even a toy implementation.
--
/* * * 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/11/2022 6:56 AM, Otto J. Makela wrote:
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>>> olcott <NoOne@NoWhere.com> wrote:
>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>>> Your halting decider H() will only work for a subset of halting
>>>>> problems, any cases including itself (or programs using similar
>>>>> methodology) are excluded?
>>>> Every case that has conditional branches is excluded from my
>>>> implementation, yet not excluded from my underlying theory. It
>>>> simply takes too much more time to correctly handle conditional
>>>> branches in working code.
>>> I see.
>>> Why don't you get back to us once you've implemented also this part,
>>> because without it, this is not even a toy implementation?
>>
>> Because it is moot. I have proven that H does correctly determine the
>> halt status of the HP's impossible input, thus correctly refuted these
>> proofs.
>
> A halting detector which purports to work for just this single case
> (in part because it IMHO incorrectly reports its own halting status)
> and fails in the majority of other cases is not really much of a
> halting detector. As I said, not even a toy implementation.

It is a verified fact that H(P,P) does correctly report that its first
argument would never reach its "return" instruction (final state) and
thus never halt.

(a) H(P,P) simulates P(P) that invokes a simulated H(P,P)
(b) that simulates P(P) that invokes a simulated H(P,P)
(c) that simulates P(P) that invokes a simulated H(P,P)...

*People that knowingly disagree with verified facts are dishonest*

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

void P(ptr x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]

_main()
[00001372](01) 55 push ebp
[00001373](02) 8bec mov ebp,esp
[00001375](05) 6852130000 push 00001352 // push P
[0000137a](05) 6852130000 push 00001352 // push P
[0000137f](05) e81efeffff call 000011a2 // call H
[00001384](03) 83c408 add esp,+08
[00001387](01) 50 push eax
[00001388](05) 6823040000 push 00000423 // "Input_Halts = "
[0000138d](05) e8e0f0ffff call 00000472 // call Output
[00001392](03) 83c408 add esp,+08
[00001395](02) 33c0 xor eax,eax
[00001397](01) 5d pop ebp
[00001398](01) c3 ret
Size in bytes:(0039) [00001398]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[00001372][0010229e][00000000] 55 push ebp
....[00001373][0010229e][00000000] 8bec mov ebp,esp
....[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
....[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
....[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
// H emulates the first seven instructions of P
....[00001352][0021233e][00212342] 55 push ebp // enter P
....[00001353][0021233e][00212342] 8bec mov ebp,esp
....[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
....[00001358][0021233a][00001352] 50 push eax // push P
....[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
....[0000135c][00212336][00001352] 51 push ecx // push P
....[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

// The emulated H emulates the first seven instructions of P
....[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
....[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
....[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
....[00001358][0025cd62][00001352] 50 push eax // push P
....[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
....[0000135c][0025cd5e][00001352] 51 push ecx // push P
....[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*Matched infinite recursion detection criteria*
(1) H(P, P) is called twice in sequence from the same machine address of
P().
(2) With the same arguments to H().
(3) With no control flow instructions between the invocation of P() and
its call to H(P,P).

....[00001384][0010229e][00000000] 83c408 add esp,+08
....[00001387][0010229a][00000000] 50 push eax
....[00001388][00102296][00000423] 6823040000 push 00000423 //
"Input_Halts = "
---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
Input_Halts = 0
....[00001392][0010229e][00000000] 83c408 add esp,+08
....[00001395][0010229e][00000000] 33c0 xor eax,eax
....[00001397][001022a2][00100000] 5d pop ebp
....[00001398][001022a6][00000004] c3 ret
Number of Instructions Executed(15892) = 237 pages

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

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*

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

int main()
{ Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
}

_Infinite_Recursion()
[000010f2](01) 55 push ebp
[000010f3](02) 8bec mov ebp,esp
[000010f5](03) 8b4508 mov eax,[ebp+08]
[000010f8](01) 50 push eax
[000010f9](05) e8f4ffffff call 000010f2
[000010fe](03) 83c404 add esp,+04
[00001101](01) 5d pop ebp
[00001102](01) c3 ret
Size in bytes:(0017) [00001102]

_main()
[000011b2](01) 55 push ebp
[000011b3](02) 8bec mov ebp,esp
[000011b5](05) 6877070000 push 00000777
[000011ba](05) 68f2100000 push 000010f2
[000011bf](05) e8aefdffff call 00000f72
[000011c4](03) 83c408 add esp,+08
[000011c7](01) 50 push eax
[000011c8](05) 68a3040000 push 000004a3
[000011cd](05) e820f3ffff call 000004f2
[000011d2](03) 83c408 add esp,+08
[000011d5](02) 33c0 xor eax,eax
[000011d7](01) 5d pop ebp
[000011d8](01) c3 ret
Size in bytes:(0039) [000011d8]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000011b2][00101f39][00000000] 55 push ebp
[000011b3][00101f39][00000000] 8bec mov ebp,esp
[000011b5][00101f35][00000777] 6877070000 push 00000777
[000011ba][00101f31][000010f2] 68f2100000 push 000010f2
[000011bf][00101f2d][000011c4] e8aefdffff call 00000f72

H: Begin Simulation Execution Trace Stored at:111fe5
[000010f2][00111fd1][00111fd5] 55 push ebp
[000010f3][00111fd1][00111fd5] 8bec mov ebp,esp
[000010f5][00111fd1][00111fd5] 8b4508 mov eax,[ebp+08]
[000010f8][00111fcd][00000777] 50 push eax // push 0x777
[000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
Infinite_Recursion
[000010f2][00111fc5][00111fd1] 55 push ebp
[000010f3][00111fc5][00111fd1] 8bec mov ebp,esp
[000010f5][00111fc5][00111fd1] 8b4508 mov eax,[ebp+08]
[000010f8][00111fc1][00000777] 50 push eax // push 0x777
[000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
Infinite_Recursion
H: Infinite Recursion Detected Simulation Stopped

(1) Infinite_Recursion() is called twice in sequence from the same
machine address of Infinite_Recursion() .
(2) With the same parameters to Infinite_Recursion()
(3) With no control flow instructions between the invocation of
Infinite_Recursion() and the call to Infinite_Recursion() from
Infinite_Recursion()

[000011c4][00101f39][00000000] 83c408 add esp,+08
[000011c7][00101f35][00000000] 50 push eax
[000011c8][00101f31][000004a3] 68a3040000 push 000004a3
[000011cd][00101f31][000004a3] e820f3ffff call 000004f2
Input_Halts = 0
[000011d2][00101f39][00000000] 83c408 add esp,+08
[000011d5][00101f39][00000000] 33c0 xor eax,eax
[000011d7][00101f3d][00000018] 5d pop ebp
[000011d8][00101f41][00000000] c3 ret
Number of Instructions Executed(1118) == 17 Pages

--
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 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, whose halt criteria is a computation that runs for more that 3 steps.

Ha3(Infinite_Recursion) correctly simulates the first 3 instructions of Infinite_Recursion. At that point, its halt status criteria of 3 steps is met and it aborts its simulation and returns 0. Ha3 has done a correct simulation of its input that exactly matches the x86 code of Infinite_Recursion.

So you say that because Ha(Infinite_Recursion) correctly reports 0 then Ha(Pa,Pa)==0 is correct. Then according to your logic, because Ha3(Infinite_Recursion) correctly reports 0 then Ha3(N,5)==0 is correct.

Agreed? If not, then this proves that Ha(Infinite_Recursion)==0 is not proof that your criteria is correct.

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.

Are you *ONLY* a deceiver?

*straw man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

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

You said "Because Ha does X it is correct", which means that any decider that does X is correct.

I showed that Ha3 (which is obviously not correct) does X, which means the fact that Ha does X does NOT prove it is correct.

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);

*I know that you know that you can't that is why you change the subject*

Example 02:
H correctly determines that Infinite_Recursion() never halts

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

int main()
{ Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
}

_Infinite_Recursion()
[000010f2](01) 55 push ebp
[000010f3](02) 8bec mov ebp,esp
[000010f5](03) 8b4508 mov eax,[ebp+08]
[000010f8](01) 50 push eax
[000010f9](05) e8f4ffffff call 000010f2
[000010fe](03) 83c404 add esp,+04
[00001101](01) 5d pop ebp
[00001102](01) c3 ret
Size in bytes:(0017) [00001102]

_main()
[000011b2](01) 55 push ebp
[000011b3](02) 8bec mov ebp,esp
[000011b5](05) 6877070000 push 00000777
[000011ba](05) 68f2100000 push 000010f2
[000011bf](05) e8aefdffff call 00000f72
[000011c4](03) 83c408 add esp,+08
[000011c7](01) 50 push eax
[000011c8](05) 68a3040000 push 000004a3
[000011cd](05) e820f3ffff call 000004f2
[000011d2](03) 83c408 add esp,+08
[000011d5](02) 33c0 xor eax,eax
[000011d7](01) 5d pop ebp
[000011d8](01) c3 ret
Size in bytes:(0039) [000011d8]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000011b2][00101f39][00000000] 55 push ebp
[000011b3][00101f39][00000000] 8bec mov ebp,esp
[000011b5][00101f35][00000777] 6877070000 push 00000777
[000011ba][00101f31][000010f2] 68f2100000 push 000010f2
[000011bf][00101f2d][000011c4] e8aefdffff call 00000f72

H: Begin Simulation Execution Trace Stored at:111fe5
[000010f2][00111fd1][00111fd5] 55 push ebp
[000010f3][00111fd1][00111fd5] 8bec mov ebp,esp
[000010f5][00111fd1][00111fd5] 8b4508 mov eax,[ebp+08]
[000010f8][00111fcd][00000777] 50 push eax // push 0x777
[000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
Infinite_Recursion
[000010f2][00111fc5][00111fd1] 55 push ebp
[000010f3][00111fc5][00111fd1] 8bec mov ebp,esp
[000010f5][00111fc5][00111fd1] 8b4508 mov eax,[ebp+08]
[000010f8][00111fc1][00000777] 50 push eax // push 0x777
[000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
Infinite_Recursion
H: Infinite Recursion Detected Simulation Stopped

(1) Infinite_Recursion() is called twice in sequence from the same
machine address of Infinite_Recursion() .
(2) With the same parameters to Infinite_Recursion()
(3) With no control flow instructions between the invocation of
Infinite_Recursion() and the call to Infinite_Recursion() from
Infinite_Recursion()

[000011c4][00101f39][00000000] 83c408 add esp,+08
[000011c7][00101f35][00000000] 50 push eax
[000011c8][00101f31][000004a3] 68a3040000 push 000004a3
[000011cd][00101f31][000004a3] e820f3ffff call 000004f2
Input_Halts = 0
[000011d2][00101f39][00000000] 83c408 add esp,+08
[000011d5][00101f39][00000000] 33c0 xor eax,eax
[000011d7][00101f3d][00000018] 5d pop ebp
[000011d8][00101f41][00000000] c3 ret
Number of Instructions Executed(1118) == 17 Pages

--
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 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. The fact that it did doesn't mean that Ha(Pa,Pa)==0 is correct.

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?

On Wednesday, August 10, 2022 at 9:30:21 PM UTC-7, olcott wrote:
> On 8/10/2022 11:19 PM, dklei...@gmail.com wrote:
> > On Wednesday, August 10, 2022 at 2:50:12 PM UTC-7, olcott wrote:
> >> On 8/10/2022 4:42 PM, dklei...@gmail.com wrote:
> >>> On Wednesday, August 10, 2022 at 1:55:17 PM UTC-7, olcott wrote:
> >>>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
> >>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
> >>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
> >>>>>>>>> I assume also a direct call of H(H,H) will produce the same
> >>>>>>>>> "non-halting" result?
> >>>>>>>> That is not in the domain of H.
> >>>>>>> Your halting decider H() will only work for a subset of halting
> >>>>>>> problems, any cases including itself (or programs using similar
> >>>>>>> methodology) are excluded?
> >>>>>>
> >>>>>> Every case that has conditional branches is excluded from my
> >>>>>> implementation, yet not excluded from my underlying theory. It simply
> >>>>>> takes too much more time to correctly handle conditional branches in
> >>>>>> working code.
> >>>>>
> >>>>> I see.
> >>>>>
> >>>>> Why don't you get back to us once you've implemented also this part,
> >>>>> because without it, this is not even a toy implementation?
> >>>>>
> >>>> Because it is moot. I have proven that H does correctly determine the
> >>>> halt status of the HP's impossible input, thus correctly refuted these
> >>>> proofs.
> >>>
> >>> Once again - just exactly what are you trying to prove?
> >> You must be brain dead.
> >>
> > I'm old but still living.
> >>
> > Do you imagine that the paragraph I questioned is a statement than might
> > be proven or disproven?
> I spent thousands of hours on it, it is proven.
>
> H(P,P) correctly maps the behavior of its first argument to its own
> reject state on the basis that the correct simulation that H(P,P)
> performs on its first argument:
>
I think you are confusing proof with the method of proof. What you
seem to claim as true is: H(P.P) returns I if something about P
happens or 0 otherwise. This is defective as a proposition because
it doesn't tell what H and P are, how the notation H(P.P) works or
what it is about P that is tested.

> (a) Would never reach its "return" instruction (final state).
> or
>
> (b) on the basis the its simulation only stops running when it had been
> aborted by H.
>
> *This is the proof even if no one here besides me understands it*

On 8/11/2022 12:42 PM, dklei...@gmail.com wrote:
> On Wednesday, August 10, 2022 at 9:30:21 PM UTC-7, olcott wrote:
>> On 8/10/2022 11:19 PM, dklei...@gmail.com wrote:
>>> On Wednesday, August 10, 2022 at 2:50:12 PM UTC-7, olcott wrote:
>>>> On 8/10/2022 4:42 PM, dklei...@gmail.com wrote:
>>>>> On Wednesday, August 10, 2022 at 1:55:17 PM UTC-7, olcott wrote:
>>>>>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>>>> On 8/10/2022 4:17 AM, Otto J. Makela wrote:
>>>>>>>>>>> I assume also a direct call of H(H,H) will produce the same
>>>>>>>>>>> "non-halting" result?
>>>>>>>>>> That is not in the domain of H.
>>>>>>>>> Your halting decider H() will only work for a subset of halting
>>>>>>>>> problems, any cases including itself (or programs using similar
>>>>>>>>> methodology) are excluded?
>>>>>>>>
>>>>>>>> Every case that has conditional branches is excluded from my
>>>>>>>> implementation, yet not excluded from my underlying theory. It simply
>>>>>>>> takes too much more time to correctly handle conditional branches in
>>>>>>>> working code.
>>>>>>>
>>>>>>> I see.
>>>>>>>
>>>>>>> Why don't you get back to us once you've implemented also this part,
>>>>>>> because without it, this is not even a toy implementation?
>>>>>>>
>>>>>> Because it is moot. I have proven that H does correctly determine the
>>>>>> halt status of the HP's impossible input, thus correctly refuted these
>>>>>> proofs.
>>>>>
>>>>> Once again - just exactly what are you trying to prove?
>>>> You must be brain dead.
>>>>
>>> I'm old but still living.
>>>>
>>> Do you imagine that the paragraph I questioned is a statement than might
>>> be proven or disproven?
>> I spent thousands of hours on it, it is proven.
>>
>> H(P,P) correctly maps the behavior of its first argument to its own
>> reject state on the basis that the correct simulation that H(P,P)
>> performs on its first argument:
>>
> I think you are confusing proof with the method of proof. What you
> seem to claim as true is: H(P.P) returns I if something about P
> happens or 0 otherwise. This is defective as a proposition because
> it doesn't tell what H and P are, how the notation H(P.P) works or
> what it is about P that is tested.

https://www.liarparadox.org/2022_07_22.zip
This is the complete system that compiles under:

Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

It has not been recently compiled under UBUNTU

>
>> (a) Would never reach its "return" instruction (final state).
>> or
>>
>> (b) on the basis the its simulation only stops running when it had been
>> aborted by H.
>>
>> *This is the proof even if no one here besides me understands it*
>

--
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/11/22 9:35 AM, olcott wrote:
> On 8/11/2022 6:56 AM, Otto J. Makela wrote:
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/10/2022 3:15 PM, Otto J. Makela wrote:
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/10/2022 9:02 AM, Otto J. Makela wrote:
>>>>>> Your halting decider H() will only work for a subset of halting
>>>>>> problems, any cases including itself (or programs using similar
>>>>>> methodology) are excluded?
>>>>> Every case that has conditional branches is excluded from my
>>>>> implementation, yet not excluded from my underlying theory. It
>>>>> simply takes too much more time to correctly handle conditional
>>>>> branches in working code.
>>>> I see.
>>>> Why don't you get back to us once you've implemented also this part,
>>>> because without it, this is not even a toy implementation?
>>>
>>> Because it is moot. I have proven that H does correctly determine the
>>> halt status of the HP's impossible input, thus correctly refuted these
>>> proofs.
>>
>> A halting detector which purports to work for just this single case
>> (in part because it IMHO incorrectly reports its own halting status)
>> and fails in the majority of other cases is not really much of a
>> halting detector. As I said, not even a toy implementation.
>
> It is a verified fact that H(P,P) does correctly report that its first
> argument would never reach its "return" instruction (final state) and
> thus never halt.
>
> (a) H(P,P) simulates P(P) that invokes a simulated H(P,P)
> (b)   that simulates P(P) that invokes a simulated H(P,P)
> (c)   that simulates P(P) that invokes a simulated H(P,P)...

Except that ISN'T what H(P,P) would do, as you current definition of H
says that as soon as your H(P,P) that started (a) gets to the invoke a
simulated H(P,P) at the end of the line, that H(P,P) never gets the
chance to do (b0 because the first H aborts its simultion.

Thus there IS NO INFINITE RECURSION.
PERIOD.

And you are proved to be a LIAR.

>
> *People that knowingly disagree with verified facts are dishonest*

Like your disagreeing with the behavior of the program that you wrote?

>
> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
> _P()
> [00001352](01)  55              push ebp
> [00001353](02)  8bec            mov ebp,esp
> [00001355](03)  8b4508          mov eax,[ebp+08]
> [00001358](01)  50              push eax      // push P
> [00001359](03)  8b4d08          mov ecx,[ebp+08]
> [0000135c](01)  51              push ecx      // push P
> [0000135d](05)  e840feffff      call 000011a2 // call H
> [00001362](03)  83c408          add esp,+08
> [00001365](02)  85c0            test eax,eax
> [00001367](02)  7402            jz 0000136b
> [00001369](02)  ebfe            jmp 00001369
> [0000136b](01)  5d              pop ebp
> [0000136c](01)  c3              ret
> Size in bytes:(0027) [0000136c]
>
> _main()
> [00001372](01)  55              push ebp
> [00001373](02)  8bec            mov ebp,esp
> [00001375](05)  6852130000      push 00001352 // push P
> [0000137a](05)  6852130000      push 00001352 // push P
> [0000137f](05)  e81efeffff      call 000011a2 // call H
> [00001384](03)  83c408          add esp,+08
> [00001387](01)  50              push eax
> [00001388](05)  6823040000      push 00000423 // "Input_Halts = "
> [0000138d](05)  e8e0f0ffff      call 00000472 // call Output
> [00001392](03)  83c408          add esp,+08
> [00001395](02)  33c0            xor eax,eax
> [00001397](01)  5d              pop ebp
> [00001398](01)  c3              ret
> Size in bytes:(0039) [00001398]
>
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ========  ========  ========  =========  =============
> ...[00001372][0010229e][00000000] 55         push ebp
> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
> ...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
> ...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
> // H emulates the first seven instructions of P
> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
> ...[00001358][0021233a][00001352] 50         push eax      // push P
> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][00212336][00001352] 51         push ecx      // push P
> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>
> // The emulated H emulates the first seven instructions of P
> ...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
> ...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
> ...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
> ...[00001358][0025cd62][00001352] 50         push eax      // push P
> ...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> *Matched infinite recursion detection criteria*
> (1) H(P, P) is called twice in sequence from the same machine address of
> P().
> (2) With the same arguments to H().
> (3) With no control flow instructions between the invocation of P() and
> its call to H(P,P).

But (3) isn't part of an actual infinite recursion detection criteria.

So, your logic is bad, and you prove yourself to be incompetent.

>
> ...[00001384][0010229e][00000000] 83c408     add esp,+08
> ...[00001387][0010229a][00000000] 50         push eax
> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> "Input_Halts = "
> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
> Input_Halts = 0
> ...[00001392][0010229e][00000000] 83c408     add esp,+08
> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
> ...[00001397][001022a2][00100000] 5d         pop ebp
> ...[00001398][001022a6][00000004] c3         ret
> Number of Instructions Executed(15892) = 237 pages
>
>

On 8/11/22 10:11 AM, 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*

FALSE.

"Proof By Example" is a fallacious arguement.

You are just proving your stupdity by it.

Note, Your example doesn't even match the criteria you are claiming.

Infinite_Recursion never calls H(P,P) as your rule states.

Note, to be the equivalent of THIS example, you would need to trace the
FULL loop from one call of P(P) to the next, or from one call of H(P,P)
to the next, both of which go through H, which your trace doesn't do.

>
> Example 02:
> *H correctly determines that Infinite_Recursion() never halts*
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }
>
> _Infinite_Recursion()
> [000010f2](01)  55         push ebp
> [000010f3](02)  8bec       mov ebp,esp
> [000010f5](03)  8b4508     mov eax,[ebp+08]
> [000010f8](01)  50         push eax
> [000010f9](05)  e8f4ffffff call 000010f2
> [000010fe](03)  83c404     add esp,+04
> [00001101](01)  5d         pop ebp
> [00001102](01)  c3         ret
> Size in bytes:(0017) [00001102]
>
> _main()
> [000011b2](01)  55         push ebp
> [000011b3](02)  8bec       mov ebp,esp
> [000011b5](05)  6877070000 push 00000777
> [000011ba](05)  68f2100000 push 000010f2
> [000011bf](05)  e8aefdffff call 00000f72
> [000011c4](03)  83c408     add esp,+08
> [000011c7](01)  50         push eax
> [000011c8](05)  68a3040000 push 000004a3
> [000011cd](05)  e820f3ffff call 000004f2
> [000011d2](03)  83c408     add esp,+08
> [000011d5](02)  33c0       xor eax,eax
> [000011d7](01)  5d         pop ebp
> [000011d8](01)  c3         ret
> Size in bytes:(0039) [000011d8]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [000011b2][00101f39][00000000] 55         push ebp
> [000011b3][00101f39][00000000] 8bec       mov ebp,esp
> [000011b5][00101f35][00000777] 6877070000 push 00000777
> [000011ba][00101f31][000010f2] 68f2100000 push 000010f2
> [000011bf][00101f2d][000011c4] e8aefdffff call 00000f72
>
> H: Begin Simulation   Execution Trace Stored at:111fe5
> [000010f2][00111fd1][00111fd5] 55         push ebp
> [000010f3][00111fd1][00111fd5] 8bec       mov ebp,esp
> [000010f5][00111fd1][00111fd5] 8b4508     mov eax,[ebp+08]
> [000010f8][00111fcd][00000777] 50         push eax      // push 0x777
> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
> Infinite_Recursion
> [000010f2][00111fc5][00111fd1] 55         push ebp
> [000010f3][00111fc5][00111fd1] 8bec       mov ebp,esp
> [000010f5][00111fc5][00111fd1] 8b4508     mov eax,[ebp+08]
> [000010f8][00111fc1][00000777] 50         push eax      // push 0x777
> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
> Infinite_Recursion
> H: Infinite Recursion Detected Simulation Stopped
>
> (1) Infinite_Recursion() is called twice in sequence from the same
> machine address of Infinite_Recursion() .
> (2) With the same parameters to Infinite_Recursion()
> (3) With no control flow instructions between the invocation of
> Infinite_Recursion() and the call to Infinite_Recursion() from
> Infinite_Recursion()
>
> [000011c4][00101f39][00000000] 83c408     add esp,+08
> [000011c7][00101f35][00000000] 50         push eax
> [000011c8][00101f31][000004a3] 68a3040000 push 000004a3
> [000011cd][00101f31][000004a3] e820f3ffff call 000004f2
> Input_Halts = 0
> [000011d2][00101f39][00000000] 83c408     add esp,+08
> [000011d5][00101f39][00000000] 33c0       xor eax,eax
> [000011d7][00101f3d][00000018] 5d         pop ebp
> [000011d8][00101f41][00000000] c3         ret
> Number of Instructions Executed(1118) == 17 Pages
>
>

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.

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

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

STF up about it !!!

--
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 2:21 AM, 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.
>
>>  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.
>
>>
>> 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.
>
> STF up about it !!!
>
>
>

Which one is "Correct"? We know that P(P) Hslts, so both deciders need
to say 1 to be correct.

You just seem to stupid to know the right answer, or even the right
question it seems.

olcott <NoOne@NoWhere.com> wrote:
> On 8/11/2022 6:56 AM, Otto J. Makela wrote:
>> A halting detector which purports to work for just this single case
>> (in part because it IMHO incorrectly reports its own halting status)
>> and fails in the majority of other cases is not really much of a
>> halting detector. As I said, not even a toy implementation.
>
> It is a verified fact that H(P,P) does correctly report that its first
> argument would never reach its "return" instruction (final state) and
> thus never halt.

Just to understand how you define this to be a working H(), when

void P(ptr x) {
return;
}

What does H(H,P) return?

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

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.

So anything you use to prove Ha is correct can be used to prove that Ha3 is correct. And anything you use to prove that Ha3 is wrong can be used to prove that Ha is wrong.

And THAT is why you hate talking about Ha3, and why I will continue to talk about it.

On 8/12/2022 6:26 AM, Otto J. Makela wrote:
> olcott <NoOne@NoWhere.com> wrote:
>> On 8/11/2022 6:56 AM, Otto J. Makela wrote:
>>> A halting detector which purports to work for just this single case
>>> (in part because it IMHO incorrectly reports its own halting status)
>>> and fails in the majority of other cases is not really much of a
>>> halting detector. As I said, not even a toy implementation.
>>
>> It is a verified fact that H(P,P) does correctly report that its first
>> argument would never reach its "return" instruction (final state) and
>> thus never halt.
>
> 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.

--
Copyright 2022 Pete Olcott

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