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

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
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer