Re: DDD emulated by HHH --- (does not refer to prior posts)

On 8/31/24 8:03 AM, olcott wrote:

On 8/31/2024 4:07 AM, Fred. Zwarts wrote:

Op 30.aug.2024 om 16:58 schreef olcott:

On 8/30/2024 9:56 AM, joes wrote:

Am Thu, 29 Aug 2024 09:07:39 -0500 schrieb olcott:

On 8/29/2024 2:17 AM, Mikko wrote:

On 2024-08-28 12:08:06 +0000, olcott said:

On 8/28/2024 2:39 AM, Mikko wrote:

On 2024-08-27 12:44:31 +0000, olcott said:

On 8/27/2024 3:38 AM, Fred. Zwarts wrote:

Op 27.aug.2024 om 04:33 schreef olcott:

This is intended to be a stand-alone post that does not reference
anything else mentioned in any other posts.
_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]
>
When we assume that:
(a) HHH is an x86 emulator that is in the same memory space as
DDD. (b) HHH emulates DDD according to the semantics of the x86
language.
then we can see that DDD emulated by HHH cannot possibly get past
its own machine address 0000217a.
>

Yes, we see. In fact DDD is not needed at all.

https://en.wikipedia.org/wiki/Straw_man

You should also point a link to the equivocation fallacy. You use it
more often than straw man.

Isomorphism is not equivocation

The use of HHH for many purposes (a specific program, an unpsecified
memeber of a set of programs, a hypothetical program) is.
Your first posting looked like you were going to apply equivocation
later in the discussion. Now, after several later messages, it seems
that you want to apply the fallacy of "moving the goal posts" instead.
>

HHH correctly predicts what the behavior of DDD would be if this HHH
never aborted its emulation of DDD.

Problem is, DDD is then not calling itself, but the non-input of a
not-aborting HHH.
>

>
*This is before any aborting occurs*
*This is before any aborting occurs*
*This is before any aborting occurs*

>
Here is your problem. The code of the program and its meaning according to the semantics of the x86 language, does not suddenly change when the aborting occurs.

 You cannot possibly say one damn thing about the behavior of DDD
until you first understand that a world class x86 emulator that
HHH calls does enable HHH to correctly emulate itself emulating
DDD and the following execution trace proves this.
 SE CANNOT POSSIBLY HAVE ANY HONEST DIALOGUE WHEN MY REVIEWERS
INSIST ON LYING ABOUT VERIFIED FACTS.

No, we can't possibly have any honest dialogue when *YOU* insist on lying about the verified facts.
It is a *FACT* that since your final HHH returns to its caller, that DDD, and thus a correct emulation of DDD will reach its final state,
Your world class emulator has proven this, but you close your eyes to that fact.
Your HHH LIES to you, because you taught it to do so, about what it sees.

 _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]
 _main()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404     add esp,+04
[000021a2] 50         push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408     add esp,+08
[000021b0] 33c0       xor eax,eax
[000021b2] 5d         pop ebp
[000021b3] c3         ret
Size in bytes:(0034) [000021b3]
   machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002192][00103820][00000000] 55         push ebp      ; Begin main()
[00002193][00103820][00000000] 8bec       mov ebp,esp   ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
 New slave_stack at:1038c4
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc
[00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
[00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 [0000219f][00103820][00000000] 83c404     add esp,+04
[000021a2][0010381c][00000000] 50         push eax
[000021a3][00103818][00000743] 6843070000 push 00000743
[000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408     add esp,+08
[000021b0][00103820][00000000] 33c0       xor eax,eax
[000021b2][00103824][00000018] 5d         pop ebp
[000021b3][00103828][00000000] c3         ret
Number of Instructions Executed(10069) == 150 Pages
 

Note, this trace shows, by simply isomorphism that DDD must halt when correctly emulated as the trace would be INDENTICAL (except for the 4 inital lines, and just the addresses of those lines) to the point of HHH returning if we change the initial addresses to be thato of DDD instead of main.
The only way for there to be a difference is if HHH fails to be the "pure function" that a correct emulator needs to be (or a decider).
The fact that you HHH turns out to NOT be such a thing, just proves your example is based on lying.
Thus PROVING beyond ALL DOUBT that DDD is actually halting, and that HHH, becuase YOU TAUGHT IT THAT WAY, lies about what the input does.
Sorry, you are just proving your utter stupidity