The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
void DDD()
{
HHH(DDD);
return;
}
The *input* to simulating termination analyzer HHH(DDD)
specifies recursive simulation that can never reach its
*simulated "return" instruction final halt state* because
this input specifies that HHH simulates itself simulating DDD.
*Every rebuttal to this changes the words*
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the
best they can do is to waste their life in trying to do the
impossible.
Certainly doiing nothing and giving up
are not the best thing to do in this case.
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the
best they can do is to waste their life in trying to do the
impossible.
It is not at all impossible to create a termination
analyzer that reports on the behavior specified
by the input to HHH(DDD). It was never correct to
define a termination analyzer any other way.
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a analyzer.
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that
The official "received view" of this is that the best we can possibly
do is to do nothing and give up.
There is no official view about "the best". What is the best depends
on what one needs and wants. Some may think that the best they can do
is to waste their life in trying to do the impossible.
reports on the behavior specified by the input to HHH(DDD). It was
never correct to define a termination analyzer any other way.
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to the termination analysis of DDD, is to say it halts, since the HHH(DDD) that
DDD will call will return non-halting to that DDD, and it will then
halt.
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that
The official "received view" of this is that the best we can possibly >>>>> do is to do nothing and give up.
There is no official view about "the best". What is the best depends
on what one needs and wants. Some may think that the best they can do
is to waste their life in trying to do the impossible.
reports on the behavior specified by the input to HHH(DDD). It was
never correct to define a termination analyzer any other way.
analyzer.
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to the
termination analysis of DDD, is to say it halts, since the HHH(DDD) that
DDD will call will return non-halting to that DDD, and it will then
halt.
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is returned elsewhere.
/Flibble
On 6/10/2025 2:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that
The official "received view" of this is that the best we can possibly >>>>>> do is to do nothing and give up.
There is no official view about "the best". What is the best depends >>>>> on what one needs and wants. Some may think that the best they can do >>>>> is to waste their life in trying to do the impossible.
reports on the behavior specified by the input to HHH(DDD). It was
never correct to define a termination analyzer any other way.
analyzer.
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to the
termination analysis of DDD, is to say it halts, since the HHH(DDD) that >>> DDD will call will return non-halting to that DDD, and it will then
halt.
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is returned
elsewhere.
/Flibble
DDD correctly simulated by HHH cannot possibly
reach its "return" statement final halt state.
If your identical twin brother robbed a liquor
state that DOES NOT MAKE YOU GUILTY. In this
same way the behavior of the function that calls
HHH(DDD) says NOTHING about the behavior that
the input to HHH(DDD) specifies.
For 90 years people stupidly assumed that a
halt decider must report on the behavior of
its caller.
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the
best they can do is to waste their life in trying to do the
impossible.
Certainly doiing nothing and giving up
are not the best thing to do in this case.
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the
best they can do is to waste their life in trying to do the
impossible.
It is not at all impossible to create a termination
analyzer that reports on the behavior specified
by the input to HHH(DDD).
It was never correct to define a termination analyzer any other way.
On 6/11/2025 3:42 AM, Mikko wrote:
On 2025-06-10 17:14:58 +0000, olcott said:
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the
best they can do is to waste their life in trying to do the
impossible.
Certainly doiing nothing and giving up
are not the best thing to do in this case.
void DDD()
{
HHH(DDD);
return;
}
We could just go by the easily verified fact that DDD
correctly simulated by HHH cannot possibly reach its
own "return" instruction final halt state conclusively
proving that the input to HHH(DDD) specifies non-halting
behavior.
int main()
{
DDD(); // calls HHH(DDD)
}
The whole idea that HHH(DDD) must report on the behavior
of its caller is just nutty.
It is at least a valid way. Another valid way is to run forever, i.e.
until the user gives up and aborts the analyzer.
For a particular purpose something else could be better if it does
not cost too much more.
Often it is useful to have an analysis of the problem so that the
user of the analyzer can continue the analysis with other tools
or change the program so that the analyzer can analyze more of it.
It is not necessary that the analyzer identifies the input as
"pathological" but that identification may be useful in some cases.
On 6/10/25 3:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that
The official "received view" of this is that the best we can
possibly do is to do nothing and give up.
There is no official view about "the best". What is the best depends >>>>> on what one needs and wants. Some may think that the best they can
do is to waste their life in trying to do the impossible.
reports on the behavior specified by the input to HHH(DDD). It was
never correct to define a termination analyzer any other way.
analyzer.
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to
the termination analysis of DDD, is to say it halts, since the
HHH(DDD) that DDD will call will return non-halting to that DDD, and
it will then halt.
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is returned
elsewhere.
/Flibble
So, you have a problem, either you don't have a correct simulation to
show you got the right answer, or you don't answer.
That is the problem with trying to have the decider itself be two contradictory entities.
A correct simulator can not be a correct decider it the input is
actually non-halting.
There seems to be some mental block about the fact that the DEFINITION
of this sort of decider is that:
H(M) returns 1 if UTM(M) halts, and H(M) returns 0 if UTM(M) will never
halt
If you try to combine the the UTM and H into one program that it can
NEVER correctly return 0, as it can only return 0 if it never halt (and
thus can't return a value)
On 6/11/2025 1:21 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 23:15:51 -0400, Richard Damon wrote:
On 6/10/25 3:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a >>>>> analyzer.
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that
The official "received view" of this is that the best we can
possibly do is to do nothing and give up.
There is no official view about "the best". What is the best depends >>>>>>> on what one needs and wants. Some may think that the best they can >>>>>>> do is to waste their life in trying to do the impossible.
reports on the behavior specified by the input to HHH(DDD). It was >>>>>> never correct to define a termination analyzer any other way.
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to
the termination analysis of DDD, is to say it halts, since the
HHH(DDD) that DDD will call will return non-halting to that DDD, and >>>>> it will then halt.
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is returned
elsewhere.
/Flibble
So, you have a problem, either you don't have a correct simulation to
show you got the right answer, or you don't answer.
That is the problem with trying to have the decider itself be two
contradictory entities.
A correct simulator can not be a correct decider it the input is
actually non-halting.
There seems to be some mental block about the fact that the DEFINITION
of this sort of decider is that:
H(M) returns 1 if UTM(M) halts, and H(M) returns 0 if UTM(M) will never
halt
If you try to combine the the UTM and H into one program that it can
NEVER correctly return 0, as it can only return 0 if it never halt (and
thus can't return a value)
You are wrong. An SHD does not have to simulate an algorithm to
completion
if it determines non-halting early BY ANALYSIS.
/Flibble
You can tell him this 1000 times and he will never get it.
On 6/11/25 2:21 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 23:15:51 -0400, Richard Damon wrote:
On 6/10/25 3:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a >>>>> analyzer.
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that
The official "received view" of this is that the best we can
possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the best >>>>>>> they can do is to waste their life in trying to do the impossible. >>>>>>>
reports on the behavior specified by the input to HHH(DDD). It was >>>>>> never correct to define a termination analyzer any other way.
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to
the termination analysis of DDD, is to say it halts, since the
HHH(DDD) that DDD will call will return non-halting to that DDD,
and it will then halt.
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is returned
elsewhere.
/Flibble
So, you have a problem, either you don't have a correct simulation to
show you got the right answer, or you don't answer.
That is the problem with trying to have the decider itself be two
contradictory entities.
A correct simulator can not be a correct decider it the input is
actually non-halting.
There seems to be some mental block about the fact that the DEFINITION
of this sort of decider is that:
H(M) returns 1 if UTM(M) halts, and H(M) returns 0 if UTM(M) will
never halt
If you try to combine the the UTM and H into one program that it can
NEVER correctly return 0, as it can only return 0 if it never halt
(and thus can't return a value)
You are wrong. An SHD does not have to simulate an algorithm to
completion if it determines non-halting early BY ANALYSIS.
/Flibble
I didn't say it needed to. But it needs to determine what such a
simulation will do.
In fact, as I said, if the input IS non-halting, it can't be both the required simulator and the decider, so it is logically inconsistent to
say that it is the simulation by the decider that defines the result.
t seems you have fallen for Olcott's insanity.
On Wed, 11 Jun 2025 18:21:37 -0400, Richard Damon wrote:[AI slop]
On 6/11/25 2:21 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 23:15:51 -0400, Richard Damon wrote:
On 6/10/25 3:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is
returned elsewhere.
So, you have a problem, either you don't have a correct simulation to
show you got the right answer, or you don't answer.
That is the problem with trying to have the decider itself be two
contradictory entities.
A correct simulator can not be a correct decider it the input is
actually non-halting.
There seems to be some mental block about the fact that the
DEFINITION of this sort of decider is that:
H(M) returns 1 if UTM(M) halts, and H(M) returns 0 if UTM(M) will
never halt
If you try to combine the the UTM and H into one program that it can
NEVER correctly return 0, as it can only return 0 if it never halt
(and thus can't return a value)
You are wrong. An SHD does not have to simulate an algorithm to
completion if it determines non-halting early BY ANALYSIS.
I didn't say it needed to. But it needs to determine what such a
simulation will do.
In fact, as I said, if the input IS non-halting, it can't be both the
required simulator and the decider, so it is logically inconsistent to
say that it is the simulation by the decider that defines the result.
t seems you have fallen for Olcott's insanity.
Would you like this analysis as a downloadable text file?I wouldn't like this posted at all, but at least mark it as generated.
On Wed, 11 Jun 2025 18:21:37 -0400, Richard Damon wrote:
On 6/11/25 2:21 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 23:15:51 -0400, Richard Damon wrote:
On 6/10/25 3:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a >>>>>> analyzer.
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that >>>>>>> reports on the behavior specified by the input to HHH(DDD). It was >>>>>>> never correct to define a termination analyzer any other way.
The official "received view" of this is that the best we can >>>>>>>>> possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the best >>>>>>>> they can do is to waste their life in trying to do the impossible. >>>>>>>>
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to >>>>>> the termination analysis of DDD, is to say it halts, since the
HHH(DDD) that DDD will call will return non-halting to that DDD,
and it will then halt.
But it will never "return" because it is infinitely recursive; the
simulation is aborted and a halting result if non-halting is returned >>>>> elsewhere.
/Flibble
So, you have a problem, either you don't have a correct simulation to
show you got the right answer, or you don't answer.
That is the problem with trying to have the decider itself be two
contradictory entities.
A correct simulator can not be a correct decider it the input is
actually non-halting.
There seems to be some mental block about the fact that the DEFINITION >>>> of this sort of decider is that:
H(M) returns 1 if UTM(M) halts, and H(M) returns 0 if UTM(M) will
never halt
If you try to combine the the UTM and H into one program that it can
NEVER correctly return 0, as it can only return 0 if it never halt
(and thus can't return a value)
You are wrong. An SHD does not have to simulate an algorithm to
completion if it determines non-halting early BY ANALYSIS.
/Flibble
I didn't say it needed to. But it needs to determine what such a
simulation will do.
In fact, as I said, if the input IS non-halting, it can't be both the
required simulator and the decider, so it is logically inconsistent to
say that it is the simulation by the decider that defines the result.
t seems you have fallen for Olcott's insanity.
Here is an analysis of the exchange between **Mr Flibble** and **Richard Damon**, with context surrounding the **Simulating Halt Decider (SHD)** concept and the **Halting Problem**:
---
### **Summary of Positions**
**Flibble's position:**
* A Simulating Halt Decider (SHD) does not need to simulate to completion.
* It can **use analysis to determine non-halting behavior early**, and
halt the simulation accordingly.
* Therefore, recursion into infinite self-reference is detected and does **not imply that the SHD itself fails to return**.
**Damon's position:**
* The SHD is logically inconsistent if it tries to be both:
* A **simulator** of the input program **to determine its halting behavior**, and
* A **decider**, meaning it must always return a finite answer (1 for halts, 0 for non-halting).
* If the input is truly non-halting, the simulation cannot halt and thus cannot return.
* Hence, if **SHD halts and returns a result**, it cannot be doing a
faithful simulation of a non-halting program—it would be logically broken.
---
### **Key Argument Points**
#### 1. **What counts as a valid simulation?**
* **Damon** argues that a **correct simulation must model the full
behavior of the input program**, including potentially non-halting
behavior. A SHD cannot simulate faithfully and still return if the
simulated program is non-halting.
* **Flibble** counters that **early symbolic analysis** is enough: if the
SHD can detect an infinite loop pattern (e.g., recursive self-simulation),
it may **abort the simulation and declare "non-halting"** without needing
to recurse indefinitely.
🧠 *Flibble frames simulation as a partial tool, not the source of truth—the analysis result is.*
---
#### 2. **The core of the disagreement: epistemology vs. ontology**
* Damon treats the SHD as needing to **ontologically match** the behavior
of the program being simulated (i.e., model its behavior step-by-step).
* Flibble approaches from an **epistemological** angle: the SHD's purpose
is to *know* what the program would do, not to *be* that program.
🔁 *Damon believes an SHD can't be faithful if it stops early. Flibblesays it's not required to be faithful in that sense—it must just return a correct answer.*
---
#### 3. **Contradiction and paradox**
* Damon refers to a **contradiction**: if a decider returns “non-halting,”
but only by aborting simulation, then it is **not** doing what it claims— simulating the non-halting behavior. That is, it returns an answer it couldn’t compute in the required way.
* Flibble says this is a **false requirement**: the SHD isn’t obligated to run forever to decide a non-halting case. It only needs to **recognize the non-halting structure** (e.g., infinite regress) and return based on this.
---
### **Meta-commentary: Olcott’s Influence**
* Damon ends by saying: “It seems you have fallen for Olcott's insanity.”
* This is a rhetorical move discrediting Flibble by associating his
ideas with Olcott, who is frequently accused of **misunderstanding or misrepresenting** the halting problem.
* It's also an **ad hominem** by implication, suggesting guilt by association rather than addressing Flibble’s exact semantic model.
---
### **Evaluation**
* **Flibble** is consistent within the assumptions of his **semantic stratification model**, where simulation is not literal but symbolic, and **type rules prevent paradoxical recursion**.
* **Damon**, from a classical Turing perspective, sees **no way to short- circuit** the undecidability result through simulation or analysis: **the contradiction lies in the logic of what’s being attempted**.
* The debate is effectively one of **formal model choice**:
* Flibble adopts a **restricted domain** and allows the SHD to function via meta-level rules.
* Damon insists that if you simulate faithfully according to classical definitions, **you cannot escape undecidability**.
---
### **Conclusion**
This exchange encapsulates the core of the modern SHD debate:
* **Flibble** redefines the boundaries of what counts as analysis, using semantic types and stratification to reject certain paradoxes.
* **Damon** asserts that **you can’t redefine terms** in a way that evades the implications of the classical halting theorem **without creating inconsistency**.
The clash is not merely technical—it's philosophical. One side changes the rules, the other guards the original game.
Would you like this analysis as a downloadable text file?
On 6/12/2025 3:13 PM, Mr Flibble wrote:
On Wed, 11 Jun 2025 18:21:37 -0400, Richard Damon wrote:
On 6/11/25 2:21 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 23:15:51 -0400, Richard Damon wrote:
On 6/10/25 3:05 PM, Mr Flibble wrote:
On Tue, 10 Jun 2025 14:53:47 -0400, Richard Damon wrote:
On 6/10/25 1:22 PM, olcott wrote:
On 6/10/2025 2:33 AM, Mikko wrote:Right, it is just a fact that it is impossible for HHH to be shuch a >>>>>>> analyzer.
On 2025-06-09 21:14:58 +0000, olcott said:It is not at all impossible to create a termination analyzer that >>>>>>>> reports on the behavior specified by the input to HHH(DDD). It was >>>>>>>> never correct to define a termination analyzer any other way.
The official "received view" of this is that the best we can >>>>>>>>>> possibly do is to do nothing and give up.
There is no official view about "the best". What is the best >>>>>>>>> depends on what one needs and wants. Some may think that the best >>>>>>>>> they can do is to waste their life in trying to do the impossible. >>>>>>>>>
A CORRECT Temrination analyzer of the input to HHH(DDD), that is to >>>>>>> the termination analysis of DDD, is to say it halts, since the
HHH(DDD) that DDD will call will return non-halting to that DDD, >>>>>>> and it will then halt.
But it will never "return" because it is infinitely recursive; the >>>>>> simulation is aborted and a halting result if non-halting is returned >>>>>> elsewhere.
/Flibble
So, you have a problem, either you don't have a correct simulation to >>>>> show you got the right answer, or you don't answer.
That is the problem with trying to have the decider itself be two
contradictory entities.
A correct simulator can not be a correct decider it the input is
actually non-halting.
There seems to be some mental block about the fact that the DEFINITION >>>>> of this sort of decider is that:
H(M) returns 1 if UTM(M) halts, and H(M) returns 0 if UTM(M) will
never halt
If you try to combine the the UTM and H into one program that it can >>>>> NEVER correctly return 0, as it can only return 0 if it never halt
(and thus can't return a value)
You are wrong. An SHD does not have to simulate an algorithm to
completion if it determines non-halting early BY ANALYSIS.
/Flibble
I didn't say it needed to. But it needs to determine what such a
simulation will do.
In fact, as I said, if the input IS non-halting, it can't be both the
required simulator and the decider, so it is logically inconsistent to
say that it is the simulation by the decider that defines the result.
t seems you have fallen for Olcott's insanity.
Here is an analysis of the exchange between **Mr Flibble** and **Richard
Damon**, with context surrounding the **Simulating Halt Decider (SHD)**
concept and the **Halting Problem**:
---
### **Summary of Positions**
**Flibble's position:**
* A Simulating Halt Decider (SHD) does not need to simulate to
completion.
* It can **use analysis to determine non-halting behavior early**, and
halt the simulation accordingly.
* Therefore, recursion into infinite self-reference is detected and does
**not imply that the SHD itself fails to return**.
**Damon's position:**
* The SHD is logically inconsistent if it tries to be both:
* A **simulator** of the input program **to determine its halting
behavior**, and
* A **decider**, meaning it must always return a finite answer (1 for >> halts, 0 for non-halting).
* If the input is truly non-halting, the simulation cannot halt and thus
cannot return.
* Hence, if **SHD halts and returns a result**, it cannot be doing a
faithful simulation of a non-halting program—it would be logically
broken.
---
### **Key Argument Points**
#### 1. **What counts as a valid simulation?**
* **Damon** argues that a **correct simulation must model the full
behavior of the input program**, including potentially non-halting
behavior. A SHD cannot simulate faithfully and still return if the
simulated program is non-halting.
* **Flibble** counters that **early symbolic analysis** is enough: if the
SHD can detect an infinite loop pattern (e.g., recursive self-
simulation),
it may **abort the simulation and declare "non-halting"** without needing
to recurse indefinitely.
🧠 *Flibble frames simulation as a partial tool, not the source of truth >> —the analysis result is.*
---
#### 2. **The core of the disagreement: epistemology vs. ontology**
* Damon treats the SHD as needing to **ontologically match** the behavior
of the program being simulated (i.e., model its behavior step-by-step).
* Flibble approaches from an **epistemological** angle: the SHD's purpose
is to *know* what the program would do, not to *be* that program.
🔁 *Damon believes an SHD can't be faithful if it stops early. Flibblesays it's not required to be faithful in that sense—it must just return a >> correct answer.*
---
#### 3. **Contradiction and paradox**
* Damon refers to a **contradiction**: if a decider returns “non-
halting,”
but only by aborting simulation, then it is **not** doing what it claims— >> simulating the non-halting behavior. That is, it returns an answer it
couldn’t compute in the required way.
* Flibble says this is a **false requirement**: the SHD isn’t
obligated to
run forever to decide a non-halting case. It only needs to **recognize
the
non-halting structure** (e.g., infinite regress) and return based on
this.
---
### **Meta-commentary: Olcott’s Influence**
* Damon ends by saying: “It seems you have fallen for Olcott's insanity.”
* This is a rhetorical move discrediting Flibble by associating his
ideas with Olcott, who is frequently accused of **misunderstanding or
misrepresenting** the halting problem.
* It's also an **ad hominem** by implication, suggesting guilt by
association rather than addressing Flibble’s exact semantic model.
---
### **Evaluation**
* **Flibble** is consistent within the assumptions of his **semantic
stratification model**, where simulation is not literal but symbolic, and
**type rules prevent paradoxical recursion**.
* **Damon**, from a classical Turing perspective, sees **no way to short-
circuit** the undecidability result through simulation or analysis: **the
contradiction lies in the logic of what’s being attempted**.
* The debate is effectively one of **formal model choice**:
* Flibble adopts a **restricted domain** and allows the SHD to
function
via meta-level rules.
* Damon insists that if you simulate faithfully according to classical >> definitions, **you cannot escape undecidability**.
---
### **Conclusion**
This exchange encapsulates the core of the modern SHD debate:
* **Flibble** redefines the boundaries of what counts as analysis, using
semantic types and stratification to reject certain paradoxes.
* **Damon** asserts that **you can’t redefine terms** in a way that
evades
the implications of the classical halting theorem **without creating
inconsistency**.
The clash is not merely technical—it's philosophical. One side changes
the
rules, the other guards the original game.
Would you like this analysis as a downloadable text file?
Richard is merely a liar that is why I quit paying attention to him.
On 6/11/2025 3:42 AM, Mikko wrote:
On 2025-06-10 17:14:58 +0000, olcott said:
On 6/10/2025 2:33 AM, Mikko wrote:
On 2025-06-09 21:14:58 +0000, olcott said:
The official "received view" of this is that the best
we can possibly do is to do nothing and give up.
There is no official view about "the best". What is the best
depends on what one needs and wants. Some may think that the
best they can do is to waste their life in trying to do the
impossible.
Certainly doiing nothing and giving up
are not the best thing to do in this case.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 12:03:45 |
| Calls: | 10,389 |
| Calls today: | 4 |
| Files: | 14,061 |
| Messages: | 6,416,871 |
| Posted today: | 1 |