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.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)