On 5/31/2025 4:45 PM, Mr Flibble wrote:
On Sat, 31 May 2025 16:38:41 -0500, olcott wrote:
On 5/31/2025 4:30 PM, Mr Flibble wrote:
On Sat, 31 May 2025 16:27:07 -0500, olcott wrote:
>
On 5/31/2025 4:00 PM, Mr Flibble wrote:
On Sat, 31 May 2025 15:54:52 -0500, olcott wrote:
>
On 5/31/2025 3:43 PM, Mr Flibble wrote:
On Sat, 31 May 2025 15:40:15 -0500, olcott wrote:
>
On 5/31/2025 3:30 PM, Mr Flibble wrote:
On Sat, 31 May 2025 15:10:39 -0500, olcott wrote:
>
On 5/31/2025 2:44 PM, Mr Flibble wrote:
Flibble's Argument: Execution vs Simulation in SHDs
====================================================
>
In the context of Simulating Halt Deciders (SHDs), the
distinction between execution and simulation is fundamental.
>
Correct: External Simulation ----------------------------
int main() {
HHH(DDD); // SHD simulates/analyzes DDD from the
outside.
}
>
- In this model, DDD is not being executed — it's being passed
as data to HHH, which is analyzing it.
- Even if DDD() (the function definition) contains a recursive
call to HHH(DDD), this is just part of the code being
simulated, not something that is actively executing.
- Thus, the simulation can detect infinite recursion
structurally, without running DDD.
>
Incorrect: Active Execution ---------------------------
int main() {
DDD(); // Directly executes DDD, which calls HHH(DDD)
during runtime.
}
>
>
We can't simply reject this as incorrect since it is the basis
of every rebuttal of my work.
>
It *is* incorrect to assume that the HHH that DDD calls is
supposed to report on the behavior of its caller.
>
- In this scenario, you’re actually running DDD, not simulating
it. - If DDD() calls HHH(DDD) at runtime, you're now mixing
execution and analysis in the same layer, violating the
stratified model.
- This results in self-referential execution that undermines
decidability — a category error akin to the original halting
paradox.
>
Key Insight -----------
As long as DDD is not executing and is only being simulated by
HHH, it doesn’t matter that DDD would call HHH(DDD) — because
that call is never actually made. It exists in the simulated
model, not in the runtime environment. Thus, structural
recursion can be detected safely and treated as non-halting
without triggering a paradox.
>
This stratification (meta → base) is what keeps the model
coherent.
>
A PhD computer scientist Eric Hehner has this same view. He
explains this view as the analyzer and the analyzed are in
different programming languages where the input cannot directly
call its analyzer.
>
I only very recently discovered that it is 100% impossible to
actually define *an input* that does the opposite of whatever
value its analyzer returns.
>
In every conventional proof of the halting problem it has always
been that the decider cannot correctly report on the behavior of
its caller.
>
You will find thousands of messages posted in this forum where
everyone says that I am wrong because HHH does not report on the
behavior of the direct execution of DDD() (AKA its caller).
>
You cannot both execute and simulate DDD as part of the same
analysis,
if you do that then you are WRONG.
>
/Flibble
>
int main()
{
DDD(); // calls HHH(DDD) that simulates its own separate
} // instance of DDD. The analysis does not begin
// until after HHH(DDD) is called.
>
That is a type violation (category error), i.e. WRONG. Simulation
analysis of DDD should involve no DIRECT execution of DDD
WHATSOEVER.
>
/Flibble
>
I know that and you know that yet no one else here knows that.
>
Stop lying, you don't know that at all: you are just wrong unless you
accept that what I am saying is correct and you have been wrong until
I told you how you were wrong.
>
/Flibble
>
You are much more correct than anyone else here besides me.
>
You are wrong unless you accept that you cannot simulate DDD if DDD is
already executing.
>
/Flibble
>
If you know object oriented programming then you understand the idea of
distinct object instances.
>
There are three different instances of DDD when DDD() is directly
executed from main().
>
I have fully operational code that proves that the directly executed
DDD() invokes HHH(DDD) that does simulate its input.
>
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The main() in that code does call HHH(DDD) not DDD() so what the fuck are
you talking about on Usenet?
/Flibble
I simplified that one so that people don't get confused.
main() usually has 30 function calls where 29 are
commented out. Here is the full execution trace of
the directly executed DDD().
_DDD()
[00002177] 55 push ebp
[00002178] 8bec mov ebp,esp
[0000217a] 6877210000 push 00002177 ; push DDD
[0000217f] e853f4ffff call 000015d7 ; call HHH
[00002184] 83c404 add esp,+04
[00002187] 5d pop ebp
[00002188] c3 ret
Size in bytes:(0018) [00002188]
_main()
[00002197] 55 push ebp
[00002198] 8bec mov ebp,esp
[0000219a] e8d8ffffff call 00002177 ; call DDD
[0000219f] 33c0 xor eax,eax
[000021a1] 5d pop ebp
[000021a2] c3 ret
Size in bytes:(0012) [000021a2]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00002197][001037e9][00000000] 55 push ebp
[00002198][001037e9][00000000] 8bec mov ebp,esp
[0000219a][001037e5][0000219f] e8d8ffffff call 00002177 ; call DDD
[00002177][001037e1][001037e9] 55 push ebp
[00002178][001037e1][001037e9] 8bec mov ebp,esp
[0000217a][001037dd][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][001037d9][00002184] e853f4ffff call 000015d7 ; call HHH
// executed HHH emulates 1st instance of DDD
New slave_stack at:10388d
Begin Local Halt Decider Simulation Execution Trace Stored at:113895
[00002177][00113885][00113889] 55 push ebp
[00002178][00113885][00113889] 8bec mov ebp,esp
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
// emulated HHH emulates 2nd instance of DDD
New slave_stack at:14e2b5
[00002177][0015e2ad][0015e2b1] 55 push ebp
[00002178][0015e2ad][0015e2b1] 8bec mov ebp,esp
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[00002184][001037e1][001037e9] 83c404 add esp,+04
[00002187][001037e5][0000219f] 5d pop ebp
[00002188][001037e9][00000000] c3 ret
[0000219f][001037e9][00000000] 33c0 xor eax,eax
[000021a1][001037ed][00000018] 5d pop ebp
[000021a2][001037f1][00000000] c3 ret
Number of Instructions Executed(10071) == 150 Pages
-- Copyright 2025 Olcott "Talent hits a target no one else can hit; Geniushits a target no one else can see." Arthur Schopenhauer
Every HHH(DDD) is correct to reject its input
Re: Every HHH(DDD) is correct to reject its input