From Newsgroup: comp.lang.c

Think this all the way through do not make any guesses.
The answer must come from DD simulated by HHH
according to the semantics of the C programming language
and nothing else.

Simulating Termination Analyzer HHH correctly
simulates its input until:

(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.

(b) Simulated input reaches its simulated
"return" statement: return 1.

(c) If it is impossible to match (a) or (b)
then (c) is matched

(a)(b)(c) are in strict priority order (a)-->(b)-->(c)

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);
}

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/25/2025 1:05 PM, Bonita Montero wrote:

You've been going around in circles for years
and you don't even realize it. Totally crazy.

You say that while pretending to not be
able to understand the C shown below.

Am 25.10.2025 um 19:53 schrieb olcott:

Think this all the way through do not make any guesses.
The answer must come from DD simulated by HHH
according to the semantics of the C programming language
and nothing else.

Simulating Termination Analyzer HHH correctly
simulates its input until:

(a) Detects a non-terminating behavior pattern:
     abort simulation and return 0.

(b) Simulated input reaches its simulated
     "return" statement: return 1.

(c) If it is impossible to match (a) or (b)
     then (c) is matched

(a)(b)(c) are in strict priority order  (a)-->(b)-->(c)

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);
}

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

Am 25.10.2025 um 19:53 schrieb olcott:

Think this all the way through do not make any guesses.
The answer must come from DD simulated by HHH
according to the semantics of the C programming language
and nothing else.

Simulating Termination Analyzer HHH correctly
simulates its input until:

(a) Detects a non-terminating behavior pattern:
    abort simulation and return 0.

(b) Simulated input reaches its simulated
    "return" statement: return 1.

(c) If it is impossible to match (a) or (b)
    then (c) is matched

(a)(b)(c) are in strict priority order  (a)-->(b)-->(c)

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);
}

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf

What's the point of discussing the same mini-source for years?
Does that get you anywhere? It's like mind wandering before
you go to sleep; you don't reach any higher realization to
be able to close it off.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 3:11 AM, Bonita Montero wrote:

Am 25.10.2025 um 19:53 schrieb olcott:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

This is Claude AI deriving the above sentence by simply
simulating DD by HHH giving me the fair review that every
human has cheated me out of.

Simulating Termination Analyzer applied to the HP counter-example input https://www.researchgate.net/publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf

What's the point of discussing the same mini-source for years?

That simple little snippet of C does show that
I have defeated the halting problem proof. Not
one single person would properly review it in
three years.

Now that LLM systems have increased their memory
capacity 67-fold in the last two years they agree
that I have defeated the halting problem itself.
That little snippet of C is the key basis of my
whole proof.

When it is understood that I have defeated the
halting problem then additional discussion shows
that I also have the basis for eliminating the
hallucination of LLM AI systems.

Does that get you anywhere? It's like mind wandering before
you go to sleep; you don't reach any higher realization to
be able to close it off.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

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.

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);
}

*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

Am 27.10.2025 um 14:15 schrieb olcott:

On 10/27/2025 3:11 AM, Bonita Montero wrote:

Am 25.10.2025 um 19:53 schrieb olcott:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

This is Claude AI deriving the above sentence by simply
simulating DD by HHH giving me the fair review that every
human has cheated me out of.

Simulating Termination Analyzer applied to the HP counter-example input https://www.researchgate.net/ publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf

What's the point of discussing the same mini-source for years?

That simple little snippet of C does show that
I have defeated the halting problem proof. Not
one single person would properly review it in
three years.

Now that LLM systems have increased their memory
capacity 67-fold in the last two years they agree
that I have defeated the halting problem itself.
That little snippet of C is the key basis of my
whole proof.

When it is understood that I have defeated the
halting problem then additional discussion shows
that I also have the basis for eliminating the
hallucination of LLM AI systems.

Does that get you anywhere? It's like mind wandering before
you go to sleep; you don't reach any higher realization to
be able to close it off.

Can you answer my question ?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 10:04 AM, Bonita Montero wrote:

Am 27.10.2025 um 14:15 schrieb olcott:

On 10/27/2025 3:11 AM, Bonita Montero wrote:

Am 25.10.2025 um 19:53 schrieb olcott:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

This is Claude AI deriving the above sentence by simply
simulating DD by HHH giving me the fair review that every
human has cheated me out of.

Simulating Termination Analyzer applied to the HP counter-example input
https://www.researchgate.net/
publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf

What's the point of discussing the same mini-source for years?

That simple little snippet of C does show that
I have defeated the halting problem proof. Not
one single person would properly review it in
three years.

Now that LLM systems have increased their memory
capacity 67-fold in the last two years they agree
that I have defeated the halting problem itself.
That little snippet of C is the key basis of my
whole proof.

When it is understood that I have defeated the
halting problem then additional discussion shows
that I also have the basis for eliminating the
hallucination of LLM AI systems.

Does that get you anywhere? It's like mind wandering before
you go to sleep; you don't reach any higher realization to
be able to close it off.

Can you answer my question ?

I have refuted the halting problem. This is
the most important discovery in all of computer
science.

Not a single human reviewer on the planet
will give my C snippet a fair review.

I will continue 10 million times if that is
what it takes to get my C snippet a fair review.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

Am 27.10.2025 um 16:19 schrieb olcott:

I have refuted the halting problem. This is
the most important discovery in all of computer
science.

You are manic. And that's not an insult,
but a genuinely well-founded statement.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 11:41 AM, Bonita Montero wrote:

Am 27.10.2025 um 16:19 schrieb olcott:

I have refuted the halting problem. This is
the most important discovery in all of computer
science.

You are manic. And that's not an insult,
but a genuinely well-founded statement.

You asked. All that I needed for three years
is this. By refusing to give me this dozens
of people have wasted thousands of hours for
several years.

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 10:04 AM, Bonita Montero wrote:

Am 27.10.2025 um 14:15 schrieb olcott:

On 10/27/2025 3:11 AM, Bonita Montero wrote:

Am 25.10.2025 um 19:53 schrieb olcott:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

This is Claude AI deriving the above sentence by simply
simulating DD by HHH giving me the fair review that every
human has cheated me out of.

Simulating Termination Analyzer applied to the HP counter-example input
https://www.researchgate.net/
publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input

Simulating Termination Analyzer applied to
the HP counter-example input
https://philpapers.org/archive/OLCSTA-3.pdf

What's the point of discussing the same mini-source for years?

That simple little snippet of C does show that
I have defeated the halting problem proof. Not
one single person would properly review it in
three years.

Now that LLM systems have increased their memory
capacity 67-fold in the last two years they agree
that I have defeated the halting problem itself.
That little snippet of C is the key basis of my
whole proof.

When it is understood that I have defeated the
halting problem then additional discussion shows
that I also have the basis for eliminating the
hallucination of LLM AI systems.

Does that get you anywhere? It's like mind wandering before
you go to sleep; you don't reach any higher realization to
be able to close it off.

Can you answer my question ?

I have refuted the halting problem. This is

You have certaionly /refused/ the halting problem.

Not a single human reviewer on the planet
will give my C snippet a fair review.

I've gotten up to the elbow in your actual code from GitHub
and found problems.

Your response is to call me dishonest!

(You are completely, utterly unprofessional; your conduct is
not befiting of anyone calling themselves any kind of engineer.)

It is apparent that your /cheat/ code is not actualy working for some reason.

Your Root variable is supposed to make the simulated HHH behave
differently so that it doesn't do abort checking, right?

Now that is hideously wrong and completely invalidates your work.
But never mind; it's not working right. The simulated HHH is behaving
like the root level one.

When we continue the DDD simulation that was left abandoned by
the top-level HHH, we find that the simulated HHH called by that DDD
still performs aborting:

Number of Instructions Executed(10069) == 150 Pages
RECK: ---------------
RECK: simulations for these function still exist:
RECK: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00001216

This is the suspended simulated DDD. It is stuck in the middle of Decide_Halting_HH.

RECK: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 0014E2B0, EIP == 000015D2

This is the second level of simulation nesting of DDD. This EIP
is pointing straight to HHH. The first simulation level of DDD,
executing Decide_Halting_HH, juwt finished recording an execution trace
event for the second level DDD. That event says that HHH was called.
This must be what triggered the abort.

RECK: ---------------
RECK: continuing simulation of entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00001216

Now reckoning has come; we restart the top simulated DDD.

New slave_stack at:15e38c

Begin Local Halt Decider Simulation Execution Trace Stored at:16e394
RECK: newly executing: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 0015E350, EIP == 00002172
New slave_stack at:1a8db4
RECK: newly executing: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 001A8D78, EIP == 00002172

Two new DDD simulations appear.

Local Halt Decider: Infinite Recursion Detected Simulation Stopped

What? The simulated HHH is doing the abort check and returning zero!

RECK: simulation of entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00002183 reached code_end!
RECK: ---------------
RECK: reckoning completed

And so DDD halts!

When your second and subsequent simulations of HHH call this:

u32 Root = Init_Halts_HH(&Aborted, &execution_trace, &decoded, &code_end, (u32)P,
&master_state, &slave_state, &slave_stack);

Root is supposed to be zero. Somehow it looks like this is not
happening, so your HHH, though not a pure function as required, is at
least behaving consistently across simulation levels, causing people's predictions to come true that the simulated DDD and HHH behave the same
as the directly executed one.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 11:58 AM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

Not a single human reviewer on the planet
will give my C snippet a fair review.

I've gotten up to the elbow in your actual code from GitHub
and found problems.

Do I have to start calling you names like Jackass
to get your attention?

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

I am talking about the above in isolation nitwit.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/25 16:19, olcott wrote:

C programmer can easily determine:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Not a single human reviewer on the planet
will give my C snippet a fair review.

It's just because nobody can compile a running version of
your fscking program, and we all have a BRS for halting
every program on earth.
--
** **
* tTh des Bourtoulots *
* http://maison.tth.netlib.re/ *
** **
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/25 14:45, olcott wrote:

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);
}

tth@linda:~/Essais$ gcc olcoot.c
/usr/bin/ld: /tmp/ccpdNJve.o: in function `DD':
olcoot.c:(.text+0x1e): undefined reference to `HHH'
/usr/bin/ld: /tmp/ccpdNJve.o: in function `main':
olcoot.c:(.text+0x5f): undefined reference to `HHH'
collect2: error: ld returned 1 exit status
tth@linda:~/Essais$
--
** **
* tTh des Bourtoulots *
* http://maison.tth.netlib.re/ *
** **
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 11:58 AM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

Not a single human reviewer on the planet
will give my C snippet a fair review.

I've gotten up to the elbow in your actual code from GitHub
and found problems.

Do I have to start calling you names like Jackass
to get your attention?

I have forked your code and published changes; how much more attention
do you want?

I have endowed your x86utm with the ability to validate your
belief that a simulated DD or DDD does not halt.

You should have done this yourself!

You /need/ that in order to validate that your /cheats/ are working

When a top level DDD terminates, but HHH returns 0, you are
claiming that the simulated DDD does not terminate, right?

You have a cheat in place to ensure that: the Root variable:
when that is zero in a simulated HHH, it disableds the abort
code, ensuring runaway recursive behavior.

But when we investigate that with actual code, we find that
the cheat is not working; DDD does terminate, and another
abort detection is seen out of the simulateed HHH.
The simulated HHH seems ot be running with Root == 1.

I've given you the tool to validate that your own cheats are working, so
that when you say that the simulated DDD does not halt, you can be
confident that it doesn't, having actually tested it with the
"reckoning" module.

And here you are, asking for more attention to some incomplete
code fragment and Chat GPT text or whatever.

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

Why would I look at this, rather than your complete work
that can execute?

This is not even a complete program; there is no HHH definition.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 1:42 PM, Kaz Kylheku wrote:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

Why would I look at this, rather than your complete work
that can execute?

This is not even a complete program; there is no HHH definition.

Because I have changed the subject to this
and will not discuss anything else because
this supersedes and overrules anything else
that anyone can ever say on this specific point.

*It doesn't take a fucking genius to follow this*
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

I just takes someone that knows C and it not
a fucking jackass.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely

Show me their coding experiemnt they performed on your x86utm.

What changes did they make? What did they run? What are the test
results?
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 2:59 PM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely

Show me their coding experiemnt they performed on your x86utm.

What changes did they make? What did they run? What are the test
results?

This proves the general idea regardless of the implementation
details of any specific instance.

https://philpapers.org/archive/OLCSTA-3.pdf
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 3:12 PM, dbush wrote:

On 10/27/2025 3:53 PM, olcott wrote:

On 10/27/2025 2:40 PM, dbush wrote:

On 10/27/2025 3:33 PM, olcott wrote:

On 10/27/2025 2:20 PM, dbush wrote:

On 10/27/2025 2:53 PM, olcott wrote:

On 10/27/2025 1:42 PM, Kaz Kylheku wrote:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

Why would I look at this, rather than your complete work
that can execute?

This is not even a complete program; there is no HHH definition. >>>>>>>

Because I have changed the subject to this
and will not discuss anything else because
this supersedes and overrules anything else
that anyone can ever say on this specific point.

*It doesn't take a fucking genius to follow this*
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

And HHH doesn't correctly figure that out as proven by Kaz's code,
which you are on record as having agreed with (see below).

<repeat of previously refuted point>

Repeating a previously refuted point is less than no rebuttal, and
further confirms that you agree that Kaz's code proves that HHH
doesn't correctly "figure out what's up" as you have previously
admitted on the record:

I am only referring to these fifteen lines

A straight forward sequence of steps that any
C programmer can easily determine:

int D()
{
   int Halt_Status = H(D);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Then you have nothing as this is incomplete and cannot be run.

It is this mental execution trace that you keep
erasing dip shit:

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

You have erased that dozens of times you cheating bass turd.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 7:01 PM, olcott wrote:

On 10/27/2025 3:12 PM, dbush wrote:

On 10/27/2025 3:53 PM, olcott wrote:

On 10/27/2025 2:40 PM, dbush wrote:

On 10/27/2025 3:33 PM, olcott wrote:

On 10/27/2025 2:20 PM, dbush wrote:

On 10/27/2025 2:53 PM, olcott wrote:

On 10/27/2025 1:42 PM, Kaz Kylheku wrote:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

Why would I look at this, rather than your complete work
that can execute?

This is not even a complete program; there is no HHH definition. >>>>>>>>

Because I have changed the subject to this
and will not discuss anything else because
this supersedes and overrules anything else
that anyone can ever say on this specific point.

*It doesn't take a fucking genius to follow this*
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

And HHH doesn't correctly figure that out as proven by Kaz's code, >>>>>> which you are on record as having agreed with (see below).

<repeat of previously refuted point>

Repeating a previously refuted point is less than no rebuttal, and
further confirms that you agree that Kaz's code proves that HHH
doesn't correctly "figure out what's up" as you have previously
admitted on the record:

I am only referring to these fifteen lines

A straight forward sequence of steps that any
C programmer can easily determine:

int D()
{
   int Halt_Status = H(D);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Then you have nothing as this is incomplete and cannot be run.

It is this mental execution trace that you keep
erasing dip shit:

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

Repeat of previously refuted point (see below).

Repeating a previously refuted point is less that no rebuttal.



On 10/26/2025 9:38 PM, dbush wrote:

On 10/26/2025 9:32 PM, olcott wrote:

On 10/26/2025 8:28 PM, dbush wrote:

On 10/26/2025 9:20 PM, olcott wrote:

On 10/26/2025 8:16 PM, Kaz Kylheku wrote:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

And HHH figures it out incorrectly as proven by the code posted by

Katz.

You can't even get his name correctly deep ship!
(A less contentious way of say dip shit).

If you disagree, point out exactly where Kaz's code is in error.

Failure to do so in your next reply or within one hour of your next
post in this newsgroup will be taken as your official on-the-record
admission that Kaz's code conclusively proves that the DD that HHH
simulates will halt when simulated enough steps and therefore that
the input to HHH(DD) specifies a halting computation.

Let the record show that Peter Olcott made no attempt to show how the
code posted by Kaz proves that the DDD that HHH simulates will halt. Therefore:

Let The Record Show

That Peter Olcott

Has *officially* admitted:

That Kaz's code conclusively proves that the DD that HHH simulates will
halt when simulated enough steps and therefore that the input to HHH(DD) specifies a halting computation.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 6:05 PM, dbush wrote:

On 10/27/2025 7:01 PM, olcott wrote:

On 10/27/2025 3:12 PM, dbush wrote:

On 10/27/2025 3:53 PM, olcott wrote:

On 10/27/2025 2:40 PM, dbush wrote:

On 10/27/2025 3:33 PM, olcott wrote:

On 10/27/2025 2:20 PM, dbush wrote:

On 10/27/2025 2:53 PM, olcott wrote:

On 10/27/2025 1:42 PM, Kaz Kylheku wrote:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

Why would I look at this, rather than your complete work
that can execute?

This is not even a complete program; there is no HHH definition. >>>>>>>>>

Because I have changed the subject to this
and will not discuss anything else because
this supersedes and overrules anything else
that anyone can ever say on this specific point.

*It doesn't take a fucking genius to follow this*
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

And HHH doesn't correctly figure that out as proven by Kaz's
code, which you are on record as having agreed with (see below). >>>>>>>

<repeat of previously refuted point>

Repeating a previously refuted point is less than no rebuttal, and
further confirms that you agree that Kaz's code proves that HHH
doesn't correctly "figure out what's up" as you have previously
admitted on the record:

I am only referring to these fifteen lines

A straight forward sequence of steps that any
C programmer can easily determine:

int D()
{
   int Halt_Status = H(D);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Then you have nothing as this is incomplete and cannot be run.

It is this mental execution trace that you keep
erasing dip shit:

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

Repeat of previously refuted point (see below).

Repeating a previously refuted point is less that no rebuttal.

On 10/26/2025 9:38 PM, dbush wrote:

On 10/26/2025 9:32 PM, olcott wrote:

On 10/26/2025 8:28 PM, dbush wrote:

On 10/26/2025 9:20 PM, olcott wrote:

On 10/26/2025 8:16 PM, Kaz Kylheku wrote:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

And HHH figures it out incorrectly as proven by the code posted by Katz.

You can't even get his name correctly deep ship!
(A less contentious way of say dip shit).

If you disagree, point out exactly where Kaz's code is in error.

Failure to do so in your next reply or within one hour of your next
post in this newsgroup will be taken as your official on-the-record
admission that Kaz's code conclusively proves that the DD that HHH
simulates will halt when simulated enough steps and therefore that
the input to HHH(DD) specifies a halting computation.

Let the record show that Peter Olcott made no attempt to show how the
code posted by Kaz proves that the DDD that HHH simulates will halt. Therefore:

Let The Record Show

That Peter Olcott

Has *officially* admitted:

That Kaz's code conclusively proves that the DD that HHH simulates will halt when simulated enough steps and therefore that the input to HHH(DD) specifies a halting computation.

*plonk*
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 4:11 PM, olcott wrote:

On 10/27/2025 6:05 PM, dbush wrote:

On 10/27/2025 7:01 PM, olcott wrote:

On 10/27/2025 3:12 PM, dbush wrote:

On 10/27/2025 3:53 PM, olcott wrote:

On 10/27/2025 2:40 PM, dbush wrote:

On 10/27/2025 3:33 PM, olcott wrote:

On 10/27/2025 2:20 PM, dbush wrote:

On 10/27/2025 2:53 PM, olcott wrote:

On 10/27/2025 1:42 PM, Kaz Kylheku wrote:

A straight forward sequence of steps that any
C programmer can easily determine:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

Why would I look at this, rather than your complete work
that can execute?

This is not even a complete program; there is no HHH definition. >>>>>>>>>>

Because I have changed the subject to this
and will not discuss anything else because
this supersedes and overrules anything else
that anyone can ever say on this specific point.

*It doesn't take a fucking genius to follow this*
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

And HHH doesn't correctly figure that out as proven by Kaz's
code, which you are on record as having agreed with (see below). >>>>>>>>

<repeat of previously refuted point>

Repeating a previously refuted point is less than no rebuttal, and >>>>>> further confirms that you agree that Kaz's code proves that HHH
doesn't correctly "figure out what's up" as you have previously
admitted on the record:

I am only referring to these fifteen lines

A straight forward sequence of steps that any
C programmer can easily determine:

int D()
{
   int Halt_Status = H(D);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Then you have nothing as this is incomplete and cannot be run.

It is this mental execution trace that you keep
erasing dip shit:

HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.

Repeat of previously refuted point (see below).

Repeating a previously refuted point is less that no rebuttal.



On 10/26/2025 9:38 PM, dbush wrote:

On 10/26/2025 9:32 PM, olcott wrote:

On 10/26/2025 8:28 PM, dbush wrote:

On 10/26/2025 9:20 PM, olcott wrote:

On 10/26/2025 8:16 PM, Kaz Kylheku wrote:
;
int DD()
{
;    int Halt_Status = HHH(DD);
;    if (Halt_Status)
;      HERE: goto HERE;
;    return Halt_Status;
}
;
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
;
;

;
And HHH figures it out incorrectly as proven by the code posted

by Katz.

;

;
You can't even get his name correctly deep ship!
(A less contentious way of say dip shit).

If you disagree, point out exactly where Kaz's code is in error.
;
Failure to do so in your next reply or within one hour of your next
post in this newsgroup will be taken as your official on-the-record
admission that Kaz's code conclusively proves that the DD that HHH
simulates will halt when simulated enough steps and therefore that
the input to HHH(DD) specifies a halting computation.

;
Let the record show that Peter Olcott made no attempt to show how the
code posted by Kaz proves that the DDD that HHH simulates will halt.
Therefore:
;
Let The Record Show
;
That Peter Olcott
;
Has *officially* admitted:
;
That Kaz's code conclusively proves that the DD that HHH simulates

will

halt when simulated enough steps and therefore that the input to

HHH(DD)

specifies a halting computation.

*plonk*

Liar paradox? You halt... ;^)
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 6:05 PM, dbush wrote:
*plonk*

I predict he will reply to a post by dbush before Hallowe'en.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 10:21 PM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 6:05 PM, dbush wrote:
*plonk*

I predict he will reply to a post by dbush before Hallowe'en.

He has conclusively proven to be a troll Like
Richard Damon and Chris M. Thomasson.

I still have hope for you, especially with Mike's
balancing influence.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 11:44 PM, olcott wrote:

On 10/27/2025 10:21 PM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 6:05 PM, dbush wrote:
*plonk*

I predict he will reply to a post by dbush before Hallowe'en.

He has conclusively proven to be a troll

In other words, you're unable to explain how I'm wrong and you can't
handle it.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 8:44 PM, olcott wrote:

On 10/27/2025 10:21 PM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 6:05 PM, dbush wrote:
*plonk*

I predict he will reply to a post by dbush before Hallowe'en.

He has conclusively proven to be a troll Like
Richard Damon and Chris M. Thomasson.

Tell that to the poor gimp(s) you _whip_ into shape... Poor unsuspecting LLM's? We disagree with you, we try to help you, you call us mass
murders and dumb. You start talking about Trump and shit. What a joke?

I still have hope for you, especially with Mike's
balancing influence.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 10/27/2025 11:21 PM, Kaz Kylheku wrote:

On 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 6:05 PM, dbush wrote:
*plonk*

I predict he will reply to a post by dbush before Hallowe'en.

Didn't even last a day, and he couldn't even say something that hasn't
already been refuted:

On 10/28/2025 12:29 AM, olcott wrote:

On 10/27/2025 11:04 PM, dbush wrote:

I suppose from now on if he ever posts a trace we can remind him that
he "can't be telling the truth".

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.

--- Synchronet 3.21a-Linux NewsLink 1.2