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
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 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
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 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 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
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 Fri, 01 Aug 2025 21:46:44 -0500, olcott wrote:
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.
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
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 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
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 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:False. Diagonalization is a legitimate technique: you haven't >>>>>>>>> proven otherwise.
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. >>>>>>>>>
/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.
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
On 8/1/2025 11:05 PM, Mr Flibble wrote:
On Fri, 01 Aug 2025 22:55:57 -0500, olcott wrote: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.
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 ⟨Ĥ⟩ ⊢*
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
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 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
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/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.
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.
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,
The truth is that not all truth is knowable, and you need to learn to
live with that.
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,
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.
All you are doing is proving you are a LIAR that is too stupid to--
understand what truth is,
Op 02.aug.2025 om 04:09 schreef olcott:
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)
As usual incorrect claims without evidence.
A finite recursion is not a non-halting behaviour.
You are trying to get away with the idea that if you close your eyes for
the halting behaviour, it does not exists.
The simulating HHH aborts before it reaches the final halt state of the simulated HHH that has the same code to abort, so it does not see it and pretends that it does not exist.
Changing the meaning of the words will not help you to find the truth.
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 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.
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
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/2/25 9:54 AM, olcott wrote:
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
Not "Proven" in the logical sense, just a very sketchy argument.
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
is not equivalent to non-halting but
is instead simply a manifestation which proves the diagnolization proofs
are correct however your halt decider is partial so the fact it "aborts
the simulation" is irrelevant as far as the halting problem is concerned
as that is about total deciders not partial deciders.
/Flibble
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.
On 8/2/25 2:46 PM, olcott wrote:
On 8/2/2025 1:19 PM, joes wrote:
Change it to what?
I say DDD correctly emulated by HHH does not halt
and Richard says no I am wrong the directly executed
DDD() does halt. He has done this hundreds of times.
But the problem is, if that WERE true, then HHH doesn't answer, as so
wasn't a correct halt decider either.
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 Sun, 2025-08-03 at 09:30 -0500, olcott wrote:
On 8/3/2025 6:05 AM, Richard Damon wrote:
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.
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]
DD correctly emulated by HHH cannot possibly reach
its own "if" statement, thus the "do the opposite"
code is unreachable.
I agree with the point here. The halt decider cannot exist is
because it will be stuck in the infinite recursive call, not
because it would return something for "if' to detect and do
something opposite. But the "if" part is an assumption, easy
to explain. IMO, it all about self-reference.
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
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 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
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.
On 8/3/2025 11:03 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 10:56:17 -0500, olcott wrote:You are conflating the halting problem with its convetional proof.
On 8/3/2025 10:45 AM, Mr Flibble wrote:
Halting problem proofs are predicated on total deciders so cannot be
refuted using partial deciders.
/Flibble
You are incorrect about that.
No I am correct about that: you do not get to change definition of the
halting problem unless you are working on a different problem.
They are not the same thing.
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: your work is unrelated to the halting problem and is
sufficiently uninteresting to be considered a waste of 22 years of
effort.
/Flibble
I have not refuting the halting problem.
I have refuted the conventional halting problem proof.
On 8/3/2025 6:31 AM, Richard Damon wrote:
On 8/2/25 2:46 PM, olcott wrote:
On 8/2/2025 1:19 PM, joes wrote:
Change it to what?
I say DDD correctly emulated by HHH does not halt
and Richard says no I am wrong the directly executed
DDD() does halt. He has done this hundreds of times.
But the problem is, if that WERE true, then HHH doesn't answer, as so
wasn't a correct halt decider either.
void DDD()
{
HHH(DDD);
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
This is merely you hypocritically requiring HHH to report
on the 100% complete step-by-step behavior of some non-halting
inputs such as HHH(DDD) and not requiring this of other inputs HHH(Infinite_Loop).
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
HHH simulates Infinite_Recursion that
calls Infinite_Recursion that proves it
does not halt even when HHH aborts its
simulation.
HHH simulates DDD that calls HHH(DDD)
that proves it does not halt even when
HHH aborts its simulation.
On 8/2/2025 10:08 PM, Richard Damon wrote:
On 8/2/25 9:54 AM, olcott wrote:
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
Not "Proven" in the logical sense, just a very sketchy argument.
That CO2 has increased 126-fold faster in the last 70
years than any other time in the last 800,000 years
proves that very drastic climate change is caused by humans.
I didn't think that you would lie at the expense of the
survival of life on Earth.
On 8/3/2025 9:48 AM, wij wrote:
On Sun, 2025-08-03 at 09:30 -0500, olcott wrote:
On 8/3/2025 6:05 AM, Richard Damon wrote:
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.
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]
DD correctly emulated by HHH cannot possibly reach
its own "if" statement, thus the "do the opposite"
code is unreachable.
I agree with the point here. The halt decider cannot exist is
because it will be stuck in the infinite recursive call, not
because it would return something for "if' to detect and do
something opposite. But the "if" part is an assumption, easy
to explain. IMO, it all about self-reference.
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.
On 8/3/2025 11:03 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 10:56:17 -0500, olcott wrote:
On 8/3/2025 10:45 AM, Mr Flibble wrote:
Halting problem proofs are predicated on total deciders so cannot be
refuted using partial deciders.
/Flibble
You are incorrect about that.
No I am correct about that: you do not get to change definition of the
halting problem unless you are working on a different problem.
You are conflating the halting problem with its convetional proof.
They are not the same thing.
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: your work is unrelated to the halting problem and is sufficiently
uninteresting to be considered a waste of 22 years of effort.
/Flibble
I have not refuting the halting problem.
I have refuted the conventional halting problem proof.
Once this is fully understood the exact same reasoning
equally applies to the Tarksi Undefinability theorem.
On 8/3/25 12:17 PM, olcott wrote:
On 8/3/2025 11:03 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 10:56:17 -0500, olcott wrote:You are conflating the halting problem with its convetional proof.
On 8/3/2025 10:45 AM, Mr Flibble wrote:
Halting problem proofs are predicated on total deciders so cannot be >>>>> refuted using partial deciders.
/Flibble
You are incorrect about that.
No I am correct about that: you do not get to change definition of the
halting problem unless you are working on a different problem.
They are not the same thing.
Maybe your problem is you don't understand the proof, because it uses
logic foreign to you.
The standard proof, is a proof by contradiction, something you have
shown a problem in understand, because you have problem with logic.
The basic idea is we create a specific input, based on whatever decider
you want to claim/assume to be correct, and show that it can not be
correct. To counter-example that proof means you need to show a decider,
that meets the requirements of that decider, that gives the correct
answer, per the definition of the problem, for an input that is built
exactly by the method of the proof.
Your argument fails to do this, because you keep on not using the
definitions and requirments of the problem.
Let us look in detail at some of these requirements.
First, you seem to not understand the requirements for things to be a "program" or more specifically a "computation" in the system.
There requirements include:
R1) That the algorithm of the program be a fully, completely, and in
full detail listing of deterministic steps that are to be used. *ALL*
the step of the algorithm are part of the program. there is no
"reference" to some other program, but that code needs to be included
into the code of that program.
You have problem with that for DDD, as DDD when it calls HHH, doesn't
call some external HHH, but the copy of the code that has been put
inside the code of DDD.
R2) That the algorithm of the program only depends on the values on its "tape", which starts as the contents of its input, to which it can
modify or add more information to it, and at the end becomes part of its "output", completed with the final-state it ends in. In particular, it
means the algorith can use "global" or "static" memory as a back channel between instances of the program or between other programs. All
communication is done via the use of "input".
Thus, for you HHH to simulate the code of "itself" that code needs to be
part of the input, but since that code should have been part of the code
of DDD in the first place, it should have been there.
If the code of HHH isn't there, then HHH just can't simulate the input correctly past the call HHH instruction.
Next we need to look at the DEFINITION of the problem. The decider H is
to decide on the behavior of some machine M given input w, and since
Turing Machines can't just be put on the input tape, are communicated by
ways of a representation WM. Note, the string WM fully represents the
machine W, and the method to prepare this representation is defined by
the programmer of the decider, so if there is some machine for which you can't make a representation to mean what that machine does, that is an
error in the definition of the representation.
The existance of the UTM, which can EXACTLY reproduce the behavior of
any machine, says that it is possible to define a representation that
can correctly represent any machine and input.
Nwxt, if the representation system is sufficient, but a given input
doesn't represent the machine it is supposed to, but something else,
then that is an error in the person preparing that usage of the decider.
Since you are on both sides of this when trying to present you counter example, YOU are at fault if the input doesn't mean what it must mean.
Now for the proof program D, We start with a definition of the decider
we are going to show doesn't handle *ALL* inputs, by making an input,
called WM, which is a representation for a program M, that *IT* (the specified decider) doesn't get right. Said proof program takes as an
input, a description of an arbitrary program (that later we will make a specific program).
The proof program then, using its copy of the decider to foil, asks that decider what M applied to WM will do, by applying H to WM WM.
Again, since you are claiming to be following the proof, what ever D
does to ask H what M WM does must be asking THAT question or you have
failed to follow the proof, and you don't have a counter example.
After D asks H about that input, it then does the opposite of that
result, Halting if H says it will not halt, and looping forever if H
says it will halt.
Lastly we make the representation of D and make that be the input, WD
and give it to D.
So, D will ask H applied to WD WD, which means what does D applied to WD
do, and it it doesn't mean that, then YOU didn't follow the proof. and
then do the opposite.
Because H and D are programs per the rules of Computation Theory, all instances of them will behave the same, so
If H WD WD says non-halting, then D WD, whose behavior is the meaning of
the behavior of the input to H, will also use H WD WD and get that same non-halting answer, and then Halt, and thus H was wrong.
If H WD WD says halting, then D WD will get that same answer and loop forever, and H was wrong.
If H WD WD says anything else, or fails to answer, it is just wrong as a
halt decider.
There is also a varient where D doesn't take an input. but has encoded
in it a way to generate its own representation, but otherwise works the
same.
Again H WD is DEFINED to be asking about the behavior of the Machine D,
as that is what D is defined to be asking H about with that call. WD
must be created to ask that question, and if you can't make such an
input, that just invalidates the counter-example.
A quick summary of your errors.
HHH must be a specific machine, not a set of infinite machines, you need
to choose the ONE that you are going to call correct. (as you can't
build an input based on the infinite set).
DDD must be a full program, and thus includes the HHH that it calls, it doesn't "refer" to the HHH that is simulating/deciding it. It is based
on a specific one, which to be the counter example, must be the one that
it is give to, but the "structure" of DDD doesn't enforce that, as if
you have a set of possible HHHs, any HHH could be given any of the DDD,
the pairing is just a requirement to be the proof set.
Since that HHH is part of DDD, it should be part of the input, and if it wasn't, then HHH couldn't emulate that code, as HHH can't "assume" that
the HHH is itself.
Your putting them at the same address actually breaks this part of your arguement, as it makes your DDD not the DDD of the proof, since you
can't give a given DDD to any other version of HHH, and your DDD isn't a program on its own.
And this breaks your attempt to argue about no HHH can simulate DDD to a final state, as that presumes ONE DDD, not an big set of them, so your
claim "induciton" just isn't one.
But the problem is you haven't been refuting the conventonal proofs,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: your work is unrelated to the halting problem and is
sufficiently uninteresting to be considered a waste of 22 years of
effort.
/Flibble
I have not refuting the halting problem.
I have refuted the conventional halting problem proof.
Once this is fully understood the exact same reasoning equally applies
to the Tarksi Undefinability theorem.
just strawman, and just lying about what you are doing.
See above for the requirements to do what you claim to be doing.
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/25 12:17 PM, olcott wrote:
On 8/3/2025 11:03 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 10:56:17 -0500, olcott wrote:
On 8/3/2025 10:45 AM, Mr Flibble wrote:
Halting problem proofs are predicated on total deciders so cannot be >>>>> refuted using partial deciders.
/Flibble
You are incorrect about that.
No I am correct about that: you do not get to change definition of the
halting problem unless you are working on a different problem.
You are conflating the halting problem with its convetional proof.
They are not the same thing.
Maybe your problem is you don't understand the proof, because it uses
logic foreign to you.
The standard proof, is a proof by contradiction, something you have
shown a problem in understand, because you have problem with logic.
The basic idea is we create a specific input, based on whatever decider
you want to claim/assume to be correct, and show that it can not be
correct. To counter-example that proof means you need to show a decider, that meets the requirements of that decider, that gives the correct
answer, per the definition of the problem, for an input that is built exactly by the method of the proof.
Your argument fails to do this, because you keep on not using the definitions and requirments of the problem.
Let us look in detail at some of these requirements.
First, you seem to not understand the requirements for things to be a "program" or more specifically a "computation" in the system.
There requirements include:
R1) That the algorithm of the program be a fully, completely, and in
full detail listing of deterministic steps that are to be used. *ALL*
the step of the algorithm are part of the program. there is no
"reference" to some other program, but that code needs to be included
into the code of that program.
You have problem with that for DDD, as DDD when it calls HHH, doesn't
call some external HHH, but the copy of the code that has been put
inside the code of DDD.
R2) That the algorithm of the program only depends on the values on its "tape", which starts as the contents of its input, to which it can
modify or add more information to it, and at the end becomes part of its "output", completed with the final-state it ends in. In particular, it
means the algorith can use "global" or "static" memory as a back channel between instances of the program or between other programs. All communication is done via the use of "input".
Thus, for you HHH to simulate the code of "itself" that code needs to be part of the input, but since that code should have been part of the code
of DDD in the first place, it should have been there.
If the code of HHH isn't there, then HHH just can't simulate the input correctly past the call HHH instruction.
Next we need to look at the DEFINITION of the problem. The decider H is
to decide on the behavior of some machine M given input w, and since
Turing Machines can't just be put on the input tape, are communicated by ways of a representation WM. Note, the string WM fully represents the machine W, and the method to prepare this representation is defined by
the programmer of the decider, so if there is some machine for which you can't make a representation to mean what that machine does, that is an
error in the definition of the representation.
The existance of the UTM, which can EXACTLY reproduce the behavior of
any machine, says that it is possible to define a representation that
can correctly represent any machine and input.
Nwxt, if the representation system is sufficient, but a given input
doesn't represent the machine it is supposed to, but something else,
then that is an error in the person preparing that usage of the decider.
Since you are on both sides of this when trying to present you counter example, YOU are at fault if the input doesn't mean what it must mean.
Now for the proof program D, We start with a definition of the decider
we are going to show doesn't handle *ALL* inputs, by making an input,
called WM, which is a representation for a program M, that *IT* (the specified decider) doesn't get right. Said proof program takes as an
input, a description of an arbitrary program (that later we will make a specific program).
The proof program then, using its copy of the decider to foil, asks that decider what M applied to WM will do, by applying H to WM WM.
Again, since you are claiming to be following the proof, what ever D
does to ask H what M WM does must be asking THAT question or you have
failed to follow the proof, and you don't have a counter example.
After D asks H about that input, it then does the opposite of that
result, Halting if H says it will not halt, and looping forever if H
says it will halt.
Lastly we make the representation of D and make that be the input, WD
and give it to D.
So, D will ask H applied to WD WD, which means what does D applied to WD
do, and it it doesn't mean that, then YOU didn't follow the proof. and
then do the opposite.
Because H and D are programs per the rules of Computation Theory, all instances of them will behave the same, so
If H WD WD says non-halting, then D WD, whose behavior is the meaning of
the behavior of the input to H, will also use H WD WD and get that same non-halting answer, and then Halt, and thus H was wrong.
If H WD WD says halting, then D WD will get that same answer and loop forever, and H was wrong.
If H WD WD says anything else, or fails to answer, it is just wrong as a halt decider.
There is also a varient where D doesn't take an input. but has encoded
in it a way to generate its own representation, but otherwise works the same.
Again H WD is DEFINED to be asking about the behavior of the Machine D,
as that is what D is defined to be asking H about with that call. WD
must be created to ask that question, and if you can't make such an
input, that just invalidates the counter-example.
A quick summary of your errors.
HHH must be a specific machine, not a set of infinite machines, you need
to choose the ONE that you are going to call correct. (as you can't
build an input based on the infinite set).
DDD must be a full program, and thus includes the HHH that it calls, it doesn't "refer" to the HHH that is simulating/deciding it. It is based
on a specific one, which to be the counter example, must be the one that
it is give to, but the "structure" of DDD doesn't enforce that, as if
you have a set of possible HHHs, any HHH could be given any of the DDD,
the pairing is just a requirement to be the proof set.
Since that HHH is part of DDD, it should be part of the input, and if it wasn't, then HHH couldn't emulate that code, as HHH can't "assume" that
the HHH is itself.
Your putting them at the same address actually breaks this part of your arguement, as it makes your DDD not the DDD of the proof, since you
can't give a given DDD to any other version of HHH, and your DDD isn't a program on its own.
And this breaks your attempt to argue about no HHH can simulate DDD to a final state, as that presumes ONE DDD, not an big set of them, so your
claim "induciton" just isn't one.
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: your work is unrelated to the halting problem and is sufficiently >>> uninteresting to be considered a waste of 22 years of effort.
/Flibble
I have not refuting the halting problem.
I have refuted the conventional halting problem proof.
Once this is fully understood the exact same reasoning
equally applies to the Tarksi Undefinability theorem.
But the problem is you haven't been refuting the conventonal proofs,
just strawman, and just lying about what you are doing.
See above for the requirements to do what you claim to be doing.
On 8/3/25 11:43 AM, olcott wrote:
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.
Except your doesn't as HHH(DDD) says that DDD doesn't halt, when it does.
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.
But that isn't the criteria that HHH is supposed to use.
The question is, does the program, that the input represents. halts when run.
On 8/3/2025 3:15 PM, Richard Damon wrote:
On 8/3/25 12:17 PM, olcott wrote:
On 8/3/2025 11:03 AM, Mr Flibble wrote:
On Sun, 03 Aug 2025 10:56:17 -0500, olcott wrote:
On 8/3/2025 10:45 AM, Mr Flibble wrote:
Halting problem proofs are predicated on total deciders so cannot be >>>>>> refuted using partial deciders.
/Flibble
You are incorrect about that.
No I am correct about that: you do not get to change definition of the >>>> halting problem unless you are working on a different problem.
You are conflating the halting problem with its convetional proof.
They are not the same thing.
Maybe your problem is you don't understand the proof, because it uses
logic foreign to you.
The standard proof, is a proof by contradiction, something you have
shown a problem in understand, because you have problem with logic.
The basic idea is we create a specific input, based on whatever
decider you want to claim/assume to be correct, and show that it can
not be correct. To counter-example that proof means you need to show a
decider, that meets the requirements of that decider, that gives the
correct answer, per the definition of the problem, for an input that
is built exactly by the method of the proof.
Your argument fails to do this, because you keep on not using the
definitions and requirments of the problem.
Let us look in detail at some of these requirements.
First, you seem to not understand the requirements for things to be a
"program" or more specifically a "computation" in the system.
There requirements include:
R1) That the algorithm of the program be a fully, completely, and in
full detail listing of deterministic steps that are to be used. *ALL*
the step of the algorithm are part of the program. there is no
"reference" to some other program, but that code needs to be included
into the code of that program.
You have problem with that for DDD, as DDD when it calls HHH, doesn't
call some external HHH, but the copy of the code that has been put
inside the code of DDD.
R2) That the algorithm of the program only depends on the values on
its "tape", which starts as the contents of its input, to which it can
modify or add more information to it, and at the end becomes part of
its "output", completed with the final-state it ends in. In
particular, it means the algorith can use "global" or "static" memory
as a back channel between instances of the program or between other
programs. All communication is done via the use of "input".
Thus, for you HHH to simulate the code of "itself" that code needs to
be part of the input, but since that code should have been part of the
code of DDD in the first place, it should have been there.
If the code of HHH isn't there, then HHH just can't simulate the input
correctly past the call HHH instruction.
Next we need to look at the DEFINITION of the problem. The decider H
is to decide on the behavior of some machine M given input w, and
since Turing Machines can't just be put on the input tape, are
communicated by ways of a representation WM. Note, the string WM fully
represents the machine W, and the method to prepare this
representation is defined by the programmer of the decider, so if
there is some machine for which you can't make a representation to
mean what that machine does, that is an error in the definition of the
representation.
The existance of the UTM, which can EXACTLY reproduce the behavior of
any machine, says that it is possible to define a representation that
can correctly represent any machine and input.
Nwxt, if the representation system is sufficient, but a given input
doesn't represent the machine it is supposed to, but something else,
then that is an error in the person preparing that usage of the decider.
Since you are on both sides of this when trying to present you counter
example, YOU are at fault if the input doesn't mean what it must mean.
Now for the proof program D, We start with a definition of the decider
we are going to show doesn't handle *ALL* inputs, by making an input,
called WM, which is a representation for a program M, that *IT* (the
specified decider) doesn't get right. Said proof program takes as an
input, a description of an arbitrary program (that later we will make
a specific program).
The proof program then, using its copy of the decider to foil, asks
that decider what M applied to WM will do, by applying H to WM WM.
Again, since you are claiming to be following the proof, what ever D
does to ask H what M WM does must be asking THAT question or you have
failed to follow the proof, and you don't have a counter example.
After D asks H about that input, it then does the opposite of that
result, Halting if H says it will not halt, and looping forever if H
says it will halt.
Lastly we make the representation of D and make that be the input, WD
and give it to D.
So, D will ask H applied to WD WD, which means what does D applied to
WD do, and it it doesn't mean that, then YOU didn't follow the proof.
and then do the opposite.
Because H and D are programs per the rules of Computation Theory, all
instances of them will behave the same, so
If H WD WD says non-halting, then D WD, whose behavior is the meaning
of the behavior of the input to H, will also use H WD WD and get that
same non-halting answer, and then Halt, and thus H was wrong.
If H WD WD says halting, then D WD will get that same answer and loop
forever, and H was wrong.
If H WD WD says anything else, or fails to answer, it is just wrong as
a halt decider.
There is also a varient where D doesn't take an input. but has encoded
in it a way to generate its own representation, but otherwise works
the same.
Again H WD is DEFINED to be asking about the behavior of the Machine
D, as that is what D is defined to be asking H about with that call.
WD must be created to ask that question, and if you can't make such an
input, that just invalidates the counter-example.
A quick summary of your errors.
HHH must be a specific machine, not a set of infinite machines, you
need to choose the ONE that you are going to call correct. (as you
can't build an input based on the infinite set).
DDD must be a full program, and thus includes the HHH that it calls,
it doesn't "refer" to the HHH that is simulating/deciding it. It is
based on a specific one, which to be the counter example, must be the
one that it is give to, but the "structure" of DDD doesn't enforce
that, as if you have a set of possible HHHs, any HHH could be given
any of the DDD, the pairing is just a requirement to be the proof set.
Since that HHH is part of DDD, it should be part of the input, and if
it wasn't, then HHH couldn't emulate that code, as HHH can't "assume"
that the HHH is itself.
Your putting them at the same address actually breaks this part of
your arguement, as it makes your DDD not the DDD of the proof, since
you can't give a given DDD to any other version of HHH, and your DDD
isn't a program on its own.
And this breaks your attempt to argue about no HHH can simulate DDD to
a final state, as that presumes ONE DDD, not an big set of them, so
your claim "induciton" just isn't one.
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: your work is unrelated to the halting problem and is
sufficiently
uninteresting to be considered a waste of 22 years of effort.
/Flibble
I have not refuting the halting problem.
I have refuted the conventional halting problem proof.
Once this is fully understood the exact same reasoning
equally applies to the Tarksi Undefinability theorem.
But the problem is you haven't been refuting the conventonal proofs,
just strawman, and just lying about what you are doing.
See above for the requirements to do what you claim to be doing.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
The above is a Turing Machine template that includes
the infinite set of every Linz H.
It is true that N recursive simulations of ⟨Ĥ⟩ ⟨Ĥ⟩
by Ĥ.embedded_H never reach their simulated final
halt state of ⟨Ĥ.qn⟩ for any value of N.
It is true that that when Ĥ.embedded_H transitions
to its own Ĥ.qn on the basis of the above then it
is correct.
It is also true that Ĥ applied to ⟨Ĥ⟩ halts for every
value of N.
On 8/3/2025 4:37 PM, Richard Damon wrote:
On 8/3/25 11:43 AM, olcott wrote:
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.
Except your doesn't as HHH(DDD) says that DDD doesn't halt, when it does.
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.
But that isn't the criteria that HHH is supposed to use.
The question is, does the program, that the input represents. halts
when run.
The actual textbook short hand was:
Does machine M halt in input w?
It turns out that has merely been short-hand for:
Does the input to the halt decider specify non-halting behavior?
Just like when I say:
HHH emulates itself emulating DDD was short-hand for
HHH emulates an instance of itself emulating an instance of DDD.
In both cases the short-hand version is not precisely accurate.
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,
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.
On 8/2/2025 4:38 AM, Fred. Zwarts wrote:
Op 02.aug.2025 om 04:09 schreef olcott:
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)
As usual incorrect claims without evidence.
I am not going to repeat all of the lines of my proof
every single time. That I presented all of the lines
of my proof once is sufficient to refute your claims
of no evidence.
A finite recursion is not a non-halting behaviour.
Finite recursion by itself is not non-halting behavior.
Finite recursion that correctly detects a pattern that
would infinitely repeat *IS NON-HALTING BEHAVIOR*
typedef void (*ptr)();
int Simulate(ptr x)
{
x();
return 1;
}
void Infinite_Recursion()
{
Simulate(Infinite_Recursion);
return;
}
HHH detects the behavior pattern where Infinite_Recursion()
cannot possibly reach its own final halt state and it does
this in finite steps.
You are trying to get away with the idea that if you close your eyes
for the halting behaviour, it does not exists.
Not at all. I repeatedly challenge you to show how
DDD emulated by HHH halts and you change the subject.
Changing the subject this way is known as the strawman error.
A straw man fallacy (sometimes written as strawman)
is the informal fallacy of refuting an argument
different from the one actually under discussion,
while not recognizing or acknowledging the distinction. https://en.wikipedia.org/wiki/Straw_man
The simulating HHH aborts before it reaches the final halt state of
the simulated HHH that has the same code to abort, so it does not see
it and pretends that it does not exist.
Each HHH aborts as soon as it has seen one recursive simulation.
We could change this to each HHH aborts after it sees N recursive simulations. In every case the outer HHH meets its criteria first.
If this HHH waited for the next, they would all wait for the next
and no abort would ever occur.
Changing the meaning of the words will not help you to find the truth.
I don't change the meaning of words. I correct the erroneous
ambiguity of the meaning or words. I also correct the definitions
of the meaning of words when these definitions directly contradict
other definitions.
The input to a halt decider specifies its behavior.
Directly executed Turing machines are outside of the
domain of every halt decider.
Op 02.aug.2025 om 17:03 schreef olcott:
On 8/2/2025 4:38 AM, Fred. Zwarts wrote:
Op 02.aug.2025 om 04:09 schreef olcott:
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)
As usual incorrect claims without evidence.
I am not going to repeat all of the lines of my proof
every single time. That I presented all of the lines
of my proof once is sufficient to refute your claims
of no evidence.
As usual repeated incorrect claims without evidence. There never has
been a proof.
A finite recursion is not a non-halting behaviour.
Finite recursion by itself is not non-halting behavior.
Finite recursion that correctly detects a pattern that
would infinitely repeat *IS NON-HALTING BEHAVIOR*
As usual irrelevant remarks.
There is no such pattern. There is only a finite recursion, after which
the program halts. That is what the code of the input specifies. That
HHH does not see it, does not change the specification.
The code specifies a finite recursion, followed by an abort by the
simulated HHH. HHH does not se that, because of a premature abort.
typedef void (*ptr)();
int Simulate(ptr x)
{
x();
return 1;
}
void Infinite_Recursion()
{
Simulate(Infinite_Recursion);
return;
}
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");
}
HHH detects the behavior pattern where Infinite_Recursion()
cannot possibly reach its own final halt state and it does
this in finite steps.
But HHH does not recognise that there is only a finite recursion in the simulated HHH, because it does not keep track of the internal state of
the simulated HHH and its conditional branch instructions.
You are trying to get away with the idea that if you close your eyes
for the halting behaviour, it does not exists.
Not at all. I repeatedly challenge you to show how
DDD emulated by HHH halts and you change the subject.
Changing the subject this way is known as the strawman error.
Yes, you keep closing your eyes for the errors in HHH and that it not possible to correct them.
You also use the strange logic that if no correction exists, HHH must be correct.
A straw man fallacy (sometimes written as strawman)
is the informal fallacy of refuting an argument
different from the one actually under discussion,
while not recognizing or acknowledging the distinction.
https://en.wikipedia.org/wiki/Straw_man
Why are you using straw man fallacies, if you know that the have no
value? That looks very dishonest.
The simulating HHH aborts before it reaches the final halt state of
the simulated HHH that has the same code to abort, so it does not see
it and pretends that it does not exist.
Each HHH aborts as soon as it has seen one recursive simulation.
But only a finite recursion, where correct simulaters show that for the exact same input only one more recursion is needed to reach the final
halt state.
We could change this to each HHH aborts after it sees N recursive
simulations. In every case the outer HHH meets its criteria first.
If this HHH waited for the next, they would all wait for the next
and no abort would ever occur.
Only, if you change the input. If you increase N, but use the same
input, then we see that it reaches the final halt state.
Of, cours, with this other new HHH, we can construct another new DDD,
for which this HHH will fail to. The only think you do is proving that
it is impossible to create an HHH that is correct for all possible inputs.
Changing the meaning of the words will not help you to find the truth.
I don't change the meaning of words. I correct the erroneous
ambiguity of the meaning or words. I also correct the definitions
of the meaning of words when these definitions directly contradict
other definitions.
No, you change the meaning of the words.
A finite recursion is not non-halting behaviour.
The input to a halt decider specifies its behavior.
Directly executed Turing machines are outside of the
domain of every halt decider.
Yes, but when the input specifies a finite recursion, followed by a
final halt state, HHH is incorrect when it does not see that and starts
to reason about a hypothetical non-input that does not halt.
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.
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> 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.
[ .... ]
On Mon, 2025-08-04 at 11:21 -0500, olcott wrote:
On 8/4/2025 11:03 AM, wij wrote:
On Mon, 2025-08-04 at 10:49 -0500, olcott wrote:
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
The above is a Turing Machine template that includes
the infinite set of every Linz H.
It is true that N recursive simulations of ⟨Ĥ⟩ ⟨Ĥ⟩
by Ĥ.embedded_H never reach their simulated final
halt state of ⟨Ĥ.qn⟩ for any value of N.
It is true that that when Ĥ.embedded_H transitions
to its own Ĥ.qn on the basis of the above then it is
correct.
It is also true that Ĥ applied to ⟨Ĥ⟩ halts for every
value of N.
We know you don't understand the basic logic, just copy-and-paste. You don't
understand what TM really is, too.
I did not merely copy and paste Linz.
I corrected his error of having to start states
and made several other changes to make things
much more clear.
Ĥ applied to ⟨Ĥ⟩ is much clearer notation for
machine Ĥ and machine description ⟨Ĥ⟩ than M and WM.
Ĥ.embedded_H is much clearer notion specifying that
it is a copy of Linz H embedded within Linz Ĥ than Ĥq0.
The tape states of y1 and y2 make the notation more
complex than needed.
<Linz text>
From H' we construct another Turing machine Ĥ.
This new machine takes as input WM, copies it,
and then behaves exactly like H'. Then the action
of Ĥ is such that
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
</Linz text>
And now, one more to the list: You don't understand what your PC tell you, too.As a rebuttal you only have ad hominem attacks
that is mild saying that you 'makeup' fact (I already know that from the beginning).
That is what you thought, I (and others) have no need to resort to ad hominem attack an apparent CS idiot, that would only degrade the 'attacker'.
People had pretended to be kind to lies, but now cannot bear no more.
I would suggest you go attract new person to comp.theory.
and cannot point to any specific error that I made.
Your errors had been pointed out millions times. What is about mine?
A plain spec. of Halting Problem.
If HHH(D4) returns 1, we know D4() will halt.
If HHH(D4) returns 0, we know D4() will not halt.
If HHH(D4) cannot return, we say D4 (or maybe HHH(D4)) is undecidable.
If the result of HHH(D4) is not fixed (across platforms), HHH is badly implemented.
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 <F.Zwarts@hetnet.nl> 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⟩.
On 8/4/25 9:49 AM, olcott wrote:
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.
IN other wwrds you are stipulating that your HHH is DEFINED to do a
correct simulation, and thus NEVER abort, and thus isn't a decider?
On 8/4/25 10:54 AM, olcott wrote:In other words you are saying the Linz only proved
On 8/4/2025 9:38 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> 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.
But Linz doesn't give the TEMPLATE to the decider, but the program built
by it, and THAT includes the HHH that it was built on, and thus every instance is different, so your claim about the infinite set is
worthless,
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,064 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 148:14:15 |
| Calls: | 13,691 |
| Calls today: | 1 |
| Files: | 186,936 |
| D/L today: |
33 files (6,120K bytes) |
| Messages: | 2,410,932 |