Path: news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory
Subject: Every HHH(DDD) is correct to reject its input
Date: Sat, 31 May 2025 15:10:39 -0500
Organization: A noiseless patient Spider
Lines: 74
Message-ID: <101fnnv$1dq3l$1@dont-email.me>
References: <Y_I_P.776479$B6tf.389685@fx02.ams4>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 31 May 2025 22:10:39 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="c9a131a468f55446a50ed4b18f7c4193";
	logging-data="1501301"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX18zmkhXwmcVNdmAsV2rQ34V"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:nOwZiml+Dq2Nh05qzmzLjtJRKJA=
X-Antivirus-Status: Clean
Content-Language: en-US
X-Antivirus: Norton (VPS 250531-4, 5/31/2025), Outbound message
In-Reply-To: <Y_I_P.776479$B6tf.389685@fx02.ams4>

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).



-- 
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer