On 11/2/2025 8:13 AM, dbush wrote:
On 11/2/2025 9:09 AM, olcott wrote:
On 11/2/2025 8:00 AM, dbush wrote:
On 11/2/2025 8:57 AM, olcott wrote:
On 11/2/2025 7:48 AM, dbush wrote:
On 11/2/2025 8:16 AM, olcott wrote:
On 11/2/2025 1:15 AM, Tristan Wibberley wrote:
On 02/11/2025 02:41, olcott wrote in reply to Mike Terry:> ... >>>>>>>> what is
up with the "duffer speak" reference
to my perfectly unambiguous statements?
I think he might have a problem with your ambiguous ones.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
H does report on the semantic property that its
finite input string specifies.
(a) "finite input string" term of the art from computer science
(b) "semantic property" term of the art from Rice's Theorem.
Rejected out-of-hand as unclear. All references to "D" and "H" must >>>> be prefixed by exactly one of:
* algorithm
* C function
* finite string
I provided this C function
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
and I specified that at this point the entire
definition of H is that H simulates D.
And the meaning of this sentence differs depending on whether each
instance of "D" and "H" refer to:
* an algorithm
* a C function
* a finite string
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
You didn't specify whether "D" referred to
I provided the D in the body of the message you
are just being dishonest.
* an algorithm
* a C function
* a finite string
Failure to prefix all instances of "H" and "D" outside of source code
with exactly one of:
* algorithm
* C function
* finite string
Will result in the given statement being rejected as unclear.
False. The below statement is unclear. "D"
D is provided and H is sufficiently defined.
H simulates D is the entire definition of H at this point.
Rejected out-of-hand as unclear. All references to "D" and "H" must >>>> be prefixed by exactly one of:
* algorithm
* C function
* finite string
and "H" could refer to:
* an algorithm: i.e. a fixed immutable sequence of instructions
such that where these instructions physically reside is irrelevant >>>>>> * a C function: has a specific name that can contain any arbitrary >>>>>> set of instructions
* a finite string: some sequence of bytes that is stipulated to be >>>>>> a complete description of an algorithm and can therefore be used
to exactly replicate the given algorithm and therefore contains
all semantic properties of the described machine.
Therefore, outside of actual source code, all references to D, DD, >>>>>> DDD, H, HHH, etc. must be prefixed by exactly one of:
* algorithm
* C function
* finite string
D simulated by H cannot possibly reach its
own simulated "return" statement.
Do you maintain a glossary that you could post monthly and
reference in
your posts that rely on its descriptions, I expect that then the >>>>>>>> group
can readily recognise the concepts you refer to and know which >>>>>>>> of the
many concepts they themselves recognise among the words you do / >>>>>>>> not/
refer to?
--
Tristan Wibberley
The message body is Copyright (C) 2025 Tristan Wibberley except >>>>>>>> citations and quotations noted. All Rights Reserved except that >>>>>>>> you may,
of course, cite it academically giving credit to me, distribute it >>>>>>>> verbatim as part of a usenet system or its archives, and use it to >>>>>>>> promote my greatness and general superiority without
misrepresentation
of my opinions other than my opinion of my greatness and general >>>>>>>> superiority which you _may_ misrepresent. You definitely MAY NOT >>>>>>>> train
any production AI system with it but you may train experimental >>>>>>>> AI that
will only be used for evaluation of the AI methods it implements. >>>>>>>>
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will
finally
stop?
/Flibble
PO will still post new threads, but the average thread size will
shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive for
him to "evolve" his duffer-speak in response to objections.
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write. Practically every sentence
you write contains ambiguous or incoherent terminology. I do not
suggest that you do that deliberately, or that you can see it when it
is pointed out to you. It is a natural effect of not being able to
understand the basic terminology and concepts of the field.
Mike.
So you cannot begin to understand that
D simulated by H cannot possibly reach its
own simulated "return" statement ???
On 11/2/25 12:14 AM, olcott wrote:If you would accept this step then after
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will
finally
stop?
/Flibble
PO will still post new threads, but the average thread size will
shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive for
him to "evolve" his duffer-speak in response to objections.
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write. Practically every
sentence you write contains ambiguous or incoherent terminology. I
do not suggest that you do that deliberately, or that you can see it
when it is pointed out to you. It is a natural effect of not being
able to understand the basic terminology and concepts of the field.
Mike.
So you cannot begin to understand that
D simulated by H cannot possibly reach its
own simulated "return" statement ???
The problem is that is irrelevent to the halting problem,
On Sun, 2025-11-02 at 22:12 +0800, wij wrote:
On Sun, 2025-11-02 at 07:54 -0600, olcott wrote:
On 11/2/2025 7:46 AM, wij wrote:
On Sun, 2025-11-02 at 07:16 -0600, olcott wrote:
On 11/2/2025 1:15 AM, Tristan Wibberley wrote:
On 02/11/2025 02:41, olcott wrote in reply to Mike Terry:> ... what is >>>>>> up with the "duffer speak" reference
to my perfectly unambiguous statements?
I think he might have a problem with your ambiguous ones.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Yes, this is the proof that olcott contradicted POO H.
You can even get the insult correctly.
What? It is smear.
I said you posted an evidence that contradicts what POOH claims.
I already know you are very shameless to be impenetrable by any insult,
why would I do that?
On the other hand, this is an evidence that olcott deliberately lies:
he knows exactly what undecidable is and hide it in 'proof'.
H does report on the semantic property that its
finite input string specifies.
(a) "finite input string" term of the art from computer science
(b) "semantic property" term of the art from Rice's Theorem.
What you said is NOT what you showed, as the above D() which is pretty much the simple pattern of HP proof. You slapped your face.
You confirmed that:
"*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.:
On 11/2/2025 10:12 AM, olcott wrote:
On 11/2/2025 8:13 AM, dbush wrote:
On 11/2/2025 9:09 AM, olcott wrote:
On 11/2/2025 8:00 AM, dbush wrote:
On 11/2/2025 8:57 AM, olcott wrote:
On 11/2/2025 7:48 AM, dbush wrote:
On 11/2/2025 8:16 AM, olcott wrote:
On 11/2/2025 1:15 AM, Tristan Wibberley wrote:
On 02/11/2025 02:41, olcott wrote in reply to Mike Terry:> ... >>>>>>>>> what is
up with the "duffer speak" reference
to my perfectly unambiguous statements?
I think he might have a problem with your ambiguous ones.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
H does report on the semantic property that its
finite input string specifies.
(a) "finite input string" term of the art from computer science
(b) "semantic property" term of the art from Rice's Theorem.
Rejected out-of-hand as unclear. All references to "D" and "H"
must be prefixed by exactly one of:
* algorithm
* C function
* finite string
I provided this C function
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
and I specified that at this point the entire
definition of H is that H simulates D.
And the meaning of this sentence differs depending on whether each
instance of "D" and "H" refer to:
* an algorithm
* a C function
* a finite string
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
Why the Hell did you say that D was not defined when D was provided?
You didn't specify whether "D" referred to
I provided the D in the body of the message you
are just being dishonest.
C function D, algorithm D, or finite string D?
On 11/2/2025 11:18 AM, dbush wrote:
On 11/2/2025 10:12 AM, olcott wrote:
On 11/2/2025 8:13 AM, dbush wrote:
On 11/2/2025 9:09 AM, olcott wrote:
On 11/2/2025 8:00 AM, dbush wrote:
On 11/2/2025 8:57 AM, olcott wrote:
On 11/2/2025 7:48 AM, dbush wrote:
On 11/2/2025 8:16 AM, olcott wrote:
On 11/2/2025 1:15 AM, Tristan Wibberley wrote:
On 02/11/2025 02:41, olcott wrote in reply to Mike Terry:> ... >>>>>>>>>> what is
up with the "duffer speak" reference
to my perfectly unambiguous statements?
I think he might have a problem with your ambiguous ones.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
H does report on the semantic property that its
finite input string specifies.
(a) "finite input string" term of the art from computer science
(b) "semantic property" term of the art from Rice's Theorem.
Rejected out-of-hand as unclear. All references to "D" and "H"
must be prefixed by exactly one of:
* algorithm
* C function
* finite string
I provided this C function
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
and I specified that at this point the entire
definition of H is that H simulates D.
And the meaning of this sentence differs depending on whether each
instance of "D" and "H" refer to:
* an algorithm
* a C function
* a finite string
Why the Hell did you say that D was not defined when D was provided? >>>>> Why the Hell did you say that D was not defined when D was provided? >>>>> Why the Hell did you say that D was not defined when D was provided? >>>>> Why the Hell did you say that D was not defined when D was provided? >>>>> Why the Hell did you say that D was not defined when D was provided?
You didn't specify whether "D" referred to
I provided the D in the body of the message you
are just being dishonest.
C function D, algorithm D, or finite string D?
This thing right here that I have been repeating
20 times a day every day for the last three years.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
On 11/2/2025 7:25 PM, olcott wrote:
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H"
must be prefixed by exactly one of:
* algorithm
* C function
* finite string
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must
be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
On 03/11/2025 00:32, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
<snip>
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must
be prefixed by exactly one of:
* algorithm
* C function
* finite string
It can be re-stated clearly enough:
"Olcott claims that H's simulation of D never halts."
Observation shows that Olcott's claim is mistaken.
So nothing new there.
On 03/11/2025 00:32, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
<snip>
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must
be prefixed by exactly one of:
* algorithm
* C function
* finite string
It can be re-stated clearly enough:
"Olcott claims that H's simulation of D never halts."
Observation shows that Olcott's claim is mistaken.
So nothing new there.
On 11/2/2025 7:00 PM, Richard Heathfield wrote:
On 03/11/2025 00:32, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
<snip>
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must
be prefixed by exactly one of:
* algorithm
* C function
* finite string
It can be re-stated clearly enough:
"Olcott claims that H's simulation of D never halts."
It has taken me three years to get those words
exactly correctly so that they form the basis
for the next step of my proof.
*These are those words*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Observation shows that Olcott's claim is mistaken.
Because you cheated and changed the words that
took me three years to get exactly correctly.
So nothing new there.
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must
be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must >>>> be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
D is a finite string
in the C programming
language that specifies a sequence of steps
and defines a C function.
Did you think it was a box of chocolates?
H is something or other that can simulate
D and is callable from D.
Does that sound like a dead bullfrog?
On 11/2/2025 8:17 PM, olcott wrote:
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H"
must be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
D is a finite string
And what exactly is that finite string composed of?
in the C programming
language that specifies a sequence of steps
and defines a C function.
So you're claiming that finite string D is a description of C function D?
Did you think it was a box of chocolates?
H is something or other that can simulate
D and is callable from D.
So it sounds like H is not well-defined.
Unless you can classify it as
a C function, finite string, or algorithm, you claim will be dismissed out-of-hand as unclear.
Does that sound like a dead bullfrog?
On 11/2/2025 7:26 PM, dbush wrote:
On 11/2/2025 8:17 PM, olcott wrote:
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H"
must be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
D is a finite string
And what exactly is that finite string composed of?
in the C programming
language that specifies a sequence of steps
and defines a C function.
So you're claiming that finite string D is a description of C function D?
No that is too vague. It is exactly what I said it is.
Did you think it was a box of chocolates?
Did you think it was a box of chocolates?
H is something or other that can simulate
D and is callable from D.
So it sounds like H is not well-defined.
It is 100% perfectly and completely defined for
its specific purpose.
Unless you can classify it as a C function, finite string, or
algorithm, you claim will be dismissed out-of-hand as unclear.
Yes because simulation might be construed as an
actual slap in the actual face and have nothing
to do with following the steps specified by the
C source code.
Does that sound like a dead bullfrog?
On 11/2/2025 8:00 PM, Richard Heathfield wrote:
On 03/11/2025 00:32, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
<snip>
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and
"H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
It can be re-stated clearly enough:
"Olcott claims that H's simulation of D never halts."
But is that:
* C function H's simulation of C function D
* Algorithm H's simulation of algorithm D
* C function H's simulation of algorithm D
* Algorithm H's simulation of C function D
The answer differs depending on which one is meant.
On 11/2/2025 9:25 PM, olcott wrote:
On 11/2/2025 7:26 PM, dbush wrote:
On 11/2/2025 8:17 PM, olcott wrote:
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" >>>>>>> must be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
D is a finite string
And what exactly is that finite string composed of?
The lack of reply here indicates you don't know what the finite string D
is.
in the C programming
language that specifies a sequence of steps
and defines a C function.
So you're claiming that finite string D is a description of C
function D?
No that is too vague. It is exactly what I said it is.
And what exactly is vague about it?
Did you think it was a box of chocolates?
Did you think it was a box of chocolates?
H is something or other that can simulate
D and is callable from D.
So it sounds like H is not well-defined.
It is 100% perfectly and completely defined for
its specific purpose.
"something or other" is the exact opposite of 100% perfectly and
completely defined.
Unless you can classify it as a C function, finite string, or
algorithm, you claim will be dismissed out-of-hand as unclear.
Yes because simulation might be construed as an
actual slap in the actual face and have nothing
to do with following the steps specified by the
C source code.
Then your statement is dismissed out-of-hand as unclear as you haven't defined whether "H" refers a C function, algorithm, finite string, or something else.
Does that sound like a dead bullfrog?
On 03/11/2025 01:06, dbush wrote:
On 11/2/2025 8:00 PM, Richard Heathfield wrote:
On 03/11/2025 00:32, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
<snip>
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must >>>> be prefixed by exactly one of:
* algorithm
* C function
* finite string
It can be re-stated clearly enough:
"Olcott claims that H's simulation of D never halts."
But is that:
* C function H's simulation of C function D
No. H doesn't have access to the C code. Clearly it *could* have -
Olcott could pass a .c file name - but he doesn't like the idea.
* Algorithm H's simulation of algorithm D
No. Olcott's claim that it's simulating D is mistaken. H is not
simulating an algorithm. It's trying to simulate an x86 (and making a
lousy job of it).
* C function H's simulation of algorithm D
No. H isn't simulating an algorithm.
* Algorithm H's simulation of C function D
No. H isn't simulating an algorithm.
The answer differs depending on which one is meant.
No, I don't think so. The answer is no no no no no no no.
On 11/2/2025 8:33 PM, dbush wrote:
On 11/2/2025 9:25 PM, olcott wrote:
On 11/2/2025 7:26 PM, dbush wrote:
On 11/2/2025 8:17 PM, olcott wrote:
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" >>>>>>>> must be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
D is a finite string
And what exactly is that finite string composed of?
The lack of reply here indicates you don't know what the finite string
D is.
You never heard of ASCII characters?
in the C programming
language that specifies a sequence of steps
and defines a C function.
So you're claiming that finite string D is a description of C
function D?
No that is too vague. It is exactly what I said it is.
And what exactly is vague about it?
The term "description" when applied in software
engineering has a different much more vague
meaning that machine description in theoretical
computer science.
Did you think it was a box of chocolates?
Did you think it was a box of chocolates?
H is something or other that can simulate
D and is callable from D.
So it sounds like H is not well-defined.
It is 100% perfectly and completely defined for
its specific purpose.
"something or other" is the exact opposite of 100% perfectly and
completely defined.
For the purposes of verifying this statement
D simulated by H cannot possibly reach its
own simulated "return" statement.
It is 100% completely defined.
That you insist on knowing irrelevant
details such as that the C function is
encoded in ASCII proves that you are
not being honest.
Unless you can classify it as a C function, finite string, or
algorithm, you claim will be dismissed out-of-hand as unclear.
Yes because simulation might be construed as an
actual slap in the actual face and have nothing
to do with following the steps specified by the
C source code.
Then your statement is dismissed out-of-hand as unclear as you haven't
defined whether "H" refers a C function, algorithm, finite string, or
something else.
Does that sound like a dead bullfrog?
On 03/11/2025 01:06, dbush wrote:
On 11/2/2025 8:00 PM, Richard Heathfield wrote:
On 03/11/2025 00:32, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
<snip>
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" must >>>> be prefixed by exactly one of:
* algorithm
* C function
* finite string
It can be re-stated clearly enough:
"Olcott claims that H's simulation of D never halts."
But is that:
* C function H's simulation of C function D
No. H doesn't have access to the C code. Clearly it *could* have -
Olcott could pass a .c file name - but he doesn't like the idea.
* Algorithm H's simulation of algorithm D
No. Olcott's claim that it's simulating D is mistaken. H is not
simulating an algorithm. It's trying to simulate an x86 (and making a
lousy job of it).
I can write a C interpreter which can interpret itself.
* C function H's simulation of algorithm D
No. H isn't simulating an algorithm.
* Algorithm H's simulation of C function D
No. H isn't simulating an algorithm.
The answer differs depending on which one is meant.
No, I don't think so. The answer is no no no no no no no.
On 11/2/2025 9:53 PM, olcott wrote:
On 11/2/2025 8:33 PM, dbush wrote:
On 11/2/2025 9:25 PM, olcott wrote:
On 11/2/2025 7:26 PM, dbush wrote:
On 11/2/2025 8:17 PM, olcott wrote:
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and "H" >>>>>>>>> must be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of: >>>>>>> * algorithm
* C function
* finite string
D is a finite string
And what exactly is that finite string composed of?
The lack of reply here indicates you don't know what the finite
string D is.
You never heard of ASCII characters?
Are you suggesting finite string D is the ASCII character 'D'? That's
not what the above code is being passed.
On 11/2/2025 9:11 PM, dbush wrote:
On 11/2/2025 9:53 PM, olcott wrote:
On 11/2/2025 8:33 PM, dbush wrote:
On 11/2/2025 9:25 PM, olcott wrote:
On 11/2/2025 7:26 PM, dbush wrote:
On 11/2/2025 8:17 PM, olcott wrote:
On 11/2/2025 7:04 PM, dbush wrote:
On 11/2/2025 7:35 PM, olcott wrote:
On 11/2/2025 6:32 PM, dbush wrote:
On 11/2/2025 7:25 PM, olcott wrote:
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write.
*Just pay 100% complete attention to this one sentence*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Rejected out-of-hand as unclear. All references to "D" and >>>>>>>>>> "H" must be prefixed by exactly one of:
* algorithm
* C function
* finite string
Did you think that this might be a box of
chocolates unless I told you otherwise?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
That part is clear. What's not clear is the sentence:
D simulated by H cannot possibly reach its
own simulated "return" statement.
All references to "D" and "H" must be prefixed by exactly one of: >>>>>>>> * algorithm
* C function
* finite string
D is a finite string
And what exactly is that finite string composed of?
The lack of reply here indicates you don't know what the finite
string D is.
You never heard of ASCII characters?
Are you suggesting finite string D is the ASCII character 'D'? That's
not what the above code is being passed.
The finite string of the source code for the C
function named D is composed of ASCII characters.
As has been dead fucking obvious all along. You
only ask to play childish head games.
On 11/2/2025 10:16 PM, olcott wrote:
The finite string of the source code for the C
function named D is composed of ASCII characters.
The function H is clearly being passed a function pointer, not a
string of ASCII characters.
On 11/2/2025 1:10 PM, Richard Damon wrote:
On 11/2/25 12:14 AM, olcott wrote:If you would accept this step then after
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will >>>>>>> finally
stop?
/Flibble
PO will still post new threads, but the average thread size will
shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive for >>>>>> him to "evolve" his duffer-speak in response to objections.
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write. Practically every
sentence you write contains ambiguous or incoherent terminology. I
do not suggest that you do that deliberately, or that you can see it
when it is pointed out to you. It is a natural effect of not being
able to understand the basic terminology and concepts of the field.
Mike.
So you cannot begin to understand that
D simulated by H cannot possibly reach its
own simulated "return" statement ???
The problem is that is irrelevent to the halting problem,
a few more steps I could show something
quite interesting. No one has ever accepted
this truism besides Ben.
On 03/11/2025 03:27, dbush wrote:
On 11/2/2025 10:16 PM, olcott wrote:
<snip>
The finite string of the source code for the C
function named D is composed of ASCII characters.
The function H is clearly being passed a function pointer, not a
string of ASCII characters.
Clearly a bug in H. Let us take Olcott at his word and give H a finite string. Since he insists that the universe of discourse is C, let us
make it a C string.
const char *D =
"int D()\n"
"{\n"
" int Halt_Status = H(D);\n"
" if (Halt_Status)\n"
" HERE: goto HERE;\n"
" return Halt_Status;\n
"} \n";
Now do H(D) and watch what happens when you take Olcott at his word.
This is why I stopped replying directly to Olcott. It's just too cruel.
On 11/2/25 3:26 PM, olcott wrote:
On 11/2/2025 1:10 PM, Richard Damon wrote:
On 11/2/25 12:14 AM, olcott wrote:If you would accept this step then after
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will >>>>>>>> finally
stop?
/Flibble
PO will still post new threads, but the average thread size will >>>>>>> shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive for >>>>>>> him to "evolve" his duffer-speak in response to objections.
There is no duffer speak to this.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write. Practically every
sentence you write contains ambiguous or incoherent terminology. I >>>>> do not suggest that you do that deliberately, or that you can see
it when it is pointed out to you. It is a natural effect of not
being able to understand the basic terminology and concepts of the
field.
Mike.
So you cannot begin to understand that
D simulated by H cannot possibly reach its
own simulated "return" statement ???
The problem is that is irrelevent to the halting problem,
a few more steps I could show something
quite interesting. No one has ever accepted
this truism besides Ben.
Why should I accept a self-contradictory and ambigious definition?
On 11/2/2025 9:58 PM, Richard Damon wrote:
On 11/2/25 3:26 PM, olcott wrote:
On 11/2/2025 1:10 PM, Richard Damon wrote:
On 11/2/25 12:14 AM, olcott wrote:If you would accept this step then after
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:There is no duffer speak to this.
Once Olcott has plonked everyone I guess the shitshow here will >>>>>>>>> finally
stop?
/Flibble
PO will still post new threads, but the average thread size will >>>>>>>> shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive >>>>>>>> for him to "evolve" his duffer-speak in response to objections. >>>>>>>
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write. Practically every
sentence you write contains ambiguous or incoherent terminology. >>>>>> I do not suggest that you do that deliberately, or that you can
see it when it is pointed out to you. It is a natural effect of >>>>>> not being able to understand the basic terminology and concepts of >>>>>> the field.
Mike.
So you cannot begin to understand that
D simulated by H cannot possibly reach its
own simulated "return" statement ???
The problem is that is irrelevent to the halting problem,
a few more steps I could show something
quite interesting. No one has ever accepted
this truism besides Ben.
Why should I accept a self-contradictory and ambigious definition?
*ALL four LLMs got this correctly*
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
when given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
On 11/2/25 11:27 PM, olcott wrote:
On 11/2/2025 9:58 PM, Richard Damon wrote:
On 11/2/25 3:26 PM, olcott wrote:
On 11/2/2025 1:10 PM, Richard Damon wrote:
On 11/2/25 12:14 AM, olcott wrote:If you would accept this step then after
On 11/1/2025 11:08 PM, Mike Terry wrote:
On 02/11/2025 02:41, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:There is no duffer speak to this.
Once Olcott has plonked everyone I guess the shitshow here >>>>>>>>>> will finally
stop?
/Flibble
PO will still post new threads, but the average thread size >>>>>>>>> will shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive >>>>>>>>> for him to "evolve" his duffer-speak in response to objections. >>>>>>>>
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
D simulated by H cannot possibly reach its
own simulated "return" statement.
I don't think that you have become dishonest
so what is up with the "duffer speak" reference
to my perfectly unambiguous statements?
It is my honest opinion of what you write. Practically every
sentence you write contains ambiguous or incoherent terminology. >>>>>>> I do not suggest that you do that deliberately, or that you can >>>>>>> see it when it is pointed out to you. It is a natural effect of >>>>>>> not being able to understand the basic terminology and concepts >>>>>>> of the field.
Mike.
So you cannot begin to understand that
D simulated by H cannot possibly reach its
own simulated "return" statement ???
The problem is that is irrelevent to the halting problem,
a few more steps I could show something
quite interesting. No one has ever accepted
this truism besides Ben.
Why should I accept a self-contradictory and ambigious definition?
*ALL four LLMs got this correctly*
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
when given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
No, they didn't, but failed because your input deceptively avoided
allowing them for a possible solution, that the decider, in waiting till
it can actually prove it has the correct answer, ends up looping forever.
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to "evolve" his duffer-speak in response to objections.
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to "evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally >>>> stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to >>> "evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You did not pay enough attention to the exact wordsYes, people had paid >100% attention to your exact words, which is proved (for the past years, every day) meaningless hallucination.
that I said. LLM systems were able to pay 100% complete
attention to every singe word.
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally >>>> stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to >>> "evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).You ignored the fact that HP asks for a real halt decider, not 'words'.
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally >>>>>> stop?
/Flibble
PO will still post new threads, but the average thread size will shrink >>>>> to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to >>>>> "evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'.
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'.
You ignored the fact that I am only talking aboutYour D says:
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
That is why I had to specify the above verboseThen, tell to LLM.
paragraphs to the LLM systems so they would not
merely guess and guess incorrectly.
On Mon, 2025-11-03 at 12:00 -0600, olcott wrote:
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink >>>>>>> to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'.
You ignored the fact that I am only talking about
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
Your D says:
On 11/3/2025 12:13 PM, wij wrote:
On Mon, 2025-11-03 at 12:00 -0600, olcott wrote:
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'.
Repeat. you seemingly like to erase what you don't understand.You ignored the fact that I am only talking about
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
Your D says:
Nothing matters besides the actual execution trace
of D simulated by H.
LLM systems were also veryThese are useless POO details we don't need to know.
stupid about this until I added these two paragraphs.
Maybe paying 100% complete attention to every detail of
these two paragraph is beyond your attention span:
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen), what
result should H(D) produce?
On Mon, 2025-11-03 at 12:30 -0600, olcott wrote:That is the guess what D does mode,
On 11/3/2025 12:13 PM, wij wrote:
On Mon, 2025-11-03 at 12:00 -0600, olcott wrote:
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown. >>>>>>>
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'. >>>>>
You ignored the fact that I am only talking about
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
Your D says:
Nothing matters besides the actual execution trace
of D simulated by H.
Repeat. you seemingly like to erase what you don't understand.
Your D says:
If H(D) returns non-zero
On 11/3/2025 1:09 PM, wij wrote:
On Mon, 2025-11-03 at 12:30 -0600, olcott wrote:
On 11/3/2025 12:13 PM, wij wrote:
On Mon, 2025-11-03 at 12:00 -0600, olcott wrote:
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'.
You ignored the fact that I am only talking about
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
Your D says:
Nothing matters besides the actual execution trace
of D simulated by H.
Repeat. you seemingly like to erase what you don't understand.
Your D says:
If H(D) returns non-zeroThat is the guess what D does mode,
not the actually trace what D actually
simulated by H actually does mode.
On Mon, 2025-11-03 at 13:16 -0600, olcott wrote:
On 11/3/2025 1:09 PM, wij wrote:
On Mon, 2025-11-03 at 12:30 -0600, olcott wrote:That is the guess what D does mode,
On 11/3/2025 12:13 PM, wij wrote:
On Mon, 2025-11-03 at 12:00 -0600, olcott wrote:
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what
should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown. >>>>>>>>>
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'. >>>>>>>
You ignored the fact that I am only talking about
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
Your D says:
Nothing matters besides the actual execution trace
of D simulated by H.
Repeat. you seemingly like to erase what you don't understand.
Your D says:
If H(D) returns non-zero
not the actually trace what D actually
simulated by H actually does mode.
So, the actual code is not what you shown? Why you post a false report?
On 11/3/2025 1:23 PM, wij wrote:
On Mon, 2025-11-03 at 13:16 -0600, olcott wrote:
On 11/3/2025 1:09 PM, wij wrote:
On Mon, 2025-11-03 at 12:30 -0600, olcott wrote:
On 11/3/2025 12:13 PM, wij wrote:
On Mon, 2025-11-03 at 12:00 -0600, olcott wrote:
On 11/3/2025 11:33 AM, wij wrote:
On Mon, 2025-11-03 at 11:18 -0600, olcott wrote:
On 11/3/2025 8:19 AM, wij wrote:
On Mon, 2025-11-03 at 07:47 -0600, olcott wrote:
On 11/1/2025 9:12 PM, Mike Terry wrote:
On 02/11/2025 01:46, Mr Flibble wrote:
Once Olcott has plonked everyone I guess the shitshow here will finally
stop?
/Flibble
PO will still post new threads, but the average thread size will shrink
to about 6 posts.
PO will only see his own posts, so there will be no incentive for him to
"evolve" his duffer-speak in response to objections.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
when given a function P, it literally simulates
each step of executing P() to see whether that
simulated execution ever reaches a return statement.
Now let H simulate D. Based only on the outcome of
that literal simulation (not on reasoning about what should happen), what result should H(D) produce?
H(D) can never return.
This condition is described as 'undecidable' as HP proof has shown.
You simply ignored (a).
You ignored the fact that HP asks for a real halt decider, not 'words'.
You ignored the fact that I am only talking about
the actual steps of D actually simulated by H and
not one damn thing else in the universe.
Your D says:
Nothing matters besides the actual execution trace
of D simulated by H.
Repeat. you seemingly like to erase what you don't understand.
Your D says:
If H(D) returns non-zeroThat is the guess what D does mode,
not the actually trace what D actually
simulated by H actually does mode.
So, the actual code is not what you shown? Why you post a false report?
This might just be beyond your intellectual capacity.You seems not to understand what your D says. Your D says:
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen), what
result should H(D) produce?
On Mon, 2025-11-03 at 13:27 -0600, olcott wrote:
This might just be beyond your intellectual capacity.
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seems not to understand what your D says.
Your D says:
If H(D) returns non-zero (e.g. 1), D() will never return,
else (i.e. 0), D() will return.
It does not matter what H is (as whatever you say). The H inside D
cannot be a correct halt decider.
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen), what
result should H(D) produce?
On 11/3/2025 1:34 PM, wij wrote:Then, what does D says?
On Mon, 2025-11-03 at 13:27 -0600, olcott wrote:
This might just be beyond your intellectual capacity.
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seems not to understand what your D says.
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY HThe HP does not care what the implement of H is (simulation or whatever is your own business).
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
Your D says:
If H(D) returns non-zero (e.g. 1), D() will never return,
else (i.e. 0), D() will return.
It does not matter what H is (as whatever you say). The H inside D
cannot be a correct halt decider.
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
When given a function P, it literally simulates each step of executing P() to see whether that simulated execution ever reaches a return statement. Now let H simulate D. Based only on the outcome of that literal simulation (not on reasoning about what should happen), what result should H(D) produce?
On Mon, 2025-11-03 at 13:37 -0600, olcott wrote:
On 11/3/2025 1:34 PM, wij wrote:
On Mon, 2025-11-03 at 13:27 -0600, olcott wrote:
This might just be beyond your intellectual capacity.
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seems not to understand what your D says.
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
Then, what does D says?
Why you post a false report?
On 11/3/2025 1:52 PM, wij wrote:
On Mon, 2025-11-03 at 13:37 -0600, olcott wrote:
On 11/3/2025 1:34 PM, wij wrote:
On Mon, 2025-11-03 at 13:27 -0600, olcott wrote:
This might just be beyond your intellectual capacity.
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seems not to understand what your D says.
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
Then, what does D says?
Why you post a false report?
If you had any attention span at all you wouldSo, the H(D) in D never returns ?
see that when D is simulated by H then D doesn't
get to say anything. D remains stuck in recursive
simulation never getting past its first line.
On Mon, 2025-11-03 at 13:57 -0600, olcott wrote:
On 11/3/2025 1:52 PM, wij wrote:
On Mon, 2025-11-03 at 13:37 -0600, olcott wrote:
On 11/3/2025 1:34 PM, wij wrote:
On Mon, 2025-11-03 at 13:27 -0600, olcott wrote:
This might just be beyond your intellectual capacity.
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seems not to understand what your D says.
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
Then, what does D says?
Why you post a false report?
If you had any attention span at all you would
see that when D is simulated by H then D doesn't
get to say anything. D remains stuck in recursive
simulation never getting past its first line.
So, the H(D) in D never returns ?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seem to not even understand what you typed.
On 2025-11-03, olcott <[email protected]> wrote:
Yet H must simulate itself simulating D
and H1 must not simulate itself simulating D.
I never even had to tell the LLMs about this
they all figured this out on their own.
If they didn't write a working simulator that produces concrete,
verifiable execution traces, it is just nice sounding hot air.
On 11/3/2025 2:29 PM, Kaz Kylheku wrote:
On 2025-11-03, olcott <[email protected]> wrote:
Yet H must simulate itself simulating D
and H1 must not simulate itself simulating D.
I never even had to tell the LLMs about this
they all figured this out on their own.
If they didn't write a working simulator that produces concrete,
verifiable execution traces, it is just nice sounding hot air.
It has been three years and every single rebuttal has
either changed my words or skipped the exact meaning
of some of my words as the entire basis for their fake
rebuttal.
Claude AI, ChatGPT 5.0, Grok and Gemini all paid
100% complete attention to every single detail.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
No human here seems to have enough attention span to
pay attention to every 100% of single detail of this:
On 2025-11-03, olcott <[email protected]> wrote:If that was not a damned lie you could point to
On 11/3/2025 2:29 PM, Kaz Kylheku wrote:
On 2025-11-03, olcott <[email protected]> wrote:
Yet H must simulate itself simulating D
and H1 must not simulate itself simulating D.
I never even had to tell the LLMs about this
they all figured this out on their own.
If they didn't write a working simulator that produces concrete,
verifiable execution traces, it is just nice sounding hot air.
It has been three years and every single rebuttal has
either changed my words or skipped the exact meaning
of some of my words as the entire basis for their fake
rebuttal.
... or showed that your garbage code doesn't corroborate the
nonsense that are spewing. But let's sweep that back under
the rug ....
Claude AI, ChatGPT 5.0, Grok and Gemini all paid
100% complete attention to every single detail.
That amounts to fuck all; just clap-trap
On 11/3/2025 2:01 PM, wij wrote:
On Mon, 2025-11-03 at 13:57 -0600, olcott wrote:
On 11/3/2025 1:52 PM, wij wrote:
On Mon, 2025-11-03 at 13:37 -0600, olcott wrote:
On 11/3/2025 1:34 PM, wij wrote:
On Mon, 2025-11-03 at 13:27 -0600, olcott wrote:
This might just be beyond your intellectual capacity.
Claude AI, ChatGPT 5.0, Grok and Gemini could all pay
100% complete attention to every single detail.
That may simply be too much for you.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seems not to understand what your D says.
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
IT IS ABOUT THE EXACT EXECUTION TRACE OF D SIMULATED BY H
DO YOU KNOW WHAT AN EXECUTION TRACE IS?
IT IS NOT ABOUT WHAT D SAYS
Then, what does D says?
Why you post a false report?
If you had any attention span at all you would
see that when D is simulated by H then D doesn't
get to say anything. D remains stuck in recursive
simulation never getting past its first line.
So, the H(D) in D never returns ?
*D simulated by H remains stuck in recursive simulation*If H(D) does return, what does your post mean:
I have been proving this ten times a day every single
day for three years. If you had any idea what an execution
trace is you would have immediately known that.
H(D) does return because
it is as smart as Claude AI,You don't realize you are CS idiot in computer programming.
ChatGPT 5.0, Grok, and Gemini and can directly see
the trivial non-halting behavior pattern.
H simulates D that calls H
that simulates D that calls H
that simulates D that calls H
that simulates D that calls H
that simulates D that calls H...
Do people that come to comp.theory typically not
know ANYTHING about actual computer programming?
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
You seem to not even understand what you typed.
On Mon, 2025-11-03 at 14:31 -0600, olcott wrote:
On 11/3/2025 2:01 PM, wij wrote:
If H(D) does return, what does your post mean:
int D()
{
int Halt_Status = H(D); // <---- Does this H(D) return?
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
On 11/3/2025 3:22 PM, wij wrote:
On Mon, 2025-11-03 at 14:31 -0600, olcott wrote:
On 11/3/2025 2:01 PM, wij wrote:
If H(D) does return, what does your post mean:Maybe you need to carefully study these words reading them over-and-over again and again until you can pay 100% complete attention to every tiny detail of everything that they specify.
int D()
{
int Halt_Status = H(D); // <---- Does this H(D) return?
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its own simulated "return"
statement.
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen), what
result should H(D) produce?
On Mon, 03 Nov 2025 15:32:08 -0600, olcott wrote:
On 11/3/2025 3:22 PM, wij wrote:
On Mon, 2025-11-03 at 14:31 -0600, olcott wrote:
On 11/3/2025 2:01 PM, wij wrote:
If H(D) does return, what does your post mean:Maybe you need to carefully study these words reading them over-and-over
int D()
{
int Halt_Status = H(D); // <---- Does this H(D) return?
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its own simulated "return"
statement.
again and again until you can pay 100% complete attention to every tiny
detail of everything that they specify.
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen), what
result should H(D) produce?
It doesn't matter what result H(D) produces because D will do the opposite making H wrong.
On 11/3/2025 3:22 PM, wij wrote:
On Mon, 2025-11-03 at 14:31 -0600, olcott wrote:
On 11/3/2025 2:01 PM, wij wrote:
If H(D) does return, what does your post mean:
int D()
{
int Halt_Status = H(D); // <---- Does this H(D) return? if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Maybe you need to carefully study these words readingSo, all are just 'joke' (polite word). You know what the HP proof is about, but, you direct people's attention to something unsolvable (or difficult) or provide various 'proofs' for people to headache, or change subject, or change proof... various skills to manipulate.
them over-and-over again and again until you can pay 100%
complete attention to every tiny detail of everything that
they specify.
The function H is a simulating termination analyzer:These are what the halt decider must do, not proof.
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
On Mon, 2025-11-03 at 15:32 -0600, olcott wrote:
On 11/3/2025 3:22 PM, wij wrote:
On Mon, 2025-11-03 at 14:31 -0600, olcott wrote:
On 11/3/2025 2:01 PM, wij wrote:
If H(D) does return, what does your post mean:
int D()
{
int Halt_Status = H(D); // <---- Does this H(D) return? >>> if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Maybe you need to carefully study these words reading
them over-and-over again and again until you can pay 100%
complete attention to every tiny detail of everything that
they specify.
So, all are just 'joke' (polite word). You know what the HP proof is about, but, you direct people's attention to something unsolvable (or difficult) or provide various 'proofs' for people to headache, or change subject, or change proof... various skills to manipulate.
Maybe, you just like to chat, or, to create god-like feeling?
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
These are what the halt decider must do, not proof.
Otherwise, what do you think the H should do? print "abc" and say "hello"?.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
On 11/4/2025 5:40 AM, wij wrote:Rejected out-of-hand as unclear. "D" and "H" in the above sentence
On Mon, 2025-11-03 at 15:32 -0600, olcott wrote:
On 11/3/2025 3:22 PM, wij wrote:
On Mon, 2025-11-03 at 14:31 -0600, olcott wrote:
On 11/3/2025 2:01 PM, wij wrote:
If H(D) does return, what does your post mean:
int D()
{
int Halt_Status = H(D); // <---- Does this H(D) return?
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*THIS IS THE KEY MOST IMPORTANT UNAMBIGUOUS STATEMENT*
D simulated by H cannot possibly reach its
own simulated "return" statement.
Maybe you need to carefully study these words reading
them over-and-over again and again until you can pay 100%
complete attention to every tiny detail of everything that
they specify.
So, all are just 'joke' (polite word). You know what the HP proof is
about,
but, you direct people's attention to something unsolvable (or
difficult) or
provide various 'proofs' for people to headache, or change subject, or
change
proof... various skills to manipulate.
When D is simulated by H this D cannot possibly reach
the contradictory code, it remains stuck in recursive
emulation.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 76:03:08 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
4,753 files (1,565M bytes) |
| Messages: | 2,443,114 |