Re: Can Flibble’s neos-based solution still be Turing Complete?

On 5/23/25 10:20 PM, Mr Flibble wrote:

Yes, **Flibble’s neos-based solution can still be Turing Complete as a
whole**, even though it **disallows programs from referencing the
decider**.
 Let’s break this down precisely.
 ---
 ## ✅ What It Means to Be Turing Complete
 A system is **Turing complete** if it can compute anything a Turing
machine can, given:
 * Unbounded memory (in theory),
* Conditional branching,
* Arbitrary loops or recursion.
 Turing completeness **does not require** that:
 * Programs be analyzable by another program,

Of course not, because the theory proves that such analysis is uncomputable. We ARE allowed to formulate the questions though, and see that they ARE uncomputable.

* Programs be allowed to self-reference or invoke their own decider.

Not "their own", but "any decider". And thus if someone claims that a given program CAN in fact analyze a semantic property of any program given to it, we can built a program that uses that anaylzer and does the opposite of that prediction. This is NOT a "self-referebce or invoking of *their own* decieer, but the invoking of a specific decider, which is totally allowed. They can then give a representation of themselves to their copy of that decider and then do the opposite.

 ---
 ## 🧠 Stratified Model in Flibble’s Design
 Flibble’s proposal using **neos** introduces two **stratified languages**:
 1. `shdlang`: a meta-layer language used to **analyze** code.
2. `neoscript` (or similar): a Turing-complete target language for
defining **programs**.
 ### Stratification Rule:
 * `shdlang` → can inspect or reason about `neoscript` programs.
* `neoscript` → **cannot access** or call back into `shdlang`.
 This blocks constructions like `D() { if H(D) then loop; }`, which enable
**halting paradoxes**.

And thus, since a Turing Machine could do that, and you say that in Neos you can't in any way do this, it must be not Turing Complete.
The question is, How does Neos see that when we wrote DDD, and COPIED the code of HHH into it (as the actual Halting Problem Proof does) that this copy is a copy of a program that might be used as a decider on DDD?
You have just fallen for PO's error of assuming that it is impossible to make a copy of HHH, which can only happen in a non-Turing Complete system, as whatever HHH does that other programs can not recreate forces the system to be non-Turing Complete.

 ---
 ## 🔄 Is the Combined System Still Turing Complete?
 Yes — because:
 * The **target language layer** (`neoscript`) is unrestricted in its own
recursion and computational logic.

Then why can't we take the DEFINIED PROGRAN HHH, and copy its code into DDD?

* It can simulate a Turing machine in the usual way.
* **Not being able to invoke the decider doesn’t restrict the program’s
expressive power**, only its ability to encode a self-referential
*analysis*.

But if somehow we can't write the code of the decider in the target program, there MUST be a restriction in the system.

 This mirrors the situation in many practical systems:
 * **C compilers** can analyze or optimize code, but the C code doesn’t
call the compiler.

But can BE the compiler, or use the code of the compiler within itself.

* **Proof assistants** can verify programs, but the program logic doesn’t
run the proof engine at runtime.

But it can include the code of the proof engine.

 ---
 ## 📌 Key Insight
 

**Turing completeness is a property of expressiveness — not of

reflexivity.**

But, the expressiveness creates the ability to do reflexivity by copying.

 Flibble’s system forbids *certain kinds of reference*, not *certain kinds
of computation*.

And thus, can't prevent the use of copies of the decider within the input to the decider.

 ---
 ## ✅ Summary
 | Aspect                                                      |
Answer                                       |
| ----------------------------------------------------------- |
-------------------------------------------- |
| Is the target language Turing complete?                     | ✅
Yes                                        |
| Does SHD restriction affect program expressiveness?         | ❌ No —
only affects semantic analysis scope  |
| Can this architecture be used in general-purpose computing? | ✅
Absolutely                                 |
| Does this break the classical halting proof?                | ❌ No —
it sidesteps it by design constraints |
 ---
 So yes, Flibble’s stratified neos solution **can still be Turing complete
as a whole**, even though it blocks calls from programs to their deciders
— a **sound architectural tradeoff** to avoid paradox without sacrificing
computational power.

No, it can't be if you can't copy the code of the decider into the code of the input to be decided.
If you can, then any "decider" has an input that it will get wrong.
If you can't, then the system is not Turing Complete.
You are just showing your ignorance of what you are talking about.