Re: Every HHH(DDD) is correct to reject its input

On 5/31/2025 5:03 PM, Mr Flibble wrote:

On Sat, 31 May 2025 17:00:17 -0500, olcott wrote:
 

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

 Show the C code to which that assembly relates.
 /Flibble

void DDD()
{
   HHH(DDD);
   return;
}
int main()
{
//DD();
   DDD();
//Output("Input_Halts = ", HHH(main));
//Output("Input_Halts = ", HHH(Infinite_Loop));
//Output("Input_Halts = ", HHH(Infinite_Recursion));
//Output("Input_Halts = ", D(D));
//  Output("Input_Halts = ", HHH(Infinite_Recursion));
//Output("Input_Halts = ", HHH(Sipser_D));
//Output("Input_Halts = ", HHH(DDD));
//Output("Input_Halts = ", HHH(DD));
//Output("Input_Halts = ", HHH1(DDD));
//Output("Input_Halts = ", HHH1(DD));
   return 0;
}
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer