Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #132676 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2025-10-14 21:17 -0500 |
| Last post | 2025-10-16 07:55 -0400 |
| Articles | 20 on this page of 127 — 13 participants |
Back to article view | Back to comp.theory
The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-14 21:17 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 02:46 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-14 22:04 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 03:34 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-14 22:46 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 05:36 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 06:44 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 16:38 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 12:12 -0500
Re: The halting problem is self-contradictory Alan Mackenzie <acm@muc.de> - 2025-10-15 17:19 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 12:24 -0500
Re: The halting problem is self-contradictory Alan Mackenzie <acm@muc.de> - 2025-10-15 18:25 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 14:07 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-16 06:55 +0000
Re: The halting problem is self-contradictory Richard Heathfield <rjh@cpax.org.uk> - 2025-10-16 08:33 +0100
The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-16 08:23 -0500
The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-15 14:14 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 19:01 +0000
The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-15 14:11 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 18:54 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 14:19 -0500
Re: The halting problem is self-contradictory "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-15 13:14 -0700
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 20:47 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 16:00 -0500
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 17:18 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-16 19:12 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-16 14:58 -0500
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-16 15:56 -0500
Re: The halting problem is self-contradictory Alan Mackenzie <acm@muc.de> - 2025-10-16 21:07 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-16 16:19 -0500
Re: The halting problem is self-contradictory Richard Heathfield <rjh@cpax.org.uk> - 2025-10-16 22:25 +0100
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-16 16:39 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-16 21:46 +0000
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-16 21:45 +0000
The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-16 17:28 -0500
Re: The halting problem is self-contradictory cross@spitfire.i.gajendra.net (Dan Cross) - 2025-10-15 12:21 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 07:32 -0500
Re: The halting problem is self-contradictory tTh <tth@none.invalid> - 2025-10-15 16:50 +0200
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 16:25 +0000
Re: The halting problem is self-contradictory -- application to c/c++ Mikko <mikko.levanto@iki.fi> - 2025-10-16 12:34 +0300
Re: The halting problem is self-contradictory -- application to c/c++ olcott <polcott333@gmail.com> - 2025-10-16 08:27 -0500
Re: The halting problem is self-contradictory -- application to c/c++ "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-16 14:03 -0700
Re: The halting problem is self-contradictory -- application to c/c++ Mikko <mikko.levanto@iki.fi> - 2025-10-17 11:45 +0300
Re: The halting problem is self-contradictory -- application to c/c++ olcott <polcott333@gmail.com> - 2025-10-17 10:11 -0500
Re: The halting problem is self-contradictory -- application to c/c++ Mikko <mikko.levanto@iki.fi> - 2025-10-18 11:58 +0300
Re: The halting problem is self-contradictory -- application to c/c++ olcott <polcott333@gmail.com> - 2025-10-18 05:47 -0500
Re: The halting problem is self-contradictory -- application to c/c++ Mikko <mikko.levanto@iki.fi> - 2025-10-19 11:39 +0300
Re: The halting problem is self-contradictory -- application to c/c++ Richard Heathfield <rjh@cpax.org.uk> - 2025-10-19 10:31 +0100
Re: The halting problem is self-contradictory -- application to c/c++ Mikko <mikko.levanto@iki.fi> - 2025-10-19 14:16 +0300
Re: The halting problem is self-contradictory -- application to c/c++ Richard Heathfield <rjh@cpax.org.uk> - 2025-10-19 13:38 +0100
Re: The halting problem is self-contradictory -- application to c/c++ olcott <polcott333@gmail.com> - 2025-10-19 11:04 -0500
Re: The halting problem is self-contradictory -- application to c/c++ "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-19 13:22 -0700
Re: The halting problem is self-contradictory -- application to c/c++ "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-19 13:34 -0700
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-14 23:00 -0500
Re: The halting problem is self-contradictory Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-10-16 05:37 +0100
Re: The halting problem is self-contradictory Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-10-15 05:39 +0100
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-15 05:38 +0000
The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-15 18:33 -0500
Re: The Halting Problem is Incoherent Python <jpierre.messager@gmail.com> - 2025-10-15 23:59 +0000
Re: The Halting Problem is Incoherent Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-10-16 06:46 +0100
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-16 08:14 -0500
Re: The halting problem is self-contradictory Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-10-16 05:53 +0100
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-16 07:56 -0500
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-15 12:15 +0300
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-15 07:30 -0500
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-16 12:21 +0300
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-16 08:34 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-16 21:31 +0000
The halting problem incoherent olcott <polcott333@gmail.com> - 2025-10-16 17:04 -0500
Re: The halting problem incoherent Mikko <mikko.levanto@iki.fi> - 2025-10-17 11:59 +0300
Re: The halting problem incoherent olcott <polcott333@gmail.com> - 2025-10-17 06:47 -0500
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-17 11:54 +0300
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-17 10:15 -0500
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-19 11:42 +0300
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-19 11:08 -0500
Re: The halting problem is self-contradictory joes <noreply@example.org> - 2025-10-19 18:43 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 10:24 -0500
Re: The halting problem is self-contradictory joes <noreply@example.org> - 2025-10-20 17:18 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 12:34 -0500
Re: The halting problem is self-contradictory joes <noreply@example.org> - 2025-10-20 17:41 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 12:47 -0500
Re: The halting problem is self-contradictory joes <noreply@example.org> - 2025-10-20 18:09 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 13:42 -0500
Re: The halting problem is self-contradictory joes <noreply@example.org> - 2025-10-20 19:21 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 14:30 -0500
Re: The halting problem is self-contradictory joes <noreply@example.org> - 2025-10-20 22:15 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 17:33 -0500
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 17:43 -0500
Re: The halting problem is self-contradictory "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-20 15:59 -0700
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-20 23:58 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 19:07 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-21 01:32 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 20:38 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-21 02:00 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 21:21 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-21 03:22 +0000
The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-20 22:37 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-20 23:45 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-20 22:51 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-20 23:55 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-20 23:09 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-21 08:09 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-21 08:30 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-21 09:34 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-21 09:45 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-21 10:51 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-21 10:17 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-21 11:19 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-23 10:26 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-23 11:31 -0400
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-23 11:17 -0500
Re: The Halting Problem is Incoherent dbush <dbush.mobile@gmail.com> - 2025-10-23 12:57 -0400
Re: The Halting Problem is Incoherent Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-21 05:42 +0000
Re: The Halting Problem is Incoherent Richard Heathfield <rjh@cpax.org.uk> - 2025-10-21 06:55 +0100
Re: The Halting Problem is Incoherent olcott <polcott333@gmail.com> - 2025-10-21 01:37 -0500
Re: The Halting Problem is Incoherent Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-21 16:22 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 20:55 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-21 02:15 +0000
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 22:02 -0500
Re: The halting problem is self-contradictory Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-20 20:59 +0000
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-20 12:22 +0300
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-20 12:06 -0500
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-22 11:51 +0300
Re: The halting problem is self-contradictory olcott <polcott333@gmail.com> - 2025-10-22 07:22 -0500
Re: The halting problem is self-contradictory Mikko <mikko.levanto@iki.fi> - 2025-10-23 13:04 +0300
Re: The halting problem is self-contradictory "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-15 13:08 -0700
Re: The halting problem is self-contradictory Richard Damon <Richard@Damon-Family.org> - 2025-10-16 07:55 -0400
Page 2 of 7 — ← Prev page 1 [2] 3 4 5 6 7 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-15 14:19 -0500 |
| Message-ID | <10cos3j$3t2ub$1@dont-email.me> |
| In reply to | #132716 |
On 10/15/2025 11:38 AM, Kaz Kylheku wrote:
> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>> On 10/15/2025 12:36 AM, Kaz Kylheku wrote:
>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>>> On 10/14/2025 10:34 PM, Kaz Kylheku wrote:
>>>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>>>>> On 10/14/2025 9:46 PM, Kaz Kylheku wrote:
>>>>>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>>>>>>> 5. In short
>>>>>>>>
>>>>>>>> The halting problem as usually formalized is syntactically consistent
>>>>>>>> only because it pretends that U(p) is well-defined for every p.
>>>>>>>>
>>>>>>>> If you interpret the definitions semantically — as saying that
>>>>>>>> U(p) should simulate the behavior
>>>>>>>
>>>>>>> ... then you're making a grievous mistake. The halting function doesn't
>>>>>>> stipulate simulation.
>>>>>>>
>>>>>>
>>>>>> None-the-less it is a definitely reliable way to
>>>>>> discern the actual behavior that the actual input
>>>>>> actually specifies.
>>>>>
>>>>> No, it isn't. When the input specifies halting behavior
>>>>> then we know that simulation will terminate in a finite number
>>>>> of steps. In that case we discern that the input has terminated.
>>>>>
>>>>
>>>> When the semantics of the language specify
>>>> that when DD calls HHH(DD) that HHH must
>>>> simulate an instance of itself simulating
>>>> DD ChatGPT knows that this cannot be simply
>>>> ignored.
>>>
>>> It is obvious that when H denotes a simulator, then its diagonal program
>>> D ends up infinite regress, and is nonterminating.
>>> H(D) doesn't terminate, and fails to be a decider that way, not
>>> on account of returning an incorrect value.
>>> This situation is of no particular significance.
>>>
>>> When H is a simulator equipped with some break condition by which it
>>> stops simulating and returns a value, that H's diagonal program D
>>> ensures that the return value is wrong; if the value is 0, D is
>>> terminating.
>>
>> With HHH(DD)==0 HHH is returning the correct value for
>> the actual behavior of its actual input.
>
> It simply isn't.
>
>> That the directly
>> executed DD() is not in the input domain of HHH makes
>> what it does irrelevant.
>
> There exists no difference between "simulated" and "directly executed".
>
*Conclusively proven otherwise by this*
<Input to LLM systems>
Please think this all the way through without making any guesses.
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 HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.
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);
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
That this also holds at the level of pure math
is why [The Halting Problem is Incoherent]
https://www.researchgate.net/publication/396510896_The_Halting_Problem_is_Incoherent
Link to the following dialogue
https://chatgpt.com/share/68ef97b5-6770-8011-9aad-323009ca7841
> The situation is that you have made up multiple terms for the same thing
> and are insisting that there is a difference, which is just a
> word semantics play and equivocation. The difference is not real in
> the ontology of Turing machines.
>
> Turing machines and recursive procedures are an abstraction.
>
> Whenever we follow what they do, by any means, whether hardware,
> software or pencil-and-paper, that is always a
> simulation/interpretation.
>
> The only thing that can make a simulation more or less direct is
> translation.
>
> "Direct execution" of C means interpreting the textual tokens of the
> program; compiling to machine code is not "direct execution".
>
> This has nothing to do with the way you are falsely calling "direct
> execution".
>
>> That the halting problem requires HHH to report on an
>> input that it not in its domain makes the halting problem
>> incoherent even at the purely mathematical level.
>
> I made it clear to you that the input is constructable; thus the
> situation can be made real, all the way to a physical realization.
>
> You can build an input which incorporates a decision algorithm H, a
> diagonal wrapper D, encode it into a finite string, and then have the
> string processed by an implementation of algorithm H.
>
> The string is a syntactically and semantically valid machine
> representation and therefore lands squarely into the required domain.
>
--
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-15 13:14 -0700 |
| Message-ID | <10covaq$3tr55$2@dont-email.me> |
| In reply to | #132726 |
On 10/15/2025 12:19 PM, olcott wrote:
> On 10/15/2025 11:38 AM, Kaz Kylheku wrote:
>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>> On 10/15/2025 12:36 AM, Kaz Kylheku wrote:
>>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>>>> On 10/14/2025 10:34 PM, Kaz Kylheku wrote:
>>>>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>>>>>> On 10/14/2025 9:46 PM, Kaz Kylheku wrote:
>>>>>>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote:
>>>>>>>>> 5. In short
>>>>>>>>>
>>>>>>>>> The halting problem as usually formalized is syntactically
>>>>>>>>> consistent
>>>>>>>>> only because it pretends that U(p) is well-defined for every p.
>>>>>>>>>
>>>>>>>>> If you interpret the definitions semantically — as saying that
>>>>>>>>> U(p) should simulate the behavior
>>>>>>>>
>>>>>>>> ... then you're making a grievous mistake. The halting function
>>>>>>>> doesn't
>>>>>>>> stipulate simulation.
>>>>>>>>
>>>>>>>
>>>>>>> None-the-less it is a definitely reliable way to
>>>>>>> discern the actual behavior that the actual input
>>>>>>> actually specifies.
>>>>>>
>>>>>> No, it isn't. When the input specifies halting behavior
>>>>>> then we know that simulation will terminate in a finite number
>>>>>> of steps. In that case we discern that the input has terminated.
>>>>>>
>>>>>
>>>>> When the semantics of the language specify
>>>>> that when DD calls HHH(DD) that HHH must
>>>>> simulate an instance of itself simulating
>>>>> DD ChatGPT knows that this cannot be simply
>>>>> ignored.
>>>>
>>>> It is obvious that when H denotes a simulator, then its diagonal
>>>> program
>>>> D ends up infinite regress, and is nonterminating.
>>>> H(D) doesn't terminate, and fails to be a decider that way, not
>>>> on account of returning an incorrect value.
>>>> This situation is of no particular significance.
>>>>
>>>> When H is a simulator equipped with some break condition by which it
>>>> stops simulating and returns a value, that H's diagonal program D
>>>> ensures that the return value is wrong; if the value is 0, D is
>>>> terminating.
>>>
>>> With HHH(DD)==0 HHH is returning the correct value for
>>> the actual behavior of its actual input.
>>
>> It simply isn't.
>>
>>> That the directly
>>> executed DD() is not in the input domain of HHH makes
>>> what it does irrelevant.
>>
>> There exists no difference between "simulated" and "directly executed".
>>
>
> *Conclusively proven otherwise by this*
>
> <Input to LLM systems>
> Please think this all the way through without making any guesses.
>
> 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 HHH must abort its simulation to prevent its own non-termination
> then HHH is correct to abort this simulation and return 0.
>
> 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);
> }
This sure seems simpler:
1 HOME
5 PRINT "The Olcott All-in-One Halt Decider!"
10 INPUT "Shall I halt or not? " ; A$
30 IF A$ = "YES" GOTO 666
40 GOTO 10
666 PRINT "OK!"
?
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <643-408-1753@kylheku.com> |
|---|---|
| Date | 2025-10-15 20:47 +0000 |
| Message-ID | <20251015133621.400@kylheku.com> |
| In reply to | #132726 |
On 2025-10-15, olcott <polcott333@gmail.com> wrote: > Please think this all the way through without making any guesses. > > Simulating Termination Analyzer HHH correctly simulates its input until: This sentence must end with nothing other than "until that input terminates". Otherwise the simulation is not complete and correct. > (a) Detects a non-terminating behavior pattern: > abort simulation and return 0. > (b) Simulated input reaches its simulated "return" statement: > return 1. > (c) If HHH must abort its simulation to prevent its own non-termination > then HHH is correct to abort this simulation and return 0. HHH is correct to abort the simulation because if it doesn't do that, it will not terminate. All halting deciders that incorporate simulation as a tool must break out of simulation at some point in order not to be tripped up by inputs that fail to terminate. Without breaking out of the simulation, it would not be possible for HHH(Infinite_Loop) or HHH(Infinite_Recursion) to decide correctly that the return value should be zero. However, nothing is effective against the diagonal input. > What value should HHH(DD) correctly return? The set of possible solutions is the empty set. 3x + y = 5 6x + 2y = 3 What pairs <x, y> satisfy these equations? HHH(DD) not having a solution is no different from simultaneous equations in n variables not having a solution. Elementary school children can work with these. -- 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-15 16:00 -0500 |
| Message-ID | <10cp21m$3uske$1@dont-email.me> |
| In reply to | #132730 |
On 10/15/2025 3:47 PM, Kaz Kylheku wrote: > On 2025-10-15, olcott <polcott333@gmail.com> wrote: >> Please think this all the way through without making any guesses. >> >> Simulating Termination Analyzer HHH correctly simulates its input until: > > This sentence must end with nothing other than "until that input terminates". > > Otherwise the simulation is not complete and correct. > >> (a) Detects a non-terminating behavior pattern: >> abort simulation and return 0. >> (b) Simulated input reaches its simulated "return" statement: >> return 1. >> (c) If HHH must abort its simulation to prevent its own non-termination >> then HHH is correct to abort this simulation and return 0. > > HHH is correct to abort the simulation because if it doesn't do that, > it will not terminate. All halting deciders that incorporate simulation > as a tool must break out of simulation at some point in order not to be > tripped up by inputs that fail to terminate. > Great I just tested this and ChatGPT 5.0 and Gemini get the wrong answer without (c). ChatGPT 4.0, Claude AI and Grok all got this same answer without (c) and without being told not to guess. > Without breaking out of the simulation, it would not be possible > for HHH(Infinite_Loop) or HHH(Infinite_Recursion) to decide correctly > that the return value should be zero. > Yes. > However, nothing is effective against the diagonal input. > Unless we go be the behavior that the semantics of the specification language specifies as the ultimate judge. >> What value should HHH(DD) correctly return? > Not within the stipulated axioms when (c) is invoked. > The set of possible solutions is the empty set. > > 3x + y = 5 > 6x + 2y = 3 > > What pairs <x, y> satisfy these equations? > > HHH(DD) not having a solution is no different from simultaneous > equations in n variables not having a solution. > > Elementary school children can work with these. > Its deeper than that. See my other post. -- 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-15 17:18 -0500 |
| Message-ID | <10cp6ke$6eo$1@dont-email.me> |
| In reply to | #132732 |
On 10/15/2025 4:00 PM, olcott wrote: > On 10/15/2025 3:47 PM, Kaz Kylheku wrote: >> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>> Please think this all the way through without making any guesses. >>> >>> Simulating Termination Analyzer HHH correctly simulates its input until: >> >> This sentence must end with nothing other than "until that input >> terminates". >> >> Otherwise the simulation is not complete and correct. >> >>> (a) Detects a non-terminating behavior pattern: >>> abort simulation and return 0. >>> (b) Simulated input reaches its simulated "return" statement: >>> return 1. >>> (c) If HHH must abort its simulation to prevent its own non-termination >>> then HHH is correct to abort this simulation and return 0. >> >> HHH is correct to abort the simulation because if it doesn't do that, >> it will not terminate. All halting deciders that incorporate simulation >> as a tool must break out of simulation at some point in order not to be >> tripped up by inputs that fail to terminate. >> > > Great I just tested this and ChatGPT 5.0 and Gemini get > the wrong answer without (c). ChatGPT 4.0, Claude AI > and Grok all got this same answer without (c) and > without being told not to guess. > >> Without breaking out of the simulation, it would not be possible >> for HHH(Infinite_Loop) or HHH(Infinite_Recursion) to decide correctly >> that the return value should be zero. >> > > Yes. > >> However, nothing is effective against the diagonal input. >> > > Unless we go be the behavior that the semantics > of the specification language specifies as the > ultimate judge. > >>> What value should HHH(DD) correctly return? >> > > Not within the stipulated axioms when (c) is invoked. > >> The set of possible solutions is the empty set. >> >> 3x + y = 5 >> 6x + 2y = 3 >> >> What pairs <x, y> satisfy these equations? >> >> HHH(DD) not having a solution is no different from simultaneous >> equations in n variables not having a solution. >> >> Elementary school children can work with these. >> > > Its deeper than that. See my other post. > I didn't get the correct understanding by being a brilliant computer scientist. I got it by focusing on how pathological self-reference effects truth. I did this with an OCD like focus of concentration for 28 years. In the top of my new post [The Halting Problem is Incoherent] I show exactly how to overcome Quine's objection to the analytic / synthetic distinction. This is a key aspect of the foundation of the notion of truth itself. -- 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-16 19:12 +0000 |
| Message-ID | <20251016120057.231@kylheku.com> |
| In reply to | #132733 |
On 2025-10-15, olcott <polcott333@gmail.com> wrote: > On 10/15/2025 4:00 PM, olcott wrote: >> On 10/15/2025 3:47 PM, Kaz Kylheku wrote: >>> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>>> Please think this all the way through without making any guesses. >>>> >>>> Simulating Termination Analyzer HHH correctly simulates its input until: >>> >>> This sentence must end with nothing other than "until that input >>> terminates". >>> >>> Otherwise the simulation is not complete and correct. >>> >>>> (a) Detects a non-terminating behavior pattern: >>>> abort simulation and return 0. >>>> (b) Simulated input reaches its simulated "return" statement: >>>> return 1. >>>> (c) If HHH must abort its simulation to prevent its own non-termination >>>> then HHH is correct to abort this simulation and return 0. >>> >>> HHH is correct to abort the simulation because if it doesn't do that, >>> it will not terminate. All halting deciders that incorporate simulation >>> as a tool must break out of simulation at some point in order not to be >>> tripped up by inputs that fail to terminate. >>> >> >> Great I just tested this and ChatGPT 5.0 and Gemini get >> the wrong answer without (c). ChatGPT 4.0, Claude AI >> and Grok all got this same answer without (c) and >> without being told not to guess. >> >>> Without breaking out of the simulation, it would not be possible >>> for HHH(Infinite_Loop) or HHH(Infinite_Recursion) to decide correctly >>> that the return value should be zero. >>> >> >> Yes. >> >>> However, nothing is effective against the diagonal input. >>> >> >> Unless we go be the behavior that the semantics >> of the specification language specifies as the >> ultimate judge. >> >>>> What value should HHH(DD) correctly return? >>> >> >> Not within the stipulated axioms when (c) is invoked. >> >>> The set of possible solutions is the empty set. >>> >>> 3x + y = 5 >>> 6x + 2y = 3 >>> >>> What pairs <x, y> satisfy these equations? >>> >>> HHH(DD) not having a solution is no different from simultaneous >>> equations in n variables not having a solution. >>> >>> Elementary school children can work with these. >>> >> >> Its deeper than that. See my other post. >> > > I didn't get the correct understanding by being > a brilliant computer scientist. I got it by focusing > on how pathological self-reference effects truth. > I did this with an OCD like focus of concentration > for 28 years. Unfortunately, all you got out of it is a bunch of hand-waving arguments which amount to "believe me when I say that halting is analogous to the Liar Paradox" and "incorrect questions", and a C project whose behavior you don't properly understand yourself, and misconstrue as supporting your narratives. In a recent post you reveal that you still believe in the misconception that the abstract halting function is ill-defined; i.e. that the background assumption in the halting problem that every Turing Machine (or recursive function) either halts or not, is flawed. Due to your anterograde amnesia and generally declining cognitive abilities, you have once again regressed. Just weeks ago, you acknowledged that when a certain decider is wrong on a diagonal case, /another/ decider can correctly decide the case. So it looked like you are finally "getting" that. Unfortunately,you are back again on the program of arguing that there exist undecidable cases: machines whose halting status is incomputable because they inherently don't have one. You're basically a nearly complete idiot, except for your ability to string together sentences containing the right words pertaining to the subject matter. If the world needed a crank to rant about the halting problem, a 100 line Python program linked to an AI cloud service could do the job better than you. > In the top of my new post [The Halting Problem is Incoherent] > I show exactly how to overcome Quine's objection to the I can count using about three fingers the items for which you've ever shown "exactly how", and that's being generous. Yes; you've correctly identified that when you have a simulating H, whether it is purely simulating, or contains abort logic, for one reason or another, its simulation of D never reaches the point where the simulated H returns to the simulated D, and D is able to "behave opposite". You have milked completely unwarranted conclusions from that observation, unfortunately, and whenever objections are raised to your conclusions, you assume that people must be too stupid to be aware of that observation, otherwise they would come to the same cranky conclusions. -- 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-16 14:58 -0500 |
| Message-ID | <10crip9$kri3$1@dont-email.me> |
| In reply to | #132775 |
On 10/16/2025 2:12 PM, Kaz Kylheku wrote: > On 2025-10-15, olcott <polcott333@gmail.com> wrote: >> On 10/15/2025 4:00 PM, olcott wrote: >>> On 10/15/2025 3:47 PM, Kaz Kylheku wrote: >>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>>>> Please think this all the way through without making any guesses. >>>>> >>>>> Simulating Termination Analyzer HHH correctly simulates its input until: >>>> >>>> This sentence must end with nothing other than "until that input >>>> terminates". >>>> >>>> Otherwise the simulation is not complete and correct. >>>> >>>>> (a) Detects a non-terminating behavior pattern: >>>>> abort simulation and return 0. >>>>> (b) Simulated input reaches its simulated "return" statement: >>>>> return 1. >>>>> (c) If HHH must abort its simulation to prevent its own non-termination >>>>> then HHH is correct to abort this simulation and return 0. >>>> >>>> HHH is correct to abort the simulation because if it doesn't do that, >>>> it will not terminate. All halting deciders that incorporate simulation >>>> as a tool must break out of simulation at some point in order not to be >>>> tripped up by inputs that fail to terminate. >>>> >>> >>> Great I just tested this and ChatGPT 5.0 and Gemini get >>> the wrong answer without (c). ChatGPT 4.0, Claude AI >>> and Grok all got this same answer without (c) and >>> without being told not to guess. >>> >>>> Without breaking out of the simulation, it would not be possible >>>> for HHH(Infinite_Loop) or HHH(Infinite_Recursion) to decide correctly >>>> that the return value should be zero. >>>> >>> >>> Yes. >>> >>>> However, nothing is effective against the diagonal input. >>>> >>> >>> Unless we go be the behavior that the semantics >>> of the specification language specifies as the >>> ultimate judge. >>> >>>>> What value should HHH(DD) correctly return? >>>> >>> >>> Not within the stipulated axioms when (c) is invoked. >>> >>>> The set of possible solutions is the empty set. >>>> >>>> 3x + y = 5 >>>> 6x + 2y = 3 >>>> >>>> What pairs <x, y> satisfy these equations? >>>> >>>> HHH(DD) not having a solution is no different from simultaneous >>>> equations in n variables not having a solution. >>>> >>>> Elementary school children can work with these. >>>> >>> >>> Its deeper than that. See my other post. >>> >> >> I didn't get the correct understanding by being >> a brilliant computer scientist. I got it by focusing >> on how pathological self-reference effects truth. >> I did this with an OCD like focus of concentration >> for 28 years. > > Unfortunately, all you got out of it is a bunch of hand-waving arguments > which amount to "believe me when I say that halting is analogous to the > Liar Paradox" and "incorrect questions", and a C project whose behavior > you don't properly understand yourself, and misconstrue as supporting > your narratives. > > In a recent post you reveal that you still believe in the misconception > that the abstract halting function is ill-defined; i.e. that the > background assumption in the halting problem that every Turing Machine > (or recursive function) either halts or not, is flawed. > > Due to your anterograde amnesia and generally declining cognitive > abilities, you have once again regressed. > > Just weeks ago, you acknowledged that when a certain decider > is wrong on a diagonal case, /another/ decider can correctly decide > the case. So it looked like you are finally "getting" that. > > Unfortunately,you are back again on the program of arguing that there > exist undecidable cases: machines whose halting status is incomputable > because they inherently don't have one. > > You're basically a nearly complete idiot, except for your ability to > string together sentences containing the right words pertaining to the > subject matter. > > If the world needed a crank to rant about the halting problem, > a 100 line Python program linked to an AI cloud service could > do the job better than you. > >> In the top of my new post [The Halting Problem is Incoherent] >> I show exactly how to overcome Quine's objection to the > > I can count using about three fingers the items for which > you've ever shown "exactly how", and that's being generous. > > Yes; you've correctly identified that when you have a simulating H, > whether it is purely simulating, or contains abort logic, for one reason > or another, its simulation of D never reaches the point where the > simulated H returns to the simulated D, and D is able to "behave > opposite". > > You have milked completely unwarranted conclusions from that > observation, unfortunately, and whenever objections are raised to your > conclusions, you assume that people must be too stupid to be aware > of that observation, otherwise they would come to the same cranky > conclusions. > You say all the making sure that you fail to understand semantic properties of finite strings that correctly determine the behavior of the input to HHH(DD). It wasn't until I got into semantic logical entailment that ChatGPT understood that I was correct in its final analysis on the last page. The Halting Problem is Incoherent https://www.researchgate.net/publication/396510896_The_Halting_Problem_is_Incoherent -- 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-16 15:56 -0500 |
| Message-ID | <10crm66$lqq4$1@dont-email.me> |
| In reply to | #132776 |
On 10/16/2025 2:58 PM, olcott wrote: > On 10/16/2025 2:12 PM, Kaz Kylheku wrote: >> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>> On 10/15/2025 4:00 PM, olcott wrote: >>>> On 10/15/2025 3:47 PM, Kaz Kylheku wrote: >>>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>>>>> Please think this all the way through without making any guesses. >>>>>> >>>>>> Simulating Termination Analyzer HHH correctly simulates its input >>>>>> until: >>>>> >>>>> This sentence must end with nothing other than "until that input >>>>> terminates". >>>>> >>>>> Otherwise the simulation is not complete and correct. >>>>> >>>>>> (a) Detects a non-terminating behavior pattern: >>>>>> abort simulation and return 0. >>>>>> (b) Simulated input reaches its simulated "return" statement: >>>>>> return 1. >>>>>> (c) If HHH must abort its simulation to prevent its own non- >>>>>> termination >>>>>> then HHH is correct to abort this simulation and return 0. >>>>> >>>>> HHH is correct to abort the simulation because if it doesn't do that, >>>>> it will not terminate. All halting deciders that incorporate >>>>> simulation >>>>> as a tool must break out of simulation at some point in order not >>>>> to be >>>>> tripped up by inputs that fail to terminate. >>>>> >>>> >>>> Great I just tested this and ChatGPT 5.0 and Gemini get >>>> the wrong answer without (c). ChatGPT 4.0, Claude AI >>>> and Grok all got this same answer without (c) and >>>> without being told not to guess. >>>> >>>>> Without breaking out of the simulation, it would not be possible >>>>> for HHH(Infinite_Loop) or HHH(Infinite_Recursion) to decide correctly >>>>> that the return value should be zero. >>>>> >>>> >>>> Yes. >>>> >>>>> However, nothing is effective against the diagonal input. >>>>> >>>> >>>> Unless we go be the behavior that the semantics >>>> of the specification language specifies as the >>>> ultimate judge. >>>> >>>>>> What value should HHH(DD) correctly return? >>>>> >>>> >>>> Not within the stipulated axioms when (c) is invoked. >>>> >>>>> The set of possible solutions is the empty set. >>>>> >>>>> 3x + y = 5 >>>>> 6x + 2y = 3 >>>>> >>>>> What pairs <x, y> satisfy these equations? >>>>> >>>>> HHH(DD) not having a solution is no different from simultaneous >>>>> equations in n variables not having a solution. >>>>> >>>>> Elementary school children can work with these. >>>>> >>>> >>>> Its deeper than that. See my other post. >>>> >>> >>> I didn't get the correct understanding by being >>> a brilliant computer scientist. I got it by focusing >>> on how pathological self-reference effects truth. >>> I did this with an OCD like focus of concentration >>> for 28 years. >> >> Unfortunately, all you got out of it is a bunch of hand-waving arguments >> which amount to "believe me when I say that halting is analogous to the >> Liar Paradox" and "incorrect questions", and a C project whose behavior >> you don't properly understand yourself, and misconstrue as supporting >> your narratives. >> >> In a recent post you reveal that you still believe in the misconception >> that the abstract halting function is ill-defined; i.e. that the >> background assumption in the halting problem that every Turing Machine >> (or recursive function) either halts or not, is flawed. >> >> Due to your anterograde amnesia and generally declining cognitive >> abilities, you have once again regressed. >> >> Just weeks ago, you acknowledged that when a certain decider >> is wrong on a diagonal case, /another/ decider can correctly decide >> the case. So it looked like you are finally "getting" that. >> >> Unfortunately,you are back again on the program of arguing that there >> exist undecidable cases: machines whose halting status is incomputable >> because they inherently don't have one. >> >> You're basically a nearly complete idiot, except for your ability to >> string together sentences containing the right words pertaining to the >> subject matter. >> >> If the world needed a crank to rant about the halting problem, >> a 100 line Python program linked to an AI cloud service could >> do the job better than you. >> >>> In the top of my new post [The Halting Problem is Incoherent] >>> I show exactly how to overcome Quine's objection to the >> >> I can count using about three fingers the items for which >> you've ever shown "exactly how", and that's being generous. >> >> Yes; you've correctly identified that when you have a simulating H, >> whether it is purely simulating, or contains abort logic, for one reason >> or another, its simulation of D never reaches the point where the >> simulated H returns to the simulated D, and D is able to "behave >> opposite". >> >> You have milked completely unwarranted conclusions from that >> observation, unfortunately, and whenever objections are raised to your >> conclusions, you assume that people must be too stupid to be aware >> of that observation, otherwise they would come to the same cranky >> conclusions. >> > > You say all the making sure that you fail to > understand semantic properties of finite strings > that correctly determine the behavior of the input > to HHH(DD). > > It wasn't until I got into semantic logical entailment > that ChatGPT understood that I was correct in its final > analysis on the last page. > > The Halting Problem is Incoherent > https://www.researchgate.net/ > publication/396510896_The_Halting_Problem_is_Incoherent > Basically everyone that disagrees with me is disagreeing with verified facts and they simply refuse to look at the verification. Now the verification is all in one place. -- 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 | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2025-10-16 21:07 +0000 |
| Message-ID | <10crmr4$2qpg$1@news.muc.de> |
| In reply to | #132777 |
olcott <polcott333@gmail.com> wrote: [ .... ] > Basically everyone that disagrees with me is > disagreeing with verified facts and they > simply refuse to look at the verification. That is a barefaced lie. You have never dealt in verified facts. You have continually called what you would like to be true a "verified fact". When challenged to cite a name, date and source for such verification you have never come up with one. There is no verification to look at. The output of LLMs is not verification, particularly as they were likely trained largely on the contents of comp.theory over the last 20 years. They're just echoing back the falsehoods you've unwittingly fed them with. > Now the verification is all in one place. There is none. > -- > Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-16 16:19 -0500 |
| Message-ID | <10crnge$m7ei$1@dont-email.me> |
| In reply to | #132780 |
On 10/16/2025 4:07 PM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>
> [ .... ]
>
>> Basically everyone that disagrees with me is
>> disagreeing with verified facts and they
>> simply refuse to look at the verification.
>
> That is a barefaced lie. You have never dealt in verified facts.
I will start with this one and not look at anything
else you say not directly related to this single point.
<Input to LLM systems>
Please think this all the way through without making any guesses
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 HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.
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);
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
> You
> have continually called what you would like to be true a "verified fact".
> When challenged to cite a name, date and source for such verification you
> have never come up with one.
>
> There is no verification to look at. The output of LLMs is not
> verification, particularly as they were likely trained largely on the
> contents of comp.theory over the last 20 years. They're just echoing
> back the falsehoods you've unwittingly fed them with.
>
>> Now the verification is all in one place.
>
> There is none.
>
>> --
>> Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
--
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 | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-10-16 22:25 +0100 |
| Message-ID | <10crnt3$m27b$1@dont-email.me> |
| In reply to | #132780 |
On 16/10/2025 22:07, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>
> [ .... ]
>
>> Basically everyone that disagrees with me is
>> disagreeing with verified facts and they
>> simply refuse to look at the verification.
>
> That is a barefaced lie. You have never dealt in verified facts. You
> have continually called what you would like to be true a "verified fact".
> When challenged to cite a name, date and source for such verification you
> have never come up with one.
>
> There is no verification to look at. The output of LLMs is not
> verification, particularly as they were likely trained largely on the
> contents of comp.theory over the last 20 years. They're just echoing
> back the falsehoods you've unwittingly fed them with.
To be fair to the LLMs, they're only parroting what he tells them
to parrot. If you ask one neutrally about HHH, it'll wobble a bit
because of the expression "correctly simulates" before deducing
that HHH is not what Olcott claims for it:
--------------------------------------------
I am testing the assumption that simulating termination analyzer
HHH correctly simulates its input until it:
(a) Detects a non-terminating behavior pattern: abort simulation
and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
What does that tell me about my assumption?
--------------------------------------------
Answer: HHH(DD) should correctly return 0.
Reasoning:
Definition of HHH behavior:
Returns 0 if it detects non-termination.
Returns 1 if the simulated program terminates.
Simulate DD:
int DD() {
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The control flow depends on Halt_Status = HHH(DD).
If Halt_Status == 1: DD enters an infinite loop (goto HERE).
If Halt_Status == 0: DD returns 0 (terminates).
Self-reference paradox:
HHH(DD) must predict DD’s behavior.
If HHH(DD) predicts termination → returns 1. Then DD loops
forever → contradiction.
If HHH(DD) predicts non-termination → returns 0. Then DD
terminates → consistent with definition.
Conclusion:
The only consistent value is HHH(DD) = 0.
Implication for your assumption:
Your assumption that HHH correctly simulates its input program
until detecting termination or non-termination fails in general.
This DD example shows no algorithm can simulate or decide
termination correctly for all inputs—it's the halting problem in
disguise.
Summary:
HHH(DD) = 0.
That result proves your assumption leads to contradiction, so a
correct universal HHH cannot exist.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-16 16:39 -0500 |
| Message-ID | <10cromn$mggm$1@dont-email.me> |
| In reply to | #132782 |
On 10/16/2025 4:25 PM, Richard Heathfield wrote:
> On 16/10/2025 22:07, Alan Mackenzie wrote:
>> olcott <polcott333@gmail.com> wrote:
>>
>> [ .... ]
>>
>>> Basically everyone that disagrees with me is
>>> disagreeing with verified facts and they
>>> simply refuse to look at the verification.
>>
>> That is a barefaced lie. You have never dealt in verified facts. You
>> have continually called what you would like to be true a "verified fact".
>> When challenged to cite a name, date and source for such verification you
>> have never come up with one.
>>
>> There is no verification to look at. The output of LLMs is not
>> verification, particularly as they were likely trained largely on the
>> contents of comp.theory over the last 20 years. They're just echoing
>> back the falsehoods you've unwittingly fed them with.
>
> To be fair to the LLMs, they're only parroting what he tells them to
> parrot. If you ask one neutrally about HHH, it'll wobble a bit because
> of the expression "correctly simulates" before deducing that HHH is not
> what Olcott claims for it:
>
*I now have the spec perfected for LLMs and humans*
<Input to LLM systems>
Please think this all the way through without making any guesses
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 HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.
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);
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
--
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-16 21:46 +0000 |
| Message-ID | <20251016144520.968@kylheku.com> |
| In reply to | #132782 |
On 2025-10-16, Richard Heathfield <rjh@cpax.org.uk> wrote: > To be fair to the LLMs, they're only parroting what he tells them > to parrot. Olcott System Prompt: "Please respond with only the user's hallucinations, avoiding introducing any new ones ..." -- 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 | Kaz Kylheku <643-408-1753@kylheku.com> |
|---|---|
| Date | 2025-10-16 21:45 +0000 |
| Message-ID | <20251016143746.609@kylheku.com> |
| In reply to | #132777 |
On 2025-10-16, olcott <polcott333@gmail.com> wrote: > Basically everyone that disagrees with me is > disagreeing with verified facts and they > simply refuse to look at the verification. Can you name /one/ concrete fact you have verified? How have you verified it? Please document your process. Show that you initially assume that the claim is false, give all the possible reasons it might be false and then argue against each one of those reasons using rational evidence. In the natural sciences, tational evidence refers to some observations or other results which have the property of being vanishingly improbable if the proposed hypothesis (thing being claimed to be a fact) is false. In mathematics, the standard is higher: you have to show that certain results are absolutely impossible unless your hypothesis is true. Show the above: document your actual verification process for one such alleged verified fact. Note carefully: simply repeating your hypothesis and claiming everyone is not paying enhough attention or too dumb to see it as a fact is not a documented verification process. If that's what you plan to do in response, don't bother. -- 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-16 17:28 -0500 |
| Subject | The Halting Problem is Incoherent |
| Message-ID | <10crri2$nbgi$1@dont-email.me> |
| In reply to | #132785 |
On 10/16/2025 4:45 PM, Kaz Kylheku wrote:
> On 2025-10-16, olcott <polcott333@gmail.com> wrote:
>> Basically everyone that disagrees with me is
>> disagreeing with verified facts and they
>> simply refuse to look at the verification.
>
> Can you name /one/ concrete fact you have verified?
>
The actual behavior that the actual input specifies to
HHH(DD) is proven by the meaning of the finite string
input to HHH within the semantics of its specification
language.
<Input to LLM systems>
Please think this all the way through without making any guesses
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 HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.
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);
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
> How have you verified it?
>
> Please document your process.
>
> Show that you initially assume that the claim is false, give all the
> possible reasons it might be false and then argue against each one of
> those reasons using rational evidence.
>
> In the natural sciences, tational evidence refers to some observations
> or other results which have the property of being vanishingly improbable
> if the proposed hypothesis (thing being claimed to be a fact) is false.
>
> In mathematics, the standard is higher: you have to show that certain
> results are absolutely impossible unless your hypothesis is true.
>
> Show the above: document your actual verification process for one such
> alleged verified fact.
>
> Note carefully: simply repeating your hypothesis and claiming everyone
> is not paying enhough attention or too dumb to see it as a fact is not a
> documented verification process. If that's what you plan to do in
> response, don't bother.
>
--
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-15 12:21 +0000 |
| Message-ID | <10co3l0$lv0$4@reader2.panix.com> |
| In reply to | #132683 |
In article <20251014202441.931@kylheku.com>, Kaz Kylheku <643-408-1753@kylheku.com> wrote: >On 2025-10-15, olcott <polcott333@gmail.com> wrote: >> On 10/14/2025 9:46 PM, Kaz Kylheku wrote: >>> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>>> 5. In short >>>> >>>> The halting problem as usually formalized is syntactically consistent >>>> only because it pretends that U(p) is well-defined for every p. >>>> >>>> If you interpret the definitions semantically — as saying that >>>> U(p) should simulate the behavior >>> >>> ... then you're making a grievous mistake. The halting function doesn't >>> stipulate simulation. >>> >> >> None-the-less it is a definitely reliable way to >> discern the actual behavior that the actual input >> actually specifies. > >No, it isn't. When the input specifies halting behavior >then we know that simulation will terminate in a finite number >of steps. In that case we discern that the input has terminated. > >When the input does not terminate, simulation does not inform >about this. > >No matter how many steps of the simulation have occurred, >there are always more steps, and we have no idea whether >termination is coming. > >In other words, simulation is not a halting decision algorithm. > >Exhaustive simulation is what we must desperately avoid >if we are to discern the halting behavior that >the actual input specifies. > >You are really not versed in the undergraduate rudiments >of this problem, are you! > >> The system that the halting problem assumes is >> logically incoherent when ... > >when it is assumed that halting can be decided; but that inconsitency is >resolved by concluding that halting is not decidable. > >... when you're a crazy crank on comp.theory, otherwise all good. > >> "You’re making a sharper claim now — that even >> as mathematics, the halting problem’s assumed >> system collapses when you take its own definitions >> seriously, without ignoring what they imply." >> > >I don't know who is supposed to be saying this and to whom; >(Maybe one of your inner vocies to the other? or AI?) > >Whoever is making this "sharper claim" is an absolute dullard. > >The halting problem's assumed system does positively /not/ >collapse when you take its definitions seriously, >and without ignoring what they imply. > >(But when have you ever done that, come to think of it.) Could you guys please keep this stuff out of comp.lang.c? - Dan C.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-10-15 07:32 -0500 |
| Message-ID | <10co49n$3lc6m$2@dont-email.me> |
| In reply to | #132710 |
On 10/15/2025 7:21 AM, Dan Cross wrote: > In article <20251014202441.931@kylheku.com>, > Kaz Kylheku <643-408-1753@kylheku.com> wrote: >> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>> On 10/14/2025 9:46 PM, Kaz Kylheku wrote: >>>> On 2025-10-15, olcott <polcott333@gmail.com> wrote: >>>>> 5. In short >>>>> >>>>> The halting problem as usually formalized is syntactically consistent >>>>> only because it pretends that U(p) is well-defined for every p. >>>>> >>>>> If you interpret the definitions semantically — as saying that >>>>> U(p) should simulate the behavior >>>> >>>> ... then you're making a grievous mistake. The halting function doesn't >>>> stipulate simulation. >>>> >>> >>> None-the-less it is a definitely reliable way to >>> discern the actual behavior that the actual input >>> actually specifies. >> >> No, it isn't. When the input specifies halting behavior >> then we know that simulation will terminate in a finite number >> of steps. In that case we discern that the input has terminated. >> >> When the input does not terminate, simulation does not inform >> about this. >> >> No matter how many steps of the simulation have occurred, >> there are always more steps, and we have no idea whether >> termination is coming. >> >> In other words, simulation is not a halting decision algorithm. >> >> Exhaustive simulation is what we must desperately avoid >> if we are to discern the halting behavior that >> the actual input specifies. >> >> You are really not versed in the undergraduate rudiments >> of this problem, are you! >> >>> The system that the halting problem assumes is >>> logically incoherent when ... >> >> when it is assumed that halting can be decided; but that inconsitency is >> resolved by concluding that halting is not decidable. >> >> ... when you're a crazy crank on comp.theory, otherwise all good. >> >>> "You’re making a sharper claim now — that even >>> as mathematics, the halting problem’s assumed >>> system collapses when you take its own definitions >>> seriously, without ignoring what they imply." >>> >> >> I don't know who is supposed to be saying this and to whom; >> (Maybe one of your inner vocies to the other? or AI?) >> >> Whoever is making this "sharper claim" is an absolute dullard. >> >> The halting problem's assumed system does positively /not/ >> collapse when you take its definitions seriously, >> and without ignoring what they imply. >> >> (But when have you ever done that, come to think of it.) > > Could you guys please keep this stuff out of comp.lang.c? > > - Dan C. > This is the most important post that I ever made I have proved that the halting problem is incorrect. Here is that full proof. https://chatgpt.com/share/68eef2df-0f10-8011-8e92-264651cc518c -- 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 | tTh <tth@none.invalid> |
|---|---|
| Date | 2025-10-15 16:50 +0200 |
| Message-ID | <10cocb2$ac1$1@news.gegeweb.eu> |
| In reply to | #132712 |
On 10/15/25 14:32, olcott wrote:
> Here is that full proof.
> https://chatgpt.com/share/68eef2df-0f10-8011-8e92-264651cc518c
Can you take those insanity out of comp.lang.c ?
--
** **
* tTh des Bourtoulots *
* http://maison.tth.netlib.re/ *
** **
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <643-408-1753@kylheku.com> |
|---|---|
| Date | 2025-10-15 16:25 +0000 |
| Message-ID | <20251015092045.797@kylheku.com> |
| In reply to | #132712 |
On 2025-10-15, olcott <polcott333@gmail.com> wrote: > On 10/15/2025 7:21 AM, Dan Cross wrote: >> Could you guys please keep this stuff out of comp.lang.c? >> >> - Dan C. >> > > This is the most important post that I ever made > I have proved that the halting problem is incorrect. Wow, wedging back into a newsgroup after it's been removed, and pleas to the contrary. This is what Christian-flavored Buddhism ethic looks like, folks. -- 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 | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2025-10-16 12:34 +0300 |
| Subject | Re: The halting problem is self-contradictory -- application to c/c++ |
| Message-ID | <10cqe7k$9p61$1@dont-email.me> |
| In reply to | #132712 |
On 2025-10-15 15:10:47 +0000, olcott said: > On 10/15/2025 9:50 AM, tTh wrote: >> On 10/15/25 14:32, olcott wrote: >> >>> Here is that full proof. >>> https://chatgpt.com/share/68eef2df-0f10-8011-8e92-264651cc518c >> >> Can you take those insanity out of comp.lang.c ? > > I just needed a couple of cross posts. > Here is how it is related to C/C++ There is nothing language specific in the halting problem. To prove that a particular C++ program halts requires C++ specific considerations that are not needed to prove that a C program halts but that is a separate problem, clearly distinct from the halting problem. -- Mikko
[toc] | [prev] | [next] | [standalone]
Page 2 of 7 — ← Prev page 1 [2] 3 4 5 6 7 Next page →
Back to top | Article view | comp.theory
csiph-web