On 6/22/22 9:41 PM, olcott wrote:
> On 6/22/2022 8:36 PM, Richard Damon wrote:
>> On 6/22/22 9:29 PM, olcott wrote:
>>> On 6/22/2022 8:14 PM, Richard Damon wrote:
>>>> On 6/22/22 8:55 PM, olcott wrote:
>>>>> On 6/22/2022 7:48 PM, Richard Damon wrote:
>>>>>> On 6/22/22 8:37 PM, olcott wrote:
>>>>>
>>>>>>> First you agree that my words are perfectly correct within their
>>>>>>> specified context
>>>>>>
>>>>>> Since you haven't actualy defined you context, and imply that it
>>>>>> is the halting problem, where they can not be correct, that is not
>>>>>> possible.
>>>>>>>
>>>>> First you agree that these words are 100% correct within the
>>>>> context of software engineering totally ignoring the context of the
>>>>> halting problem.
>>>>>
>>>>> #include <stdint.h>
>>>>> #define u32 uint32_t
>>>>>
>>>>> #include <stdint.h>
>>>>> typedef void (*ptr)();
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>    if (H(x, x))
>>>>>      HERE: goto HERE;
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(P, P));
>>>>> }
>>>>>
>>>>> _P()
>>>>> [000010d2](01)  55              push ebp
>>>>> [000010d3](02)  8bec            mov ebp,esp
>>>>> [000010d5](03)  8b4508          mov eax,[ebp+08]
>>>>> [000010d8](01)  50              push eax
>>>>> [000010d9](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [000010dc](01)  51              push ecx
>>>>> [000010dd](05)  e820feffff      call 00000f02
>>>>> [000010e2](03)  83c408          add esp,+08
>>>>> [000010e5](02)  85c0            test eax,eax
>>>>> [000010e7](02)  7402            jz 000010eb
>>>>> [000010e9](02)  ebfe            jmp 000010e9
>>>>> [000010eb](01)  5d              pop ebp
>>>>> [000010ec](01)  c3              ret
>>>>> Size in bytes:(0027) [000010ec]
>>>>>
>>>>> Every sufficiently competent software engineer can easily verify
>>>>> that the complete and correct x86 emulation of the input to H(P,P)
>>>>> by H would never reach the "ret" instruction of P because both H
>>>>> and P would remain stuck in infinitely recursive emulation.
>>>>>
>>>>
>>>> So, if H actually is a program that does a COMPLETE and correct x86
>>>> emulation of its input, then YES, as I have said many time before,
>>>> this combination is non-halting.
>>>>
>>>> The fact that you need to keep going back to this, and seem to just
>>>> be refusing to accept the conditions under which you have proved it
>>>> just shows the problems with your thought process.
>>>>
>>>>> If H does correctly determine that this is the case in a finite
>>>>> number of steps then H could reject its input on this basis. Here
>>>>> are the details of exactly how H does this in a finite number of
>>>>> steps.
>>>>
>>>> Except that NOW H isn't the H we were just talking about, so you are
>>>> just proving that you are either lying or an idiot.
>>>>
>>>> Remember, the first analysis had the CONDITION on it that H did a
>>>> COMPLETE and correct x86 emulation.
>>>>
>>>> Once you remove that property form H, that conclusion no long holds
>>>> and you are shown to be a lying idiot.
>>>>
>>>>>
>>>>> typedef struct Decoded
>>>>> {
>>>>>    u32 Address;
>>>>>    u32 ESP;          // Current value of ESP
>>>>>    u32 TOS;          // Current value of Top of Stack
>>>>>    u32 NumBytes;
>>>>>    u32 Simplified_Opcode;
>>>>>    u32 Decode_Target;
>>>>> } Decoded_Line_Of_Code;
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [000010d2][00211e8a][00211e8e] 55         push ebp
>>>>> [000010d3][00211e8a][00211e8e] 8bec       mov ebp,esp
>>>>> [000010d5][00211e8a][00211e8e] 8b4508     mov eax,[ebp+08]
>>>>> [000010d8][00211e86][000010d2] 50         push eax        // push P
>>>>> [000010d9][00211e86][000010d2] 8b4d08     mov ecx,[ebp+08]
>>>>> [000010dc][00211e82][000010d2] 51         push ecx        // push P
>>>>> [000010dd][00211e7e][000010e2] e820feffff call 00000f02   // call H
>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>
>>>>> // actual fully operational code in the x86utm operating system
>>>>> u32 H(u32 P, u32 I)
>>>>> {
>>>>> HERE:
>>>>>    u32 End_Of_Code;
>>>>>    u32 Address_of_H;              // 2022-06-17
>>>>>    u32 code_end                  = get_code_end(P);
>>>>>    Decoded_Line_Of_Code *decoded = (Decoded_Line_Of_Code*)
>>>>> Allocate(sizeof(Decoded_Line_Of_Code));
>>>>>    Registers*  master_state      = (Registers*)
>>>>> Allocate(sizeof(Registers));
>>>>>    Registers*  slave_state       = (Registers*)
>>>>> Allocate(sizeof(Registers));
>>>>>    u32*        slave_stack       = Allocate(0x10000); // 64k;
>>>>>    u32  execution_trace =
>>>>> (u32)Allocate(sizeof(Decoded_Line_Of_Code) * 1000);
>>>>>
>>>>>    __asm lea eax, HERE             // 2022-06-18
>>>>>    __asm sub eax, 6                // 2022-06-18
>>>>>    __asm mov Address_of_H, eax     // 2022-06-18
>>>>>    __asm mov eax, END_OF_CODE
>>>>>    __asm mov End_Of_Code, eax
>>>>>
>>>>>    Output("Address_of_H:", Address_of_H); // 2022-06-11
>>>>>    Init_slave_state(P, I, End_Of_Code, slave_state, slave_stack);
>>>>>    Output("\nBegin Simulation   Execution Trace Stored at:",
>>>>> execution_trace);
>>>>>    if (Decide_Halting(&execution_trace, &decoded, code_end,
>>>>> &master_state,
>>>>>                       &slave_state, &slave_stack, Address_of_H, P, I))
>>>>>        goto END_OF_CODE;
>>>>>    return 0;  // Does not halt
>>>>> END_OF_CODE:
>>>>>    return 1; // Input has normally terminated
>>>>> }
>>>>>
>>>>> H knows its own machine address and on this basis it can easily
>>>>> examine its stored execution_trace of P and determine:
>>>>> (a) P is calling H with the same arguments that H was called with.
>>>>> (b) No instructions in P could possibly escape this otherwise
>>>>> infinitely recursive emulation.
>>>>> (c) H aborts its emulation of P before its call to H is invoked.
>>>>>
>>>>>
>>>>
>>>> (b) is NOT a correct rule. Thos has been pointed out before, and you
>>>> have ignored it.
>>>>
>>> That you don't understand what I mean does not mean that it is an
>>> incorrect rule.
>>>
>>> Here is an example where P does have instruction that could possibly
>>> escape this otherwise infinitely recursive emulation:
>>>
>>>
>>> void P(ptr x)
>>> {
>>> static count = 0;
>>>    count++;
>>>    if count > 3)
>>>      return;
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>
>> FALLACY of proof by example. I never said that (b) isn't sometimes
>> true, just it isn't an always true condition. You fail at elementary
>> logic.
>
> Try and find a valid counter-example. Every attempt at rebuttal that is
> not a valid counter-example is one form of deception or another.
>
>

P(P)

The conditional that break the loop is in the H that you are excluding
from the 'function' P incorrectly.

I have said this before. You just can't learn it seems.