On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: goto HERE;
return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he
thinks others understand what actually is nonsense without any
meaningful content to be understood.
Now that four different LLM systems have been able reverse-
engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this
proves that all of my reviewers have been dishonest with me
for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely
a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often
called other people dishonest without sufficient evidence. It
is hard to tell whether he is actually dishonest or stupid or
both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly determine what >>>>>> other people understand and what they don't. Sometimes he assumes
nobody understands what others see sas obvious and well known, ar
other times he thinks others understand what actually is nonsense
without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether someone >>>> is honest. To determine honesty is not solely a matter of skill as the >>>> information necessary for the determination is not always avoalable.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: >>>>>>>>> goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he
thinks others understand what actually is nonsense without any >>>>>>>> meaningful content to be understood.
Now that four different LLM systems have been able reverse-
engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this
proves that all of my reviewers have been dishonest with me
for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely
a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often
called other people dishonest without sufficient evidence. It
is hard to tell whether he is actually dishonest or stupid or
both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks summporting reasoning but it shows that you try to look as if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
On 2025-10-29 16:29:54 +0000, olcott said:
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly determine what >>>>>>> other people understand and what they don't. Sometimes he assumes >>>>>>> nobody understands what others see sas obvious and well known, ar >>>>>>> other times he thinks others understand what actually is nonsense >>>>>>> without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether someone >>>>> is honest. To determine honesty is not solely a matter of skill as the >>>>> information necessary for the determination is not always avoalable.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
Maybe, but for a long time it has been sufficiently clear that you
lack the skills to determine whether someone is honest and what
someone understands.
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: goto HERE;
return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he
thinks others understand what actually is nonsense without any >>>>>>>>> meaningful content to be understood.
Now that four different LLM systems have been able reverse-
engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this
proves that all of my reviewers have been dishonest with me
for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely
a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often
called other people dishonest without sufficient evidence. It
is hard to tell whether he is actually dishonest or stupid or
both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks
summporting reasoning but it shows that you try to look as if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
On 10/30/2025 5:29 AM, Mikko wrote:
On 2025-10-29 16:29:54 +0000, olcott said:
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:int D()
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly determine what >>>>>>>> other people understand and what they don't. Sometimes he assumes >>>>>>>> nobody understands what others see sas obvious and well known, ar >>>>>>>> other times he thinks others understand what actually is nonsense >>>>>>>> without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether someone >>>>>> is honest. To determine honesty is not solely a matter of skill as the >>>>>> information necessary for the determination is not always avoalable. >>>>>
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
Maybe, but for a long time it has been sufficiently clear that you
lack the skills to determine whether someone is honest and what
someone understands.
(a) Do you know C?
(b) Do you deny that D simulated by H cannot reach
its own simulated "return" statement?
If (a) and (b) then you are a liar.
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: >>>>>>>>>>> goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he
thinks others understand what actually is nonsense without any >>>>>>>>>> meaningful content to be understood.
Now that four different LLM systems have been able reverse-
engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this
proves that all of my reviewers have been dishonest with me
for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely
a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often
called other people dishonest without sufficient evidence. It
is hard to tell whether he is actually dishonest or stupid or
both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks
summporting reasoning but it shows that you try to look as if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing machine
that can be given as an input a description of any Turing machine and
of any valid input to that Truing machine and that accepts if the input describes a halting computation but rejects if the input describes a non-halting computation. People who know computation theory and deny
this are liars.
On 2025-10-30 13:17:26 +0000, olcott said:
On 10/30/2025 5:29 AM, Mikko wrote:
On 2025-10-29 16:29:54 +0000, olcott said:
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:int D()
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly determine >>>>>>>>> what
other people understand and what they don't. Sometimes he assumes >>>>>>>>> nobody understands what others see sas obvious and well known, ar >>>>>>>>> other times he thinks others understand what actually is nonsense >>>>>>>>> without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether
someone
is honest. To determine honesty is not solely a matter of skill >>>>>>> as the
information necessary for the determination is not always avoalable. >>>>>>
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
Maybe, but for a long time it has been sufficiently clear that you
lack the skills to determine whether someone is honest and what
someone understands.
(a) Do you know C?
Yes, but not the latest revision.
(b) Do you deny that D simulated by H cannot reach
its own simulated "return" statement?
The question is ambiguous. The usual meaning of "D simulated by H"
is the particular D that H simulates or tries to simulate. But there
is only one D in the context of the question so it seems a little
odd to be so verbose oabout its identity.
However, some poeple may
interprete it to mean something that only has the behavour H has
simulated and not the behavour specified by the input to H.
Therefore it is better note that the question is ill-posed and to
answer only when the question is corrected.
If (a) and (b) then you are a liar.
Because (b) is not yet answered or even properly asked this must
wait, too.
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: >>>>>>>>>>>> goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he >>>>>>>>>>> thinks others understand what actually is nonsense without >>>>>>>>>>> any meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>> engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this
proves that all of my reviewers have been dishonest with me >>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely >>>>>>>>> a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often
called other people dishonest without sufficient evidence. It >>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>> both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks
summporting reasoning but it shows that you try to look as if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing machine
that can be given as an input a description of any Turing machine and
of any valid input to that Truing machine and that accepts if the input
describes a halting computation but rejects if the input describes a
non-halting computation. People who know computation theory and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
*This is the first step of my proof*
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
When the halting problem requires a halt decider
to report on something that its input does not say
then the halting problem itself is a category error.
On 10/31/2025 7:02 AM, Mikko wrote:
On 2025-10-30 13:17:26 +0000, olcott said:
On 10/30/2025 5:29 AM, Mikko wrote:
On 2025-10-29 16:29:54 +0000, olcott said:
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly determine >>>>>>>>>> what
other people understand and what they don't. Sometimes he assumes >>>>>>>>>> nobody understands what others see sas obvious and well known, ar >>>>>>>>>> other times he thinks others understand what actually is nonsense >>>>>>>>>> without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether >>>>>>>> someone
is honest. To determine honesty is not solely a matter of skill >>>>>>>> as the
information necessary for the determination is not always
avoalable.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
Maybe, but for a long time it has been sufficiently clear that you
lack the skills to determine whether someone is honest and what
someone understands.
(a) Do you know C?
Yes, but not the latest revision.
I started with K & R back when it was brand new.
(b) Do you deny that D simulated by H cannot reach
its own simulated "return" statement?
The question is ambiguous. The usual meaning of "D simulated by H"
is the particular D that H simulates or tries to simulate. But there
is only one D in the context of the question so it seems a little
odd to be so verbose oabout its identity.
Lets back up a step. Do you know what ordinary recursion is:
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
However, some poeple may
interprete it to mean something that only has the behavour H has
simulated and not the behavour specified by the input to H.
Some people think that cats are dogs, they are simply wrong.
Therefore it is better note that the question is ill-posed and to
answer only when the question is corrected.
If (a) and (b) then you are a liar.
Because (b) is not yet answered or even properly asked this must
wait, too.
When D is simulated by H according to the semantics of C
until H detects a repeating pattern that proves that D
cannot possibly reach its own "return" statement the
execution trace goes like this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
Any other understanding is a lack of understanding.
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: goto HERE;
return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he >>>>>>>>>>> thinks others understand what actually is nonsense without any >>>>>>>>>>> meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>> engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this
proves that all of my reviewers have been dishonest with me >>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely >>>>>>>>> a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often
called other people dishonest without sufficient evidence. It >>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>> both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks
summporting reasoning but it shows that you try to look as if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing machine
that can be given as an input a description of any Turing machine and
of any valid input to that Truing machine and that accepts if the input
describes a halting computation but rejects if the input describes a
non-halting computation. People who know computation theory and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
On 10/31/2025 7:02 AM, Mikko wrote:
On 2025-10-30 13:17:26 +0000, olcott said:
On 10/30/2025 5:29 AM, Mikko wrote:
On 2025-10-29 16:29:54 +0000, olcott said:
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:int D()
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly determine what >>>>>>>>>> other people understand and what they don't. Sometimes he assumes >>>>>>>>>> nobody understands what others see sas obvious and well known, ar >>>>>>>>>> other times he thinks others understand what actually is nonsense >>>>>>>>>> without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether someone >>>>>>>> is honest. To determine honesty is not solely a matter of skill as the >>>>>>>> information necessary for the determination is not always avoalable. >>>>>>>
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
Maybe, but for a long time it has been sufficiently clear that you
lack the skills to determine whether someone is honest and what
someone understands.
(a) Do you know C?
Yes, but not the latest revision.
I started with K & R back when it was brand new.
(b) Do you deny that D simulated by H cannot reach
its own simulated "return" statement?
The question is ambiguous. The usual meaning of "D simulated by H"
is the particular D that H simulates or tries to simulate. But there
is only one D in the context of the question so it seems a little
odd to be so verbose oabout its identity.
Lets back up a step. Do you know what ordinary recursion is:
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
However, some poeple may
interprete it to mean something that only has the behavour H has
simulated and not the behavour specified by the input to H.
Some people think that cats are dogs, they are simply wrong.
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:Your "People that know C and deny this are dishonest" indeed lacks
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) >>>>>>>>>>>>> HERE: goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly
determine what other people understand and what they
don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he >>>>>>>>>>>> thinks others understand what actually is nonsense without >>>>>>>>>>>> any meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>>> engineer the non-halting result by merely being told to
faithfully simulate DD with HHH and see what happens this >>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely >>>>>>>>>> a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often >>>>>>>>>> called other people dishonest without sufficient evidence. It >>>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>>> both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR >>>>>
summporting reasoning but it shows that you try to look as if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing machine
that can be given as an input a description of any Turing machine and
of any valid input to that Truing machine and that accepts if the input
describes a halting computation but rejects if the input describes a
non-halting computation. People who know computation theory and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof.
When the exact identity of "the" proof is not specified it is an
error to accept it.
On 2025-10-31 13:50:12 +0000, olcott said:
On 10/31/2025 7:02 AM, Mikko wrote:
On 2025-10-30 13:17:26 +0000, olcott said:
On 10/30/2025 5:29 AM, Mikko wrote:
On 2025-10-29 16:29:54 +0000, olcott said:
On 10/29/2025 6:03 AM, Mikko wrote:
On 2025-10-28 14:55:21 +0000, olcott said:
On 10/28/2025 4:09 AM, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Olcott has showm many times that he cannot correctly
determine what
other people understand and what they don't. Sometimes he >>>>>>>>>>> assumes
nobody understands what others see sas obvious and well >>>>>>>>>>> known, ar
other times he thinks others understand what actually is >>>>>>>>>>> nonsense
without any meaningful content to be understood.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
Another skill Olcott has shown to lack is to determine whether >>>>>>>>> someone
is honest. To determine honesty is not solely a matter of skill >>>>>>>>> as the
information necessary for the determination is not always
avoalable.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Anyone that knows C and denies this is dishonest.
Thank you for the example.
That is the clearest that I could make it
after nearly 21 years.
Maybe, but for a long time it has been sufficiently clear that you
lack the skills to determine whether someone is honest and what
someone understands.
(a) Do you know C?
Yes, but not the latest revision.
I started with K & R back when it was brand new.
I started with the complier my professor gave me and told to use.
I quickly found out that there was a serious bug in the compiler.
Fortunately I found a work-around so that I could proceed while
waiting for a corrected compiler.
(b) Do you deny that D simulated by H cannot reach
its own simulated "return" statement?
The question is ambiguous. The usual meaning of "D simulated by H"
is the particular D that H simulates or tries to simulate. But there
is only one D in the context of the question so it seems a little
odd to be so verbose oabout its identity.
Lets back up a step. Do you know what ordinary recursion is:
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
Yes, that is an important idea both in mathematics and in programming.
For programming one must also know what to do when recurion is not
supperted by the language or is prohibited for some reason.
However, some poeple may
interprete it to mean something that only has the behavour H has
simulated and not the behavour specified by the input to H.
Some people think that cats are dogs, they are simply wrong.
Not very many people. Likewise, I don't think many people misinterprete
"D simulated by H" to mean the simulation of D by H. But I have seen at
least one who does.
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:Your "People that know C and deny this are dishonest" indeed lacks >>>>>> summporting reasoning but it shows that you try to look as if you
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) >>>>>>>>>>>>>> HERE: goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he >>>>>>>>>>>>> thinks others understand what actually is nonsense without >>>>>>>>>>>>> any meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>>>> engineer the non-halting result by merely being told to >>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely >>>>>>>>>>> a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often >>>>>>>>>>> called other people dishonest without sufficient evidence. It >>>>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>>>> both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR >>>>>>
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing machine >>>> that can be given as an input a description of any Turing machine and
of any valid input to that Truing machine and that accepts if the input >>>> describes a halting computation but rejects if the input describes a
non-halting computation. People who know computation theory and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof.
When the exact identity of "the" proof is not specified it is an
error to accept it.
The actual sequence of steps that the input to H(D)
specifies are the steps shown above.
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:2 + 3 = 5
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) >>>>>>>>>>>>>>> HERE: goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>> others see sas obvious and well known, ar other times he >>>>>>>>>>>>>> thinks others understand what actually is nonsense without >>>>>>>>>>>>>> any meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>>>>> engineer the non-halting result by merely being told to >>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>> whether someone is honest. To determine honesty is not solely >>>>>>>>>>>> a matter of skill as the information necessary for the >>>>>>>>>>>> determination is not always avoalable. But Olcott has often >>>>>>>>>>>> called other people dishonest without sufficient evidence. It >>>>>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>>>>> both, but the result is the same anyway: in matters of >>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning.
EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks >>>>>>> summporting reasoning but it shows that you try to look as if you >>>>>>> knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment. >>>>>>
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing
machine
that can be given as an input a description of any Turing machine and >>>>> of any valid input to that Truing machine and that accepts if the
input
describes a halting computation but rejects if the input describes a >>>>> non-halting computation. People who know computation theory and deny >>>>> this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof.
When the exact identity of "the" proof is not specified it is an
error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and
therefore is stipulated to specify all semantic properties of machine D, including the fact that machine D halts when executed directly.
specifies are the steps shown above.
False, as shown above.
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:2 + 3 = 5
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) >>>>>>>>>>>>>>>> HERE: goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>> others see sas obvious and well known, ar other times he >>>>>>>>>>>>>>> thinks others understand what actually is nonsense >>>>>>>>>>>>>>> without any meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>>>>>> engineer the non-halting result by merely being told to >>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>> whether someone is honest. To determine honesty is not solely >>>>>>>>>>>>> a matter of skill as the information necessary for the >>>>>>>>>>>>> determination is not always avoalable. But Olcott has often >>>>>>>>>>>>> called other people dishonest without sufficient evidence. It >>>>>>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>>>>>> both, but the result is the same anyway: in matters of >>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. >>>>>>>>> EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks >>>>>>>> summporting reasoning but it shows that you try to look as if you >>>>>>>> knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment. >>>>>>>
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing
machine
that can be given as an input a description of any Turing machine and >>>>>> of any valid input to that Truing machine and that accepts if the >>>>>> input
describes a halting computation but rejects if the input describes a >>>>>> non-halting computation. People who know computation theory and deny >>>>>> this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof.
When the exact identity of "the" proof is not specified it is an
error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and
therefore is stipulated to specify all semantic properties of machine
D, including the fact that machine D halts when executed directly.
Simply a counter-factual assumption.
On 11/1/2025 10:22 AM, olcott wrote:
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:2 + 3 = 5
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:Now that four different LLM systems have been able reverse- >>>>>>>>>>>>>>> engineer the non-halting result by merely being told to >>>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>>>>>> for three years.
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) >>>>>>>>>>>>>>>>> HERE: goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>>> others see sas obvious and well known, ar other times he >>>>>>>>>>>>>>>> thinks others understand what actually is nonsense >>>>>>>>>>>>>>>> without any meaningful content to be understood. >>>>>>>>>>>>>>>
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>>> whether someone is honest. To determine honesty is not solely >>>>>>>>>>>>>> a matter of skill as the information necessary for the >>>>>>>>>>>>>> determination is not always avoalable. But Olcott has often >>>>>>>>>>>>>> called other people dishonest without sufficient evidence. It >>>>>>>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>>>>>>> both, but the result is the same anyway: in matters of >>>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. >>>>>>>>>> EREBoSR
Your "People that know C and deny this are dishonest" indeed lacks >>>>>>>>> summporting reasoning but it shows that you try to look as if you >>>>>>>>> knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment. >>>>>>>>
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing >>>>>>> machine
that can be given as an input a description of any Turing machine >>>>>>> and
of any valid input to that Truing machine and that accepts if the >>>>>>> input
describes a halting computation but rejects if the input describes a >>>>>>> non-halting computation. People who know computation theory and deny >>>>>>> this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof. >>>>> When the exact identity of "the" proof is not specified it is an
error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and
therefore is stipulated to specify all semantic properties of machine
D, including the fact that machine D halts when executed directly.
Simply a counter-factual assumption.
False. The above is proven true by the meaning of the words.
On 11/1/2025 9:37 AM, dbush wrote:
On 11/1/2025 10:22 AM, olcott wrote:
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:Now that four different LLM systems have been able reverse- >>>>>>>>>>>>>>>> engineer the non-halting result by merely being told to >>>>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>>>>>>> for three years.
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) >>>>>>>>>>>>>>>>>> HERE: goto HERE; return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>>>> others see sas obvious and well known, ar other times he >>>>>>>>>>>>>>>>> thinks others understand what actually is nonsense >>>>>>>>>>>>>>>>> without any meaningful content to be understood. >>>>>>>>>>>>>>>>
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>>>> whether someone is honest. To determine honesty is not >>>>>>>>>>>>>>> solely
a matter of skill as the information necessary for the >>>>>>>>>>>>>>> determination is not always avoalable. But Olcott has often >>>>>>>>>>>>>>> called other people dishonest without sufficient >>>>>>>>>>>>>>> evidence. It
is hard to tell whether he is actually dishonest or >>>>>>>>>>>>>>> stupid or
both, but the result is the same anyway: in matters of >>>>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. >>>>>>>>>>> EREBoSR
Your "People that know C and deny this are dishonest" indeed >>>>>>>>>> lacks
summporting reasoning but it shows that you try to look as if you >>>>>>>>>> knew what you actually don't know.
Anyway, thank you for an example that supports my earlier >>>>>>>>>> comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing >>>>>>>> machine
that can be given as an input a description of any Turing
machine and
of any valid input to that Truing machine and that accepts if >>>>>>>> the input
describes a halting computation but rejects if the input
describes a
non-halting computation. People who know computation theory and >>>>>>>> deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof. >>>>>> When the exact identity of "the" proof is not specified it is an
error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and
therefore is stipulated to specify all semantic properties of
machine D, including the fact that machine D halts when executed
directly.
Simply a counter-factual assumption.
False. The above is proven true by the meaning of the words.
Then go through the steps detail by detail.
On 11/1/2025 10:41 AM, olcott wrote:
On 11/1/2025 9:37 AM, dbush wrote:
On 11/1/2025 10:22 AM, olcott wrote:
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said: >>>>>>>>>>>>>>>>>>Now that four different LLM systems have been able >>>>>>>>>>>>>>>>> reverse-
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if >>>>>>>>>>>>>>>>>>> (Halt_Status) HERE: goto HERE; return Halt_Status; } >>>>>>>>>>>>>>>>>>>
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>>>>> others see sas obvious and well known, ar other times he >>>>>>>>>>>>>>>>>> thinks others understand what actually is nonsense >>>>>>>>>>>>>>>>>> without any meaningful content to be understood. >>>>>>>>>>>>>>>>>
engineer the non-halting result by merely being told to >>>>>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>>>>>>> proves that all of my reviewers have been dishonest >>>>>>>>>>>>>>>>> with me
for three years.
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>>>>> whether someone is honest. To determine honesty is not >>>>>>>>>>>>>>>> solely
a matter of skill as the information necessary for the >>>>>>>>>>>>>>>> determination is not always avoalable. But Olcott has often >>>>>>>>>>>>>>>> called other people dishonest without sufficient >>>>>>>>>>>>>>>> evidence. It
is hard to tell whether he is actually dishonest or >>>>>>>>>>>>>>>> stupid or
both, but the result is the same anyway: in matters of >>>>>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. >>>>>>>>>>>> EREBoSR
Your "People that know C and deny this are dishonest" indeed >>>>>>>>>>> lacks
summporting reasoning but it shows that you try to look as if >>>>>>>>>>> you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier >>>>>>>>>>> comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing >>>>>>>>> machine
that can be given as an input a description of any Turing
machine and
of any valid input to that Truing machine and that accepts if >>>>>>>>> the input
describes a halting computation but rejects if the input
describes a
non-halting computation. People who know computation theory and >>>>>>>>> deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof. >>>>>>> When the exact identity of "the" proof is not specified it is an >>>>>>> error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and
therefore is stipulated to specify all semantic properties of
machine D, including the fact that machine D halts when executed
directly.
Simply a counter-factual assumption.
False. The above is proven true by the meaning of the words.
Then go through the steps detail by detail.
The above is a semantic tautology. Disagreeing with a semantic
tautology is always incorrect.
On 11/1/2025 10:24 AM, dbush wrote:
On 11/1/2025 10:41 AM, olcott wrote:
On 11/1/2025 9:37 AM, dbush wrote:
On 11/1/2025 10:22 AM, olcott wrote:
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote: >>>>>>>>>>>>>>>> On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said: >>>>>>>>>>>>>>>>>>>Now that four different LLM systems have been able >>>>>>>>>>>>>>>>>> reverse-
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if >>>>>>>>>>>>>>>>>>>> (Halt_Status) HERE: goto HERE; return Halt_Status; } >>>>>>>>>>>>>>>>>>>>
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>>>>>> others see sas obvious and well known, ar other times he >>>>>>>>>>>>>>>>>>> thinks others understand what actually is nonsense >>>>>>>>>>>>>>>>>>> without any meaningful content to be understood. >>>>>>>>>>>>>>>>>>
engineer the non-halting result by merely being told to >>>>>>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>>>>>>>> proves that all of my reviewers have been dishonest >>>>>>>>>>>>>>>>>> with me
for three years.
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>>>>>> whether someone is honest. To determine honesty is not >>>>>>>>>>>>>>>>> solely
a matter of skill as the information necessary for the >>>>>>>>>>>>>>>>> determination is not always avoalable. But Olcott has >>>>>>>>>>>>>>>>> often
called other people dishonest without sufficient >>>>>>>>>>>>>>>>> evidence. It
is hard to tell whether he is actually dishonest or >>>>>>>>>>>>>>>>> stupid or
both, but the result is the same anyway: in matters of >>>>>>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting
reasoning. EREBoSR
Your "People that know C and deny this are dishonest" indeed >>>>>>>>>>>> lacks
summporting reasoning but it shows that you try to look as >>>>>>>>>>>> if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier >>>>>>>>>>>> comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no
Truing machine
that can be given as an input a description of any Turing >>>>>>>>>> machine and
of any valid input to that Truing machine and that accepts if >>>>>>>>>> the input
describes a halting computation but rejects if the input
describes a
non-halting computation. People who know computation theory >>>>>>>>>> and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a >>>>>>>> proof.
When the exact identity of "the" proof is not specified it is an >>>>>>>> error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and
therefore is stipulated to specify all semantic properties of
machine D, including the fact that machine D halts when executed
directly.
Simply a counter-factual assumption.
False. The above is proven true by the meaning of the words.
Then go through the steps detail by detail.
The above is a semantic tautology. Disagreeing with a semantic
tautology is always incorrect.
This is the actual semantic tautology and all
you have as rebuttal is mindless dogmatism.
every TM has a machine description
On 11/1/2025 11:32 AM, olcott wrote:
On 11/1/2025 10:24 AM, dbush wrote:
On 11/1/2025 10:41 AM, olcott wrote:
On 11/1/2025 9:37 AM, dbush wrote:
On 11/1/2025 10:22 AM, olcott wrote:
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote: >>>>>>>>>>>>>>>>> On 28/10/2025 09:09, Mikko wrote:You say more than you know.
On 2025-10-27 13:45:13 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>Now that four different LLM systems have been able >>>>>>>>>>>>>>>>>>> reverse-
typedef int (*ptr)(); int HHH(ptr P); >>>>>>>>>>>>>>>>>>>>>
int DD() { int Halt_Status = HHH(DD); if >>>>>>>>>>>>>>>>>>>>> (Halt_Status) HERE: goto HERE; return Halt_Status; } >>>>>>>>>>>>>>>>>>>>>
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>>>>>>> others see sas obvious and well known, ar other >>>>>>>>>>>>>>>>>>>> times he
thinks others understand what actually is nonsense >>>>>>>>>>>>>>>>>>>> without any meaningful content to be understood. >>>>>>>>>>>>>>>>>>>
engineer the non-halting result by merely being told to >>>>>>>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens >>>>>>>>>>>>>>>>>>> this
proves that all of my reviewers have been dishonest >>>>>>>>>>>>>>>>>>> with me
for three years.
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>>>>>>> whether someone is honest. To determine honesty is not >>>>>>>>>>>>>>>>>> solely
a matter of skill as the information necessary for the >>>>>>>>>>>>>>>>>> determination is not always avoalable. But Olcott has >>>>>>>>>>>>>>>>>> often
called other people dishonest without sufficient >>>>>>>>>>>>>>>>>> evidence. It
is hard to tell whether he is actually dishonest or >>>>>>>>>>>>>>>>>> stupid or
both, but the result is the same anyway: in matters of >>>>>>>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest. >>>>>>>>>>>>>>>
Mere empty rhetoric entirely bereft of supporting >>>>>>>>>>>>>> reasoning. EREBoSR
Your "People that know C and deny this are dishonest" >>>>>>>>>>>>> indeed lacks
summporting reasoning but it shows that you try to look as >>>>>>>>>>>>> if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier >>>>>>>>>>>>> comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no >>>>>>>>>>> Truing machine
that can be given as an input a description of any Turing >>>>>>>>>>> machine and
of any valid input to that Truing machine and that accepts if >>>>>>>>>>> the input
describes a halting computation but rejects if the input >>>>>>>>>>> describes a
non-halting computation. People who know computation theory >>>>>>>>>>> and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a >>>>>>>>> proof.
When the exact identity of "the" proof is not specified it is an >>>>>>>>> error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and >>>>>>> therefore is stipulated to specify all semantic properties of
machine D, including the fact that machine D halts when executed >>>>>>> directly.
Simply a counter-factual assumption.
False. The above is proven true by the meaning of the words.
Then go through the steps detail by detail.
The above is a semantic tautology. Disagreeing with a semantic
tautology is always incorrect.
This is the actual semantic tautology and all
you have as rebuttal is mindless dogmatism.
In other words you're claiming that finite string D does not have all semantic properties of machine D,
and are therefore claiming finite
string D is not the description of machine D.
If that's the case, what finite string is the description of machine D?
One *must* exist, as you've admitted:
On 9/12/2025 9:30 AM, olcott wrote:
every TM has a machine description
On 11/1/2025 10:44 AM, dbush wrote:
On 11/1/2025 11:32 AM, olcott wrote:
On 11/1/2025 10:24 AM, dbush wrote:
On 11/1/2025 10:41 AM, olcott wrote:
On 11/1/2025 9:37 AM, dbush wrote:
On 11/1/2025 10:22 AM, olcott wrote:
On 11/1/2025 8:53 AM, dbush wrote:
On 11/1/2025 9:27 AM, olcott wrote:
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote: >>>>>>>>>>>>>>>>>> On 28/10/2025 09:09, Mikko wrote:You say more than you know.
On 2025-10-27 13:45:13 +0000, olcott said: >>>>>>>>>>>>>>>>>>>
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>Now that four different LLM systems have been able >>>>>>>>>>>>>>>>>>>> reverse-
typedef int (*ptr)(); int HHH(ptr P); >>>>>>>>>>>>>>>>>>>>>>
int DD() { int Halt_Status = HHH(DD); if >>>>>>>>>>>>>>>>>>>>>> (Halt_Status) HERE: goto HERE; return Halt_Status; } >>>>>>>>>>>>>>>>>>>>>>
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what >>>>>>>>>>>>>>>>>>>>> others see sas obvious and well known, ar other >>>>>>>>>>>>>>>>>>>>> times he
thinks others understand what actually is nonsense >>>>>>>>>>>>>>>>>>>>> without any meaningful content to be understood. >>>>>>>>>>>>>>>>>>>>
engineer the non-halting result by merely being told to >>>>>>>>>>>>>>>>>>>> faithfully simulate DD with HHH and see what happens >>>>>>>>>>>>>>>>>>>> this
proves that all of my reviewers have been dishonest >>>>>>>>>>>>>>>>>>>> with me
for three years.
Another skill Olcott has shown to lack is to determine >>>>>>>>>>>>>>>>>>> whether someone is honest. To determine honesty is >>>>>>>>>>>>>>>>>>> not solely
a matter of skill as the information necessary for the >>>>>>>>>>>>>>>>>>> determination is not always avoalable. But Olcott has >>>>>>>>>>>>>>>>>>> often
called other people dishonest without sufficient >>>>>>>>>>>>>>>>>>> evidence. It
is hard to tell whether he is actually dishonest or >>>>>>>>>>>>>>>>>>> stupid or
both, but the result is the same anyway: in matters of >>>>>>>>>>>>>>>>>>> honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest. >>>>>>>>>>>>>>>>
Mere empty rhetoric entirely bereft of supporting >>>>>>>>>>>>>>> reasoning. EREBoSR
Your "People that know C and deny this are dishonest" >>>>>>>>>>>>>> indeed lacks
summporting reasoning but it shows that you try to look as >>>>>>>>>>>>>> if you
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier >>>>>>>>>>>>>> comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no >>>>>>>>>>>> Truing machine
that can be given as an input a description of any Turing >>>>>>>>>>>> machine and
of any valid input to that Truing machine and that accepts >>>>>>>>>>>> if the input
describes a halting computation but rejects if the input >>>>>>>>>>>> describes a
non-halting computation. People who know computation theory >>>>>>>>>>>> and deny
this are liars.
I have proven that this is incorrect yet the damned liars >>>>>>>>>>> on this forum refuse to accept the first step of my proof >>>>>>>>>>> because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a >>>>>>>>>> proof.
When the exact identity of "the" proof is not specified it is an >>>>>>>>>> error to accept it.
The actual sequence of steps that the input to H(D)
i.e. finite string D, which is the description of machine D and >>>>>>>> therefore is stipulated to specify all semantic properties of >>>>>>>> machine D, including the fact that machine D halts when executed >>>>>>>> directly.
Simply a counter-factual assumption.
False. The above is proven true by the meaning of the words.
Then go through the steps detail by detail.
The above is a semantic tautology. Disagreeing with a semantic
tautology is always incorrect.
This is the actual semantic tautology and all
you have as rebuttal is mindless dogmatism.
In other words you're claiming that finite string D does not have all
semantic properties of machine D,
I am claiming the verified fact that D
simulated
by H specifies a different sequence of steps
On 11/1/2025 4:22 AM, Mikko wrote:
On 2025-10-31 13:42:38 +0000, olcott said:
On 10/31/2025 6:53 AM, Mikko wrote:
On 2025-10-30 13:15:03 +0000, olcott said:
On 10/30/2025 5:24 AM, Mikko wrote:
On 2025-10-29 16:29:04 +0000, olcott said:
On 10/29/2025 6:02 AM, Mikko wrote:Your "People that know C and deny this are dishonest" indeed lacks >>>>>> summporting reasoning but it shows that you try to look as if you
On 2025-10-28 14:52:54 +0000, olcott said:
On 10/28/2025 5:06 AM, Richard Heathfield wrote:
On 28/10/2025 09:09, Mikko wrote:
On 2025-10-27 13:45:13 +0000, olcott said:
On 10/27/2025 5:10 AM, Mikko wrote:
On 2025-10-25 17:53:27 +0000, olcott said:
typedef int (*ptr)(); int HHH(ptr P);
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE: goto HERE;
return Halt_Status; }
int main() { HHH(DD); }
Olcott has showm many times that he cannot correctly >>>>>>>>>>>>> determine what other people understand and what they >>>>>>>>>>>>> don't. Sometimes he assumes nobody understands what
others see sas obvious and well known, ar other times he >>>>>>>>>>>>> thinks others understand what actually is nonsense without any >>>>>>>>>>>>> meaningful content to be understood.
Now that four different LLM systems have been able reverse- >>>>>>>>>>>> engineer the non-halting result by merely being told to >>>>>>>>>>>> faithfully simulate DD with HHH and see what happens this >>>>>>>>>>>> proves that all of my reviewers have been dishonest with me >>>>>>>>>>>> for three years.
Another skill Olcott has shown to lack is to determine
whether someone is honest. To determine honesty is not solely >>>>>>>>>>> a matter of skill as the information necessary for the
determination is not always avoalable. But Olcott has often >>>>>>>>>>> called other people dishonest without sufficient evidence. It >>>>>>>>>>> is hard to tell whether he is actually dishonest or stupid or >>>>>>>>>>> both, but the result is the same anyway: in matters of
honesty Olcott can be trusted.
ITYM 'can't'.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
People that know C and deny this are dishonest.
You say more than you know.
Mere empty rhetoric entirely bereft of supporting reasoning. EREBoSR >>>>>>
knew what you actually don't know.
Anyway, thank you for an example that supports my earlier comment.
2 + 3 = 5
People that know arithmetic and deny this are liars
When any unequivocal fact is stated within any
knowledge domain and people knowing this domain
deny it then they are always liars.
Another example: it is rigrously proven that there is no Truing machine >>>> that can be given as an input a description of any Turing machine and
of any valid input to that Truing machine and that accepts if the input >>>> describes a halting computation but rejects if the input describes a
non-halting computation. People who know computation theory and deny
this are liars.
I have proven that this is incorrect yet the damned liars
on this forum refuse to accept the first step of my proof
because they are damned liars.
It is not useful to say "I have proven" wthout a pointer to a proof.
When the exact identity of "the" proof is not specified it is an
error to accept it.
The actual sequence of steps that the input to H(D)
specifies are the steps shown above. Anyone that disagrees
is not facing actual reality.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,075 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 90:34:25 |
| Calls: | 13,798 |
| Calls today: | 1 |
| Files: | 186,989 |
| D/L today: |
5,327 files (1,535M bytes) |
| Messages: | 2,438,212 |