The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
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
On 6/7/2025 9:51 AM, dbush wrote:
On 6/7/2025 10:32 AM, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
False.
The next instruction of DDD that both HHH and HHH1 emulates is at the
machine address of 000015c3,
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
_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]
On 6/7/2025 10:01 AM, dbush wrote:
On 6/7/2025 10:58 AM, olcott wrote:
On 6/7/2025 9:56 AM, dbush wrote:
On 6/7/2025 10:54 AM, olcott wrote:
On 6/7/2025 9:51 AM, dbush wrote:
On 6/7/2025 10:32 AM, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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* >>>>>>>
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
False.
The next instruction of DDD that both HHH and HHH1 emulates is at
the machine address of 000015c3,
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
In other words, you're not operating on algorithms.
In other words you are not actually paying any attention.
I'm very much paying to attention to the fact that you stated that the
code of the function H is not part of the input and that you're
therefore not working on the halting problem.
You say that I said things that I never said.
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 addressWRONG. I guess you are just asserting that it is ok to just LIE about
of 00002183.
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
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 addressWRONG. I guess you are just asserting that it is ok to just LIE about
of 00002183.
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.
**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**.
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:## 🧠 **Summary of Argument**
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 machineWRONG. I guess you are just asserting that it is ok to just LIE about
address of 00002183.
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
**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.
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
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:## 🧠 **Summary of Argument**
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 machineWRONG. I guess you are just asserting that it is ok to just LIE about
address of 00002183.
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
**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
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:## 🧠 **Summary of Argument**
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 machineWRONG. I guess you are just asserting that it is ok to just LIE
address of 00002183.
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
**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.
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:## 🧠 **Summary of Argument**
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 machineWRONG. I guess you are just asserting that it is ok to just LIE
address of 00002183.
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
**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
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
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
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <[email protected]> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
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
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions
and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <[email protected]> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
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
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions
and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims
are just lies based on the category error of you not making HHH
actually a fixed programs, and thus DDD isn't a program, and thus not
something that CAN be correctly simulated, just shows that you don't
care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by
admitting that DDD isn't amoundg the category of things that can be
simulated.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that
show that you have just been lying all these years about your system
being the equivalent of the halting problem proof, just shows how
little you care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) correctly rejects its input as specifying
a non-halting sequence of configurations.
DD *is* the HP proof counter-example input.
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <[email protected]> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
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.
*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*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
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
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions
and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims
are just lies based on the category error of you not making HHH
actually a fixed programs, and thus DDD isn't a program, and thus not
something that CAN be correctly simulated, just shows that you don't
care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by
admitting that DDD isn't amoundg the category of things that can be
simulated.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that
show that you have just been lying all these years about your system
being the equivalent of the halting problem proof, just shows how
little you care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) correctly rejects its input as specifying
a non-halting sequence of configurations.
DD *is* the HP proof counter-example input.
You arguement effective begins with a statement with as much truth as
the statement that 1 is the color BLUE.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 716 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 58:58:12 |
| Calls: | 12,117 |
| Files: | 15,010 |
| Messages: | 6,518,720 |