On Wednesday, July 27, 2022 at 7:11:10 PM UTC-4, olcott wrote:
> On 7/27/2022 5:45 PM, Richard Damon wrote:
> > On 7/27/22 10:59 AM, olcott wrote:
> >> 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)
> >
> > Then why does P{P) Halt?
> As I have proved dozens of times (including the post you are responding
> to) it is a freaking different sequence of instructions.
>
> That you don't believe this because you don't bother to look at my proof
> is asinine.
> _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]
> 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
> P(P) goes to machine address [00001362] after its call H(P,P) returns.
> The correctly simulated input to H(P,P) goes to machine address
> [00001352] because H never returns to the P because no function called
> in infinite recursion ever returns to its caller.

On 7/27/22 7:11 PM, olcott wrote:
> On 7/27/2022 5:45 PM, Richard Damon wrote:
>> On 7/27/22 10:59 AM, olcott wrote:
>>> 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)
>>
>> Then why does P{P) Halt?
>
> As I have proved dozens of times (including the post you are responding
> to) it is a freaking different sequence of instructions.

On 7/27/2022 6:27 PM, Richard Damon wrote:
> On 7/27/22 7:11 PM, olcott wrote:
>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>> On 7/27/22 10:59 AM, olcott wrote:
>>>> 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)
>>>
>>> Then why does P{P) Halt?
>>
>> As I have proved dozens of times (including the post you are
>> responding to) it is a freaking different sequence of instructions.
>
> Which INSTRUCTION is different.
>
> Both traces go to a call H instuction with the exact same parameters.
>
> The actually RUN H, and the simulation of H by H differ in results.
>
> THus, H fails to properly simulate the function H, and the proof is
> INVALID.
>
>>
>> That you don't believe this because you don't bother to look at my
>> proof is asinine.
>>
>> _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]
>>
>>      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
>
> CORRECT simulation needs to show what happens at 000011a2 next
>
> It doesn't, thus it is NOT a correct simulation, and you are proved to
> be a liar.

On Wednesday, July 27, 2022 at 8:51:09 PM UTC-4, olcott wrote:
> On 7/27/2022 6:27 PM, Richard Damon wrote:
> > On 7/27/22 7:11 PM, olcott wrote:
> >> On 7/27/2022 5:45 PM, Richard Damon wrote:
> >>> On 7/27/22 10:59 AM, olcott wrote:
> >>>> 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)
> >>>
> >>> Then why does P{P) Halt?
> >>
> >> As I have proved dozens of times (including the post you are
> >> responding to) it is a freaking different sequence of instructions.
> >
> > Which INSTRUCTION is different.
> >
> > Both traces go to a call H instuction with the exact same parameters.
> >
> > The actually RUN H, and the simulation of H by H differ in results.
> >
> > THus, H fails to properly simulate the function H, and the proof is
> > INVALID.
> >
> >>
> >> That you don't believe this because you don't bother to look at my
> >> proof is asinine.
> >>
> >> _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]
> >>
> >> 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
> >
> > CORRECT simulation needs to show what happens at 000011a2 next
> >
> > It doesn't, thus it is NOT a correct simulation, and you are proved to
> > be a liar.
> So in other words you are not bright enough to see that when the
> simulated P calls H(P,P) to simulate itself again that H does indeed
> simulate P again thus begins at the first instruction of P shown below?

On 7/27/22 8:51 PM, olcott wrote:
> On 7/27/2022 6:27 PM, Richard Damon wrote:
>> On 7/27/22 7:11 PM, olcott wrote:
>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>> 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)
>>>>
>>>> Then why does P{P) Halt?
>>>
>>> As I have proved dozens of times (including the post you are
>>> responding to) it is a freaking different sequence of instructions.
>>
>> Which INSTRUCTION is different.
>>
>> Both traces go to a call H instuction with the exact same parameters.
>>
>> The actually RUN H, and the simulation of H by H differ in results.
>>
>> THus, H fails to properly simulate the function H, and the proof is
>> INVALID.
>>
>>>
>>> That you don't believe this because you don't bother to look at my
>>> proof is asinine.
>>>
>>> _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]
>>>
>>>      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
>>
>> CORRECT simulation needs to show what happens at 000011a2 next
>>
>> It doesn't, thus it is NOT a correct simulation, and you are proved to
>> be a liar.
>
> So in other words you are not bright enough to see that when the
> simulated P calls H(P,P) to simulate itself again that H does indeed
> simulate P again thus begins at the first instruction of P shown below?

On 7/27/2022 8:13 PM, Richard Damon wrote:
> On 7/27/22 8:51 PM, olcott wrote:
>> On 7/27/2022 6:27 PM, Richard Damon wrote:
>>> On 7/27/22 7:11 PM, olcott wrote:
>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>>> 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)
>>>>>
>>>>> Then why does P{P) Halt?
>>>>
>>>> As I have proved dozens of times (including the post you are
>>>> responding to) it is a freaking different sequence of instructions.
>>>
>>> Which INSTRUCTION is different.
>>>
>>> Both traces go to a call H instuction with the exact same parameters.
>>>
>>> The actually RUN H, and the simulation of H by H differ in results.
>>>
>>> THus, H fails to properly simulate the function H, and the proof is
>>> INVALID.
>>>
>>>>
>>>> That you don't believe this because you don't bother to look at my
>>>> proof is asinine.
>>>>
>>>> _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]
>>>>
>>>>      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
>>>
>>> CORRECT simulation needs to show what happens at 000011a2 next
>>>
>>> It doesn't, thus it is NOT a correct simulation, and you are proved
>>> to be a liar.
>>
>> So in other words you are not bright enough to see that when the
>> simulated P calls H(P,P) to simulate itself again that H does indeed
>> simulate P again thus begins at the first instruction of P shown below?
>
> So, you are saying that the H that is simulating the P that is calling
> this new H can't abort that simulation by aborting its simulation of P?

On 7/27/22 9:24 PM, olcott wrote:
> On 7/27/2022 8:13 PM, Richard Damon wrote:
>> On 7/27/22 8:51 PM, olcott wrote:
>>> On 7/27/2022 6:27 PM, Richard Damon wrote:
>>>> On 7/27/22 7:11 PM, olcott wrote:
>>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>>>> 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)
>>>>>>
>>>>>> Then why does P{P) Halt?
>>>>>
>>>>> As I have proved dozens of times (including the post you are
>>>>> responding to) it is a freaking different sequence of instructions.
>>>>
>>>> Which INSTRUCTION is different.
>>>>
>>>> Both traces go to a call H instuction with the exact same parameters.
>>>>
>>>> The actually RUN H, and the simulation of H by H differ in results.
>>>>
>>>> THus, H fails to properly simulate the function H, and the proof is
>>>> INVALID.
>>>>
>>>>>
>>>>> That you don't believe this because you don't bother to look at my
>>>>> proof is asinine.
>>>>>
>>>>> _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]
>>>>>
>>>>>      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
>>>>
>>>> CORRECT simulation needs to show what happens at 000011a2 next
>>>>
>>>> It doesn't, thus it is NOT a correct simulation, and you are proved
>>>> to be a liar.
>>>
>>> So in other words you are not bright enough to see that when the
>>> simulated P calls H(P,P) to simulate itself again that H does indeed
>>> simulate P again thus begins at the first instruction of P shown below?
>>
>> So, you are saying that the H that is simulating the P that is calling
>> this new H can't abort that simulation by aborting its simulation of P?
>
> Yes I am saying that. This H does not see that its abort criteria has
> been met so the new H simulates its input as shown below.

On 7/27/2022 9:00 PM, Richard Damon wrote:
> On 7/27/22 9:24 PM, olcott wrote:
>> On 7/27/2022 8:13 PM, Richard Damon wrote:
>>> On 7/27/22 8:51 PM, olcott wrote:
>>>> On 7/27/2022 6:27 PM, Richard Damon wrote:
>>>>> On 7/27/22 7:11 PM, olcott wrote:
>>>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>>>>> 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)
>>>>>>>
>>>>>>> Then why does P{P) Halt?
>>>>>>
>>>>>> As I have proved dozens of times (including the post you are
>>>>>> responding to) it is a freaking different sequence of instructions.
>>>>>
>>>>> Which INSTRUCTION is different.
>>>>>
>>>>> Both traces go to a call H instuction with the exact same parameters.
>>>>>
>>>>> The actually RUN H, and the simulation of H by H differ in results.
>>>>>
>>>>> THus, H fails to properly simulate the function H, and the proof is
>>>>> INVALID.
>>>>>
>>>>>>
>>>>>> That you don't believe this because you don't bother to look at my
>>>>>> proof is asinine.
>>>>>>
>>>>>> _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]
>>>>>>
>>>>>>      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
>>>>>
>>>>> CORRECT simulation needs to show what happens at 000011a2 next
>>>>>
>>>>> It doesn't, thus it is NOT a correct simulation, and you are proved
>>>>> to be a liar.
>>>>
>>>> So in other words you are not bright enough to see that when the
>>>> simulated P calls H(P,P) to simulate itself again that H does indeed
>>>> simulate P again thus begins at the first instruction of P shown below?
>>>
>>> So, you are saying that the H that is simulating the P that is
>>> calling this new H can't abort that simulation by aborting its
>>> simulation of P?
>>
>> Yes I am saying that. This H does not see that its abort criteria has
>> been met so the new H simulates its input as shown below.
>
> So, since the FIRST H can't abort, because of the second H being called,
> how does the first one EVER abort to return the answer to main?>
>
> Remember, you have said that H is a pure function, so ALL copies of H
> will behave the same give the same input.
>
> It seems that the problem is that H is just incorrectly assuming that
> the second H would never halt its simulation

On Wednesday, July 27, 2022 at 10:28:56 PM UTC-4, olcott wrote:
> On 7/27/2022 9:00 PM, Richard Damon wrote:
> > On 7/27/22 9:24 PM, olcott wrote:
> >> On 7/27/2022 8:13 PM, Richard Damon wrote:
> >>> On 7/27/22 8:51 PM, olcott wrote:
> >>>> On 7/27/2022 6:27 PM, Richard Damon wrote:
> >>>>> On 7/27/22 7:11 PM, olcott wrote:
> >>>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
> >>>>>>> On 7/27/22 10:59 AM, olcott wrote:
> >>>>>>>> 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)
> >>>>>>>
> >>>>>>> Then why does P{P) Halt?
> >>>>>>
> >>>>>> As I have proved dozens of times (including the post you are
> >>>>>> responding to) it is a freaking different sequence of instructions.
> >>>>>
> >>>>> Which INSTRUCTION is different.
> >>>>>
> >>>>> Both traces go to a call H instuction with the exact same parameters.
> >>>>>
> >>>>> The actually RUN H, and the simulation of H by H differ in results.
> >>>>>
> >>>>> THus, H fails to properly simulate the function H, and the proof is
> >>>>> INVALID.
> >>>>>
> >>>>>>
> >>>>>> That you don't believe this because you don't bother to look at my
> >>>>>> proof is asinine.
> >>>>>>
> >>>>>> _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]
> >>>>>>
> >>>>>> 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
> >>>>>
> >>>>> CORRECT simulation needs to show what happens at 000011a2 next
> >>>>>
> >>>>> It doesn't, thus it is NOT a correct simulation, and you are proved
> >>>>> to be a liar.
> >>>>
> >>>> So in other words you are not bright enough to see that when the
> >>>> simulated P calls H(P,P) to simulate itself again that H does indeed
> >>>> simulate P again thus begins at the first instruction of P shown below?
> >>>
> >>> So, you are saying that the H that is simulating the P that is
> >>> calling this new H can't abort that simulation by aborting its
> >>> simulation of P?
> >>
> >> Yes I am saying that. This H does not see that its abort criteria has
> >> been met so the new H simulates its input as shown below.
> >
> > So, since the FIRST H can't abort, because of the second H being called,
> > how does the first one EVER abort to return the answer to main?>
> >
> > Remember, you have said that H is a pure function, so ALL copies of H
> > will behave the same give the same input.
> >
> > It seems that the problem is that H is just incorrectly assuming that
> > the second H would never halt its simulation
> The first H that sees that this criteria has been met sees that its
> correctly simulated input cannot possibly ever reach its "ret"
> instruction even if correctly simulated for an infinite number of steps:

On 7/27/22 10:28 PM, olcott wrote:
> On 7/27/2022 9:00 PM, Richard Damon wrote:
>> On 7/27/22 9:24 PM, olcott wrote:
>>> On 7/27/2022 8:13 PM, Richard Damon wrote:
>>>> On 7/27/22 8:51 PM, olcott wrote:
>>>>> On 7/27/2022 6:27 PM, Richard Damon wrote:
>>>>>> On 7/27/22 7:11 PM, olcott wrote:
>>>>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>>>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>>>>>> 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)
>>>>>>>>
>>>>>>>> Then why does P{P) Halt?
>>>>>>>
>>>>>>> As I have proved dozens of times (including the post you are
>>>>>>> responding to) it is a freaking different sequence of instructions.
>>>>>>
>>>>>> Which INSTRUCTION is different.
>>>>>>
>>>>>> Both traces go to a call H instuction with the exact same parameters.
>>>>>>
>>>>>> The actually RUN H, and the simulation of H by H differ in results.
>>>>>>
>>>>>> THus, H fails to properly simulate the function H, and the proof
>>>>>> is INVALID.
>>>>>>
>>>>>>>
>>>>>>> That you don't believe this because you don't bother to look at
>>>>>>> my proof is asinine.
>>>>>>>
>>>>>>> _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]
>>>>>>>
>>>>>>>      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
>>>>>>
>>>>>> CORRECT simulation needs to show what happens at 000011a2 next
>>>>>>
>>>>>> It doesn't, thus it is NOT a correct simulation, and you are
>>>>>> proved to be a liar.
>>>>>
>>>>> So in other words you are not bright enough to see that when the
>>>>> simulated P calls H(P,P) to simulate itself again that H does
>>>>> indeed simulate P again thus begins at the first instruction of P
>>>>> shown below?
>>>>
>>>> So, you are saying that the H that is simulating the P that is
>>>> calling this new H can't abort that simulation by aborting its
>>>> simulation of P?
>>>
>>> Yes I am saying that. This H does not see that its abort criteria has
>>> been met so the new H simulates its input as shown below.
>>
>> So, since the FIRST H can't abort, because of the second H being
>> called, how does the first one EVER abort to return the answer to main?>
>>
>> Remember, you have said that H is a pure function, so ALL copies of H
>> will behave the same give the same input.
>>
>> It seems that the problem is that H is just incorrectly assuming that
>> the second H would never halt its simulation
>
> The first H that sees that this criteria has been met sees that its
> correctly simulated input cannot possibly ever reach its "ret"
> instruction even if correctly simulated for an infinite number of steps:
>
> (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 possibly escape repeated simulations.
>

On 7/27/2022 8:08 PM, Dennis Bush wrote:
> On Wednesday, July 27, 2022 at 8:51:09 PM UTC-4, olcott wrote:
>> On 7/27/2022 6:27 PM, Richard Damon wrote:
>>> On 7/27/22 7:11 PM, olcott wrote:
>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>>> 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)
>>>>>
>>>>> Then why does P{P) Halt?
>>>>
>>>> As I have proved dozens of times (including the post you are
>>>> responding to) it is a freaking different sequence of instructions.
>>>
>>> Which INSTRUCTION is different.
>>>
>>> Both traces go to a call H instuction with the exact same parameters.
>>>
>>> The actually RUN H, and the simulation of H by H differ in results.
>>>
>>> THus, H fails to properly simulate the function H, and the proof is
>>> INVALID.
>>>
>>>>
>>>> That you don't believe this because you don't bother to look at my
>>>> proof is asinine.
>>>>
>>>> _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]
>>>>
>>>> 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
>>>
>>> CORRECT simulation needs to show what happens at 000011a2 next
>>>
>>> It doesn't, thus it is NOT a correct simulation, and you are proved to
>>> be a liar.
>> So in other words you are not bright enough to see that when the
>> simulated P calls H(P,P) to simulate itself again that H does indeed
>> simulate P again thus begins at the first instruction of P shown below?
>
> So the instructions that should be traced are the instructions of H that are simulating P. Those instructions will include a number of conditionals, one of which *will* trigger and return 0.

On 7/27/2022 9:37 PM, Richard Damon wrote:
> On 7/27/22 10:28 PM, olcott wrote:
>> On 7/27/2022 9:00 PM, Richard Damon wrote:
>>> On 7/27/22 9:24 PM, olcott wrote:
>>>> On 7/27/2022 8:13 PM, Richard Damon wrote:
>>>>> On 7/27/22 8:51 PM, olcott wrote:
>>>>>> On 7/27/2022 6:27 PM, Richard Damon wrote:
>>>>>>> On 7/27/22 7:11 PM, olcott wrote:
>>>>>>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
>>>>>>>>> On 7/27/22 10:59 AM, olcott wrote:
>>>>>>>>>> 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)
>>>>>>>>>
>>>>>>>>> Then why does P{P) Halt?
>>>>>>>>
>>>>>>>> As I have proved dozens of times (including the post you are
>>>>>>>> responding to) it is a freaking different sequence of instructions.
>>>>>>>
>>>>>>> Which INSTRUCTION is different.
>>>>>>>
>>>>>>> Both traces go to a call H instuction with the exact same
>>>>>>> parameters.
>>>>>>>
>>>>>>> The actually RUN H, and the simulation of H by H differ in results.
>>>>>>>
>>>>>>> THus, H fails to properly simulate the function H, and the proof
>>>>>>> is INVALID.
>>>>>>>
>>>>>>>>
>>>>>>>> That you don't believe this because you don't bother to look at
>>>>>>>> my proof is asinine.
>>>>>>>>
>>>>>>>> _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]
>>>>>>>>
>>>>>>>>      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
>>>>>>>
>>>>>>> CORRECT simulation needs to show what happens at 000011a2 next
>>>>>>>
>>>>>>> It doesn't, thus it is NOT a correct simulation, and you are
>>>>>>> proved to be a liar.
>>>>>>
>>>>>> So in other words you are not bright enough to see that when the
>>>>>> simulated P calls H(P,P) to simulate itself again that H does
>>>>>> indeed simulate P again thus begins at the first instruction of P
>>>>>> shown below?
>>>>>
>>>>> So, you are saying that the H that is simulating the P that is
>>>>> calling this new H can't abort that simulation by aborting its
>>>>> simulation of P?
>>>>
>>>> Yes I am saying that. This H does not see that its abort criteria
>>>> has been met so the new H simulates its input as shown below.
>>>
>>> So, since the FIRST H can't abort, because of the second H being
>>> called, how does the first one EVER abort to return the answer to main?>
>>>
>>> Remember, you have said that H is a pure function, so ALL copies of H
>>> will behave the same give the same input.
>>>
>>> It seems that the problem is that H is just incorrectly assuming that
>>> the second H would never halt its simulation
>>
>> The first H that sees that this criteria has been met sees that its
>> correctly simulated input cannot possibly ever reach its "ret"
>> instruction even if correctly simulated for an infinite number of steps:
>>
>> (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 possibly escape repeated simulations.
>>
>
> So, you are keeping to your LIE that you are using valid logic?
>
> Your rule (3) is FALSE, that has been told to you many times and you
> have not shown where you get the idea that it is true.

On Thursday, July 28, 2022 at 11:11:23 AM UTC-4, olcott wrote:
> On 7/27/2022 8:08 PM, Dennis Bush wrote:
> > On Wednesday, July 27, 2022 at 8:51:09 PM UTC-4, olcott wrote:
> >> On 7/27/2022 6:27 PM, Richard Damon wrote:
> >>> On 7/27/22 7:11 PM, olcott wrote:
> >>>> On 7/27/2022 5:45 PM, Richard Damon wrote:
> >>>>> On 7/27/22 10:59 AM, olcott wrote:
> >>>>>> 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)
> >>>>>
> >>>>> Then why does P{P) Halt?
> >>>>
> >>>> As I have proved dozens of times (including the post you are
> >>>> responding to) it is a freaking different sequence of instructions.
> >>>
> >>> Which INSTRUCTION is different.
> >>>
> >>> Both traces go to a call H instuction with the exact same parameters.
> >>>
> >>> The actually RUN H, and the simulation of H by H differ in results.
> >>>
> >>> THus, H fails to properly simulate the function H, and the proof is
> >>> INVALID.
> >>>
> >>>>
> >>>> That you don't believe this because you don't bother to look at my
> >>>> proof is asinine.
> >>>>
> >>>> _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]
> >>>>
> >>>> 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
> >>>
> >>> CORRECT simulation needs to show what happens at 000011a2 next
> >>>
> >>> It doesn't, thus it is NOT a correct simulation, and you are proved to
> >>> be a liar.
> >> So in other words you are not bright enough to see that when the
> >> simulated P calls H(P,P) to simulate itself again that H does indeed
> >> simulate P again thus begins at the first instruction of P shown below?
> >
> > So the instructions that should be traced are the instructions of H that are simulating P. Those instructions will include a number of conditionals, one of which *will* trigger and return 0.
> So then you too are simply not bright enough to understand that a
> function called in infinite recursion never returns to its caller.