Re: Is everyone here faking that they know anything about the x86 language? Peter Olcott sure is,

On 8/5/24 11:16 AM, olcott wrote:

I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

You started late. My first computer had 4096 bytes of ram and a cassette tape drive as storage media.

 I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

I was programming my computer in ACTUAL 8088 assembly language.

 HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

Nope, and the claim just prove you to be stupid.
You have YET to produce a trace as produced by the decider showing such a simulation.

 They did this by deriving the correct execution trace that
simulating themselves simulating their input would derive.

But that isn't a correct emulation of themselves.
Soryy, you just admitted to being a LIAR.
What its output is, and how it got it are two DIFFERENT things.

 Maybe all of my reviewers have been saying that I am wrong
about this on the basis of pure bluster in that they are
totally confused by assembly language and don't have the
slightest clue what it means.

Nope, you are wrong about it due to actual definitions, something you don't seem to understand,.

 Feigning competence with the x86 language for the purpose
of rebutting my work <is> deception.

But dispite your claims, you are still just LYING about what a correct x86 emualtion is.

 _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
[00002193][00103820][00000000] 8bec       mov ebp,esp
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4

The following is NOT a correct emulation of the above instruction.

 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
 

The following is NOT a correct emulation of the above instruction.

*The fact that this is the first instruction of DDD proves*

But since a proper emulation of HHH will never actually get there (since HHH NEVER "calls" DDD, just CONDITIONALLY emulates it) this just prove you "proof" is based on LIES.

*that HHH did correctly emulate itself emulating DDD even if*
*each HHH did this by a wild guess*

Nope, it proves you LIE.
Note, since HHH is a CONDITIONAL, a "functional" emualtion could have been done of HHH showing something like what you showed, but each point needs to have been prefaced by the fact that it was CONDITIONALLY emulated by HHH, and thus, the claim of a loop without conditionals can not be made.

 [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

And did so by incorrect logic.

 [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
 

Yep, you just proved that HHH(DDD), by your logic returns 0, and thus it doesn't correctly emulate DDD when it assumes that the HHH(DDD) that it calls never returns,
You are just proving that you are just a flat out pathological liar who doesn't actually know what he is talking about.