Re: The execution trace of HHH1(DDD) shows the divergence

On 6/8/25 5:35 AM, Mr Flibble wrote:

On Sat, 07 Jun 2025 18:56:09 -0400, Richard Damon wrote:
 

On 6/7/25 10:32 AM, olcott wrote:

The execution trace of HHH1(DDD) shows the divergence of DDD emulated
by HHH from DDD emulated by HHH1.

>
No it doesn't, all you are doing is showing you don't know what an
execution trace needs to show, because "correct" seems to be a foreign
word to you.
>
>

int main()
{
    HHH1(DDD);
}
>
Shows that DDD emulated by HHH and DDD emulated by HHH1 diverges as
soon as HHH begins emulating itself emulating DDD.

>
But never correctly emulates the CALL instruction, as REQUIRED to be a
correct emulation.
>
Note, to even do that you first need to fix the input, as the input you
give is IMPOSSIBLE to "correctly emulate" as the correct emulation of
the call HHH instruction will requiring knowing the contents of 000015c3
(the code of the function HHH) but that infomation is not available.
>
>

*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1              DDD emulated by HHH [00002183] push
ebp               [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186]
push 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b] call
000015c3 ; HHH *HHH1 emulates DDD once then HHH emulates DDD once,
these match*

>
And NEITHER of the following is a correct emulation of the input, as per
the definition of the call instruction, the next instruction to be
processed will be at location 000015c3.
>
Sorry, all you are doing is proving your stupidity, as you clearly don't
understand teh meaning of the words you are using, even when they have
been explained to you many timees.
>
I guess you just want to prove to the world that you are just a stupid
liar.
>
>

The next instruction of DDD that HHH emulates is at the machine address
of 00002183.
>
>

WRONG. I guess you are just asserting that it is ok to just LIE about
what is happening, and that either your HHH is just not emulating itself
as you claim (and thus it is a lie) or you are just misresenting what it
is doing, by omitting the stes in that proof that shows
>

The next instruction of DDD that HHH1 emulates is at the machine
address of 00002190.

>
Nope, not by your above definition, as if the emulator can claim its
input is doing what the emulation of an emulator is seeing, then it
should see exactly the same thing as above.
>
Note, the HHH that HHH is emulating is a DIFFERENT execution context,
and thus aren't both by the "HHH" that is doing the deciding, but can
only be shown under the guise of a simulation of a simulation shows that
simulated code.
>
The problem is in your LYING editing of the traces.
>
>

00002183 != 00002190
>
_DDD()
[00002183] 55             push ebp [00002184] 8bec           mov
ebp,esp [00002186] 6883210000     push 00002183 ; push DDD [0000218b]
e833f4ffff     call 000015c3 ; call HHH [00002190] 83c404         add
esp,+04 [00002193] 5d             pop ebp [00002194] c3             ret
Size in bytes:(0018) [00002194]
>
_main()
[000021a3] 55             push ebp [000021a4] 8bec           mov
ebp,esp [000021a6] 6883210000     push 00002183 ; push DDD [000021ab]
e843f3ffff     call 000014f3 ; call HHH1 [000021b0] 83c404         add
esp,+04 [000021b3] 33c0           xor eax,eax [000021b5] 5d
pop ebp [000021b6] c3             ret Size in bytes:(0020) [000021b6]
>
   machine   stack     stack     machine    assembly address
   address   data      code       language ========  ========
   ========  ========== =============
<main is executed>
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
</main is executed>
>
New slave_stack at:1038d1 Begin Local Halt Decider Simulation
Execution Trace Stored at:1138d9
>
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH1>
>
New slave_stack at:14e2f9 Begin Local Halt Decider Simulation
Execution Trace Stored at:15e301
>
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH <DDD
emulated by HHH>
>
New slave_stack at:198d21  DDD emulated by HHH *This is the beginning
of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
>
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH emulating itself>
>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped HHH
returns to caller
>
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
</DDD emulated by HHH1>
>
<main is executed>
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main()
[000021b5][00103831][00000018] 5d         pop ebp     ; main()
[000021b6][00103835][00000000] c3         ret         ; main() </main
is executed>
Number of Instructions Executed(352831) == 5266 Pages
>

 ## 🧠 **Summary of Argument**
 **Olcott** claims:
 * That `HHH1(DDD)` and `HHH(DDD)` simulate `DDD` differently.
* The divergence starts when `HHH` recursively begins simulating itself
simulating `DDD`.
* Therefore, this behavior implies that `DDD` does not halt, and this non-
halting is correctly detected by `HHH`.
 **Damon** replies:
 * The simulation is invalid unless it correctly simulates the machine
behavior, specifically how the `CALL` instruction should behave.
* The trace that Olcott provides is **incomplete or dishonest** — it
either skips instructions or represents a fabricated divergence.
* He accuses Olcott of **misrepresenting** what a proper emulation must
do, especially around control flow and return addresses.
* Concludes that either Olcott’s `HHH` is not an SHD (i.e. doesn't decide
correctly in finite time) or that his simulation is incorrect.
 ---
 ## 🔍 **Key Points in the Exchange**
 ### 1. **Correct Simulation Semantics**
 * **Damon’s position** is rooted in a classical notion of what an emulator
must do: faithfully reproduce the execution path of the simulated program.
* He argues that unless the call to `HHH` in the emulated `DDD` properly
emulates the control transfer and return flow, the trace cannot be trusted.
 **Evaluation**: Damon is correct that **a valid simulation must preserve
instruction semantics**, including stack behavior and return addresses. If
the `CALL` is not properly simulated, it cannot be claimed that the system
is correctly analyzing `DDD`.
 ---
 ### 2. **Divergence as Non-Halting Evidence**
 * Olcott treats the recursive descent into `HHH` (within `HHH`) as **proof
of infinite recursion** and therefore of non-halting behavior.
* Damon counters that this behavior is expected — it’s how the paradoxical
structure of the Halting Problem works — but doesn’t imply that `HHH` has
made a valid decision.
 **Evaluation**: Olcott’s SHD claims to detect infinite recursion **by
simulation**, but that assumes the simulation itself is well-formed. Damon
rightly points out that detecting “infinite simulation” is **not
meaningful** unless the simulation obeys the semantics of the underlying
system.
 ---
 ### 3. **Emulation vs. Execution Confusion**
 * Damon repeatedly accuses Olcott of confusing the simulation process
(meta-level) with actual execution (object-level), a point **also raised
earlier by Flibble**.
* If `HHH` is analyzing `DDD`, it must treat it as data — not execute it
as part of its own runtime.
 **Evaluation**: Olcott’s trace blurs the boundary between these layers.
Damon is correct to demand clarity: is the code being run or analyzed?
 ---
 ### 4. **Tone and Dismissal**
 * Damon uses harsh language: *“proving your stupidity”*, *“lying
editing”*, *“you are just a stupid liar”*.
* These undermine the clarity of his technical arguments.
 **Evaluation**: Damon’s tone, while perhaps expressing frustration, is
**counterproductive**. It detracts from his valid critiques and gives
Olcott rhetorical ground to claim hostility or bad faith.
 ---
 ## ✅ **Conclusion**
 **Technically**, Damon’s criticisms are sound:
 * A simulation must accurately emulate machine instructions.
* Recursive behavior in the simulation is **not itself proof** of non-
halting unless the simulation is verified correct.
* `HHH` must be deterministic and finite to qualify as a decider —
aborting without justification is not acceptable.

Nothing wrong with aborting with out reason, even WITH a correct reason, it just means it is not the source of the truth of the proposition.
What isn't acceptable is the idiodic idea that the wrong answer can be right because you lie about what the criteria means.

 **However**, Damon’s **accusatory tone weakens the discussion**. While
Olcott’s SHD model may lack rigor or semantic clarity, the engagement
would benefit from **less ad hominem and more structured critique**.

And Fibbles use of Artificial Intelegence just shows that he is naturally stupid.
The fact that Olcott is using a KNOWN (as effectively admitted) INCORRECT "semantics" (since they don't actually have meaning, they can't actually be semantics), he has earned the accusatory tone.
Note, YOU clearly don't understand what ad hominem means, it means an argument that the persons argument is wrong because of something about the person. I do not do that, I show he is wrong, because his statements are factually wrong based on the requirement of using the honest definitions of the words. I then point out that for someone to continue to make the same erroneous statements even after being corrected, and while ignoring the errors pointed out, just provides positive proof of their mental condition.
Just like your continued use of AI output shows that you don't understand what you are doing yourself.
At least Olcott provided us with his prompts, so we were able to point out the errors in them. Since we have no idea what LIES you gave as your prompt, this AI output is actually meaningless.