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

On 6/8/25 1:39 PM, Mr Flibble wrote:

On Sun, 08 Jun 2025 13:24:45 -0400, Richard Damon wrote:
 

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.

 The AI wrote it though, dear, so any errors are from the AI not me but
that is moot as I see no errors.
 /Flibble

But YOU then accepted that the AI's statement was good enough to put your name on it without even an AI disclaimer.
Repeating a statement you don't know to be likely true, make you just as guilty of the error.
Sorry, you just don't understand the rules of ethics.