On 7/27/2022 4:48 AM, Mikko wrote:
> On 2022-07-26 14:40:22 +0000, olcott said:
>
>> On 7/26/2022 8:48 AM, Mikko wrote:
>>> On 2022-07-25 20:09:42 +0000, olcott said:
>>>
>>>> On 7/25/2022 11:47 AM, Mikko wrote:
>>>>> On 2022-07-25 15:20:02 +0000, olcott said:
>>>>>
>>>>>> On 7/25/2022 10:14 AM, Mikko wrote:
>>>>>>> On 2022-07-25 13:49:20 +0000, olcott said:
>>>>>>>
>>>>>>>> On 7/25/2022 6:02 AM, Mikko wrote:
>>>>>>>>> On 2022-07-24 20:03:29 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 7/24/2022 12:01 PM, Mikko wrote:
>>>>>>>>>>> On 2022-07-24 14:53:43 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 7/24/2022 7:26 AM, Mikko wrote:
>>>>>>>>>>>>> On 2022-07-23 20:33:11 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 7/23/2022 3:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> The trace proves no such thing. Here is a basic of the
>>>>>>>>>>>>>>> x86 question for you, what is the first instruction
>>>>>>>>>>>>>>> executed in P(P) that differs from the correct simulation
>>>>>>>>>>>>>>> of H(P,P)?
>>>>>>>>>>>>>>
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [000013c6](01)  55         push ebp
>>>>>>>> [000013c7](02)  8bec       mov ebp,esp
>>>>>>>> [000013c9](01)  51         push ecx
>>>>>>>> [000013ca](03)  8b4508     mov eax,[ebp+08]
>>>>>>>> [000013cd](01)  50         push eax
>>>>>>>> [000013ce](03)  8b4d08     mov ecx,[ebp+08]
>>>>>>>> [000013d1](01)  51         push ecx
>>>>>>>> [000013d2](05)  e82ffdffff call 00001106
>>>>>>>> [000013d7](03)  83c408     add esp,+08
>>>>>>>> [000013da](03)  8945fc     mov [ebp-04],eax
>>>>>>>> [000013dd](04)  837dfc00   cmp dword [ebp-04],+00
>>>>>>>> [000013e1](02)  7402       jz 000013e5
>>>>>>>> [000013e3](02)  ebfe       jmp 000013e3
>>>>>>>> [000013e5](02)  8be5       mov esp,ebp
>>>>>>>> [000013e7](01)  5d         pop ebp
>>>>>>>> [000013e8](01)  c3         ret
>>>>>>>> Size in bytes:(0035) [000013e8]
>>>>>>>>
>>>>>>>>
>>>>>>>>>> We have to do this at the C level.
>>>>>>>>>>
>>>>>>>>>> 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));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> (a) H(P,P) simulates its input
>>>>>>>>>> (b) P calls H(P,P) to simulate itself *again*
>>>>>>>>>> (c) H(P,P) would simulate its input if it does what P asks
>>>>>>>>>> (d) P calls H(P,P) to simulate itself *again*
>>>>>>>>>> (e) H(P,P) would simulate its input if it does what P asks
>>>>>>>>>> (f) P calls H(P,P) to simulate itself *again* ...
>>>>>>>>>>
>>>>>>>>>> *Can you see the repeating pattern* ?
>>>>>>>>>
>>>>>>>>> Yes, but I cannot see any answer to any of my questions.
>>>>>>>>>
>>>>>>>>> Can you prove that 13d7 is the first differeing instruction?
>>>>>>>>> In particular, that the immediately preceding instruction is
>>>>>>>>> the same?
>>>>>>>>>
>>>>>>>>> Mikko
>>>>>>>>>
>>>>>>>>
>>>>>>>> WHEN THE DIRECTLY EXECUTED P(P) CALLS H(P,P)
>>>>>>>> The source-code of P specifies that the next instruction after
>>>>>>>> machine address 13d2 when H returns to P for P(P) is 13d7.
>>>>>>>>
>>>>>>>> WHEN THE SIMULATED INPUT TO H(P,P) CALLS H(P,P)
>>>>>>>> The source-code of P specifies the next machine address for the
>>>>>>>> correctly simulated input to H(P,P) is 13c6 (if P is not aborted)
>>>>>>>
>>>>>>> Wrong. In both cases P is the same so therefore specifies the same.
>>>>>>> The difference seems to be that in the second case the instruction
>>>>>>> H(P,P) is not simulated correctly as a call to a decider.
>>>>>>>
>>>>>>> Mikko
>>>>>>>
>>>>>>
>>>>>> You can assume that I am wrong by making sure to not even look at
>>>>>> the proof that I am correct.
>>>>>
>>>>> Wrong. I didn't assume that you are wrong. I presented a sentence that
>>>>> is true because of the meaning of the words. You have not found
>>>>> anything
>>>>> wrong in that sentence.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> The behavior of P when directly executed is different than the
>>>> behavior of P when correctly simulated by H even though each case
>>>> uses the exact same machine-code for P. This is an established fact
>>>> thus disbelieving this in incorrect.
>>>
>>> That does not contradict what I said above.
>>>
>>> However, none of that is any estabilished fact. The behaviour
>>> simulated by H is not the behaviour specified by P and there
>>> is no proof that H simulates correctly.
>>>
>>> Mikko
>>>
>>
>> That the line-by-line execution trace of the simulated input to H(P,P)
>> exactly matches the line-by-line source-code conclusively proves that
>> P is simulated correctly.
>
> Only partially, to the call of H. The simulation is discontinued before
> the return from H so the full behaviour specified by P is not simulated.
> In particular, the behaviour specified by P is either to halt or to run
> forever but the simulation does neither.
>
> Mikko
>

*Not with this version* With this version I show where the correctly
simulated input to H(P,P) goes after the call.

Example 06: H correctly determines that P() never halts (prior version
of halt decider)

#include <stdint.h>
#define u32 uint32_t

#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
WHERE DOES TO GO ???

// 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) P() calls H(P,P) twice in sequence.
(2) With the same arguments.
(3) With no control flow instructions in P preceding its invocation of
H(P,P) that could escape repeated simulations.

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