From Newsgroup: comp.lang.c

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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 2025-10-27, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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

OK, so you are saying you no longer have a viable, discussion-worthy
instance?

Oopsies, if so!
--
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 7:23 PM, Kaz Kylheku wrote:

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

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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

OK, so you are saying you no longer have a viable, discussion-worthy instance?

Oopsies, if so!

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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 10/27/2025 8:29 PM, olcott wrote:

On 10/27/2025 7:23 PM, Kaz Kylheku wrote:

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

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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

OK, so you are saying you no longer have a viable, discussion-worthy
instance?

Oopsies, if so!

Sure I do

Then you know that Kaz's code shows that HHH isn't correct as you've
admitted on the record:


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 2025-10-28, olcott <polcott333@gmail.com> wrote:

On 10/27/2025 7:23 PM, Kaz Kylheku wrote:

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

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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

OK, so you are saying you no longer have a viable, discussion-worthy
instance?

Oopsies, if so!

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

And then HHH returns a result to DD, and DD shows that it is wrong. And
then you hand wave about that the DD is a "non-input" that HHH is not
required to report on and that the DD actually simulated by HHH is non-terminating, and never reaches the "do the opposite" code.

And then we show with actual code that this is complete bullshit.

We show that the abandoned DD can be stepped to halting or possibly
to the infinite loop (proving that your simulated HHH(DD) returned
nonzero to the simulated DD).

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

HHH(DD) simulates DD that calls HHH(DD) to do this

HHH is not defined anywhere in your 15 lines.

If it is not defined, it doesn't simulate anything.

Yood luck with the rest of your crazy meltdown.
--
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 7:41 PM, Kaz Kylheku wrote:

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

On 10/27/2025 7:23 PM, Kaz Kylheku wrote:

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

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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

OK, so you are saying you no longer have a viable, discussion-worthy
instance?

Oopsies, if so!

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

And then HHH returns a result to DD, and DD shows that it is wrong.

Finally a breakthrough. Once we establish this breakthrough
we can get on to the next step that addresses your objection.

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.

Once you acknowledge that this is true we can get
on to the next point that addresses your objection.
--
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 8:48 PM, olcott wrote:

On 10/27/2025 7:41 PM, Kaz Kylheku wrote:

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

On 10/27/2025 7:23 PM, Kaz Kylheku wrote:

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

On 10/27/2025 3:48 PM, Kaz Kylheku wrote:

On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:

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.

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

OK, so you are saying you no longer have a viable, discussion-worthy
instance?

Oopsies, if so!

Sure I do, you just know that this is so dead
obviously correct that you keep erasing it

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

And then HHH returns a result to DD, and DD shows that it is wrong.

Finally a breakthrough. Once we establish this breakthrough
we can get on to the next step that addresses your objection.

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.

And reports on the following non-input:


int D()
{
int Halt_Status = UTM(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
--- Synchronet 3.21a-Linux NewsLink 1.2