On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has
nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at
this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding of
truth.
The Tarski Undefinability theorem that incorrectly "proves" that a
Boolean True(L,x) predicate cannot be consistently defined relies on the
same structure as the conventional HP proofs.
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has
nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at
this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding of
truth.
The Tarski Undefinability theorem that incorrectly "proves" that a
Boolean True(L,x) predicate cannot be consistently defined relies on
the same structure as the conventional HP proofs.
False. Diagonalization is a legitimate technique: you haven't proven
otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined on the
basis of an expression of language that is not a truth bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf
I spent 22 years on the Linz proof and have proven that it does not
prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating partial halt decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its simulated
final halt state of ⟨Ĥ.qn⟩
On 8/1/2025 9:44 PM, Mr Flibble wrote:halt
On Fri, 01 Aug 2025 21:36:08 -0500, olcott wrote:
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has
nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at >>>>>> this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding of
truth.
The Tarski Undefinability theorem that incorrectly "proves" that a
Boolean True(L,x) predicate cannot be consistently defined relies on >>>>> the same structure as the conventional HP proofs.
False. Diagonalization is a legitimate technique: you haven't proven
otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined on the
basis of an expression of language that is not a truth bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely recursive
structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf
I spent 22 years on the Linz proof and have proven that it does not
prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating partial
decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its simulated
final halt state of ⟨Ĥ.qn⟩
Sounds like 22 years of wasted effort as Linz's proof is concerned with
total deciders not partial deciders. Again: your work has nothing to
do with the Halting Problem.
/Flibble
*I will repeat: I am not solving the halting problem*
I am just showing that one proof method fails.
On 8/1/2025 9:57 PM, Mr Flibble wrote:Ĥ.embedded_H ⟨Ĥ⟩
On Fri, 01 Aug 2025 21:46:44 -0500, olcott wrote:
On 8/1/2025 9:44 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:36:08 -0500, olcott wrote:
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has >>>>>>>> nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other >>>>>>>> at this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding >>>>>>> of truth.
The Tarski Undefinability theorem that incorrectly "proves" that a >>>>>>> Boolean True(L,x) predicate cannot be consistently defined relies >>>>>>> on the same structure as the conventional HP proofs.
False. Diagonalization is a legitimate technique: you haven't
proven otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined on the >>>>> basis of an expression of language that is not a truth bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely
recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf
I spent 22 years on the Linz proof and have proven that it does not
prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ Ĥ.q0 ⟨Ĥ⟩ ⊢*
halt⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating partial
decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its simulated >>>>> final halt state of ⟨Ĥ.qn⟩
Sounds like 22 years of wasted effort as Linz's proof is concerned
with total deciders not partial deciders. Again: your work has
nothing to do with the Halting Problem.
/Flibble
*I will repeat: I am not solving the halting problem*
I am just showing that one proof method fails.
You are attempting to show that a HALTING PROBLEM proof methodology
fails but you are failing to do so as your method is predicated on
partial deciders not total deciders so has nothing to do with the
HALTING PROBLEM or HALTING PROBLEM proofs.
/Flibble
*See what you think of this* https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
On 8/1/2025 10:41 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 22:33:45 -0500, olcott wrote:
On 8/1/2025 9:57 PM, Mr Flibble wrote:Ĥ.embedded_H ⟨Ĥ⟩
On Fri, 01 Aug 2025 21:46:44 -0500, olcott wrote:
On 8/1/2025 9:44 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:36:08 -0500, olcott wrote:
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about >>>>>>>>>> has nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each >>>>>>>>>> other at this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding >>>>>>>>> of truth.
The Tarski Undefinability theorem that incorrectly "proves" that >>>>>>>>> a Boolean True(L,x) predicate cannot be consistently defined >>>>>>>>> relies on the same structure as the conventional HP proofs.
False. Diagonalization is a legitimate technique: you haven't
proven otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined on >>>>>>> the basis of an expression of language that is not a truth bearer. >>>>>>>
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely
recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf
I spent 22 years on the Linz proof and have proven that it does
not prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ Ĥ.q0 ⟨Ĥ⟩ ⊢*
⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating partial >>>> halt
decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its
simulated final halt state of ⟨Ĥ.qn⟩
Sounds like 22 years of wasted effort as Linz's proof is concerned >>>>>> with total deciders not partial deciders. Again: your work has
nothing to do with the Halting Problem.
/Flibble
*I will repeat: I am not solving the halting problem*
I am just showing that one proof method fails.
You are attempting to show that a HALTING PROBLEM proof methodology
fails but you are failing to do so as your method is predicated on
partial deciders not total deciders so has nothing to do with the
HALTING PROBLEM or HALTING PROBLEM proofs.
/Flibble
*See what you think of this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
LLM token prediction is sensitive to the actual words used in the
prompt,
so:
Me:
What if it is a HHH is halting decider rather than a "termination
analyser"?
ChatGPT:
If HHH is a “halting decider” instead of a “termination analyzer,” then
the implications change dramatically, because:
A halting decider is a hypothetical function that returns:
* 1 if its input function halts (terminates) on a given input.
* 0 if the input function does not halt on that input.
And importantly, it makes this decision without actually executing or
simulating the full behavior—it determines the result without falling
into infinite regress.
But such a function is known to be impossible in general due to the
Halting Problem: Turing proved there is no algorithm that can decide
whether any given program halts on a given input.
Still, let’s assume HHH is a magical halting decider for this language.
Now let’s re-express the code and reasoning:
Code Recap:
```c typedef void (*ptr)();
int HHH(ptr P); // halting decider: returns 1 if P terminates, 0 if
not
void DDD() {
HHH(DDD); // calls halting decider on itself return;
}
int main() {
HHH(DDD); // checks if DDD halts DDD(); // calls DDD
}
```
Let’s assume HHH works perfectly. So:
* HHH(DDD) checks whether DDD halts.
Does DDD halt?
Let’s expand DDD:
* DDD calls HHH(DDD)
* Then returns.
So DDD definitely halts, regardless of what HHH returns. It just asks
HHH something and then returns.
Therefore, DDD terminates.
So the halting decider HHH(DDD) must return 1.
Thus:
* In main(), HHH(DDD) returns 1 * Then DDD() is called, which again
calls HHH(DDD), returns 1, and then returns
Everything halts cleanly.
✅ Summary (if HHH is a true halting decider):
* DDD is terminating * HHH(DDD) returns 1 * No infinite regress occurs,
because HHH doesn’t simulate—just decides
Compare to original “termination analyzer” version, which simulates
execution and thereby enters infinite regress.
🧠 Bottom Line:
* HHH as a simulator: gets stuck simulating a self-referential call —
returns 0 * HHH as a decider: easily sees DDD halts — returns 1
Which highlights the Halting Problem's essence: The analyzer (which
uses simulation) gets trapped, while the decider (which is impossible
in practice) avoids the trap by divine insight.
/Flibble
*To get an accurate view of what I am saying you must read this* https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c ChatGPT
seems to explain it more clearly than I can explain it.
On 8/1/2025 11:05 PM, Mr Flibble wrote:partial
On Fri, 01 Aug 2025 22:55:57 -0500, olcott wrote:
On 8/1/2025 10:41 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 22:33:45 -0500, olcott wrote:
On 8/1/2025 9:57 PM, Mr Flibble wrote:Ĥ.embedded_H ⟨Ĥ⟩
On Fri, 01 Aug 2025 21:46:44 -0500, olcott wrote:
On 8/1/2025 9:44 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:36:08 -0500, olcott wrote:
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about >>>>>>>>>>>> has nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each >>>>>>>>>>>> other at this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct
understanding of truth.
The Tarski Undefinability theorem that incorrectly "proves" >>>>>>>>>>> that a Boolean True(L,x) predicate cannot be consistently >>>>>>>>>>> defined relies on the same structure as the conventional HP >>>>>>>>>>> proofs.
False. Diagonalization is a legitimate technique: you haven't >>>>>>>>>> proven otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined on >>>>>>>>> the basis of an expression of language that is not a truth
bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely
recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf
I spent 22 years on the Linz proof and have proven that it does >>>>>>>>> not prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ Ĥ.q0 ⟨Ĥ⟩ ⊢*
⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating
I use the term termination analyzer because it is not required to be infallible and its operation can be concretely defined in a high level language.halt
decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its
simulated final halt state of ⟨Ĥ.qn⟩
Sounds like 22 years of wasted effort as Linz's proof is
concerned with total deciders not partial deciders. Again: your >>>>>>>> work has nothing to do with the Halting Problem.
/Flibble
*I will repeat: I am not solving the halting problem*
I am just showing that one proof method fails.
You are attempting to show that a HALTING PROBLEM proof methodology >>>>>> fails but you are failing to do so as your method is predicated on >>>>>> partial deciders not total deciders so has nothing to do with the
HALTING PROBLEM or HALTING PROBLEM proofs.
/Flibble
*See what you think of this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
LLM token prediction is sensitive to the actual words used in the
prompt,
so:
Me:
What if it is a HHH is halting decider rather than a "termination
analyser"?
ChatGPT:
If HHH is a “halting decider” instead of a “termination analyzer,” >>>> then the implications change dramatically, because:
A halting decider is a hypothetical function that returns:
* 1 if its input function halts (terminates) on a given input.
* 0 if the input function does not halt on that input.
And importantly, it makes this decision without actually executing or
simulating the full behavior—it determines the result without falling >>>> into infinite regress.
But such a function is known to be impossible in general due to the
Halting Problem: Turing proved there is no algorithm that can decide
whether any given program halts on a given input.
Still, let’s assume HHH is a magical halting decider for this
language.
Now let’s re-express the code and reasoning:
Code Recap:
```c typedef void (*ptr)();
int HHH(ptr P); // halting decider: returns 1 if P terminates, 0 if
not
void DDD() {
HHH(DDD); // calls halting decider on itself return;
}
int main() {
HHH(DDD); // checks if DDD halts DDD(); // calls DDD
}
```
Let’s assume HHH works perfectly. So:
* HHH(DDD) checks whether DDD halts.
Does DDD halt?
Let’s expand DDD:
* DDD calls HHH(DDD)
* Then returns.
So DDD definitely halts, regardless of what HHH returns. It just asks
HHH something and then returns.
Therefore, DDD terminates.
So the halting decider HHH(DDD) must return 1.
Thus:
* In main(), HHH(DDD) returns 1 * Then DDD() is called, which again
calls HHH(DDD), returns 1, and then returns
Everything halts cleanly.
✅ Summary (if HHH is a true halting decider):
* DDD is terminating * HHH(DDD) returns 1 * No infinite regress
occurs, because HHH doesn’t simulate—just decides
Compare to original “termination analyzer” version, which simulates >>>> execution and thereby enters infinite regress.
🧠 Bottom Line:
* HHH as a simulator: gets stuck simulating a self-referential call — >>>> returns 0 * HHH as a decider: easily sees DDD halts — returns 1
Which highlights the Halting Problem's essence: The analyzer (which
uses simulation) gets trapped, while the decider (which is impossible
in practice) avoids the trap by divine insight.
/Flibble
*To get an accurate view of what I am saying you must read this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c ChatGPT
seems to explain it more clearly than I can explain it.
You cannot get an accurate view of what you are saying by using a
stochastic parrot if you load the dice by using prompt manipulation to
get the parrot to give you a favourable response (like you did by using
the term "termination analyser" instead of the term "halt decider").
Please tell me, which part of the following sentence don't you
understand:
Halting problem proofs are predicated on total deciders so you cannot
use a partial decider to refute a halting problem proof.
/Flibble
I have studied this for 22 years. The way that the HP proof is supposed
to work is to hypothesize that a universal halt decider exists. Then all
that is needed is a single counter-example that cannot be decided and
this refutes that a universal halt decider exists.
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has nothing
to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at this
point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct
understanding of truth.
The Tarski Undefinability theorem that incorrectly
"proves" that a Boolean True(L,x) predicate cannot
be consistently defined relies on the same structure
as the conventional HP proofs.
Because of this humans have no perfectly objective
way to discern truth from very well crafted lies,
thus the well crafted lies win.
Richard is still trying to get away with saying that
the repeating pattern shown below does not exist.
void DDD()
{
HHH(DDD);
return;
}
HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has nothing
to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at this
point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct
understanding of truth.
The Tarski Undefinability theorem that incorrectly
"proves" that a Boolean True(L,x) predicate cannot
be consistently defined relies on the same structure
as the conventional HP proofs.
Because of this humans have no perfectly objective
way to discern truth from very well crafted lies,
thus the well crafted lies win.
Richard is still trying to get away with saying that
the repeating pattern shown below does not exist.
void DDD()
{
HHH(DDD);
return;
}
HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has
nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at
this point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding of
truth.
The Tarski Undefinability theorem that incorrectly "proves" that a
Boolean True(L,x) predicate cannot be consistently defined relies on the >>> same structure as the conventional HP proofs.
False. Diagonalization is a legitimate technique: you haven't proven
otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently
defined on the basis of an expression of language that
is not a truth bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the
same infinitely recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof
https://liarparadox.org/Tarski_275_276.pdf
I spent 22 years on the Linz proof and have proven
that it does not prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
simulating partial halt decider
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩
On 8/2/2025 8:14 AM, Richard Damon wrote:
On 8/1/25 10:09 PM, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has
nothing
to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at
this
point.
/Flibble
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct
understanding of truth.
No, every attempt at you trying to explain your logic has been
counter- factual
All you arguing has done is validate the bad logic used by the climate
deniers.
Severe anthropogenic climate change proven
entirely with verifiable facts
October 2019 PL Olcott
https://www.researchgate.net/ publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts
The Tarski Undefinability theorem that incorrectly
"proves" that a Boolean True(L,x) predicate cannot
be consistently defined relies on the same structure
as the conventional HP proofs.
And it is true, but you don't understand what it means.
Anyone that does not understand Tarski can say that.
The more difficult thing is to show any specific mistake
that I made.
You already know the mistake that Tarski made.
You understand that this sentence: "This sentence is not true"
is neither true nor false. Tarski didn't understand that.
Because of this humans have no perfectly objective
way to discern truth from very well crafted lies,
thus the well crafted lies win.
Nope, and it just shows you don't have an objective view of truth,
When starting with the basic facts of the world and only
applying semantic logical entailment as the inference steps
we always derive statements that are true.
The truth is that not all truth is knowable, and you need to learn to
live with that.
Yet whether or not election fraud changed the outcome
of the 2020 election is known truth.
That some truth is not knowable, doesn't mean that no truth is
knowable, and that error goes back to some of your fundamental errors
in understanding of how logic works, as shown by your use of so many
logical fallacies,
Richard is still trying to get away with saying that
the repeating pattern shown below does not exist.
Because it doesn't happen with your actual HHH.
Only in your lies where you change what HHH is,
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement then it returns 1.
Below is the pattern that DDD simulated by HHH
would produce if it took HHH ten recursive
simulations to detect the repeating pattern.
void DDD()
{
HHH(DDD);
return;
}
HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
And if that WAS true, then HHH can never stop to answer and is just as
wrong as YOU.
Above is the pattern that DDD simulated by HHH
would produce if it took HHH ten recursive
simulations to detect the repeating pattern.
All you are doing is proving you are a LIAR that is too stupid to
understand what truth is,
On 8/1/2025 11:25 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 23:11:47 -0500, olcott wrote:
On 8/1/2025 11:05 PM, Mr Flibble wrote:partial
On Fri, 01 Aug 2025 22:55:57 -0500, olcott wrote:
On 8/1/2025 10:41 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 22:33:45 -0500, olcott wrote:
On 8/1/2025 9:57 PM, Mr Flibble wrote:Ĥ.embedded_H ⟨Ĥ⟩
On Fri, 01 Aug 2025 21:46:44 -0500, olcott wrote:
On 8/1/2025 9:44 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:36:08 -0500, olcott wrote:
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about >>>>>>>>>>>>>> has nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each >>>>>>>>>>>>>> other at this point.
/Flibble
Every attempt to refute me has been counter-factual. >>>>>>>>>>>>> The survival of life an Earth depends on a correct
understanding of truth.
The Tarski Undefinability theorem that incorrectly "proves" >>>>>>>>>>>>> that a Boolean True(L,x) predicate cannot be consistently >>>>>>>>>>>>> defined relies on the same structure as the conventional HP >>>>>>>>>>>>> proofs.
False. Diagonalization is a legitimate technique: you haven't >>>>>>>>>>>> proven otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined on >>>>>>>>>>> the basis of an expression of language that is not a truth >>>>>>>>>>> bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely >>>>>>>>>>> recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf >>>>>>>>>>>
I spent 22 years on the Linz proof and have proven that it does >>>>>>>>>>> not prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ Ĥ.q0 ⟨Ĥ⟩ ⊢*
⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating
I use the term termination analyzer because it is not required to behalt
decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its >>>>>>>>>>> simulated final halt state of ⟨Ĥ.qn⟩
Sounds like 22 years of wasted effort as Linz's proof is
concerned with total deciders not partial deciders. Again: your >>>>>>>>>> work has nothing to do with the Halting Problem.
/Flibble
*I will repeat: I am not solving the halting problem*
I am just showing that one proof method fails.
You are attempting to show that a HALTING PROBLEM proof methodology >>>>>>>> fails but you are failing to do so as your method is predicated on >>>>>>>> partial deciders not total deciders so has nothing to do with the >>>>>>>> HALTING PROBLEM or HALTING PROBLEM proofs.
/Flibble
*See what you think of this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
LLM token prediction is sensitive to the actual words used in the
prompt,
so:
Me:
What if it is a HHH is halting decider rather than a "termination
analyser"?
ChatGPT:
If HHH is a “halting decider” instead of a “termination analyzer,”
then the implications change dramatically, because:
A halting decider is a hypothetical function that returns:
* 1 if its input function halts (terminates) on a given input.
* 0 if the input function does not halt on that input.
And importantly, it makes this decision without actually executing or >>>>>> simulating the full behavior—it determines the result without falling >>>>>> into infinite regress.
But such a function is known to be impossible in general due to the >>>>>> Halting Problem: Turing proved there is no algorithm that can decide >>>>>> whether any given program halts on a given input.
Still, let’s assume HHH is a magical halting decider for this
language.
Now let’s re-express the code and reasoning:
Code Recap:
```c typedef void (*ptr)();
int HHH(ptr P); // halting decider: returns 1 if P terminates, 0 if >>>>>> not
void DDD() {
HHH(DDD); // calls halting decider on itself return;
}
int main() {
HHH(DDD); // checks if DDD halts DDD(); // calls DDD >>>>>> }
```
Let’s assume HHH works perfectly. So:
* HHH(DDD) checks whether DDD halts.
Does DDD halt?
Let’s expand DDD:
* DDD calls HHH(DDD)
* Then returns.
So DDD definitely halts, regardless of what HHH returns. It just asks >>>>>> HHH something and then returns.
Therefore, DDD terminates.
So the halting decider HHH(DDD) must return 1.
Thus:
* In main(), HHH(DDD) returns 1 * Then DDD() is called, which again >>>>>> calls HHH(DDD), returns 1, and then returns
Everything halts cleanly.
✅ Summary (if HHH is a true halting decider):
* DDD is terminating * HHH(DDD) returns 1 * No infinite regress
occurs, because HHH doesn’t simulate—just decides
Compare to original “termination analyzer” version, which simulates >>>>>> execution and thereby enters infinite regress.
🧠 Bottom Line:
* HHH as a simulator: gets stuck simulating a self-referential call — >>>>>> returns 0 * HHH as a decider: easily sees DDD halts — returns 1
Which highlights the Halting Problem's essence: The analyzer (which >>>>>> uses simulation) gets trapped, while the decider (which is impossible >>>>>> in practice) avoids the trap by divine insight.
/Flibble
*To get an accurate view of what I am saying you must read this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c ChatGPT >>>>> seems to explain it more clearly than I can explain it.
You cannot get an accurate view of what you are saying by using a
stochastic parrot if you load the dice by using prompt manipulation to >>>> get the parrot to give you a favourable response (like you did by using >>>> the term "termination analyser" instead of the term "halt decider").
infallible and its operation can be concretely defined in a high level
language.
No, you used that term to get ChatGPT to give you a favourable response
unrelated to the halting problem. Ask ChatGPT, "What if HHH is a halt
decider rather than a termination analyser?".
Please tell me, which part of the following sentence don't you
understand:
Halting problem proofs are predicated on total deciders so you cannot
use a partial decider to refute a halting problem proof.
/Flibble
I have studied this for 22 years. The way that the HP proof is supposed
to work is to hypothesize that a universal halt decider exists. Then all >>> that is needed is a single counter-example that cannot be decided and
this refutes that a universal halt decider exists.
You are not working on the halting problem, you are working on the Olcott
problem, wasting 22 years.
/Flibble
My prior paragraph is the basic structure of the halting problem proofs.
On 8/2/25 12:59 AM, olcott wrote:⊢*
On 8/1/2025 11:25 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 23:11:47 -0500, olcott wrote:
On 8/1/2025 11:05 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 22:55:57 -0500, olcott wrote:
On 8/1/2025 10:41 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 22:33:45 -0500, olcott wrote:
On 8/1/2025 9:57 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:46:44 -0500, olcott wrote:
On 8/1/2025 9:44 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:36:08 -0500, olcott wrote:
On 8/1/2025 9:21 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 21:09:14 -0500, olcott wrote:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on >>>>>>>>>>>>>>> about has nothing to do with the Halting Problem. >>>>>>>>>>>>>>>
Damon, stop feeding Olcott: you are just talking over each >>>>>>>>>>>>>>> other at this point.
/Flibble
Every attempt to refute me has been counter-factual. >>>>>>>>>>>>>> The survival of life an Earth depends on a correct >>>>>>>>>>>>>> understanding of truth.
The Tarski Undefinability theorem that incorrectly "proves" >>>>>>>>>>>>>> that a Boolean True(L,x) predicate cannot be consistently >>>>>>>>>>>>>> defined relies on the same structure as the conventional HP >>>>>>>>>>>>>> proofs.
False. Diagonalization is a legitimate technique: you >>>>>>>>>>>>> haven't proven otherwise.
/Flibble
Tarski "proved" that True(L,x) cannot be consistently defined >>>>>>>>>>>> on the basis of an expression of language that is not a truth >>>>>>>>>>>> bearer.
Liar Paradox basis of his proof
https://liarparadox.org/Tarski_247_248.pdf
Prolog proves that the Liar Paradox has the same infinitely >>>>>>>>>>>> recursive structure as the HP proof:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false
His actual proof https://liarparadox.org/Tarski_275_276.pdf >>>>>>>>>>>>
I spent 22 years on the Linz proof and have proven that it >>>>>>>>>>>> does not prove that halting is undecidable.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ Ĥ.q0 ⟨Ĥ⟩
Your problem is you don't find an error in the shown counter example,partialĤ.embedded_H ⟨Ĥ⟩
⟨Ĥ⟩ ⊢* Ĥ.qn
When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a simulating
I use the term termination analyzer because it is not required to behalt
decider (a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
derives a repeating pattern that cannot possibly reach its >>>>>>>>>>>> simulated final halt state of ⟨Ĥ.qn⟩
Sounds like 22 years of wasted effort as Linz's proof is >>>>>>>>>>> concerned with total deciders not partial deciders. Again: >>>>>>>>>>> your work has nothing to do with the Halting Problem.
/Flibble
*I will repeat: I am not solving the halting problem*
I am just showing that one proof method fails.
You are attempting to show that a HALTING PROBLEM proof
methodology fails but you are failing to do so as your method is >>>>>>>>> predicated on partial deciders not total deciders so has nothing >>>>>>>>> to do with the HALTING PROBLEM or HALTING PROBLEM proofs.
/Flibble
*See what you think of this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
LLM token prediction is sensitive to the actual words used in the >>>>>>> prompt,
so:
Me:
What if it is a HHH is halting decider rather than a "termination >>>>>>> analyser"?
ChatGPT:
If HHH is a “halting decider” instead of a “termination analyzer,”
then the implications change dramatically, because:
A halting decider is a hypothetical function that returns:
* 1 if its input function halts (terminates) on a given input.
* 0 if the input function does not halt on that input.
And importantly, it makes this decision without actually executing >>>>>>> or simulating the full behavior—it determines the result without >>>>>>> falling into infinite regress.
But such a function is known to be impossible in general due to
the Halting Problem: Turing proved there is no algorithm that can >>>>>>> decide whether any given program halts on a given input.
Still, let’s assume HHH is a magical halting decider for this
language.
Now let’s re-express the code and reasoning:
Code Recap:
```c typedef void (*ptr)();
int HHH(ptr P); // halting decider: returns 1 if P terminates, 0 >>>>>>> if not
void DDD() {
HHH(DDD); // calls halting decider on itself return;
}
int main() {
HHH(DDD); // checks if DDD halts DDD(); // calls DDD >>>>>>> }
```
Let’s assume HHH works perfectly. So:
* HHH(DDD) checks whether DDD halts.
Does DDD halt?
Let’s expand DDD:
* DDD calls HHH(DDD)
* Then returns.
So DDD definitely halts, regardless of what HHH returns. It just >>>>>>> asks HHH something and then returns.
Therefore, DDD terminates.
So the halting decider HHH(DDD) must return 1.
Thus:
* In main(), HHH(DDD) returns 1 * Then DDD() is called, which
again calls HHH(DDD), returns 1, and then returns
Everything halts cleanly.
✅ Summary (if HHH is a true halting decider):
* DDD is terminating * HHH(DDD) returns 1 * No infinite regress
occurs, because HHH doesn’t simulate—just decides
Compare to original “termination analyzer” version, which
simulates execution and thereby enters infinite regress.
🧠 Bottom Line:
* HHH as a simulator: gets stuck simulating a self-referential
call — returns 0 * HHH as a decider: easily sees DDD halts — >>>>>>> returns 1
Which highlights the Halting Problem's essence: The analyzer
(which uses simulation) gets trapped, while the decider (which is >>>>>>> impossible in practice) avoids the trap by divine insight.
/Flibble
*To get an accurate view of what I am saying you must read this*
https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
ChatGPT seems to explain it more clearly than I can explain it.
You cannot get an accurate view of what you are saying by using a
stochastic parrot if you load the dice by using prompt manipulation
to get the parrot to give you a favourable response (like you did by >>>>> using the term "termination analyser" instead of the term "halt
decider").
infallible and its operation can be concretely defined in a high
level language.
No, you used that term to get ChatGPT to give you a favourable
response unrelated to the halting problem. Ask ChatGPT, "What if HHH
is a halt decider rather than a termination analyser?".
Please tell me, which part of the following sentence don't you
understand:
Halting problem proofs are predicated on total deciders so you
cannot use a partial decider to refute a halting problem proof.
/Flibble
I have studied this for 22 years. The way that the HP proof is
supposed to work is to hypothesize that a universal halt decider
exists. Then all that is needed is a single counter-example that
cannot be decided and this refutes that a universal halt decider
exists.
You are not working on the halting problem, you are working on the
Olcott problem, wasting 22 years.
/Flibble
My prior paragraph is the basic structure of the halting problem
proofs.
because your created input that you claim to solve has essential
differences from it.
The first one is that you keep on trying to use a non-program, that
doesn't include all of its code, like a copy of the decider as part of
it,
IF you acknoledge that the code of HHH is part of DDD as well as being
the decider, then your "simuation of DDD" becomes wrong, as you can't
then ignore that the code of the copy of HHH that is in DDD will break
the cycle you are seeing in just the function DDD.
Sorry. all you are doing is showing that you think lying is ok, which
goes counter to your claimed goal of finding a way to determine truth
better.
On 8/3/2025 7:09 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 07:05:50 -0400, Richard Damon wrote:Yet again you try to get away with "stopping running"
Your problem is you don't find an error in the shown counter example,
because your created input that you claim to solve has essential
differences from it.
The first one is that you keep on trying to use a non-program, that
doesn't include all of its code, like a copy of the decider as part of
it,
IF you acknoledge that the code of HHH is part of DDD as well as being
the decider, then your "simuation of DDD" becomes wrong, as you can't
then ignore that the code of the copy of HHH that is in DDD will break
the cycle you are seeing in just the function DDD.
as the same thing as "halting" even though you recently acknowledged
that they are not the same.
DDD and HHH correctly emulated by the executed HHH cannot possibly ever
reach their own final halt states no matter what HHH does.
If HHH aborts after one billion recursive emulations neither the
correctly emulated HHH nor the correctly emulated DDD would ever halt
even though they stop running.
Richard always uses the strawman fallacy and changes the subject away
from DDD correctly simulated by HHH.
This is a dishonest attempt at deception. https://en.wikipedia.org/wiki/Straw_man
Sorry. all you are doing is showing that you think lying is ok, which
goes counter to your claimed goal of finding a way to determine truth
better.
So Olcott is lying, where do you go from here?
/Flibble
*I am not lying. Richard is the liar*
When I say that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H cannot possibly reach its own final halt state of ⟨Ĥ.qn⟩
because it remains stuck in recursive simulation this is self-evident by
the meaning of my words.
On 8/3/2025 8:54 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 08:28:09 -0500, olcott wrote:
On 8/3/2025 7:09 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 07:05:50 -0400, Richard Damon wrote:Yet again you try to get away with "stopping running"
Your problem is you don't find an error in the shown counter
example, because your created input that you claim to solve has
essential differences from it.
The first one is that you keep on trying to use a non-program, that
doesn't include all of its code, like a copy of the decider as part
of it,
IF you acknoledge that the code of HHH is part of DDD as well as
being the decider, then your "simuation of DDD" becomes wrong, as
you can't then ignore that the code of the copy of HHH that is in
DDD will break the cycle you are seeing in just the function DDD.
as the same thing as "halting" even though you recently acknowledged
that they are not the same.
DDD and HHH correctly emulated by the executed HHH cannot possibly
ever reach their own final halt states no matter what HHH does.
If HHH aborts after one billion recursive emulations neither the
correctly emulated HHH nor the correctly emulated DDD would ever halt
even though they stop running.
Richard always uses the strawman fallacy and changes the subject away
from DDD correctly simulated by HHH.
This is a dishonest attempt at deception.
https://en.wikipedia.org/wiki/Straw_man
Sorry. all you are doing is showing that you think lying is ok,
which goes counter to your claimed goal of finding a way to
determine truth better.
So Olcott is lying, where do you go from here?
/Flibble
*I am not lying. Richard is the liar*
When I say that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H cannot
possibly reach its own final halt state of ⟨Ĥ.qn⟩
because it remains stuck in recursive simulation this is self-evident
by the meaning of my words.
Being "stuck in" recursive simulation
Means that the simulated final halt state cannot possibly be reached.
This *is* non-halting behavior.
On 8/3/2025 9:47 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 09:25:35 -0500, olcott wrote:
Means that the simulated final halt state cannot possibly be reached.
This *is* non-halting behavior.
No, it isn't non-halting behaviour, it is Olcott Partial Halt Decider
(OPHD) behaviour which is nothing to do with the halting problem.
/Flibble
When a partial halt decider correctly decides the impossible input the
proof that claims this input was impossible is proved wrong.
When the halting problem proof claims that it has proven that no
universal halt decider HHH can possibly exist on the basis that no
algorithm exists that returns a Boolean value that corresponds to the behavior of this input DD:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002162] 55 push ebp [00002163] 8bec mov ebp,esp [00002165] 51 push ecx [00002166] 6862210000 push
00002162 // push DD [0000216b] e862f4ffff call 000015d2 // call HHH [00002170] 83c404 add esp,+04 [00002173] 8945fc mov [ebp-04],eax [00002176] 837dfc00 cmp dword [ebp-04],+00 [0000217a]
7402 jz 0000217e [0000217c] ebfe jmp 0000217c
[0000217e] 8b45fc mov eax,[ebp-04]
[00002181] 8be5 mov esp,ebp [00002183] 5d pop ebp [00002184] c3 ret Size in bytes:(0035) [00002184]
This halting problem proof is proved wrong because the recursive
structure of DD correctly emulated by HHH cannot possibly reach its
final halt state at machine address [00002184] thus HHH(DD)==0 is
correct.
On 8/3/2025 10:45 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 10:43:25 -0500, olcott wrote:
When the halting problem proof claims that it has proven that no
universal halt decider HHH can possibly exist on the basis that no
algorithm exists that returns a Boolean value that corresponds to the
behavior of this input DD:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002162] 55 push ebp [00002163] 8bec mov
ebp,esp [00002165] 51 push ecx [00002166] 6862210000
push 00002162 // push DD [0000216b] e862f4ffff call 000015d2 //
call HHH [00002170] 83c404 add esp,+04 [00002173] 8945fc
mov [ebp-04],eax [00002176] 837dfc00 cmp dword [ebp-04],+00
[0000217a]
7402 jz 0000217e [0000217c] ebfe jmp 0000217c
[0000217e] 8b45fc mov eax,[ebp-04]
[00002181] 8be5 mov esp,ebp [00002183] 5d pop
ebp [00002184] c3 ret Size in bytes:(0035) [00002184]
This halting problem proof is proved wrong because the recursive
structure of DD correctly emulated by HHH cannot possibly reach its
final halt state at machine address [00002184] thus HHH(DD)==0 is
correct.
Yet again I have to point out to you the following:
Halting problem proofs are predicated on total deciders so cannot be
refuted using partial deciders.
/Flibble
You are incorrect about that.
They propose that no universal halt decider exists is proven entirely on
the basis that HHH(DD) has no correct answer.
It may be the case that no universal halt decider exists, yet the conventional proofs do not prove that.
Again, irrelevant examples.
The input for HHH is more like:
void Finite_Recursion () {
static int N = 5;
if (N > 0) Finite_Recursion ();
printf ("Olcott thinks this is never printed.\n");
}
On 8/4/2025 6:07 AM, Richard Damon wrote:
On 8/3/25 10:45 PM, olcott wrote:
On 8/3/2025 9:24 PM, Richard Damon wrote:
On 8/3/25 9:53 PM, olcott wrote:Yes the words that I said do have a defined meaning
On 8/3/2025 8:22 PM, Richard Damon wrote:
On 8/3/25 6:24 PM, olcott wrote:
On 8/3/2025 12:13 PM, wij wrote:
On Mon, 2025-08-04 at 00:45 +0800, wij wrote:
On Sun, 2025-08-03 at 11:13 -0500, olcott wrote:
On 8/3/2025 11:00 AM, wij wrote:
On Sun, 2025-08-03 at 10:29 -0500, olcott wrote:
Self-reference has been the focus of my primary research >>>>>>>>>>>> into the philosophy of:
(a) logic
(b) computation and
(c) math for 22 years.
I began with the Liar Paradox.
That is why I own the domain LiarParadox.org.
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Just like Prolog correctly detects and rejects
the infinitely recursive structure of the Liar
Paradox HHH(DD) correctly detects and rejects
the infinitely recursive structure of its input.
I had explicitly put it in ClassGuidelines.txt to suggest >>>>>>>>>>> 'self- reference' is
impossible to detect in (TM equvilent) programming langage. >>>>>>>>>>>
*Yet the equivalent of self-reference is detectable*
HHH does not know its own machine address so it cannot tell >>>>>>>>>> that DDD is actually calling itself. What it sees is that DDD >>>>>>>>>> is calling the same function with the same parameter twice >>>>>>>>>> in sequence.
So, is HHH a function? Can a function D4 call it?
void D4() {
HHH(D4);
}
Will HHH be stuck in infinite recursion?
How do you conclude HHH(D4)=0 is correct?
_D4()
[000021c3] 55 push ebp
[000021c4] 8bec mov ebp,esp
[000021c6] 68c3210000 push 000021c3 // push D4
[000021cb] e8f3f3ffff call 000015c3 // call HHH
[000021d0] 83c404 add esp,+04
[000021d3] 5d pop ebp
[000021d4] c3 ret
Size in bytes:(0018) [000021d4]
D4 correctly emulated by HHH cannot possibly get
past its own machine address [000021cb] thus the
input to HHH(D4) does specify non-halting behavior
no matter what the D4() that is not an input does.
Nope. As if HHH ever returns an answer because it doesn't do the
correct simulation and aborts, D4 will be halting.
Like always you remain a despicable lying scumbag and change
the words that I said as the basis of your rebuttal.
Only changing them to the definitions of the problem from your lies
about it.
I really sincerely hope that this does not get you condemned
to Hell. You certainly don't deserve that.
No, the problem that you don't understand is that the words you use
have a defined meaning, and in particular,
in the x86 language and you deny this only because
you are a despicable scumbag liar.
No, they don't, as you code doesn't have meaning as it isn't complete,
and doesn't definie (in x86 langugage) what HHH is.
"D4 correctly emulated by HHH" is a sufficiently
complete definition of HHH even if you never heard
of the word "emulated". You remain a liar. I hope
that this does not cost your soul.
On 8/4/2025 9:38 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <[email protected]> wrote:
[ .... ]
Again, irrelevant examples.
The input for HHH is more like:
void Finite_Recursion () {
static int N = 5;
if (N > 0) Finite_Recursion ();
printf ("Olcott thinks this is never printed.\n");
}
Careful! I think you meant "if (N-- > 0) ...." :-)
The fact that PO missed this shows how little attention he pays to
detail.
[ .... ]
The above function has nothing to do with what I am
claiming it is merely dodging the actual point.
I call out any attempt at twisting the words that I
actually said for the purpose of the strawman deception.
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192 // push DDD
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Each element of the infinite set of HHH/DDD pairs
that emulates a natural number N number of instructions
of DDD never reaches past machine address [0000219a].
This is the same template as the Linz proof where
Ĥ.embedded_H is every Linz H that can possibly exist.
N) steps, and thus HHH was just wrong.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
No ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H can
possibly reach its own simulated final state of ⟨Ĥ.qn⟩.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 716 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 59:04:16 |
| Calls: | 12,117 |
| Files: | 15,010 |
| Messages: | 6,518,720 |