Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #394729 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2025-10-25 12:53 -0500 |
| Last post | 2025-10-27 17:38 -0500 |
| Articles | 20 on this page of 83 — 10 participants |
Back to article view | Back to comp.lang.c
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 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
| From | Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> |
|---|---|
| Date | 2025-10-27 05:59 +0000 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10dn1ni$iav5$1@dont-email.me> |
| In reply to | #394775 |
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except as noted in
the sig.
On 27/10/2025 04:47, Kaz Kylheku wrote:
> HHH(DDD) can return 1; why doesn't it?
In the different challenge with much less constrained, HHH can return
anything convertible to int or it can call abort(), or even execute "for
(;;);" once it figures out what is up, which is so poorly defined HHH
could just be:
int HHH(){for (;;);}
having been written under the free assumption that 'up' is mere
'purported presence' (a pointer is passed). My HHH here has no prototype
and I'm using C89 so that's sufficient (IIRC).
Writing C code you better have a lot of free assumption or you'd never
get little programs finished.
--
Tristan Wibberley
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 08:18 -0500 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10dnrfo$r5i3$2@dont-email.me> |
| In reply to | #394777 |
On 10/27/2025 12:59 AM, Tristan Wibberley wrote:
> The message body is Copyright (C) 2025 Tristan Wibberley except
> citations and quotations noted. All Rights Reserved except as noted in
> the sig.
>
> On 27/10/2025 04:47, Kaz Kylheku wrote:
>> HHH(DDD) can return 1; why doesn't it?
>
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
I am only looking for a fair review of the above
15 lines.
> --
> Tristan Wibberley
>
> The message body is Copyright (C) 2025 Tristan Wibberley except
> citations and quotations noted. All Rights Reserved except that you may,
> of course, cite it academically giving credit to me, distribute it
> verbatim as part of a usenet system or its archives, and use it to
> promote my greatness and general superiority without misrepresentation
> of my opinions other than my opinion of my greatness and general
> superiority which you _may_ misrepresent. You definitely MAY NOT train
> any production AI system with it but you may train experimental AI that
> will only be used for evaluation of the AI methods it implements.
>
--
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]
| From | Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> |
|---|---|
| Date | 2025-10-27 16:50 +0000 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10do7se$10jcj$2@dont-email.me> |
| In reply to | #394787 |
The message body is Copyright (C) 2025 Tristan Wibberley except citations and quotations noted. All Rights Reserved except as noted in the sig. On 27/10/2025 13:18, olcott wrote: [immediately preceding content snipped from message 10dnrfo$r5i3$2@dont-email.me] > I am only looking for a fair review of the above > 15 lines. I'll call them The Olcott 15 lines of 10dnrfo$r5i3$2@dont-email.me for the moment. The purpose of The Olcott 15 lines of 10dnrfo$r5i3$2@dont-email.me is not clear enough to me for my fair review beyond noting that absence of clear purpose itself. How did I do? -- Tristan Wibberley The message body is Copyright (C) 2025 Tristan Wibberley except citations and quotations noted. All Rights Reserved except that you may, of course, cite it academically giving credit to me, distribute it verbatim as part of a usenet system or its archives, and use it to promote my greatness and general superiority without misrepresentation of my opinions other than my opinion of my greatness and general superiority which you _may_ misrepresent. You definitely MAY NOT train any production AI system with it but you may train experimental AI that will only be used for evaluation of the AI methods it implements.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 11:58 -0500 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10do8c3$11af0$1@dont-email.me> |
| In reply to | #394801 |
On 10/27/2025 11:50 AM, Tristan Wibberley wrote:
> The message body is Copyright (C) 2025 Tristan Wibberley except
> citations and quotations noted. All Rights Reserved except as noted in
> the sig.
>
> On 27/10/2025 13:18, olcott wrote:
>
> [immediately preceding content snipped from message
> 10dnrfo$r5i3$2@dont-email.me]
>
>> I am only looking for a fair review of the above
>> 15 lines.
>
> I'll call them The Olcott 15 lines of 10dnrfo$r5i3$2@dont-email.me for
> the moment.
>
> The purpose of The Olcott 15 lines of 10dnrfo$r5i3$2@dont-email.me is
> not clear enough to me for my fair review beyond noting that absence of
> clear purpose itself.
>
> How did I do?
>
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
Any C programmer should be able to validate
the above in less than one minute.
The perfectly clear version is much more verbose:
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
> --
> Tristan Wibberley
>
> The message body is Copyright (C) 2025 Tristan Wibberley except
> citations and quotations noted. All Rights Reserved except that you may,
> of course, cite it academically giving credit to me, distribute it
> verbatim as part of a usenet system or its archives, and use it to
> promote my greatness and general superiority without misrepresentation
> of my opinions other than my opinion of my greatness and general
> superiority which you _may_ misrepresent. You definitely MAY NOT train
> any production AI system with it but you may train experimental AI that
> will only be used for evaluation of the AI methods it implements.
>
--
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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2025-10-27 11:48 -0700 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10doeq9$13a5j$2@dont-email.me> |
| In reply to | #394801 |
On 10/27/2025 9:50 AM, Tristan Wibberley wrote: > The message body is Copyright (C) 2025 Tristan Wibberley except > citations and quotations noted. All Rights Reserved except as noted in > the sig. > > On 27/10/2025 13:18, olcott wrote: > > [immediately preceding content snipped from message > 10dnrfo$r5i3$2@dont-email.me] > >> I am only looking for a fair review of the above >> 15 lines. > > I'll call them The Olcott 15 lines of 10dnrfo$r5i3$2@dont-email.me for > the moment. > > The purpose of The Olcott 15 lines of 10dnrfo$r5i3$2@dont-email.me is > not clear enough to me for my fair review beyond noting that absence of > clear purpose itself. > > How did I do? The program is so simple even a child might be able to understand it. I fuzzed it for fun, all paths hit. One path is that GOTO infinite loop. The other one halts. So, I fuzzed HHH(DD) to where it hit both paths. simple. It means that its dependent on the return value from HHH(DD). It means that DD can sometimes halt, and other times hit an infinite goto loop. That's about it. My fuzzer does not need a per(x86)-instruction simulator or anything like that. It runs the program as is on any system, just fuzzed. [...]
[toc] | [prev] | [next] | [standalone]
| From | Janis Papanagnou <janis_papanagnou+ng@hotmail.com> |
|---|---|
| Date | 2025-10-27 03:31 +0100 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10dmlh5$ere7$1@dont-email.me> |
| In reply to | #394763 |
On 27.10.2025 03:15, André G. Isaak wrote: > On 2025-10-26 19:58, olcott wrote: >> On 10/26/2025 8:50 PM, Kaz Kylheku wrote: >>>> >>>> And >> *Kaz is now dishonored in his deceit* > > How the hell is that a response to the word 'And'? At least quote enough > material that its apparent what you are responding to. I don't think this poster needs or should get such an encouragement. (I'd prefer if he'd rather stop his pathologically posted topic.) BTW, could someone who has a better oversight on the "course of discussion" adjust the newsgroups list appropriately. - Thanks. Janis > > André >
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-26 21:36 -0500 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10dmlql$evl1$1@dont-email.me> |
| In reply to | #394766 |
On 10/26/2025 9:31 PM, Janis Papanagnou wrote:
> On 27.10.2025 03:15, André G. Isaak wrote:
>> On 2025-10-26 19:58, olcott wrote:
>>> On 10/26/2025 8:50 PM, Kaz Kylheku wrote:
>>>>>
>>>>> And
>>> *Kaz is now dishonored in his deceit*
>>
>> How the hell is that a response to the word 'And'? At least quote enough
>> material that its apparent what you are responding to.
>
> I don't think this poster needs or should get such an encouragement.
> (I'd prefer if he'd rather stop his pathologically posted topic.)
>
> BTW, could someone who has a better oversight on the "course of
> discussion" adjust the newsgroups list appropriately. - Thanks.
>
> Janis
>
As soon as six people on the C or C++ group
verify this I will quit re-posting it.
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | cross@spitfire.i.gajendra.net (Dan Cross) |
|---|---|
| Date | 2025-10-27 14:08 +0000 |
| Subject | Re: Kaz is now dishonored in his deceit |
| Message-ID | <10dnudg$bir$1@reader2.panix.com> |
| In reply to | #394763 |
In article <10dmkk4$eie0$1@dont-email.me>, André G. Isaak <agisaak@gm.invalid> wrote: >On 2025-10-26 19:58, olcott wrote: >> On 10/26/2025 8:50 PM, Kaz Kylheku wrote: >>>> >>>> And >> *Kaz is now dishonored in his deceit* > >How the hell is that a response to the word 'And'? At least quote enough >material that its apparent what you are responding to. Or don't. Or if you're going to, at least set the followups to keep Olcott's spam out of groups that he, and those who cannot resist responding to him, have not already destroyed. - Dan C.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 09:48 -0500 |
| Subject | I am only in these groups because I have been cheated out of a fair review. |
| Message-ID | <10do0n4$taem$1@dont-email.me> |
| In reply to | #394792 |
On 10/27/2025 9:08 AM, Dan Cross wrote:
> In article <10dmkk4$eie0$1@dont-email.me>,
> André G. Isaak <agisaak@gm.invalid> wrote:
>> On 2025-10-26 19:58, olcott wrote:
>>> On 10/26/2025 8:50 PM, Kaz Kylheku wrote:
>>>>>
>>>>> And
>>> *Kaz is now dishonored in his deceit*
>>
>> How the hell is that a response to the word 'And'? At least quote enough
>> material that its apparent what you are responding to.
>
> Or don't. Or if you're going to, at least set the followups to
> keep Olcott's spam out of groups that he, and those who cannot
> resist responding to him, have not already destroyed.
>
> - Dan C.
>
If people in the group gave me a fair review of
this code snippet three years ago I would have
never had any need to return to these groups.
No a single person out of dozens and dozens
has ever given my a fair review of this code
snippet.
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
*It did take me 22 years to get it that simple*
*21 years, 4 months, 2 weeks, 6 days*
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.
*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]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-26 23:10 -0500 |
| Subject | Kaz proves his deceit by dodging this simple point --- Is Kaz just a Liar ??? |
| Message-ID | <10dmrcd$guu3$1@dont-email.me> |
| In reply to | #394759 |
On 10/26/2025 10:46 PM, Kaz Kylheku wrote:
>
> Paydirt!
>
*Kaz proves his deceit by dodging this simple point*
This simple point supersedes and over-rides every
other point about HHH(DD). The simple essence
about everything that can be said about HHH(DD)
is summed up below.
*It took me 21 years, 4 months, 2 weeks, 6 days*
to make this point this simple
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Bonita Montero <Bonita.Montero@gmail.com> |
|---|---|
| Date | 2025-10-27 09:11 +0100 |
| Message-ID | <10dn9f1$l1dq$1@raubtier-asyl.eternal-september.org> |
| In reply to | #394729 |
Am 25.10.2025 um 19:53 schrieb olcott:
> Think this all the way through do not make any guesses.
> The answer must come from DD simulated by HHH
> according to the semantics of the C programming language
> and nothing else.
>
> Simulating Termination Analyzer HHH correctly
> simulates its input until:
>
> (a) Detects a non-terminating behavior pattern:
> abort simulation and return 0.
>
> (b) Simulated input reaches its simulated
> "return" statement: return 1.
>
> (c) If it is impossible to match (a) or (b)
> then (c) is matched
>
> (a)(b)(c) are in strict priority order (a)-->(b)-->(c)
>
> typedef int (*ptr)();
> int HHH(ptr P);
>
> int DD()
> {
> int Halt_Status = HHH(DD);
> if (Halt_Status)
> HERE: goto HERE;
> return Halt_Status;
> }
>
> int main()
> {
> HHH(DD);
> }
>
> Simulating Termination Analyzer applied to
> the HP counter-example input
> https://philpapers.org/archive/OLCSTA-3.pdf
>
What's the point of discussing the same mini-source for years?
Does that get you anywhere? It's like mind wandering before
you go to sleep; you don't reach any higher realization to
be able to close it off.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 08:15 -0500 |
| Message-ID | <10dnr93$r5i3$1@dont-email.me> |
| In reply to | #394778 |
On 10/27/2025 3:11 AM, Bonita Montero wrote:
> Am 25.10.2025 um 19:53 schrieb olcott:
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
This is Claude AI deriving the above sentence by simply
simulating DD by HHH giving me the fair review that every
human has cheated me out of.
Simulating Termination Analyzer applied to the HP counter-example input
https://www.researchgate.net/publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input
>>
>> Simulating Termination Analyzer applied to
>> the HP counter-example input
>> https://philpapers.org/archive/OLCSTA-3.pdf
>>
>
> What's the point of discussing the same mini-source for years?
That simple little snippet of C does show that
I have defeated the halting problem proof. Not
one single person would properly review it in
three years.
Now that LLM systems have increased their memory
capacity 67-fold in the last two years they agree
that I have defeated the halting problem itself.
That little snippet of C is the key basis of my
whole proof.
When it is understood that I have defeated the
halting problem then additional discussion shows
that I also have the basis for eliminating the
hallucination of LLM AI systems.
> Does that get you anywhere? It's like mind wandering before
> you go to sleep; you don't reach any higher realization to
> be able to close it off.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Bonita Montero <Bonita.Montero@gmail.com> |
|---|---|
| Date | 2025-10-27 16:04 +0100 |
| Message-ID | <10do1mb$tpc3$1@raubtier-asyl.eternal-september.org> |
| In reply to | #394786 |
Am 27.10.2025 um 14:15 schrieb olcott:
> On 10/27/2025 3:11 AM, Bonita Montero wrote:
>> Am 25.10.2025 um 19:53 schrieb olcott:
>
> A straight forward sequence of steps that any
> C programmer can easily determine:
>
> int DD()
> {
> int Halt_Status = HHH(DD);
> if (Halt_Status)
> HERE: goto HERE;
> return Halt_Status;
> }
>
> HHH(DD) simulates DD that calls HHH(DD) to do this
> again and again until HHH figures out what is up.
>
> This is Claude AI deriving the above sentence by simply
> simulating DD by HHH giving me the fair review that every
> human has cheated me out of.
>
> Simulating Termination Analyzer applied to the HP counter-example input
> https://www.researchgate.net/
> publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input
>
>>>
>>> Simulating Termination Analyzer applied to
>>> the HP counter-example input
>>> https://philpapers.org/archive/OLCSTA-3.pdf
>>>
>>
>> What's the point of discussing the same mini-source for years?
>
> That simple little snippet of C does show that
> I have defeated the halting problem proof. Not
> one single person would properly review it in
> three years.
>
> Now that LLM systems have increased their memory
> capacity 67-fold in the last two years they agree
> that I have defeated the halting problem itself.
> That little snippet of C is the key basis of my
> whole proof.
>
> When it is understood that I have defeated the
> halting problem then additional discussion shows
> that I also have the basis for eliminating the
> hallucination of LLM AI systems.
>
>> Does that get you anywhere? It's like mind wandering before
>> you go to sleep; you don't reach any higher realization to
>> be able to close it off.
>
>
Can you answer my question ?
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 10:19 -0500 |
| Message-ID | <10do2ii$u8nq$1@dont-email.me> |
| In reply to | #394794 |
On 10/27/2025 10:04 AM, Bonita Montero wrote:
> Am 27.10.2025 um 14:15 schrieb olcott:
>> On 10/27/2025 3:11 AM, Bonita Montero wrote:
>>> Am 25.10.2025 um 19:53 schrieb olcott:
>>
>> A straight forward sequence of steps that any
>> C programmer can easily determine:
>>
>> int DD()
>> {
>> int Halt_Status = HHH(DD);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return Halt_Status;
>> }
>>
>> HHH(DD) simulates DD that calls HHH(DD) to do this
>> again and again until HHH figures out what is up.
>>
>> This is Claude AI deriving the above sentence by simply
>> simulating DD by HHH giving me the fair review that every
>> human has cheated me out of.
>>
>> Simulating Termination Analyzer applied to the HP counter-example input
>> https://www.researchgate.net/
>> publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input
>>
>>>>
>>>> Simulating Termination Analyzer applied to
>>>> the HP counter-example input
>>>> https://philpapers.org/archive/OLCSTA-3.pdf
>>>>
>>>
>>> What's the point of discussing the same mini-source for years?
>>
>> That simple little snippet of C does show that
>> I have defeated the halting problem proof. Not
>> one single person would properly review it in
>> three years.
>>
>> Now that LLM systems have increased their memory
>> capacity 67-fold in the last two years they agree
>> that I have defeated the halting problem itself.
>> That little snippet of C is the key basis of my
>> whole proof.
>>
>> When it is understood that I have defeated the
>> halting problem then additional discussion shows
>> that I also have the basis for eliminating the
>> hallucination of LLM AI systems.
>>
>>> Does that get you anywhere? It's like mind wandering before
>>> you go to sleep; you don't reach any higher realization to
>>> be able to close it off.
>>
>>
>
> Can you answer my question ?
I have refuted the halting problem. This is
the most important discovery in all of computer
science.
Not a single human reviewer on the planet
will give my C snippet a fair review.
I will continue 10 million times if that is
what it takes to get my C snippet a fair review.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Bonita Montero <Bonita.Montero@gmail.com> |
|---|---|
| Date | 2025-10-27 17:41 +0100 |
| Message-ID | <10do7av$10pe8$1@raubtier-asyl.eternal-september.org> |
| In reply to | #394796 |
Am 27.10.2025 um 16:19 schrieb olcott: > I have refuted the halting problem. This is > the most important discovery in all of computer > science. You are manic. And that's not an insult, but a genuinely well-founded statement.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 11:52 -0500 |
| Message-ID | <10do7vr$1151f$1@dont-email.me> |
| In reply to | #394800 |
On 10/27/2025 11:41 AM, Bonita Montero wrote:
> Am 27.10.2025 um 16:19 schrieb olcott:
>
>> I have refuted the halting problem. This is
>> the most important discovery in all of computer
>> science.
>
> You are manic. And that's not an insult,
> but a genuinely well-founded statement.
>
You asked. All that I needed for three years
is this. By refusing to give me this dozens
of people have wasted thousands of hours for
several years.
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <643-408-1753@kylheku.com> |
|---|---|
| Date | 2025-10-27 16:58 +0000 |
| Message-ID | <20251027094526.282@kylheku.com> |
| In reply to | #394796 |
On 2025-10-27, olcott <polcott333@gmail.com> wrote:
> On 10/27/2025 10:04 AM, Bonita Montero wrote:
>> Am 27.10.2025 um 14:15 schrieb olcott:
>>> On 10/27/2025 3:11 AM, Bonita Montero wrote:
>>>> Am 25.10.2025 um 19:53 schrieb olcott:
>>>
>>> A straight forward sequence of steps that any
>>> C programmer can easily determine:
>>>
>>> int DD()
>>> {
>>> int Halt_Status = HHH(DD);
>>> if (Halt_Status)
>>> HERE: goto HERE;
>>> return Halt_Status;
>>> }
>>>
>>> HHH(DD) simulates DD that calls HHH(DD) to do this
>>> again and again until HHH figures out what is up.
>>>
>>> This is Claude AI deriving the above sentence by simply
>>> simulating DD by HHH giving me the fair review that every
>>> human has cheated me out of.
>>>
>>> Simulating Termination Analyzer applied to the HP counter-example input
>>> https://www.researchgate.net/
>>> publication/396903511_Simulating_Termination_Analyzer_applied_to_the_HP_counter-example_input
>>>
>>>>>
>>>>> Simulating Termination Analyzer applied to
>>>>> the HP counter-example input
>>>>> https://philpapers.org/archive/OLCSTA-3.pdf
>>>>>
>>>>
>>>> What's the point of discussing the same mini-source for years?
>>>
>>> That simple little snippet of C does show that
>>> I have defeated the halting problem proof. Not
>>> one single person would properly review it in
>>> three years.
>>>
>>> Now that LLM systems have increased their memory
>>> capacity 67-fold in the last two years they agree
>>> that I have defeated the halting problem itself.
>>> That little snippet of C is the key basis of my
>>> whole proof.
>>>
>>> When it is understood that I have defeated the
>>> halting problem then additional discussion shows
>>> that I also have the basis for eliminating the
>>> hallucination of LLM AI systems.
>>>
>>>> Does that get you anywhere? It's like mind wandering before
>>>> you go to sleep; you don't reach any higher realization to
>>>> be able to close it off.
>>>
>>>
>>
>> Can you answer my question ?
>
> I have refuted the halting problem. This is
You have certaionly /refused/ the halting problem.
> Not a single human reviewer on the planet
> will give my C snippet a fair review.
I've gotten up to the elbow in your actual code from GitHub
and found problems.
Your response is to call me dishonest!
(You are completely, utterly unprofessional; your conduct is
not befiting of anyone calling themselves any kind of engineer.)
It is apparent that your /cheat/ code is not actualy working for some reason.
Your Root variable is supposed to make the simulated HHH behave
differently so that it doesn't do abort checking, right?
Now that is hideously wrong and completely invalidates your work.
But never mind; it's not working right. The simulated HHH is behaving
like the root level one.
When we continue the DDD simulation that was left abandoned by
the top-level HHH, we find that the simulated HHH called by that DDD
still performs aborting:
Number of Instructions Executed(10069) == 150 Pages
RECK: ---------------
RECK: simulations for these function still exist:
RECK: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00001216
This is the suspended simulated DDD. It is stuck in the middle of
Decide_Halting_HH.
RECK: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 0014E2B0, EIP == 000015D2
This is the second level of simulation nesting of DDD. This EIP
is pointing straight to HHH. The first simulation level of DDD,
executing Decide_Halting_HH, juwt finished recording an execution trace
event for the second level DDD. That event says that HHH was called.
This must be what triggered the abort.
RECK: ---------------
RECK: continuing simulation of entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00001216
Now reckoning has come; we restart the top simulated DDD.
New slave_stack at:15e38c
Begin Local Halt Decider Simulation Execution Trace Stored at:16e394
RECK: newly executing: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 0015E350, EIP == 00002172
New slave_stack at:1a8db4
RECK: newly executing: entry == 00002172 (_DDD), code_end == 00002183, slave_state == 001A8D78, EIP == 00002172
Two new DDD simulations appear.
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
What? The simulated HHH is doing the abort check and returning zero!
RECK: simulation of entry == 00002172 (_DDD), code_end == 00002183, slave_state == 00103888, EIP == 00002183 reached code_end!
RECK: ---------------
RECK: reckoning completed
And so DDD halts!
When your second and subsequent simulations of HHH call this:
u32 Root = Init_Halts_HH(&Aborted, &execution_trace, &decoded, &code_end, (u32)P,
&master_state, &slave_state, &slave_stack);
Root is supposed to be zero. Somehow it looks like this is not
happening, so your HHH, though not a pure function as required, is at
least behaving consistently across simulation levels, causing people's
predictions to come true that the simulated DDD and HHH behave the same
as the directly executed one.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 12:02 -0500 |
| Message-ID | <10do8ja$11er3$1@dont-email.me> |
| In reply to | #394803 |
On 10/27/2025 11:58 AM, Kaz Kylheku wrote:
> On 2025-10-27, olcott <polcott333@gmail.com> wrote:
>> Not a single human reviewer on the planet
>> will give my C snippet a fair review.
>
> I've gotten up to the elbow in your actual code from GitHub
> and found problems.
>
Do I have to start calling you names like Jackass
to get your attention?
A straight forward sequence of steps that any
C programmer can easily determine:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
I am talking about the above in isolation nitwit.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <643-408-1753@kylheku.com> |
|---|---|
| Date | 2025-10-27 18:42 +0000 |
| Message-ID | <20251027113718.83@kylheku.com> |
| In reply to | #394805 |
On 2025-10-27, olcott <polcott333@gmail.com> wrote:
> On 10/27/2025 11:58 AM, Kaz Kylheku wrote:
>> On 2025-10-27, olcott <polcott333@gmail.com> wrote:
>>> Not a single human reviewer on the planet
>>> will give my C snippet a fair review.
>>
>> I've gotten up to the elbow in your actual code from GitHub
>> and found problems.
>>
>
> Do I have to start calling you names like Jackass
> to get your attention?
I have forked your code and published changes; how much more attention
do you want?
I have endowed your x86utm with the ability to validate your
belief that a simulated DD or DDD does not halt.
You should have done this yourself!
You /need/ that in order to validate that your /cheats/ are working
When a top level DDD terminates, but HHH returns 0, you are
claiming that the simulated DDD does not terminate, right?
You have a cheat in place to ensure that: the Root variable:
when that is zero in a simulated HHH, it disableds the abort
code, ensuring runaway recursive behavior.
But when we investigate that with actual code, we find that
the cheat is not working; DDD does terminate, and another
abort detection is seen out of the simulateed HHH.
The simulated HHH seems ot be running with Root == 1.
I've given you the tool to validate that your own cheats are working, so
that when you say that the simulated DDD does not halt, you can be
confident that it doesn't, having actually tested it with the
"reckoning" module.
And here you are, asking for more attention to some incomplete
code fragment and Chat GPT text or whatever.
> A straight forward sequence of steps that any
> C programmer can easily determine:
>
> int DD()
> {
> int Halt_Status = HHH(DD);
> if (Halt_Status)
> HERE: goto HERE;
> return Halt_Status;
> }
Why would I look at this, rather than your complete work
that can execute?
This is not even a complete program; there is no HHH definition.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-27 13:53 -0500 |
| Message-ID | <10dof2k$147he$1@dont-email.me> |
| In reply to | #394812 |
On 10/27/2025 1:42 PM, Kaz Kylheku wrote:
>
>> A straight forward sequence of steps that any
>> C programmer can easily determine:
>>
>> int DD()
>> {
>> int Halt_Status = HHH(DD);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return Halt_Status;
>> }
>
> Why would I look at this, rather than your complete work
> that can execute?
>
> This is not even a complete program; there is no HHH definition.
>
Because I have changed the subject to this
and will not discuss anything else because
this supersedes and overrules anything else
that anyone can ever say on this specific point.
*It doesn't take a fucking genius to follow this*
HHH(DD) simulates DD that calls HHH(DD) to do this
again and again until HHH figures out what is up.
I just takes someone that knows C and it not
a fucking jackass.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
Back to top | Article view | comp.lang.c
csiph-web