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

On 6/8/25 10:25 AM, Mr Flibble wrote:

On Sun, 08 Jun 2025 07:08:06 -0400, Richard Damon wrote:
 

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.

 Arguing with an AI is the same as shouting into the void, dear.
 /Flibble

No, because the AI didn't actually POST it, so I was pointing out the errors made by the POSTER who is responsible for everything they post,
Just because you quoted an AI (without attribution) doesn't make you not guilty of the errors you posted.
Sorry, you are just showing how little you understand.