Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c > #394729 > unrolled thread

No human has been able to understand this simple C in three years

Back to article view | Back to comp.lang.c

Contents

  No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-25 12:53 -0500
    Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-25 13:33 -0500
    dbush is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 20:56 -0500
      Re: dbush is now dishonored in his deceit dbush <dbush.mobile@gmail.com> - 2025-10-26 22:05 -0400
        Re: dbush is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:15 -0500
          olcott tries to hide the evidence that he admitted the input to HHH(DD) is halting dbush <dbush.mobile@gmail.com> - 2025-10-26 22:33 -0400
    Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 20:58 -0500
      Re: Kaz is now dishonored in his deceit André G. Isaak <agisaak@gm.invalid> - 2025-10-26 20:15 -0600
        Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:20 -0500
          Re: Kaz is now dishonored in his deceit "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-26 19:25 -0700
          Re: Kaz is now dishonored in his deceit dbush <dbush.mobile@gmail.com> - 2025-10-26 22:35 -0400
            Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:38 -0500
              Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:45 -0500
                dbush is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:52 -0500
              Can someone from comp.lang.c or comp.lang.c++ help out here? olcott <polcott333@gmail.com> - 2025-10-26 22:02 -0500
          Re: Kaz is now dishonored in his deceit Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 04:47 +0000
            Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 23:54 -0500
              Re: Kaz is now dishonored in his deceit dbush <dbush.mobile@gmail.com> - 2025-10-27 07:30 -0400
              Re: Kaz is now dishonored in his deceit Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 18:36 +0000
                Re: Kaz is now dishonored in his deceit "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 11:55 -0700
            Re: Kaz is now dishonored in his deceit Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-10-27 05:59 +0000
              Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-27 08:18 -0500
                Re: Kaz is now dishonored in his deceit Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-10-27 16:50 +0000
                  Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-27 11:58 -0500
                  Re: Kaz is now dishonored in his deceit "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 11:48 -0700
        Re: Kaz is now dishonored in his deceit Janis Papanagnou <janis_papanagnou+ng@hotmail.com> - 2025-10-27 03:31 +0100
          Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:36 -0500
        Re: Kaz is now dishonored in his deceit cross@spitfire.i.gajendra.net (Dan Cross) - 2025-10-27 14:08 +0000
          I am only in these groups because I have been cheated out of a fair review. olcott <polcott333@gmail.com> - 2025-10-27 09:48 -0500
      Kaz proves his deceit by dodging this simple point --- Is Kaz just a Liar ??? olcott <polcott333@gmail.com> - 2025-10-26 23:10 -0500
    Re: No human has been able to understand this simple C in three years Bonita Montero <Bonita.Montero@gmail.com> - 2025-10-27 09:11 +0100
      Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 08:15 -0500
        Re: No human has been able to understand this simple C in three years Bonita Montero <Bonita.Montero@gmail.com> - 2025-10-27 16:04 +0100
          Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 10:19 -0500
            Re: No human has been able to understand this simple C in three years Bonita Montero <Bonita.Montero@gmail.com> - 2025-10-27 17:41 +0100
              Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 11:52 -0500
            Re: No human has been able to understand this simple C in three years Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 16:58 +0000
              Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 12:02 -0500
                Re: No human has been able to understand this simple C in three years Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 18:42 +0000
                  Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 13:53 -0500
                    Kaz insists on dodging this point only because he knows it is irrefutable olcott <polcott333@gmail.com> - 2025-10-27 17:40 -0500
                      Re: Kaz insists on dodging this point only because he knows it is irrefutable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 00:23 +0000
                        Re: Kaz insists on dodging this point only because he knows it is irrefutable olcott <polcott333@gmail.com> - 2025-10-27 19:29 -0500
                          Re: Kaz insists on dodging this point only because he knows it is irrefutable dbush <dbush.mobile@gmail.com> - 2025-10-27 20:32 -0400
                          Re: Kaz insists on dodging this point only because he knows it is irrefutable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 00:41 +0000
                            Re: Kaz insists on dodging this point only because he knows it is irrefutable +++ olcott <polcott333@gmail.com> - 2025-10-27 19:48 -0500
                              Re: Kaz insists on dodging this point only because he knows it is irrefutable +++ dbush <dbush.mobile@gmail.com> - 2025-10-27 20:52 -0400
                    Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 18:01 -0500
                      Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-27 19:05 -0400
                        Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 18:11 -0500
                          Re: No human has been able to understand this simple C in three years "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 18:38 -0700
                          Re: No human has been able to understand this simple C in three years Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 03:21 +0000
                            Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 22:44 -0500
                              Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-27 23:46 -0400
                              Re: No human has been able to understand this simple C in three years "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 22:38 -0700
                            Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-28 07:55 -0400
                    Kaz is a damned liar olcott <polcott333@gmail.com> - 2025-10-27 19:44 -0500
                      Re: Kaz is a damned liar Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 00:52 +0000
                        Re: Kaz is a damned liar "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 19:05 -0700
                    Kaz is a damned liar olcott <polcott333@gmail.com> - 2025-10-27 19:44 -0500
                    D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-27 21:58 -0500
                      Re: D simulated by H cannot possibly reach past its own first line "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 19:59 -0700
                      Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-27 23:10 -0400
                    D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-27 22:18 -0500
                      Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-27 23:27 -0400
                      Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 03:40 +0000
                        Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-27 22:45 -0500
                          Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-27 23:47 -0400
                          Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 03:54 +0000
                            Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-27 23:01 -0500
                              Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 06:02 +0000
                            Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-28 00:04 -0400
                              Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-27 23:29 -0500
                                Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 05:48 +0000
                                  Re: D simulated by H cannot possibly reach past its own first line "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 22:51 -0700
                                Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-28 07:48 -0400
                    D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 00:27 -0500
                      Re: D simulated by H cannot possibly reach past its own first line "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-27 22:46 -0700
            Re: No human has been able to understand this simple C in three years tTh <tth@none.invalid> - 2025-10-27 18:57 +0100
    Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 08:45 -0500
      Re: No human has been able to understand this simple C in three years tTh <tth@none.invalid> - 2025-10-27 19:00 +0100
      Re: No human has been able to understand this simple C in three years Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 19:59 +0000
        Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 17:38 -0500

Page 3 of 5 — ← Prev page 1 2 [3] 4 5  Next page →

#394827 — Kaz insists on dodging this point only because he knows it is irrefutable

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

[toc] | [prev] | [next] | [standalone]

#394831 — Re: Kaz insists on dodging this point only because he knows it is irrefutable

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

[toc] | [prev] | [next] | [standalone]

#394832 — Re: Kaz insists on dodging this point only because he knows it is irrefutable

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

[toc] | [prev] | [next] | [standalone]

#394834 — Re: Kaz insists on dodging this point only because he knows it is irrefutable

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.

[toc] | [prev] | [next] | [standalone]

#394835 — Re: Kaz insists on dodging this point only because he knows it is irrefutable

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

[toc] | [prev] | [next] | [standalone]

#394838 — Re: Kaz insists on dodging this point only because he knows it is irrefutable +++

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

[toc] | [prev] | [next] | [standalone]

#394839 — Re: Kaz insists on dodging this point only because he knows it is irrefutable +++

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

[toc] | [prev] | [next] | [standalone]

#394828

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

[toc] | [prev] | [next] | [standalone]

#394829

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.

[toc] | [prev] | [next] | [standalone]

#394830

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

[toc] | [prev] | [next] | [standalone]

#394844

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... ;^)

[toc] | [prev] | [next] | [standalone]

#394857

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

[toc] | [prev] | [next] | [standalone]

#394862

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

[toc] | [prev] | [next] | [standalone]

#394864

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.

[toc] | [prev] | [next] | [standalone]

#394871

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.
> 

[toc] | [prev] | [next] | [standalone]

#394881

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.
 >
 >

[toc] | [prev] | [next] | [standalone]

#394836 — Kaz is a damned liar

On 10/27/2025 7:37 PM, Kaz Kylheku wrote:
> On 2025-10-27, Kaz Kylheku <643-408-1753@kylheku.com> wrote:
>> On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:
>>> On 10/27/2025 4: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.
>>>>
>>>> When I posted the git repo several days ago, Olcott immediately
>>>> called me dishonest and replied with the above nonsense.
>>>>
>>>> He has been repeating it ever since.
>>>>
>>>> Basically a meltdown, of sorts.
>>>>
>>>
>>> Oh yeah, he's thrashing.  He knows he's been beat and doesn't dare look
>>> at your code, lest he has to admit he wasted the last 21 years.
>>
>> But I explained that the code can help you validate that your cheats are
>> working. If you want to say that DDD simulated by HHH does not halt, and
>> not be lying, you can now test that actual claim. If the simulated DDD
>> halts, and you would like it not to, you have something to iterate
>> against to get that fixed.
>>
>> Every engineer would be happy to have an easy, ready-made way to test
>> the property of their system that they want to believe to be true.
>>
>> Instead of thank you, we get a childish tantrum.
> 
> Unfortunately, it is not that rosy. The problem is that Olcott has not
> only been claiming that various D's do not terminate when simulated
> by various H's. He's been claiming that the D's do not terminate because
> they never reach the "do the opposite" logic at all.
> 
> For instance, I ran a test on an old Halt.obj pulled from the git
> history, and found that when its simulation of the abandoned DD is
> continued, it soon hits an infinite loop.
> 
> While, for that .obj file, it confirms the claim that the simulated DD
> doesn't terminate, the problem is that the simulated DD in that
> situation fails to terminate due to getting into the infinite loop,
> which is only possible because the simulated HHH(DD) returned non-zero
> to simulated DD.
> 
> Thus the simulated HHH says, about the doubly-simulated DD, that the
> doubly-simulated DD halts A bug or cheat has been exposed in the
> machine; it is contradicting itself.
> 
> Olcott knows that continuing the abandoned simulation uncovers
> damning evidence against his contraption, regardless of whether it
> halts or not.
> 

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



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

[toc] | [prev] | [next] | [standalone]

#394840 — Re: Kaz is a damned liar

On 2025-10-28, olcott <polcott333@gmail.com> wrote:
> On 10/27/2025 7:37 PM, Kaz Kylheku wrote:
>> On 2025-10-27, Kaz Kylheku <643-408-1753@kylheku.com> wrote:
>>> On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:
>>>> On 10/27/2025 4: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.
>>>>>
>>>>> When I posted the git repo several days ago, Olcott immediately
>>>>> called me dishonest and replied with the above nonsense.
>>>>>
>>>>> He has been repeating it ever since.
>>>>>
>>>>> Basically a meltdown, of sorts.
>>>>>
>>>>
>>>> Oh yeah, he's thrashing.  He knows he's been beat and doesn't dare look
>>>> at your code, lest he has to admit he wasted the last 21 years.
>>>
>>> But I explained that the code can help you validate that your cheats are
>>> working. If you want to say that DDD simulated by HHH does not halt, and
>>> not be lying, you can now test that actual claim. If the simulated DDD
>>> halts, and you would like it not to, you have something to iterate
>>> against to get that fixed.
>>>
>>> Every engineer would be happy to have an easy, ready-made way to test
>>> the property of their system that they want to believe to be true.
>>>
>>> Instead of thank you, we get a childish tantrum.
>> 
>> Unfortunately, it is not that rosy. The problem is that Olcott has not
>> only been claiming that various D's do not terminate when simulated
>> by various H's. He's been claiming that the D's do not terminate because
>> they never reach the "do the opposite" logic at all.
>> 
>> For instance, I ran a test on an old Halt.obj pulled from the git
>> history, and found that when its simulation of the abandoned DD is
>> continued, it soon hits an infinite loop.
>> 
>> While, for that .obj file, it confirms the claim that the simulated DD
>> doesn't terminate, the problem is that the simulated DD in that
>> situation fails to terminate due to getting into the infinite loop,
>> which is only possible because the simulated HHH(DD) returned non-zero
>> to simulated DD.
>> 
>> Thus the simulated HHH says, about the doubly-simulated DD, that the
>> doubly-simulated DD halts A bug or cheat has been exposed in the
>> machine; it is contradicting itself.
>> 
>> Olcott knows that continuing the abandoned simulation uncovers
>> damning evidence against his contraption, regardless of whether it
>> halts or not.
>> 
>
> 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

Disproof. The current Halt7.obj tests the return value of HHH(DDD),
which looks like this:

  void DDD() 
  {
    HHH(DDD); 
    return; 
  } 

according to Olcott's claim above, this is supposed to result in infinite
recursion so the return statement is never reached.

  int main() 
  { 
    Output("Input_Halts = ", HHH(DDD));
  } 

Yet, the execution trace below shows that DDD can be continued and reaches a
halting state. The trace also shows more DDD simulations starting up as a side
effect. There is the start of an infinite simulation tower, but the simulations
are terminating.

This result can be obtained with the code from this git repo:

https://www.kylheku.com/cgit/x86utm/

Everything is visible to the public to examine and criticize.  If the execution
trace is a "lie", it can easily be exposed by someone skilled in the art
(so why would I do that?)

_DDD()
[00002172] 55             push ebp
[00002173] 8bec           mov ebp,esp
[00002175] 6872210000     push 00002172
[0000217a] e853f4ffff     call 000015d2
[0000217f] 83c404         add esp,+04
[00002182] 5d             pop ebp
[00002183] c3             ret
Size in bytes:(0018) [00002183]

[ ... ]

Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[0000219f][00103820][00000000] 83c404         add esp,+04
[000021a2][0010381c][00000000] 50             push eax
[000021a3][00103818][00000743] 6843070000     push 00000743
[000021a8][00103818][00000743] e8b5e5ffff     call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408         add esp,+08
[000021b0][00103820][00000000] 33c0           xor eax,eax
[000021b2][00103824][00000018] 5d             pop ebp
[000021b3][00103828][00000000] c3             ret
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
RECK: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 0014E2B0, EIP == 000015D2
RECK: ---------------
RECK: continuing simulation of entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00001216
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
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

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


-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#394848 — Re: Kaz is a damned liar

On 10/27/2025 5:52 PM, Kaz Kylheku wrote:
[...]

Kaz, casting pearls before swine. It means you care, but Olcott says you 
are worse than a murderous tyrant.

Sigh. ;^o

[toc] | [prev] | [next] | [standalone]

#394837 — Kaz is a damned liar

On 10/27/2025 7:37 PM, Kaz Kylheku wrote:
> On 2025-10-27, Kaz Kylheku <643-408-1753@kylheku.com> wrote:
>> On 2025-10-27, dbush <dbush.mobile@gmail.com> wrote:
>>> On 10/27/2025 4: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.
>>>>
>>>> When I posted the git repo several days ago, Olcott immediately
>>>> called me dishonest and replied with the above nonsense.
>>>>
>>>> He has been repeating it ever since.
>>>>
>>>> Basically a meltdown, of sorts.
>>>>
>>>
>>> Oh yeah, he's thrashing.  He knows he's been beat and doesn't dare look
>>> at your code, lest he has to admit he wasted the last 21 years.
>>
>> But I explained that the code can help you validate that your cheats are
>> working. If you want to say that DDD simulated by HHH does not halt, and
>> not be lying, you can now test that actual claim. If the simulated DDD
>> halts, and you would like it not to, you have something to iterate
>> against to get that fixed.
>>
>> Every engineer would be happy to have an easy, ready-made way to test
>> the property of their system that they want to believe to be true.
>>
>> Instead of thank you, we get a childish tantrum.
> 
> Unfortunately, it is not that rosy. The problem is that Olcott has not
> only been claiming that various D's do not terminate when simulated
> by various H's. He's been claiming that the D's do not terminate because
> they never reach the "do the opposite" logic at all.
> 
> For instance, I ran a test on an old Halt.obj pulled from the git
> history, and found that when its simulation of the abandoned DD is
> continued, it soon hits an infinite loop.
> 
> While, for that .obj file, it confirms the claim that the simulated DD
> doesn't terminate, the problem is that the simulated DD in that
> situation fails to terminate due to getting into the infinite loop,
> which is only possible because the simulated HHH(DD) returned non-zero
> to simulated DD.
> 
> Thus the simulated HHH says, about the doubly-simulated DD, that the
> doubly-simulated DD halts A bug or cheat has been exposed in the
> machine; it is contradicting itself.
> 
> Olcott knows that continuing the abandoned simulation uncovers
> damning evidence against his contraption, regardless of whether it
> halts or not.
> 

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



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

[toc] | [prev] | [next] | [standalone]

Page 3 of 5 — ← Prev page 1 2 [3] 4 5  Next page →

Back to top | Article view | comp.lang.c

csiph-web