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

Groups > comp.theory > #133713 > unrolled thread

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

Back to article view | Back to comp.theory

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 Bonita Montero <Bonita.Montero@gmail.com> - 2025-10-25 20:05 +0200
    Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-25 14:20 -0400
      Re: No human has been able to understand this simple C in three years Richard Heathfield <rjh@cpax.org.uk> - 2025-10-25 20:44 +0100
    Re: No human has been able to understand this simple C in three years dart200 <user7160@newsgrouper.org.invalid> - 2025-10-25 11:44 -0700
      Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-25 13:58 -0500
      Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-26 17:17 -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 00:44 +0000
          Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-26 19:51 -0500
            Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-26 21:06 -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-26 18:09 -0700
            Re: No human has been able to understand this simple C in three years Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 01:16 +0000
              A dishonest dodge is all that Kaz has olcott <polcott333@gmail.com> - 2025-10-26 20:20 -0500
                Re: A dishonest dodge is all that Kaz has dbush <dbush.mobile@gmail.com> - 2025-10-26 21:28 -0400
                  Re: A dishonest dodge is all that Kaz has olcott <polcott333@gmail.com> - 2025-10-26 20:32 -0500
                    Re: A dishonest dodge is all that Kaz has dbush <dbush.mobile@gmail.com> - 2025-10-26 21:38 -0400
                  Re: A dishonest dodge is all that Kaz has Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 01:50 +0000
                    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 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 02:02 +0000
                        Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:04 -0500
                        Re: Kaz is now dishonored in his deceit Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 03:46 +0000
                          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: Kaz proves his deceit by dodging this simple point --- Is Kaz just a Liar ??? Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 04:52 +0000
                            Re: Kaz proves his deceit by dodging this simple point --- Is Kaz just a Liar ??? Richard Damon <Richard@Damon-Family.org> - 2025-10-27 20:59 -0400
                      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 dbush <dbush.mobile@gmail.com> - 2025-10-26 22:43 -0400
                                Re: Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:45 -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:47 -0400
                                    dbush is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 21:52 -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:57 -0400
                                    dbush proves his deceit by dodging this simple point olcott <polcott333@gmail.com> - 2025-10-26 22:11 -0500
                                Can someone from comp.lang.c or comp.lang.c++ help out here? olcott <polcott333@gmail.com> - 2025-10-26 22:02 -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 23:04 -0400
                                    dbush proves is deceit by dodging this simple point olcott <polcott333@gmail.com> - 2025-10-26 22:09 -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 23:14 -0400
                                        dbush proves his deceit by dodging this simple point --- dbush is a bot? olcott <polcott333@gmail.com> - 2025-10-26 22:42 -0500
                                          olcott tries to hide the evidence that he admitted the input to HHH(DD) is halting dbush <dbush.mobile@gmail.com> - 2025-10-27 07:25 -0400
                          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
                Re: A dishonest dodge is all that Kaz has Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 01:38 +0000
                  Re: A dishonest dodge is all that Kaz has --- Now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 20:45 -0500
                    Re: A dishonest dodge is all that Kaz has --- Now dishonored in his deceit dbush <dbush.mobile@gmail.com> - 2025-10-26 21:49 -0400
                      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
                    Re: A dishonest dodge is all that Kaz has --- Now dishonored in his deceit Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 01:57 +0000
                      Kaz is now dishonored in his deceit olcott <polcott333@gmail.com> - 2025-10-26 20:59 -0500
          Re: No human has been able to understand this simple C in three years Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-10-27 04:32 +0000
            Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-26 23:35 -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:45 +0000
                Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 11:53 -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:48 +0000
    Re: No human has been able to understand this simple C in three years Richard Damon <Richard@Damon-Family.org> - 2025-10-25 21:20 -0400
    Re: No human has been able to understand this simple C in three years Mikko Levanto <mikko.levanto@iki.fi> - 2025-10-26 11:06 +0200
    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
                    Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-27 15:20 -0400
                      Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 14:33 -0500
                        Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-27 15:40 -0400
                          Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 14:53 -0500
                            Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-27 16:12 -0400
                              PO Meltdown? Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 20:48 +0000
                                Re: PO Meltdown? dbush <dbush.mobile@gmail.com> - 2025-10-27 17:07 -0400
                                  Re: PO Meltdown? Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 21:14 +0000
                                    Re: PO Meltdown? Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 00:37 +0000
                                      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
                                      Re: PO Meltdown? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-10-28 02:24 +0000
                                        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 Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-10-28 15:18 +0000
                                                      Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 11:21 -0500
                                                      Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 16:44 +0000
                                                        Re: D simulated by H cannot possibly reach past its own first line Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-10-28 17:24 +0000
                                                        Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 15:15 -0500
                                                          Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-28 16:18 -0400
                                                          Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 20:23 +0000
                                                            Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 16:00 -0500
                                                              Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 21:23 +0000
                                                                Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 16:33 -0500
                                                              Re: D simulated by H cannot possibly reach past its own first line dbush <dbush.mobile@gmail.com> - 2025-10-28 18:01 -0400
                                                      Re: D simulated by H cannot possibly reach past its own first line "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-28 12:03 -0700
                                                        Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 19:56 +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-28 13:27 -0700
                                                  Re: D simulated by H cannot possibly reach past its own first line joes <noreply@example.org> - 2025-10-28 08:40 +0000
                                                    Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 09:43 -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-28 12:08 -0700
                                                      Re: D simulated by H cannot possibly reach past its own first line joes <noreply@example.org> - 2025-11-03 14:06 +0000
                                                        Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-11-03 10:13 -0600
                                                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
                                        Re: PO Meltdown? Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 03:31 +0000
                                          Re: PO Meltdown? wij <wyniijj5@gmail.com> - 2025-10-28 13:25 +0800
                                          Re: PO Meltdown? olcott <polcott333@gmail.com> - 2025-10-28 00:32 -0500
                                            Re: PO Meltdown? Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 05:53 +0000
                                              D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 09:27 -0500
                                                Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 16:48 +0000
                                                  Re: D simulated by H cannot possibly reach past its own first line olcott <polcott333@gmail.com> - 2025-10-28 15:23 -0500
                                                    Re: D simulated by H cannot possibly reach past its own first line Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-28 21:26 +0000
                                        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
                                      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
                                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
            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 Mikko <mikko.levanto@iki.fi> - 2025-10-27 12:10 +0200
      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 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-27 17:03 +0000
          Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-27 12:05 -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
        Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-28 11:09 +0200
          Re: No human has been able to understand this simple C in three years Richard Heathfield <rjh@cpax.org.uk> - 2025-10-28 10:06 +0000
            Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-28 09:52 -0500
              Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-29 13:02 +0200
                Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-29 11:29 -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-29 12:48 -0700
                  Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-30 12:24 +0200
                    Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-30 08:15 -0500
                      Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-31 13:53 +0200
                        Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-31 08:42 -0500
                          Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-10-31 10:13 -0400
                          Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-11-01 11:22 +0200
                            Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-11-01 08:27 -0500
                              Re: No human has been able to understand this simple C in three years dbush <dbush.mobile@gmail.com> - 2025-11-01 09:53 -0400
                                understand this simple C ? --- counter-factual assumptions olcott <polcott333@gmail.com> - 2025-11-01 09:22 -0500
                                  Re: understand this simple C ? --- counter-factual assumptions dbush <dbush.mobile@gmail.com> - 2025-11-01 10:37 -0400
                                    Re: understand this simple C ? --- counter-factual assumptions olcott <polcott333@gmail.com> - 2025-11-01 09:41 -0500
                                      Re: understand this simple C ? --- counter-factual assumptions dbush <dbush.mobile@gmail.com> - 2025-11-01 11:24 -0400
                                        Re: understand this simple C ? --- counter-factual assumptions olcott <polcott333@gmail.com> - 2025-11-01 10:32 -0500
                                          Re: understand this simple C ? --- counter-factual assumptions dbush <dbush.mobile@gmail.com> - 2025-11-01 11:44 -0400
                                            Re: understand this simple C ? --- counter-factual assumptions olcott <polcott333@gmail.com> - 2025-11-01 12:04 -0500
                                              Re: understand this simple C ? --- counter-factual assumptions dbush <dbush.mobile@gmail.com> - 2025-11-01 14:14 -0400
                              Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-11-02 14:35 +0200
                                Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-11-03 17:31 -0600
                                  Re: No human has been able to understand this simple C in three years Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-11-03 23:48 +0000
                                  Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-11-04 12:00 +0200
            Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-29 13:01 +0200
          Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-28 09:55 -0500
            Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-29 13:03 +0200
              Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-29 11:29 -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-29 12:49 -0700
                Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-30 12:29 +0200
                  Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-30 08:17 -0500
                    Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-10-31 14:02 +0200
                      Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-10-31 08:50 -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-31 12:58 -0700
                        Re: No human has been able to understand this simple C in three years Mikko <mikko.levanto@iki.fi> - 2025-11-01 11:32 +0200
                          Re: No human has been able to understand this simple C in three years olcott <polcott333@gmail.com> - 2025-11-01 08:32 -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:50 -0700

Page 8 of 11 — ← Prev page 1 … 6 7 [8] 9 10 11  Next page →

#133957 — 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]

#133962 — 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]

#133963 — 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]

#133964 — 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]

#133966 — 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]

#133969 — 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]

#133970 — 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]

#133959

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]

#133960

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]

#133961

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]

#133980

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]

#133997

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]

#134003

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]

#134005

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]

#134016

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]

#134041

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]

#133935

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/                *
**                                                            **

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

#133898

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.

-- 
Mikko

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

#133906

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

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

#133930

On 2025-10-27, olcott <polcott333@gmail.com> wrote:
> see what happens this proves that all of my reviewers
> have been dishonest with me for three years.

Nothing could be more dishonest than trying to make different simulation
levels of HHH behave differently with a variable Root which has a value
of 1 in the top-level HHH invocation, and 0 in the simulated levels.

Like, how is it supposed to work?

Do you think that you're actually going to go down in the annals of
mathematics as having refuted the halting problem, and nobody will ever
notice your Root variable cheat inside HHH?

You must think that everyone is an idiot in mathematics and CS.

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

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

Page 8 of 11 — ← Prev page 1 … 6 7 [8] 9 10 11  Next page →

Back to top | Article view | comp.theory

csiph-web