On 6/22/22 8:37 PM, olcott wrote:
> On 6/22/2022 7:32 PM, Richard Damon wrote:
>> On 6/22/22 4:27 PM, olcott wrote:
>>> On 6/22/2022 2:31 PM, Mr Flibble wrote:
>>>> On Tue, 21 Jun 2022 21:38:56 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> #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.
>>>>>
>>>>> 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.
>>>>>
>>>>> 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.
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> Technically competent software engineers may not know this computer
>>>>> science:
>>>>>
>>>>> A halt decider must compute the mapping from its inputs to an accept
>>>>> or reject state on the basis of the actual behavior that is actually
>>>>> specified by these inputs.
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> The "ret" instruction of P is its final state.
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>>>
>>>>
>>>> void Px(u32 x)
>>>> {
>>>>     H(x, x);
>>>>     return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>> }
>>>>
>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>> Input_Halts = 0
>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>> Number of Instructions Executed(16120)
>>>>
>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>> QED.
>>>>
>>>> /Flibble
>>>>
>>>
>>> You and Richard are insufficiently technically competent at software
>>> engineering not meeting these specs:
>>>
>>> A software engineer must be an expert in: the C programming language,
>>> the x86 programming language, exactly how C translates into x86 and
>>> the ability to recognize infinite recursion at the x86 assembly
>>> language level. No knowledge of the halting problem is required.
>>>
>>>
>>
>> Except that I am probably at least as much of an expert on those
>> fields as you are. My one problem is that I do have knowledge of the
>> halting problem, that seems to make me resistant to your lies.
>>
>> You might have more experiance with x86, but only because I work on a
>> number of different architectures, but your argument really isn't x86
>> specific, that is just the case you are working in.
>>
>> (I was producing 'production' assembly routines 50 years ago, so I
>> have seen a number of different types of machines)
>
> 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.
>
> The software engineering aspect of this original post
> On 6/21/2022 9:38 PM, olcott wrote:
>
> then after this we can proceed with your objection that they do not meet
> the definitions.
>
> It is required that we have incremental closure on sub-points or full
> closure will be impossible to achieve.
>

Until you accept accurate definitions, closure is impossible.

To get there, first you need to actually defintely DEFINE what you think
you are saying with something that describes something possible.

For instance, defining H to make decision based on H's complete and
correct emulation requires as a prerequisite that H actual DOES a
complete and correct emulation, which means that it can not EVER abort
its simulation.

So ANY arguement based on H doing both a complete and correct emulation
and also abort its emulation is illogical and ill-defined.
It is just an example of the Liar's paradox, aptly named because it is
being given by a liar.