Re: People are still trying to get away with disagreeing with the semantics of the x86 language

On 6/30/24 9:03 PM, olcott wrote:

On 6/30/2024 7:44 PM, Richard Damon wrote:

On 6/30/24 8:27 PM, olcott wrote:

On 6/30/2024 7:13 PM, Richard Damon wrote:

On 6/30/24 8:00 PM, olcott wrote:

>
THIS SEQUENCE CANNOT POSSIBLY RETURN WHY PERSISTENTLY LIE ABOUT IT?
THIS SEQUENCE CANNOT POSSIBLY RETURN WHY PERSISTENTLY LIE ABOUT IT?
THIS SEQUENCE CANNOT POSSIBLY RETURN WHY PERSISTENTLY LIE ABOUT IT?
THIS SEQUENCE CANNOT POSSIBLY RETURN WHY PERSISTENTLY LIE ABOUT IT?
THIS SEQUENCE CANNOT POSSIBLY RETURN WHY PERSISTENTLY LIE ABOUT IT?
>

>
But it does, just after H gives up its simulation.
>
You have even show that with a simulation.
>

>
Liar Liar Pants on Fire !!!
Liar Liar Pants on Fire !!!
Liar Liar Pants on Fire !!!

>
Are you forgetting this message:
>
On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
 > void H_Hat(u32 P)
 > {
 >  u32 Input_Halts = Halts(P, P);
 >  if (Input_Halts)
 >    HERE: goto HERE;
 > }
 >
 >
 > int main()
 > {
 >  H_Hat((u32)H_Hat);
 > }
 >
 >
 > _H_Hat()
 > [00000b98](01)  55                      push ebp
 > [00000b99](02)  8bec                    mov ebp,esp
 >
[00000b9b](01)  51                      push ecx
 > [00000b9c](03)  8b4508                  mov eax,[ebp+08]
 > [00000b9f](01)  50                      push eax
 > [00000ba0](03)  8b4d08                  mov ecx,[ebp+08]
 > [00000ba3](01)  51                      push ecx
 > [00000ba4](05)  e88ffdffff              call 00000938
 > [00000ba9](03)  83c408                  add esp,+08
 > [00000bac](03)  8945fc                  mov [ebp-04],eax
 > [00000baf](04)  837dfc00                cmp dword [ebp-04],+00
 > [00000bb3](02)  7402                    jz 00000bb7
 > [00000bb5](02)  ebfe                    jmp 00000bb5
 > [00000bb7](02)  8be5                    mov esp,ebp
 > [00000bb9](01)  5d                      pop ebp
 > [00000bba](01)  c3                      ret
 > Size in bytes:(0035) [00000bba]
 >
 > _main()
 > [00000bc8](01)  55                      push ebp
 > [00000bc9](02)  8bec                    mov ebp,esp
 > [00000bcb](05)  68980b0000          push 00000b98
 > [00000bd0](05)  e8c3ffffff              call 00000b98
 > [00000bd5](03)  83c404                  add esp,+04
 > [00000bd8](02)  33c0                    xor eax,eax
 > [00000bda](01)  5d                      pop ebp
 > [00000bdb](01)  c3                      ret
 > Size in bytes:(0020) [00000bdb]
 >
 > ===============================
 > ...[00000bc8][001015d4][00000000](01)  55         push ebp
 > ...[00000bc9][001015d4][00000000](02)  8bec       mov ebp,esp
 > ...[00000bcb][001015d0][00000b98](05)  68980b0000 push 00000b98
 > ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff call 00000b98
 > ...[00000b98][001015c8][001015d4](01)  55         push ebp
 > ...[00000b99][001015c8][001015d4](02)  8bec       mov ebp,esp
 > ...[00000b9b][001015c4][00000000](01)  51         push ecx
 > ...[00000b9c][001015c4][00000000](03)  8b4508     mov  eax,[ebp+08]
 > ...[00000b9f][001015c0][00000b98](01)  50         push eax
 > ...[00000ba0][001015c0][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][001015bc][00000b98](01)  51         push ecx
 > ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff call 00000938
 > Begin Local Halt Decider Simulation at Machine Address:b98
 > ...[00000b98][00211674][00211678](01)  55         push ebp
 > ...[00000b99][00211674][00211678](02)  8bec       mov ebp,esp
 > ...[00000b9b][00211670][00201644](01)  51         push ecx
 > ...[00000b9c][00211670][00201644](03)  8b4508     mov eax,[ebp+08]
 > ...[00000b9f][0021166c][00000b98](01)  50         push eax
 > ...[00000ba0][0021166c][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][00211668][00000b98](01)  51         push ecx
 > ...[00000ba4][00211664][00000ba9](05)  e88ffdffff call 00000938
 > ...[00000b98][0025c09c][0025c0a0](01)  55         push ebp
 > ...[00000b99][0025c09c][0025c0a0](02)  8bec       mov ebp,esp
 > ...[00000b9b][0025c098][0024c06c](01)  51         push ecx
 > ...[00000b9c][0025c098][0024c06c](03)  8b4508     mov eax,[ebp+08]
 > ...[00000b9f][0025c094][00000b98](01)  50         push eax
 > ...[00000ba0][0025c094][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][0025c090][00000b98](01)  51         push ecx
 > ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff call 00000938
 > Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
Above decision was from the call the Halts inside H_Hat, deciding that H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is processed below:
>
 > ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
 > ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
 > ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword [ebp-04],+00
 > ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
 > ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
 > ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
 > ...[00000bba][001015d0][00000b98](01)  c3         ret
 > ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
 > ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
 > ...[00000bda][001015d8][00100000](01)  5d         pop ebp
 > ...[00000bdb][001015dc][00000098](01)  c3         ret
>
SEE IT HALTED!
>
 > Number_of_User_Instructions(39)
 > Number of Instructions Executed(26567)
>
>
>
>

>
  DDD correctly emulated by HHH calls an emulated HHH(DDD)
that emulates its own DDD that calls an emulated HHH(DDD)
that is either aborted at some point never returning or
hits out-of-memory error never returning
>
>
>

>
But HHH doesn't "Correctly Emulation" DDD by the definition that provides the full behavior.
>
Since *THE* HHH DOES abort its emulation of *THIS* DDD, then THIS DDD will return, just after this HHH has given up its emulation.
>
You LIE by confusing THIS HHH with another machine you try to also call HHH, looking at a DIFFERENT input you deceptively try to also call DDD that is different because it has been paired with that other HHH.
>
None of that other behavior matters for THIS DDD.
>
You are just proving you don't understand the meaning of the words you are using, but you MAKE UP fake defintions out of your IGNORANCE and lie that they are the right definitions.
>
>
Sorry, it looks like you are fated for a Hot time in the future.

 Your despicable lying strawman deception may work on fools
I am no fool.
 I had to dumb this down because even the smartest
people here were overwhelmed:
 The call from DDD to HHH(DDD) when N steps of DDD are
correctly emulated by any pure function x86 emulator
HHH at machine address 0000217a cannot possibly return.

But that is NOT the "behavior of the input", and CAN NOT BE SO DEFINED.
"N Steps", where that N is determined by the decider, make the criteria NOT VALID, as it isn't a criteria based on the input alone.
All you can claim is that HHH can not simulate the input to the return statement, NOT that the "behavior of the input" is to not return.
Your claim is like the claim that "If cats were dogs, then we can show that cat bark".
You are just demonstrating your utter ignorance of the basic principles of the field.
There is not "Mathematical Mapping" of the INPUT ALONE that your deciders can be trying to compute, so your criteria is just INVALID.
Your inability to see that just means that you are just to stupid or too ignorant to know what you are talking about.

 _DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]