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

You mean

*dbush is now dishonored in his deceit*

Like you are going to try and get away with being
so stupid about the C language that the following
is not as obvious as a slap on your face.

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.

*It did take me 22 years to get it that simple*



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

--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

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

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

You mean

*dbush is now dishonored in his deceit*

There's no deceit in the fact that you admitted on the record that the
input to HHH(DD) specifies a halting computation:


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.

--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

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

There's no deceit

*Sure there is any C programmer can see this*

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.

*It did take me 22 years to get it that simple*
*21 years, 4 months, 2 weeks, 6 days to be exact*

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

--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

Subject: olcott tries to hide the evidence that he admitted the input to HHH(DD) is halting

On 10/26/2025 10:15 PM, olcott wrote:

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

There's no deceit in the fact that you admitted on the record that the
input to HHH(DD) specifies a halting computation:

*Sure there is any C programmer can see this*

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.

Repeat of previously refuted point as shown below that you dishonesty
tried to hide by erasing.

Are there no depths to which you'll sink to hide your lies?

*It did take me 22 years to get it that simple*
*21 years, 4 months, 2 weeks, 6 days to be exact*

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.

--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

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

Thanks for the confirmation

*that dbush is now dishonored in his deceit*

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.

*It did take me 22 years to get it that simple*
*21 years, 4 months, 2 weeks, 6 days to be exact*



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

--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)