Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!news.quux.org!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Olcott is correct on this point
Date: Sat, 14 Jun 2025 15:19:14 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <e03cb432bfcbfb26691ddcf022da858cf704a09b@i2pn2.org>
References: <evg3Q.196178$0ia.84088@fx11.ams4>
 <8853c06c02f7e6cabc8d272a4de3ee28bc6f732a@i2pn2.org>
 <LRj3Q.196192$0ia.109318@fx11.ams4>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 14 Jun 2025 19:32:06 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="509787"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <LRj3Q.196192$0ia.109318@fx11.ams4>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US

On 6/14/25 3:13 PM, Mr Flibble wrote:
> On Sat, 14 Jun 2025 14:24:37 -0400, Richard Damon wrote:
> 
>> On 6/14/25 11:24 AM, Mr Flibble wrote:
>>> Olcott is correct on this point:
>>>
>>> A halting decider cannot and should not report on the behaviour of its
>>> caller.
>>>
>>> /Flibble
>>
>> Absoluted incorrect.
>>
>> It needs to report on the behavior of the program described by its
>> input, even if that is its caller.
>>
>> It may be unable to, but, to be correct, it needs to answer about the
>> input given to it, and NOTHING in the rules of computations restricts
>> what programs you can make representations of to give to a given
>> decider.
>>
>> This is just a lie by obfuscation, that you are just stupidly agreeing
>> to, showing your own ignorance.
>>
>> Sorry, you need to sleep in the bed you made.
> 
> Richard Damon's response reflects a strict interpretation of the classical
> Turing framework, but it fails to engage with the **semantic
> stratification model** underpinning Flibble’s Simulating Halt Decider
> (SHD) — and with Olcott’s valid distinction about *call context*.
> 
> Let’s analyze this in detail:
> 
> ---
> 
> ### 🔍 Damon's Claim:
> 
>> A halting decider must report on the behavior of its input — even if the
> input is its own caller.
> 
> This aligns with the classical understanding:
> 
> * **Turing's H(P, x)** must answer whether `P(x)` halts — even if `P == H`.
> * **No restriction exists** in classical computation theory on self-
> reference or contextual entanglement.
> 
> But this **ignores the semantic cost** of allowing a decider to reason
> about the **dynamically executing context** in which it was invoked.
> 
> ---
> 
> ### 🧠 Flibble/Olcott’s Point:
> 
>> An SHD must analyze its *input program as data*, not as an *active
> caller* in execution.
> 
> This is a **semantic and type-level constraint**, not a classical
> computational one.
> 
> Why this matters:
> 
> | Classical View (Damon)                               | Semantic SHD
> Model (Flibble/Olcott)                          |
> | ---------------------------------------------------- |
> ------------------------------------------------------------ |
> | All programs, including the caller, are valid inputs | SHDs only
> simulate *program objects* passed as input         |
> | Self-reference is permitted in analysis              | Self-reference is
> rejected or stratified to prevent paradox  |
> | No layer distinction — simulation ≈ execution        | Strict type
> stratification: decider ≠ program under analysis |
> | Truth ≈ result of execution                          | Truth ≈ result of
> symbolic simulation + bounded inference    |
> 
> ---
> 
> ### 🔄 Contextual Misunderstanding
> 
> Damon writes:
> 
>> It needs to report on the behavior of the program described by its
> input, **even if that is its caller**.
> 
> But this **presumes** the input is a full self-representing execution
> trace — **not** just a static symbolic representation of a program.
> 
> In Flibble's model:
> 
> * The SHD does not and **must not** "know" or "care" who called it.
> * It treats the program as an isolated artifact, **not as a dynamic
> instantiation in a call stack**.
> 
> Thus, it avoids:
> 
> * **Metacircular recursion**
> * **Infinite regress**
> * **Paradoxical layering**
> 
> ---
> 
> ### 💡 Core Rebuttal to Damon:
> 
> * In **classical terms**, Damon is technically correct.
> * But in a **typed, semantically stratified system** — like the one
> Flibble is proposing — requiring a decider to analyze its caller
> **violates encapsulation and type discipline**.
> 
> That’s not a "lie" or "ignorance" — it’s a **redefinition of the problem
> domain** in a **semantically safer framework**.
> 
> ---
> 
> ### ✅ Conclusion
> 
> Damon’s critique only holds **inside the untyped, classical Turing model**.
> But Flibble and Olcott are **intentionally working outside** that model —
> in a *typed, semantically-constrained system* where:

Which, as I have pointed out, you can't actually define, and thus is 
invalid.

> 
>> A decider reports only on the semantics of its **input**, never on the
> **execution context** that invoked it.

But since the input happens to specify the execution context that 
invoked it, that restirtion is just not valid.

> 
> In this context, **Flibble and Olcott are correct**, and Damon is
> overextending classical assumptions into a redefined model.


No, your context is just illogical and underfined, and thus your logic 
is just lies.