XPost: comp.theory, sci.logic, sci.math

On 11/11/2021 10:14 AM, Richard Damon wrote:

On 11/11/21 11:00 AM, olcott wrote:

#define ptr uintptr_t

void P(ptr x)
{
   H(x, x);
}

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

int main()
{
   H((ptr)P, (ptr)P);
   return 0;
}

Yes.

So all you have proven is that if H unconditionally executes its input
you get infinite recursion.

And, H will never return.

If H isn't that function, then the computation of P changes so you have
no proof for what the behavior of that machine is.

_P()
[00001a5e](01) 55 push ebp
[00001a5f](02) 8bec mov ebp,esp
[00001a61](03) 8b4508 mov eax,[ebp+08]
[00001a64](01) 50 push eax // push P
[00001a65](03) 8b4d08 mov ecx,[ebp+08]
[00001a68](01) 51 push ecx // push P
[00001a69](05) e810000000 call 00001a7e // call H
[00001a6e](03) 83c408 add esp,+08
[00001a71](01) 5d pop ebp
[00001a72](01) c3 ret
Size in bytes:(0021) [00001a72]


If H simulates the x86 machine language of its input and sees that its simulated P is calling H with the same parameters that H was called with
H can abort its simulation of P and correctly report that P would never
reach its final state at 1a72.


--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/11/2021 10:46 AM, Richard Damon wrote:

On 11/11/21 11:31 AM, olcott wrote:

On 11/11/2021 10:14 AM, Richard Damon wrote:

On 11/11/21 11:00 AM, olcott wrote:

#define ptr uintptr_t

void P(ptr x)
{
   H(x, x);
}

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

int main()
{
   H((ptr)P, (ptr)P);
   return 0;
}

Yes.

So all you have proven is that if H unconditionally executes its
input you get infinite recursion.

And, H will never return.

If H isn't that function, then the computation of P changes so you
have no proof for what the behavior of that machine is.

_P()
[00001a5e](01)  55              push ebp
[00001a5f](02)  8bec            mov ebp,esp
[00001a61](03)  8b4508          mov eax,[ebp+08]
[00001a64](01)  50              push eax        // push P
[00001a65](03)  8b4d08          mov ecx,[ebp+08]
[00001a68](01)  51              push ecx        // push P
[00001a69](05)  e810000000      call 00001a7e   // call H
[00001a6e](03)  83c408          add esp,+08
[00001a71](01)  5d              pop ebp
[00001a72](01)  c3              ret
Size in bytes:(0021) [00001a72]


If H simulates the x86 machine language of its input and sees that its
simulated P is calling H with the same parameters that H was called
with H can abort its simulation of P and correctly report that P would
never reach its final state at 1a72.

No it can't.

If H can abort its simulation, then it needs to take into account that H
can abort its simulation. PERIOD.

H, in making that conclusion, is PRESUMING that the called H will not
abort its simulation, which it is wrong about.

Because I keep repeating these same words dozens of times and you never acknowledge that you have ever seen them I really believe that you
actually have attention deficit disorder (ADD):

(a) P only halts if it reaches its final state at 1a72.

(b) If H does not abort its simulation of P then P never reaches its
final state at 1a72.

(c) If H aborts its simulation of P then P never reaches its final state
as 1a72.

Because P never halts in all possible cases H(P,P)==0 is always correct.




--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)