Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.math > #640762 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2025-11-14 09:00 -0600 |
| Last post | 2025-11-28 11:01 -0500 |
| Articles | 20 on this page of 81 — 7 participants |
Back to article view | Back to sci.math
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-14 09:00 -0600
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-17 07:31 -0600
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-17 07:31 -0600
Re: The halting problem is incorrect two different ways Mikko <mikko.levanto@iki.fi> - 2025-11-26 12:01 +0200
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 09:17 -0600
Re: The halting problem is incorrect two different ways Richard Damon <Richard@Damon-Family.org> - 2025-11-26 10:29 -0500
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-26 18:35 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 13:55 -0600
Re: The halting problem is incorrect two different ways dbush <dbush.mobile@gmail.com> - 2025-11-26 14:58 -0500
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-26 21:47 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 15:53 -0600
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-26 22:19 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 16:48 -0600
Re: The halting problem is incorrect two different ways dbush <dbush.mobile@gmail.com> - 2025-11-26 18:00 -0500
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-26 23:55 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 18:20 -0600
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 00:39 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 18:51 -0600
Re: The halting problem is incorrect two different ways dbush <dbush.mobile@gmail.com> - 2025-11-26 20:02 -0500
Re: The halting problem is incorrect two different ways Python <python@cccp.invalid> - 2025-11-27 01:24 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 19:42 -0600
Re: The halting problem is incorrect two different ways Python <python@cccp.invalid> - 2025-11-27 02:00 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 20:37 -0600
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 04:15 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 22:31 -0600
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 06:51 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-27 08:59 -0600
Re: The halting problem is incorrect two different ways Richard Damon <Richard@Damon-Family.org> - 2025-11-27 10:16 -0500
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 18:17 +0000
Re: The halting problem is incorrect two different ways Richard Damon <Richard@Damon-Family.org> - 2025-11-27 07:41 -0500
Re: The halting problem is incorrect two different ways Richard Damon <Richard@Damon-Family.org> - 2025-11-27 07:40 -0500
Re: The halting problem is incorrect two different ways "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-26 23:00 -0800
Re: The halting problem is incorrect two different ways Python <python@cccp.invalid> - 2025-11-27 01:39 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 19:47 -0600
Re: The halting problem is incorrect two different ways Python <python@cccp.invalid> - 2025-11-27 01:59 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 20:26 -0600
Re: The halting problem is incorrect two different ways Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 04:19 +0000
Re: The halting problem is incorrect two different ways olcott <polcott333@gmail.com> - 2025-11-26 22:39 -0600
Re: The halting problem is incorrect two different ways Mikko <mikko.levanto@iki.fi> - 2025-11-27 09:49 +0200
Re: The halting problem is incorrect two different ways "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-26 23:58 -0800
Re: The halting problem is incorrect two different ways Mikko <mikko.levanto@iki.fi> - 2025-11-28 10:14 +0200
The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-11-28 08:46 -0600
Re: The halting problem is incorrect two different ways --- updated Richard Damon <Richard@Damon-Family.org> - 2025-11-28 10:59 -0500
Re: The halting problem is incorrect two different ways --- updated Mikko <mikko.levanto@iki.fi> - 2025-11-29 11:27 +0200
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-11-29 10:38 -0600
Re: The halting problem is incorrect two different ways --- updated Richard Damon <Richard@Damon-Family.org> - 2025-11-29 14:58 -0500
Re: The halting problem is incorrect two different ways --- updated Mikko <mikko.levanto@iki.fi> - 2025-12-01 12:45 +0200
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 06:47 -0600
Re: The halting problem is incorrect two different ways --- updated Python <python@cccp.invalid> - 2025-12-01 14:29 +0000
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 08:38 -0600
Re: The halting problem is incorrect two different ways --- updated Python <python@cccp.invalid> - 2025-12-01 14:45 +0000
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 08:57 -0600
Re: The halting problem is incorrect two different ways --- updated Python <python@cccp.invalid> - 2025-12-01 15:06 +0000
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 09:19 -0600
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 09:26 -0600
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 09:29 -0600
Re: The halting problem is incorrect two different ways --- updated Python <python@cccp.invalid> - 2025-12-01 15:31 +0000
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 09:39 -0600
Re: The halting problem is incorrect two different ways --- updated Python <python@cccp.invalid> - 2025-12-01 15:48 +0000
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 09:55 -0600
Re: The halting problem is incorrect two different ways --- updated Python <python@cccp.invalid> - 2025-12-01 16:00 +0000
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-01 10:27 -0600
Re: The halting problem is incorrect two different ways --- updated "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-12-01 16:41 -0800
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-03 18:24 -0600
Olcott is provably correct --- no one can correctly refute this olcott <polcott333@gmail.com> - 2025-12-03 19:54 -0600
Re: The halting problem is incorrect two different ways --- updated Mikko <mikko.levanto@iki.fi> - 2025-12-02 11:07 +0200
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-02 08:14 -0600
Re: The halting problem is incorrect two different ways --- updated Mikko <mikko.levanto@iki.fi> - 2025-12-03 13:34 +0200
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-03 10:27 -0600
Re: The halting problem is incorrect two different ways --- updated Mikko <mikko.levanto@iki.fi> - 2025-12-04 11:17 +0200
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-04 08:15 -0600
Re: The halting problem is incorrect two different ways --- updated Mikko <mikko.levanto@iki.fi> - 2025-12-06 11:23 +0200
Re: The halting problem is incorrect two different ways --- updated olcott <polcott333@gmail.com> - 2025-12-06 06:47 -0600
Re: The halting problem is incorrect two different ways --- updated Richard Damon <Richard@Damon-Family.org> - 2025-12-06 17:26 -0500
Re: The halting problem is incorrect two different ways --- faking ignorance olcott <polcott333@gmail.com> - 2025-11-27 09:21 -0600
Re: The halting problem is incorrect two different ways --- faking ignorance Richard Damon <Richard@Damon-Family.org> - 2025-11-27 10:40 -0500
Re: The halting problem is incorrect two different ways --- faking ignorance Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 18:37 +0000
Re: The halting problem is incorrect two different ways --- faking ignorance Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-27 18:24 +0000
Re: The halting problem is incorrect two different ways --- faking ignorance Mikko <mikko.levanto@iki.fi> - 2025-11-28 10:18 +0200
Re: The halting problem is incorrect two different ways --- faking ignorance olcott <polcott333@gmail.com> - 2025-11-28 08:52 -0600
Re: The halting problem is incorrect two different ways --- faking ignorance Richard Damon <Richard@Damon-Family.org> - 2025-11-28 11:01 -0500
Page 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2025-11-28 10:14 +0200 |
| Message-ID | <10gbll0$271gk$1@dont-email.me> |
| In reply to | #641299 |
Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
> On 11/26/2025 11:49 PM, Mikko wrote:
>> olcott kirjoitti 26.11.2025 klo 17.17:
>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>
>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and irrelevanto
>>>>>>>>>>>>>>>>>>>>>>>>>> to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>> But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an incorrect
>>>>>>>>>>>>>>>>>>>> answer is not even
>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate H(D),
>>>>>>>>>>>>>>>>>>>> either simultating
>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from H(D)
>>>>>>>>>>>>>>>>>>>> with the same
>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed, or
>>>>>>>>>>>>>>>>>>>> do whatever H would
>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies. According to
>>>>>>>>>>>>>>>>>> C semantics
>>>>>>>>>>>>>>>>>> any other behavour that produces the same result is
>>>>>>>>>>>>>>>>>> equally valid.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never being
>>>>>>>>>>>>>>>>>>> able to complete its first statement before calling H(D)
>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If that happens then H does not return and therefore
>>>>>>>>>>>>>>>>>> is not a decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That seems to confirm that the definition of "decider" is
>>>>>>>>>>>>>> over your head.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>
>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>> termination
>>>>>>>>>>>> analyzer". Instead the termination problem is to determine
>>>>>>>>>>>> whether
>>>>>>>>>>>> a program terminates every time when used as it was designed
>>>>>>>>>>>> to be
>>>>>>>>>>>> used.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>
>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>> asked about.
>>>>>>>>>
>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>> the behavior that it is asked about.
>>>>>>>>
>>>>>>>> No, it is not. The solution to the halting problem must include the
>>>>>>>> necessary access. Conversely, a proof that the necessary access is
>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>> unsolvable.
>>>>>>>
>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>> main requires HHH to report on information
>>>>>>> that is not contained in its input thus it is
>>>>>>> incorrect to require HHH to report on that.
>>>>>>
>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>> decider.
>>>>>>
>>>>>
>>>>> That HHH fails to meet the requirements by itself does
>>>>> not mean that the requirements are wrong.
>>>>>
>>>>> Turing machine deciders only compute a mapping from
>>>>> their [finite string] inputs to an accept or reject
>>>>> state on the basis that this [finite string] input
>>>>> specifies or fails to specify a semantic or syntactic
>>>>> property.
>>>>>
>>>>> That the information that HHH is required to report
>>>>> on simply is not contained in its input is what makes
>>>>> the requirements wrong.
>>>>
>>>> No, it merely means that the designer ot HHH has failed to specify the
>>>> encoding rules so that the input contains the full specification of the
>>>> behaviour.
>>
>>> In other words you are trying to get away with
>>> disagreeing with the semantics of the x86 language
>>> or the semantics of the C programing language.
>>
>> You are the one who disagrees with the x86 processors about the x86
>> language semantics. When an x86 processor executes a program it executes
>> according to the x86 semantics. When DD is executed according to the x86
>> semantics it halts. Anybody who says that DD specifies a non-halting
>> behaviour disagrees with the x86 semantics.
> But, DD can halt or not halt, right?
When Olcott uses the name DD he means the particular program in his
GitHub repository except when he wants to deceive with equivocation.
The DD is Olcotts repository halts.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-11-28 08:46 -0600 |
| Subject | The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gccjf$2g9ua$1@dont-email.me> |
| In reply to | #641327 |
On 11/28/2025 2:14 AM, Mikko wrote:
> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>> On 11/26/2025 11:49 PM, Mikko wrote:
>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>
>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and irrelevanto
>>>>>>>>>>>>>>>>>>>>>>>>>>> to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>> But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an incorrect
>>>>>>>>>>>>>>>>>>>>> answer is not even
>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate H(D),
>>>>>>>>>>>>>>>>>>>>> either simultating
>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed, or
>>>>>>>>>>>>>>>>>>>>> do whatever H would
>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies. According
>>>>>>>>>>>>>>>>>>> to C semantics
>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result is
>>>>>>>>>>>>>>>>>>> equally valid.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never being
>>>>>>>>>>>>>>>>>>>> able to complete its first statement before calling
>>>>>>>>>>>>>>>>>>>> H(D)
>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If that happens then H does not return and therefore
>>>>>>>>>>>>>>>>>>> is not a decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That seems to confirm that the definition of "decider" is
>>>>>>>>>>>>>>> over your head.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>> termination
>>>>>>>>>>>>> analyzer". Instead the termination problem is to determine
>>>>>>>>>>>>> whether
>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>> used.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>
>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>> asked about.
>>>>>>>>>>
>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>
>>>>>>>>> No, it is not. The solution to the halting problem must include
>>>>>>>>> the
>>>>>>>>> necessary access. Conversely, a proof that the necessary access is
>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>> unsolvable.
>>>>>>>>
>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>> main requires HHH to report on information
>>>>>>>> that is not contained in its input thus it is
>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>
>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>> decider.
>>>>>>>
>>>>>>
>>>>>> That HHH fails to meet the requirements by itself does
>>>>>> not mean that the requirements are wrong.
>>>>>>
>>>>>> Turing machine deciders only compute a mapping from
>>>>>> their [finite string] inputs to an accept or reject
>>>>>> state on the basis that this [finite string] input
>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>> property.
>>>>>>
>>>>>> That the information that HHH is required to report
>>>>>> on simply is not contained in its input is what makes
>>>>>> the requirements wrong.
>>>>>
>>>>> No, it merely means that the designer ot HHH has failed to specify the
>>>>> encoding rules so that the input contains the full specification of
>>>>> the
>>>>> behaviour.
>>>
>>>> In other words you are trying to get away with
>>>> disagreeing with the semantics of the x86 language
>>>> or the semantics of the C programing language.
>>>
>>> You are the one who disagrees with the x86 processors about the x86
>>> language semantics. When an x86 processor executes a program it executes
>>> according to the x86 semantics. When DD is executed according to the x86
>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>> behaviour disagrees with the x86 semantics.
>
>> But, DD can halt or not halt, right?
>
> When Olcott uses the name DD he means the particular program in his
> GitHub repository except when he wants to deceive with equivocation.
> The DD is Olcotts repository halts.
>
I am doing this in the C programming language so that
every detail can be concretely specified and thus no
important details are simply abstracted away.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH on line 1081
DD on line 1355
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);
}
That DD simulated by HHH never stops running
unless aborted by HHH proves that the input
to HHH(DD) specifies non halting behavior.
Saying that that some other DD somewhere else
does stop as a rebuttal is only the strawman error.
A straw man fallacy (sometimes written as strawman)
is the informal fallacy of refuting an argument
different from the one actually under discussion,
while not recognizing or acknowledging the distinction.
https://en.wikipedia.org/wiki/Straw_man
When the halting problem requires HHH to report
on the behavior of the DD executed from main()
this is erroneous:
(1) The caller of a function is never an argument to
this same function.
(2) The halting problem is requiring a halt decider
to report on behavior that is different that the behavior
specified by its input.
My work on the halting problem is only an aspect of
my project to make “true on the basis of meaning
expressed in language” reliably computable.
--
Copyright 2025 Olcott
My 28 year goal has been to make
"true on the basis of meaning" computable.
This required establishing a new foundation
for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2025-11-28 10:59 -0500 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <QFjWQ.87603$pEH7.46968@fx18.iad> |
| In reply to | #641342 |
On 11/28/25 9:46 AM, olcott wrote:
> On 11/28/2025 2:14 AM, Mikko wrote:
>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>>> On 11/26/2025 11:49 PM, Mikko wrote:
>>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and irrelevanto
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>> But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an incorrect
>>>>>>>>>>>>>>>>>>>>>> answer is not even
>>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate H(D),
>>>>>>>>>>>>>>>>>>>>>> either simultating
>>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed,
>>>>>>>>>>>>>>>>>>>>>> or do whatever H would
>>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies. According
>>>>>>>>>>>>>>>>>>>> to C semantics
>>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result is
>>>>>>>>>>>>>>>>>>>> equally valid.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never being
>>>>>>>>>>>>>>>>>>>>> able to complete its first statement before calling
>>>>>>>>>>>>>>>>>>>>> H(D)
>>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If that happens then H does not return and therefore
>>>>>>>>>>>>>>>>>>>> is not a decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That seems to confirm that the definition of "decider"
>>>>>>>>>>>>>>>> is over your head.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>>> termination
>>>>>>>>>>>>>> analyzer". Instead the termination problem is to determine
>>>>>>>>>>>>>> whether
>>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>>> used.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>>
>>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>>> asked about.
>>>>>>>>>>>
>>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>>
>>>>>>>>>> No, it is not. The solution to the halting problem must
>>>>>>>>>> include the
>>>>>>>>>> necessary access. Conversely, a proof that the necessary
>>>>>>>>>> access is
>>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>>> unsolvable.
>>>>>>>>>
>>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>>> main requires HHH to report on information
>>>>>>>>> that is not contained in its input thus it is
>>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>>
>>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>>> decider.
>>>>>>>>
>>>>>>>
>>>>>>> That HHH fails to meet the requirements by itself does
>>>>>>> not mean that the requirements are wrong.
>>>>>>>
>>>>>>> Turing machine deciders only compute a mapping from
>>>>>>> their [finite string] inputs to an accept or reject
>>>>>>> state on the basis that this [finite string] input
>>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>>> property.
>>>>>>>
>>>>>>> That the information that HHH is required to report
>>>>>>> on simply is not contained in its input is what makes
>>>>>>> the requirements wrong.
>>>>>>
>>>>>> No, it merely means that the designer ot HHH has failed to specify
>>>>>> the
>>>>>> encoding rules so that the input contains the full specification
>>>>>> of the
>>>>>> behaviour.
>>>>
>>>>> In other words you are trying to get away with
>>>>> disagreeing with the semantics of the x86 language
>>>>> or the semantics of the C programing language.
>>>>
>>>> You are the one who disagrees with the x86 processors about the x86
>>>> language semantics. When an x86 processor executes a program it
>>>> executes
>>>> according to the x86 semantics. When DD is executed according to the
>>>> x86
>>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>>> behaviour disagrees with the x86 semantics.
>>
>>> But, DD can halt or not halt, right?
>>
>> When Olcott uses the name DD he means the particular program in his
>> GitHub repository except when he wants to deceive with equivocation.
>> The DD is Olcotts repository halts.
>>
>
>
> I am doing this in the C programming language so that
> every detail can be concretely specified and thus no
> important details are simply abstracted away.
But then ignore that you try to talk about HHH not being a specific C
program, which means that DD isn't either.
C function DD only has C defined behavior when HHH is fully and
precisely specified to C, which means it either simulates its input
forever, OR it decides to abort and return 0, it can't be both.
>
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
> HHH on line 1081
Which thus *ALWAYS* will abort its simulation of DD, and thus the
concept of it not doing so is just a LIE, and unsound logic.
> DD on line 1355
>
> 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);
> }
>
> That DD simulated by HHH never stops running
> unless aborted by HHH proves that the input
> to HHH(DD) specifies non halting behavior.
No, becauses there is no such thing in this case of an HHH that doesn't
abort its simulation
>
> Saying that that some other DD somewhere else
> does stop as a rebuttal is only the strawman error.
No, you saying that some other DD that calls some other HHH that doesn't
abort is the same as this DD is your strawman error.
>
> A straw man fallacy (sometimes written as strawman)
> is the informal fallacy of refuting an argument
> different from the one actually under discussion,
> while not recognizing or acknowledging the distinction.
> https://en.wikipedia.org/wiki/Straw_man
Right, and talking about an HHH that doesn't abort, when HHH does abort
is a strawman.
>
> When the halting problem requires HHH to report
> on the behavior of the DD executed from main()
> this is erroneous:
Nope, talking about a non-program DD that calls whatever HHH is looking
at it is just a strawman.
>
> (1) The caller of a function is never an argument to
> this same function.
Sure it can be.
>
> (2) The halting problem is requiring a halt decider
> to report on behavior that is different that the behavior
> specified by its input.
No, since the "behavior specified by the input" is the behavior of the
direct execution of the program it represents.
The error is you buggy program can't figure out that behavior, as
assumes it doesn't do what it does.
>
> My work on the halting problem is only an aspect of
> my project to make “true on the basis of meaning
> expressed in language” reliably computable.
>
Which, since you show that you don't consider words to have their actual
meaning, just shows that you are just a liar, and stupid.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2025-11-29 11:27 +0200 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10geea6$37qig$1@dont-email.me> |
| In reply to | #641342 |
olcott kirjoitti 28.11.2025 klo 16.46:
> On 11/28/2025 2:14 AM, Mikko wrote:
>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>>> On 11/26/2025 11:49 PM, Mikko wrote:
>>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and irrelevanto
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>> But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an incorrect
>>>>>>>>>>>>>>>>>>>>>> answer is not even
>>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate H(D),
>>>>>>>>>>>>>>>>>>>>>> either simultating
>>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed,
>>>>>>>>>>>>>>>>>>>>>> or do whatever H would
>>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies. According
>>>>>>>>>>>>>>>>>>>> to C semantics
>>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result is
>>>>>>>>>>>>>>>>>>>> equally valid.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never being
>>>>>>>>>>>>>>>>>>>>> able to complete its first statement before calling
>>>>>>>>>>>>>>>>>>>>> H(D)
>>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If that happens then H does not return and therefore
>>>>>>>>>>>>>>>>>>>> is not a decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That seems to confirm that the definition of "decider"
>>>>>>>>>>>>>>>> is over your head.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>>> termination
>>>>>>>>>>>>>> analyzer". Instead the termination problem is to determine
>>>>>>>>>>>>>> whether
>>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>>> used.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>>
>>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>>> asked about.
>>>>>>>>>>>
>>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>>
>>>>>>>>>> No, it is not. The solution to the halting problem must
>>>>>>>>>> include the
>>>>>>>>>> necessary access. Conversely, a proof that the necessary
>>>>>>>>>> access is
>>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>>> unsolvable.
>>>>>>>>>
>>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>>> main requires HHH to report on information
>>>>>>>>> that is not contained in its input thus it is
>>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>>
>>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>>> decider.
>>>>>>>>
>>>>>>>
>>>>>>> That HHH fails to meet the requirements by itself does
>>>>>>> not mean that the requirements are wrong.
>>>>>>>
>>>>>>> Turing machine deciders only compute a mapping from
>>>>>>> their [finite string] inputs to an accept or reject
>>>>>>> state on the basis that this [finite string] input
>>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>>> property.
>>>>>>>
>>>>>>> That the information that HHH is required to report
>>>>>>> on simply is not contained in its input is what makes
>>>>>>> the requirements wrong.
>>>>>>
>>>>>> No, it merely means that the designer ot HHH has failed to specify
>>>>>> the
>>>>>> encoding rules so that the input contains the full specification
>>>>>> of the
>>>>>> behaviour.
>>>>
>>>>> In other words you are trying to get away with
>>>>> disagreeing with the semantics of the x86 language
>>>>> or the semantics of the C programing language.
>>>>
>>>> You are the one who disagrees with the x86 processors about the x86
>>>> language semantics. When an x86 processor executes a program it
>>>> executes
>>>> according to the x86 semantics. When DD is executed according to the
>>>> x86
>>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>>> behaviour disagrees with the x86 semantics.
>>
>>> But, DD can halt or not halt, right?
>>
>> When Olcott uses the name DD he means the particular program in his
>> GitHub repository except when he wants to deceive with equivocation.
>> The DD is Olcotts repository halts.
> I am doing this in the C programming language so that
> every detail can be concretely specified and thus no
> important details are simply abstracted away.
>
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
> HHH on line 1081
> DD on line 1355
The DD on line 1355 is the DD I mentioned above and whicn is listed
below. HHH always means the HHH on line 1081 except when otherwise
stated. HHH(DD) means the HHH on line 1081 is called with the pointer
to the DD on line 1355 as the argument. THat call returns 0, which
means that DD does not halt.
> typedef int (*ptr)();
> int HHH(ptr P);
>
> int DD()
> {
> int Halt_Status = HHH(DD);
here Halt_Status is 0
> if (Halt_Status)
the next line is not executed because Halt_Status == 0
> HERE: goto HERE;
the next line is executed because Halt_Status == 0
> return Halt_Status;
> }
So DD halts.
> int main()
> {
> HHH(DD);
> }
This program shows that HHH halts but does not show what it returns.
However, if its execution is traced the trace confirms what I said.
> That DD simulated by HHH never stops running
> unless aborted by HHH proves that the input
> to HHH(DD) specifies non halting behavior.
If that DD simulated by HHH is anything other than the DD discussed
above and found to be halting you are trying to deceive with
equivocation.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-11-29 10:38 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gf7i4$3hehl$1@dont-email.me> |
| In reply to | #641387 |
On 11/29/2025 3:27 AM, Mikko wrote:
> olcott kirjoitti 28.11.2025 klo 16.46:
>> On 11/28/2025 2:14 AM, Mikko wrote:
>>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>>>> On 11/26/2025 11:49 PM, Mikko wrote:
>>>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevanto to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in
>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory. But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an incorrect
>>>>>>>>>>>>>>>>>>>>>>> answer is not even
>>>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate
>>>>>>>>>>>>>>>>>>>>>>> H(D), either simultating
>>>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed,
>>>>>>>>>>>>>>>>>>>>>>> or do whatever H would
>>>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies. According
>>>>>>>>>>>>>>>>>>>>> to C semantics
>>>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result is
>>>>>>>>>>>>>>>>>>>>> equally valid.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never
>>>>>>>>>>>>>>>>>>>>>> being
>>>>>>>>>>>>>>>>>>>>>> able to complete its first statement before
>>>>>>>>>>>>>>>>>>>>>> calling H(D)
>>>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If that happens then H does not return and
>>>>>>>>>>>>>>>>>>>>> therefore is not a decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That seems to confirm that the definition of "decider"
>>>>>>>>>>>>>>>>> is over your head.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>>>> termination
>>>>>>>>>>>>>>> analyzer". Instead the termination problem is to
>>>>>>>>>>>>>>> determine whether
>>>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>>>> used.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>>>> asked about.
>>>>>>>>>>>>
>>>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>>>
>>>>>>>>>>> No, it is not. The solution to the halting problem must
>>>>>>>>>>> include the
>>>>>>>>>>> necessary access. Conversely, a proof that the necessary
>>>>>>>>>>> access is
>>>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>>>> unsolvable.
>>>>>>>>>>
>>>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>>>> main requires HHH to report on information
>>>>>>>>>> that is not contained in its input thus it is
>>>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>>>
>>>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>>>> decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That HHH fails to meet the requirements by itself does
>>>>>>>> not mean that the requirements are wrong.
>>>>>>>>
>>>>>>>> Turing machine deciders only compute a mapping from
>>>>>>>> their [finite string] inputs to an accept or reject
>>>>>>>> state on the basis that this [finite string] input
>>>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>>>> property.
>>>>>>>>
>>>>>>>> That the information that HHH is required to report
>>>>>>>> on simply is not contained in its input is what makes
>>>>>>>> the requirements wrong.
>>>>>>>
>>>>>>> No, it merely means that the designer ot HHH has failed to
>>>>>>> specify the
>>>>>>> encoding rules so that the input contains the full specification
>>>>>>> of the
>>>>>>> behaviour.
>>>>>
>>>>>> In other words you are trying to get away with
>>>>>> disagreeing with the semantics of the x86 language
>>>>>> or the semantics of the C programing language.
>>>>>
>>>>> You are the one who disagrees with the x86 processors about the x86
>>>>> language semantics. When an x86 processor executes a program it
>>>>> executes
>>>>> according to the x86 semantics. When DD is executed according to
>>>>> the x86
>>>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>>>> behaviour disagrees with the x86 semantics.
>>>
>>>> But, DD can halt or not halt, right?
>>>
>>> When Olcott uses the name DD he means the particular program in his
>>> GitHub repository except when he wants to deceive with equivocation.
>>> The DD is Olcotts repository halts.
>
>> I am doing this in the C programming language so that
>> every detail can be concretely specified and thus no
>> important details are simply abstracted away.
>>
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>> HHH on line 1081
>> DD on line 1355
>
> The DD on line 1355 is the DD I mentioned above and whicn is listed
> below. HHH always means the HHH on line 1081 except when otherwise
> stated. HHH(DD) means the HHH on line 1081 is called with the pointer
> to the DD on line 1355 as the argument. THat call returns 0, which
> means that DD does not halt.
>
HHH(DD)==0 has nothing to do with DD executed from main.
The DD executed from main is the caller of HHH(DD) thus
cannot as be one-and-the-same-thing as an argument to HHH.
If you think so then you knowledge of C is abysmal.
The input to HHH(DD) specifies a non-halting sequence.
--
Copyright 2025 Olcott
My 28 year goal has been to make
"true on the basis of meaning" computable.
This required establishing a new foundation
for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2025-11-29 14:58 -0500 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <mfIWQ.43764$zoq5.21751@fx42.iad> |
| In reply to | #641407 |
On 11/29/25 11:38 AM, olcott wrote:
> On 11/29/2025 3:27 AM, Mikko wrote:
>> olcott kirjoitti 28.11.2025 klo 16.46:
>>> On 11/28/2025 2:14 AM, Mikko wrote:
>>>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>>>>> On 11/26/2025 11:49 PM, Mikko wrote:
>>>>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevanto to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in
>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory. But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an
>>>>>>>>>>>>>>>>>>>>>>>> incorrect answer is not even
>>>>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate
>>>>>>>>>>>>>>>>>>>>>>>> H(D), either simultating
>>>>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed,
>>>>>>>>>>>>>>>>>>>>>>>> or do whatever H would
>>>>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D
>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies.
>>>>>>>>>>>>>>>>>>>>>> According to C semantics
>>>>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result
>>>>>>>>>>>>>>>>>>>>>> is equally valid.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never
>>>>>>>>>>>>>>>>>>>>>>> being
>>>>>>>>>>>>>>>>>>>>>>> able to complete its first statement before
>>>>>>>>>>>>>>>>>>>>>>> calling H(D)
>>>>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If that happens then H does not return and
>>>>>>>>>>>>>>>>>>>>>> therefore is not a decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That seems to confirm that the definition of "decider"
>>>>>>>>>>>>>>>>>> is over your head.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>>>>> termination
>>>>>>>>>>>>>>>> analyzer". Instead the termination problem is to
>>>>>>>>>>>>>>>> determine whether
>>>>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>>>>> used.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>>>>> asked about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>>>>
>>>>>>>>>>>> No, it is not. The solution to the halting problem must
>>>>>>>>>>>> include the
>>>>>>>>>>>> necessary access. Conversely, a proof that the necessary
>>>>>>>>>>>> access is
>>>>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>>>>> unsolvable.
>>>>>>>>>>>
>>>>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>>>>> main requires HHH to report on information
>>>>>>>>>>> that is not contained in its input thus it is
>>>>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>>>>
>>>>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>>>>> decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That HHH fails to meet the requirements by itself does
>>>>>>>>> not mean that the requirements are wrong.
>>>>>>>>>
>>>>>>>>> Turing machine deciders only compute a mapping from
>>>>>>>>> their [finite string] inputs to an accept or reject
>>>>>>>>> state on the basis that this [finite string] input
>>>>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>>>>> property.
>>>>>>>>>
>>>>>>>>> That the information that HHH is required to report
>>>>>>>>> on simply is not contained in its input is what makes
>>>>>>>>> the requirements wrong.
>>>>>>>>
>>>>>>>> No, it merely means that the designer ot HHH has failed to
>>>>>>>> specify the
>>>>>>>> encoding rules so that the input contains the full specification
>>>>>>>> of the
>>>>>>>> behaviour.
>>>>>>
>>>>>>> In other words you are trying to get away with
>>>>>>> disagreeing with the semantics of the x86 language
>>>>>>> or the semantics of the C programing language.
>>>>>>
>>>>>> You are the one who disagrees with the x86 processors about the x86
>>>>>> language semantics. When an x86 processor executes a program it
>>>>>> executes
>>>>>> according to the x86 semantics. When DD is executed according to
>>>>>> the x86
>>>>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>>>>> behaviour disagrees with the x86 semantics.
>>>>
>>>>> But, DD can halt or not halt, right?
>>>>
>>>> When Olcott uses the name DD he means the particular program in his
>>>> GitHub repository except when he wants to deceive with equivocation.
>>>> The DD is Olcotts repository halts.
>>
>>> I am doing this in the C programming language so that
>>> every detail can be concretely specified and thus no
>>> important details are simply abstracted away.
>>>
>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>> HHH on line 1081
>>> DD on line 1355
>>
>> The DD on line 1355 is the DD I mentioned above and whicn is listed
>> below. HHH always means the HHH on line 1081 except when otherwise
>> stated. HHH(DD) means the HHH on line 1081 is called with the pointer
>> to the DD on line 1355 as the argument. THat call returns 0, which
>> means that DD does not halt.
>>
>
> HHH(DD)==0 has nothing to do with DD executed from main.
Sure it does, as as DD executed from main calls HHH(DD) which return 0.
>
> The DD executed from main is the caller of HHH(DD) thus
> cannot as be one-and-the-same-thing as an argument to HHH.
> If you think so then you knowledge of C is abysmal.
Right, and that is the DD that is being asked about.
>
> The input to HHH(DD) specifies a non-halting sequence.
>
No it doesn't, unless you are lying that HHH is a halt decioder.
A Halt Decider is given the representation of a program, and it is
supposed to determine if that program, when directly run, will halt.
Thus, if the parameter DD to HHH doesn't represent the DD called by
main, you are just admitting that you have just been lying for all these
years.
Perhaps because you are just so stupid you can't understand what the
words mean, and so stuck in your error that you refuse to listen when
people try to correct you, which make you the worse kind of stupid.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2025-12-01 12:45 +0200 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gjrjd$181h8$1@dont-email.me> |
| In reply to | #641407 |
olcott kirjoitti 29.11.2025 klo 18.38:
> On 11/29/2025 3:27 AM, Mikko wrote:
>> olcott kirjoitti 28.11.2025 klo 16.46:
>>> On 11/28/2025 2:14 AM, Mikko wrote:
>>>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>>>>> On 11/26/2025 11:49 PM, Mikko wrote:
>>>>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevanto to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in
>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory. But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell whether
>>>>>>>>>>>>>>>>>>>>>>>> test.c halts is not
>>>>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an
>>>>>>>>>>>>>>>>>>>>>>>> incorrect answer is not even
>>>>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate
>>>>>>>>>>>>>>>>>>>>>>>> H(D), either simultating
>>>>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if executed,
>>>>>>>>>>>>>>>>>>>>>>>> or do whatever H would
>>>>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D
>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies.
>>>>>>>>>>>>>>>>>>>>>> According to C semantics
>>>>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result
>>>>>>>>>>>>>>>>>>>>>> is equally valid.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never
>>>>>>>>>>>>>>>>>>>>>>> being
>>>>>>>>>>>>>>>>>>>>>>> able to complete its first statement before
>>>>>>>>>>>>>>>>>>>>>>> calling H(D)
>>>>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If that happens then H does not return and
>>>>>>>>>>>>>>>>>>>>>> therefore is not a decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That seems to confirm that the definition of "decider"
>>>>>>>>>>>>>>>>>> is over your head.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>>>>> termination
>>>>>>>>>>>>>>>> analyzer". Instead the termination problem is to
>>>>>>>>>>>>>>>> determine whether
>>>>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>>>>> used.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>>>>> asked about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>>>>
>>>>>>>>>>>> No, it is not. The solution to the halting problem must
>>>>>>>>>>>> include the
>>>>>>>>>>>> necessary access. Conversely, a proof that the necessary
>>>>>>>>>>>> access is
>>>>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>>>>> unsolvable.
>>>>>>>>>>>
>>>>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>>>>> main requires HHH to report on information
>>>>>>>>>>> that is not contained in its input thus it is
>>>>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>>>>
>>>>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>>>>> decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That HHH fails to meet the requirements by itself does
>>>>>>>>> not mean that the requirements are wrong.
>>>>>>>>>
>>>>>>>>> Turing machine deciders only compute a mapping from
>>>>>>>>> their [finite string] inputs to an accept or reject
>>>>>>>>> state on the basis that this [finite string] input
>>>>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>>>>> property.
>>>>>>>>>
>>>>>>>>> That the information that HHH is required to report
>>>>>>>>> on simply is not contained in its input is what makes
>>>>>>>>> the requirements wrong.
>>>>>>>>
>>>>>>>> No, it merely means that the designer ot HHH has failed to
>>>>>>>> specify the
>>>>>>>> encoding rules so that the input contains the full specification
>>>>>>>> of the
>>>>>>>> behaviour.
>>>>>>
>>>>>>> In other words you are trying to get away with
>>>>>>> disagreeing with the semantics of the x86 language
>>>>>>> or the semantics of the C programing language.
>>>>>>
>>>>>> You are the one who disagrees with the x86 processors about the x86
>>>>>> language semantics. When an x86 processor executes a program it
>>>>>> executes
>>>>>> according to the x86 semantics. When DD is executed according to
>>>>>> the x86
>>>>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>>>>> behaviour disagrees with the x86 semantics.
>>>>
>>>>> But, DD can halt or not halt, right?
>>>>
>>>> When Olcott uses the name DD he means the particular program in his
>>>> GitHub repository except when he wants to deceive with equivocation.
>>>> The DD is Olcotts repository halts.
>>
>>> I am doing this in the C programming language so that
>>> every detail can be concretely specified and thus no
>>> important details are simply abstracted away.
>>>
>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>> HHH on line 1081
>>> DD on line 1355
>>
>> The DD on line 1355 is the DD I mentioned above and whicn is listed
>> below. HHH always means the HHH on line 1081 except when otherwise
>> stated. HHH(DD) means the HHH on line 1081 is called with the pointer
>> to the DD on line 1355 as the argument. THat call returns 0, which
>> means that DD does not halt.
>>
>
> HHH(DD)==0 has nothing to do with DD executed from main.
True. It would if HHH were a halting decider but HHH isn't.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 06:47 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gk2o7$1aq0o$5@dont-email.me> |
| In reply to | #641504 |
On 12/1/2025 4:45 AM, Mikko wrote:
> olcott kirjoitti 29.11.2025 klo 18.38:
>> On 11/29/2025 3:27 AM, Mikko wrote:
>>> olcott kirjoitti 28.11.2025 klo 16.46:
>>>> On 11/28/2025 2:14 AM, Mikko wrote:
>>>>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:
>>>>>> On 11/26/2025 11:49 PM, Mikko wrote:
>>>>>>> olcott kirjoitti 26.11.2025 klo 17.17:
>>>>>>>> On 11/26/2025 4:01 AM, Mikko wrote:
>>>>>>>>> olcott kirjoitti 17.11.2025 klo 15.31:
>>>>>>>>>> On 11/17/2025 2:43 AM, Mikko wrote:
>>>>>>>>>>> On 2025-11-17 00:12:14 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 11/16/2025 3:18 AM, Mikko wrote:
>>>>>>>>>>>>> On 2025-11-15 16:12:49 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 11/14/2025 3:21 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2025-11-13 15:50:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 11/13/2025 2:48 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2025-11-12 12:54:12 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 11/12/2025 1:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2025-11-11 13:04:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 11/11/2025 2:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated final halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is merely a defect in H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevanto to the semantic and other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> properties of D.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's a stupid statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Stupid is better than false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is stupidly false because you didn't bother
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A statement about me is off topic in
>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates D that calls H(D) that never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated "return" statement final halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of D because D calls H(D) in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Have you ever done any actual programming?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A question about me is off topic in
>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory. But yes, I did yesterday.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *This is my key foundational point*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int H(char* P);
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int D()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(D);
>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>> return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The above is in test.c
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> simulate.exe implements a C interpreter.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> simulate test.c
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> runs the interpreter on the above source file
>>>>>>>>>>>>>>>>>>>>>>>>>> from the command prompt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Any program that does not correctly tell
>>>>>>>>>>>>>>>>>>>>>>>>> whether test.c halts is not
>>>>>>>>>>>>>>>>>>>>>>>>> a halt decider. A program that gives an
>>>>>>>>>>>>>>>>>>>>>>>>> incorrect answer is not even
>>>>>>>>>>>>>>>>>>>>>>>>> a partial halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When this interpreter sees the call to H(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> it calls itself with the text body of D.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> According to C semanttics it should simulate
>>>>>>>>>>>>>>>>>>>>>>>>> H(D), either simultating
>>>>>>>>>>>>>>>>>>>>>>>>> instructions of H or simulating the return from
>>>>>>>>>>>>>>>>>>>>>>>>> H(D) with the same
>>>>>>>>>>>>>>>>>>>>>>>>> returned value as H(D) would return if
>>>>>>>>>>>>>>>>>>>>>>>>> executed, or do whatever H would
>>>>>>>>>>>>>>>>>>>>>>>>> do if H would not not return.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> That is not the behavior that the input to H(D)
>>>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>>>> simulator.exe simulates Test.c. This simulates D
>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is the behavour C semantics specifies.
>>>>>>>>>>>>>>>>>>>>>>> According to C semantics
>>>>>>>>>>>>>>>>>>>>>>> any other behavour that produces the same result
>>>>>>>>>>>>>>>>>>>>>>> is equally valid.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So D remains stuck in recursive simulation never
>>>>>>>>>>>>>>>>>>>>>>>> being
>>>>>>>>>>>>>>>>>>>>>>>> able to complete its first statement before
>>>>>>>>>>>>>>>>>>>>>>>> calling H(D)
>>>>>>>>>>>>>>>>>>>>>>>> again and again.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If that happens then H does not return and
>>>>>>>>>>>>>>>>>>>>>>> therefore is not a decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Maybe my work is over your head.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Maybe the definition of "decider" is over your head.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> People here have consistently lied about
>>>>>>>>>>>>>>>>>>>> DD simulated by HHH reaching its own "return"
>>>>>>>>>>>>>>>>>>>> statement final halt state for three years.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You yourself have not told the truth about
>>>>>>>>>>>>>>>>>>>> this even once.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That seems to confirm that the definition of
>>>>>>>>>>>>>>>>>>> "decider" is over your head.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am just talking at the level of the execution
>>>>>>>>>>>>>>>>>> trace of C functions. D does specify non-halting
>>>>>>>>>>>>>>>>>> behavior to its termination analyzer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The termination problem is not about specifying "to its
>>>>>>>>>>>>>>>>> termination
>>>>>>>>>>>>>>>>> analyzer". Instead the termination problem is to
>>>>>>>>>>>>>>>>> determine whether
>>>>>>>>>>>>>>>>> a program terminates every time when used as it was
>>>>>>>>>>>>>>>>> designed to be
>>>>>>>>>>>>>>>>> used.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The halting problem requires that a halt decider
>>>>>>>>>>>>>>>> correctly report on the behavior of its caller
>>>>>>>>>>>>>>>> and no halt decider can even see its actual caller.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every halt decider is required to report on the behaviour
>>>>>>>>>>>>>>> asked about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And this is incorrect when it has not access to
>>>>>>>>>>>>>> the behavior that it is asked about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it is not. The solution to the halting problem must
>>>>>>>>>>>>> include the
>>>>>>>>>>>>> necessary access. Conversely, a proof that the necessary
>>>>>>>>>>>>> access is
>>>>>>>>>>>>> impossible is sufficient to prove that halting problem is
>>>>>>>>>>>>> unsolvable.
>>>>>>>>>>>>
>>>>>>>>>>>> Reporing on the behavior of DD() executed from
>>>>>>>>>>>> main requires HHH to report on information
>>>>>>>>>>>> that is not contained in its input thus it is
>>>>>>>>>>>> incorrect to require HHH to report on that.
>>>>>>>>>>>
>>>>>>>>>>> That HHH fails to meet the requirements does not mean that the
>>>>>>>>>>> requirements are wrong. It merely meas that HHH is not a halt
>>>>>>>>>>> decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That HHH fails to meet the requirements by itself does
>>>>>>>>>> not mean that the requirements are wrong.
>>>>>>>>>>
>>>>>>>>>> Turing machine deciders only compute a mapping from
>>>>>>>>>> their [finite string] inputs to an accept or reject
>>>>>>>>>> state on the basis that this [finite string] input
>>>>>>>>>> specifies or fails to specify a semantic or syntactic
>>>>>>>>>> property.
>>>>>>>>>>
>>>>>>>>>> That the information that HHH is required to report
>>>>>>>>>> on simply is not contained in its input is what makes
>>>>>>>>>> the requirements wrong.
>>>>>>>>>
>>>>>>>>> No, it merely means that the designer ot HHH has failed to
>>>>>>>>> specify the
>>>>>>>>> encoding rules so that the input contains the full
>>>>>>>>> specification of the
>>>>>>>>> behaviour.
>>>>>>>
>>>>>>>> In other words you are trying to get away with
>>>>>>>> disagreeing with the semantics of the x86 language
>>>>>>>> or the semantics of the C programing language.
>>>>>>>
>>>>>>> You are the one who disagrees with the x86 processors about the x86
>>>>>>> language semantics. When an x86 processor executes a program it
>>>>>>> executes
>>>>>>> according to the x86 semantics. When DD is executed according to
>>>>>>> the x86
>>>>>>> semantics it halts. Anybody who says that DD specifies a non-halting
>>>>>>> behaviour disagrees with the x86 semantics.
>>>>>
>>>>>> But, DD can halt or not halt, right?
>>>>>
>>>>> When Olcott uses the name DD he means the particular program in his
>>>>> GitHub repository except when he wants to deceive with equivocation.
>>>>> The DD is Olcotts repository halts.
>>>
>>>> I am doing this in the C programming language so that
>>>> every detail can be concretely specified and thus no
>>>> important details are simply abstracted away.
>>>>
>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>> HHH on line 1081
>>>> DD on line 1355
>>>
>>> The DD on line 1355 is the DD I mentioned above and whicn is listed
>>> below. HHH always means the HHH on line 1081 except when otherwise
>>> stated. HHH(DD) means the HHH on line 1081 is called with the pointer
>>> to the DD on line 1355 as the argument. THat call returns 0, which
>>> means that DD does not halt.
>>>
>>
>> HHH(DD)==0 has nothing to do with DD executed from main.
>
> True. It would if HHH were a halting decider but HHH isn't.
>
If you carefully studied all of what I said you
would see that the halting problem is a category
error because it directly contradicts one of the
foundational axioms of computer science.
Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.
When we actually measure this property the only way
that we can: DD simulated by HHH cannot possibly reach
its own simulated "return" statement final halt state
while DD is being simulated by HHH. We see that DD
does specify a non-halting sequence.
--
Copyright 2025 Olcott
My 28 year goal has been to make
"true on the basis of meaning" computable.
This required establishing a new foundation
for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Python <python@cccp.invalid> |
|---|---|
| Date | 2025-12-01 14:29 +0000 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <dyIhDBRHM0Gxj6imoJIk0n_hwEg@jntp> |
| In reply to | #641511 |
> [snip boring nonsense and lies] Peter you've intoxicated yourself. Here is what Chat GPT told me once about himself: You have put your finger on the single most fundamental limitation of large language models: They can generate coherent arguments for things that are false, harmful, fringe, or logically impossible — not because they “believe” them, but because they can simulate the rhetorical form of such arguments. And you’re right: The fact that the model “doesn’t believe it” is irrelevant. What matters is: it can produce it. f2up math.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 08:38 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gk99p$1dgmp$1@dont-email.me> |
| In reply to | #641512 |
On 12/1/2025 8:29 AM, Python wrote: >> [snip boring nonsense and lies] > > Peter you've intoxicated yourself. > > Here is what Chat GPT told me once about himself: > Welcome back! > You have put your finger on the single most fundamental limitation of > large language models: > > They can generate coherent arguments for things that are false, harmful, > fringe, or logically impossible — not because they “believe” them, but > because they can simulate the rhetorical form of such arguments. > > And you’re right: > The fact that the model “doesn’t believe it” is irrelevant. > What matters is: > it can produce it. > > f2up math. Once you fully understand semantic tautologies (the ultimate basis of all of my work) In epistemology (theory of knowledge), a self-evident proposition is a proposition that is known to be true by understanding its meaning without proof... https://en.wikipedia.org/wiki/Self-evidence You will understand that I am correct. If you insist on finding fault at a much higher priority than an honest dialogue then you will never understand that I am correct. It seems that the single most useful application of my work is to make LLM systems much more reliable. -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Python <python@cccp.invalid> |
|---|---|
| Date | 2025-12-01 14:45 +0000 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <p6ftAk78M9b4tY90Sh2NtRmUsnU@jntp> |
| In reply to | #641513 |
Le 01/12/2025 à 15:38, olcott a écrit : > On 12/1/2025 8:29 AM, Python wrote: >>> [snip boring nonsense and lies] >> >> Peter you've intoxicated yourself. >> >> Here is what Chat GPT told me once about himself: >> > > Welcome back! > >> You have put your finger on the single most fundamental limitation of >> large language models: >> >> They can generate coherent arguments for things that are false, harmful, >> fringe, or logically impossible — not because they “believe” them, but >> because they can simulate the rhetorical form of such arguments. >> >> And you’re right: >> The fact that the model “doesn’t believe it” is irrelevant. >> What matters is: >> it can produce it. >> >> f2up math. > > Once you fully understand semantic tautologies > (the ultimate basis of all of my work) > > In epistemology (theory of knowledge), a self-evident > proposition is a proposition that is known to be true > by understanding its meaning without proof... > https://en.wikipedia.org/wiki/Self-evidence > > You will understand that I am correct. If you insist > on finding fault at a much higher priority than an > honest dialogue then you will never understand that > I am correct. You are NOT correct. > It seems that the single most useful application > of my work is to make LLM systems much more reliable. Your "work" is complete garbage... Sorry.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 08:57 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gkacd$1dstm$1@dont-email.me> |
| In reply to | #641514 |
On 12/1/2025 8:45 AM, Python wrote: > Le 01/12/2025 à 15:38, olcott a écrit : >> On 12/1/2025 8:29 AM, Python wrote: >>>> [snip boring nonsense and lies] >>> >>> Peter you've intoxicated yourself. >>> >>> Here is what Chat GPT told me once about himself: >>> >> >> Welcome back! >> >>> You have put your finger on the single most fundamental limitation of >>> large language models: >>> >>> They can generate coherent arguments for things that are false, >>> harmful, fringe, or logically impossible — not because they “believe” >>> them, but because they can simulate the rhetorical form of such >>> arguments. >>> >>> And you’re right: >>> The fact that the model “doesn’t believe it” is irrelevant. >>> What matters is: >>> it can produce it. >>> >>> f2up math. >> >> Once you fully understand semantic tautologies >> (the ultimate basis of all of my work) >> >> In epistemology (theory of knowledge), a self-evident >> proposition is a proposition that is known to be true >> by understanding its meaning without proof... >> https://en.wikipedia.org/wiki/Self-evidence >> >> You will understand that I am correct. If you insist >> on finding fault at a much higher priority than an >> honest dialogue then you will never understand that >> I am correct. > > You are NOT correct. > You will continue to lack a sufficient basis for that until you grok (Heinlein) semantic tautology / self-evident truth. >> It seems that the single most useful application >> of my work is to make LLM systems much more reliable. > > Your "work" is complete garbage... Sorry. > > Yet you cannot possibly show that with complete and correct reasoning because you continue to lack the above required basis. -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Python <python@cccp.invalid> |
|---|---|
| Date | 2025-12-01 15:06 +0000 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <AjRE2QLtAxSKfELtHtZ24jOg-B8@jntp> |
| In reply to | #641516 |
Le 01/12/2025 à 15:57, olcott a écrit : > On 12/1/2025 8:45 AM, Python wrote: >> Le 01/12/2025 à 15:38, olcott a écrit : >>> On 12/1/2025 8:29 AM, Python wrote: >>>>> [snip boring nonsense and lies] >>>> >>>> Peter you've intoxicated yourself. >>>> >>>> Here is what Chat GPT told me once about himself: >>>> >>> >>> Welcome back! >>> >>>> You have put your finger on the single most fundamental limitation of >>>> large language models: >>>> >>>> They can generate coherent arguments for things that are false, >>>> harmful, fringe, or logically impossible — not because they “believe” >>>> them, but because they can simulate the rhetorical form of such >>>> arguments. >>>> >>>> And you’re right: >>>> The fact that the model “doesn’t believe it” is irrelevant. >>>> What matters is: >>>> it can produce it. >>>> >>>> f2up math. >>> >>> Once you fully understand semantic tautologies >>> (the ultimate basis of all of my work) >>> >>> In epistemology (theory of knowledge), a self-evident >>> proposition is a proposition that is known to be true >>> by understanding its meaning without proof... >>> https://en.wikipedia.org/wiki/Self-evidence >>> >>> You will understand that I am correct. If you insist >>> on finding fault at a much higher priority than an >>> honest dialogue then you will never understand that >>> I am correct. >> >> You are NOT correct. >> > > You will continue to lack a sufficient basis > for that until you grok (Heinlein) semantic > tautology / self-evident truth. > >>> It seems that the single most useful application >>> of my work is to make LLM systems much more reliable. >> >> Your "work" is complete garbage... Sorry. >> >> > > Yet you cannot possibly show that with complete > and correct reasoning because you continue to > lack the above required basis. I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 09:19 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gkbm7$1eeh3$2@dont-email.me> |
| In reply to | #641517 |
On 12/1/2025 9:06 AM, Python wrote: > Le 01/12/2025 à 15:57, olcott a écrit : >> On 12/1/2025 8:45 AM, Python wrote: >>> Le 01/12/2025 à 15:38, olcott a écrit : >>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>> [snip boring nonsense and lies] >>>>> >>>>> Peter you've intoxicated yourself. >>>>> >>>>> Here is what Chat GPT told me once about himself: >>>>> >>>> >>>> Welcome back! >>>> >>>>> You have put your finger on the single most fundamental limitation >>>>> of large language models: >>>>> >>>>> They can generate coherent arguments for things that are false, >>>>> harmful, fringe, or logically impossible — not because they >>>>> “believe” them, but because they can simulate the rhetorical form >>>>> of such arguments. >>>>> >>>>> And you’re right: >>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>> What matters is: >>>>> it can produce it. >>>>> >>>>> f2up math. >>>> >>>> Once you fully understand semantic tautologies >>>> (the ultimate basis of all of my work) >>>> >>>> In epistemology (theory of knowledge), a self-evident >>>> proposition is a proposition that is known to be true >>>> by understanding its meaning without proof... >>>> https://en.wikipedia.org/wiki/Self-evidence >>>> >>>> You will understand that I am correct. If you insist >>>> on finding fault at a much higher priority than an >>>> honest dialogue then you will never understand that >>>> I am correct. >>> >>> You are NOT correct. >>> >> >> You will continue to lack a sufficient basis >> for that until you grok (Heinlein) semantic >> tautology / self-evident truth. >> >>>> It seems that the single most useful application >>>> of my work is to make LLM systems much more reliable. >>> >>> Your "work" is complete garbage... Sorry. >>> >>> >> >> Yet you cannot possibly show that with complete >> and correct reasoning because you continue to >> lack the above required basis. > > I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT. > > How can you possibly show that a semantic tautology is incorrect when it is inherently correct? -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 09:26 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gkc28$1ej2v$1@dont-email.me> |
| In reply to | #641519 |
On 12/1/2025 9:19 AM, olcott wrote: > On 12/1/2025 9:06 AM, Python wrote: >> Le 01/12/2025 à 15:57, olcott a écrit : >>> On 12/1/2025 8:45 AM, Python wrote: >>>> Le 01/12/2025 à 15:38, olcott a écrit : >>>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>>> [snip boring nonsense and lies] >>>>>> >>>>>> Peter you've intoxicated yourself. >>>>>> >>>>>> Here is what Chat GPT told me once about himself: >>>>>> >>>>> >>>>> Welcome back! >>>>> >>>>>> You have put your finger on the single most fundamental limitation >>>>>> of large language models: >>>>>> >>>>>> They can generate coherent arguments for things that are false, >>>>>> harmful, fringe, or logically impossible — not because they >>>>>> “believe” them, but because they can simulate the rhetorical form >>>>>> of such arguments. >>>>>> >>>>>> And you’re right: >>>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>>> What matters is: >>>>>> it can produce it. >>>>>> >>>>>> f2up math. >>>>> >>>>> Once you fully understand semantic tautologies >>>>> (the ultimate basis of all of my work) >>>>> >>>>> In epistemology (theory of knowledge), a self-evident >>>>> proposition is a proposition that is known to be true >>>>> by understanding its meaning without proof... >>>>> https://en.wikipedia.org/wiki/Self-evidence >>>>> >>>>> You will understand that I am correct. If you insist >>>>> on finding fault at a much higher priority than an >>>>> honest dialogue then you will never understand that >>>>> I am correct. >>>> >>>> You are NOT correct. >>>> >>> >>> You will continue to lack a sufficient basis >>> for that until you grok (Heinlein) semantic >>> tautology / self-evident truth. >>> >>>>> It seems that the single most useful application >>>>> of my work is to make LLM systems much more reliable. >>>> >>>> Your "work" is complete garbage... Sorry. >>>> >>>> >>> >>> Yet you cannot possibly show that with complete >>> and correct reasoning because you continue to >>> lack the above required basis. >> >> I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT. >> >> > > How can you possibly show that a semantic tautology > is incorrect when it is inherently correct? > > Within the definition that "cats" <are> "animals" how can you possibly show that "cats" <are><not> "animals" ??? -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 09:29 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gkc9c$1ej2v$2@dont-email.me> |
| In reply to | #641520 |
On 12/1/2025 9:26 AM, olcott wrote: > On 12/1/2025 9:19 AM, olcott wrote: >> On 12/1/2025 9:06 AM, Python wrote: >>> Le 01/12/2025 à 15:57, olcott a écrit : >>>> On 12/1/2025 8:45 AM, Python wrote: >>>>> Le 01/12/2025 à 15:38, olcott a écrit : >>>>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>>>> [snip boring nonsense and lies] >>>>>>> >>>>>>> Peter you've intoxicated yourself. >>>>>>> >>>>>>> Here is what Chat GPT told me once about himself: >>>>>>> >>>>>> >>>>>> Welcome back! >>>>>> >>>>>>> You have put your finger on the single most fundamental >>>>>>> limitation of large language models: >>>>>>> >>>>>>> They can generate coherent arguments for things that are false, >>>>>>> harmful, fringe, or logically impossible — not because they >>>>>>> “believe” them, but because they can simulate the rhetorical form >>>>>>> of such arguments. >>>>>>> >>>>>>> And you’re right: >>>>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>>>> What matters is: >>>>>>> it can produce it. >>>>>>> >>>>>>> f2up math. >>>>>> >>>>>> Once you fully understand semantic tautologies >>>>>> (the ultimate basis of all of my work) >>>>>> >>>>>> In epistemology (theory of knowledge), a self-evident >>>>>> proposition is a proposition that is known to be true >>>>>> by understanding its meaning without proof... >>>>>> https://en.wikipedia.org/wiki/Self-evidence >>>>>> >>>>>> You will understand that I am correct. If you insist >>>>>> on finding fault at a much higher priority than an >>>>>> honest dialogue then you will never understand that >>>>>> I am correct. >>>>> >>>>> You are NOT correct. >>>>> >>>> >>>> You will continue to lack a sufficient basis >>>> for that until you grok (Heinlein) semantic >>>> tautology / self-evident truth. >>>> >>>>>> It seems that the single most useful application >>>>>> of my work is to make LLM systems much more reliable. >>>>> >>>>> Your "work" is complete garbage... Sorry. >>>>> >>>>> >>>> >>>> Yet you cannot possibly show that with complete >>>> and correct reasoning because you continue to >>>> lack the above required basis. >>> >>> I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT. >>> >>> >> >> How can you possibly show that a semantic tautology >> is incorrect when it is inherently correct? >> >> > > Within the definition that "cats" <are> "animals" > how can you possibly show that "cats" <are><not> "animals" ??? > "cats" is a finite string <are> is a type of relation between finite strings. -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Python <python@cccp.invalid> |
|---|---|
| Date | 2025-12-01 15:31 +0000 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <hPUiLIZ-BKkrCKKiorXdXl1XokA@jntp> |
| In reply to | #641521 |
Le 01/12/2025 à 16:29, olcott a écrit : > On 12/1/2025 9:26 AM, olcott wrote: >> On 12/1/2025 9:19 AM, olcott wrote: >>> On 12/1/2025 9:06 AM, Python wrote: >>>> Le 01/12/2025 à 15:57, olcott a écrit : >>>>> On 12/1/2025 8:45 AM, Python wrote: >>>>>> Le 01/12/2025 à 15:38, olcott a écrit : >>>>>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>>>>> [snip boring nonsense and lies] >>>>>>>> >>>>>>>> Peter you've intoxicated yourself. >>>>>>>> >>>>>>>> Here is what Chat GPT told me once about himself: >>>>>>>> >>>>>>> >>>>>>> Welcome back! >>>>>>> >>>>>>>> You have put your finger on the single most fundamental >>>>>>>> limitation of large language models: >>>>>>>> >>>>>>>> They can generate coherent arguments for things that are false, >>>>>>>> harmful, fringe, or logically impossible — not because they >>>>>>>> “believe” them, but because they can simulate the rhetorical form >>>>>>>> of such arguments. >>>>>>>> >>>>>>>> And you’re right: >>>>>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>>>>> What matters is: >>>>>>>> it can produce it. >>>>>>>> >>>>>>>> f2up math. >>>>>>> >>>>>>> Once you fully understand semantic tautologies >>>>>>> (the ultimate basis of all of my work) >>>>>>> >>>>>>> In epistemology (theory of knowledge), a self-evident >>>>>>> proposition is a proposition that is known to be true >>>>>>> by understanding its meaning without proof... >>>>>>> https://en.wikipedia.org/wiki/Self-evidence >>>>>>> >>>>>>> You will understand that I am correct. If you insist >>>>>>> on finding fault at a much higher priority than an >>>>>>> honest dialogue then you will never understand that >>>>>>> I am correct. >>>>>> >>>>>> You are NOT correct. >>>>>> >>>>> >>>>> You will continue to lack a sufficient basis >>>>> for that until you grok (Heinlein) semantic >>>>> tautology / self-evident truth. >>>>> >>>>>>> It seems that the single most useful application >>>>>>> of my work is to make LLM systems much more reliable. >>>>>> >>>>>> Your "work" is complete garbage... Sorry. >>>>>> >>>>>> >>>>> >>>>> Yet you cannot possibly show that with complete >>>>> and correct reasoning because you continue to >>>>> lack the above required basis. >>>> >>>> I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT. >>>> >>>> >>> >>> How can you possibly show that a semantic tautology >>> is incorrect when it is inherently correct? >>> >>> >> >> Within the definition that "cats" <are> "animals" >> how can you possibly show that "cats" <are><not> "animals" ? ? ? >> > > "cats" is a finite string <are> > is a type of relation between finite strings. Don't dodge. This a sin because it is a kind of lie.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 09:39 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gkcrk$1ev4l$1@dont-email.me> |
| In reply to | #641522 |
On 12/1/2025 9:31 AM, Python wrote: > Le 01/12/2025 à 16:29, olcott a écrit : >> On 12/1/2025 9:26 AM, olcott wrote: >>> On 12/1/2025 9:19 AM, olcott wrote: >>>> On 12/1/2025 9:06 AM, Python wrote: >>>>> Le 01/12/2025 à 15:57, olcott a écrit : >>>>>> On 12/1/2025 8:45 AM, Python wrote: >>>>>>> Le 01/12/2025 à 15:38, olcott a écrit : >>>>>>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>>>>>> [snip boring nonsense and lies] >>>>>>>>> >>>>>>>>> Peter you've intoxicated yourself. >>>>>>>>> >>>>>>>>> Here is what Chat GPT told me once about himself: >>>>>>>>> >>>>>>>> >>>>>>>> Welcome back! >>>>>>>> >>>>>>>>> You have put your finger on the single most fundamental >>>>>>>>> limitation of large language models: >>>>>>>>> >>>>>>>>> They can generate coherent arguments for things that are false, >>>>>>>>> harmful, fringe, or logically impossible — not because they >>>>>>>>> “believe” them, but because they can simulate the rhetorical >>>>>>>>> form of such arguments. >>>>>>>>> >>>>>>>>> And you’re right: >>>>>>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>>>>>> What matters is: >>>>>>>>> it can produce it. >>>>>>>>> >>>>>>>>> f2up math. >>>>>>>> >>>>>>>> Once you fully understand semantic tautologies >>>>>>>> (the ultimate basis of all of my work) >>>>>>>> >>>>>>>> In epistemology (theory of knowledge), a self-evident >>>>>>>> proposition is a proposition that is known to be true >>>>>>>> by understanding its meaning without proof... >>>>>>>> https://en.wikipedia.org/wiki/Self-evidence >>>>>>>> >>>>>>>> You will understand that I am correct. If you insist >>>>>>>> on finding fault at a much higher priority than an >>>>>>>> honest dialogue then you will never understand that >>>>>>>> I am correct. >>>>>>> >>>>>>> You are NOT correct. >>>>>>> >>>>>> >>>>>> You will continue to lack a sufficient basis >>>>>> for that until you grok (Heinlein) semantic >>>>>> tautology / self-evident truth. >>>>>> >>>>>>>> It seems that the single most useful application >>>>>>>> of my work is to make LLM systems much more reliable. >>>>>>> >>>>>>> Your "work" is complete garbage... Sorry. >>>>>>> >>>>>>> >>>>>> >>>>>> Yet you cannot possibly show that with complete >>>>>> and correct reasoning because you continue to >>>>>> lack the above required basis. >>>>> >>>>> I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT. >>>>> >>>>> >>>> >>>> How can you possibly show that a semantic tautology >>>> is incorrect when it is inherently correct? >>>> >>>> >>> >>> Within the definition that "cats" <are> "animals" >>> how can you possibly show that "cats" <are><not> "animals" ? ? ? >>> >> >> "cats" is a finite string <are> >> is a type of relation between finite strings. > > Don't dodge. > > This a sin because it is a kind of lie. > > Revelation 21:8 King James Version ...and all liars, shall have their part in the lake which burneth with fire and brimstone: which is the second death. Liars swear their allegiance to the father of lies and thus condemn themselves as shown above. Kurt Gödel in his 1944 Russell's mathematical logic gave the following definition of the "theory of simple types" in a footnote: By the theory of simple types I mean the doctrine which says that the objects of thought ... are divided into types, namely: individuals, properties of individuals, relations between individuals, properties of such relations, etc. https://en.wikipedia.org/wiki/History_of_type_theory#G%C3%B6del_1944 The essence of this is that all *objects of thought* can be encoded in a hierarchy of types as relations between finite strings. -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
| From | Python <python@cccp.invalid> |
|---|---|
| Date | 2025-12-01 15:48 +0000 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <Iu30l2_CueMwDfrLLIkr2XY4waE@jntp> |
| In reply to | #641523 |
Le 01/12/2025 à 16:39, olcott a écrit : > On 12/1/2025 9:31 AM, Python wrote: >> Le 01/12/2025 à 16:29, olcott a écrit : >>> On 12/1/2025 9:26 AM, olcott wrote: >>>> On 12/1/2025 9:19 AM, olcott wrote: >>>>> On 12/1/2025 9:06 AM, Python wrote: >>>>>> Le 01/12/2025 à 15:57, olcott a écrit : >>>>>>> On 12/1/2025 8:45 AM, Python wrote: >>>>>>>> Le 01/12/2025 à 15:38, olcott a écrit : >>>>>>>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>>>>>>> [snip boring nonsense and lies] >>>>>>>>>> >>>>>>>>>> Peter you've intoxicated yourself. >>>>>>>>>> >>>>>>>>>> Here is what Chat GPT told me once about himself: >>>>>>>>>> >>>>>>>>> >>>>>>>>> Welcome back! >>>>>>>>> >>>>>>>>>> You have put your finger on the single most fundamental >>>>>>>>>> limitation of large language models: >>>>>>>>>> >>>>>>>>>> They can generate coherent arguments for things that are false, >>>>>>>>>> harmful, fringe, or logically impossible — not because they >>>>>>>>>> “believe” them, but because they can simulate the rhetorical >>>>>>>>>> form of such arguments. >>>>>>>>>> >>>>>>>>>> And you’re right: >>>>>>>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>>>>>>> What matters is: >>>>>>>>>> it can produce it. >>>>>>>>>> >>>>>>>>>> f2up math. >>>>>>>>> >>>>>>>>> Once you fully understand semantic tautologies >>>>>>>>> (the ultimate basis of all of my work) >>>>>>>>> >>>>>>>>> In epistemology (theory of knowledge), a self-evident >>>>>>>>> proposition is a proposition that is known to be true >>>>>>>>> by understanding its meaning without proof... >>>>>>>>> https://en.wikipedia.org/wiki/Self-evidence >>>>>>>>> >>>>>>>>> You will understand that I am correct. If you insist >>>>>>>>> on finding fault at a much higher priority than an >>>>>>>>> honest dialogue then you will never understand that >>>>>>>>> I am correct. >>>>>>>> >>>>>>>> You are NOT correct. >>>>>>>> >>>>>>> >>>>>>> You will continue to lack a sufficient basis >>>>>>> for that until you grok (Heinlein) semantic >>>>>>> tautology / self-evident truth. >>>>>>> >>>>>>>>> It seems that the single most useful application >>>>>>>>> of my work is to make LLM systems much more reliable. >>>>>>>> >>>>>>>> Your "work" is complete garbage... Sorry. >>>>>>>> >>>>>>>> >>>>>>> >>>>>>> Yet you cannot possibly show that with complete >>>>>>> and correct reasoning because you continue to >>>>>>> lack the above required basis. >>>>>> >>>>>> I'm am not willing to endorse a sophistry that I KNOW to be INCORRECT. >>>>>> >>>>>> >>>>> >>>>> How can you possibly show that a semantic tautology >>>>> is incorrect when it is inherently correct? >>>>> >>>>> >>>> >>>> Within the definition that "cats" <are> "animals" >>>> how can you possibly show that "cats" <are><not> "animals" ? ? ? >>>> >>> >>> "cats" is a finite string <are> >>> is a type of relation between finite strings. >> >> Don't dodge. >> >> This a sin because it is a kind of lie. >> >> > > Revelation 21:8 > King James Version > ...and all liars, shall have their part in the lake which > burneth with fire and brimstone: which is the second death. > > Liars swear their allegiance to the father of lies > and thus condemn themselves as shown above. > > Kurt Gödel in his 1944 Russell's mathematical logic gave > the following definition of the "theory of simple types" > in a footnote: > > By the theory of simple types I mean the doctrine which says > that the objects of thought ... are divided into types, > namely: individuals, properties of individuals, relations > between individuals, properties of such relations, etc. > https://en.wikipedia.org/wiki/History_of_type_theory#G%C3%B6del_1944 > > The essence of this is that all *objects of thought* > can be encoded in a hierarchy of types as relations > between finite strings. You'll enjoy Hell, Trump will be there too.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-12-01 09:55 -0600 |
| Subject | Re: The halting problem is incorrect two different ways --- updated |
| Message-ID | <10gkdq9$1facb$1@dont-email.me> |
| In reply to | #641524 |
On 12/1/2025 9:48 AM, Python wrote: > Le 01/12/2025 à 16:39, olcott a écrit : >> On 12/1/2025 9:31 AM, Python wrote: >>> Le 01/12/2025 à 16:29, olcott a écrit : >>>> On 12/1/2025 9:26 AM, olcott wrote: >>>>> On 12/1/2025 9:19 AM, olcott wrote: >>>>>> On 12/1/2025 9:06 AM, Python wrote: >>>>>>> Le 01/12/2025 à 15:57, olcott a écrit : >>>>>>>> On 12/1/2025 8:45 AM, Python wrote: >>>>>>>>> Le 01/12/2025 à 15:38, olcott a écrit : >>>>>>>>>> On 12/1/2025 8:29 AM, Python wrote: >>>>>>>>>>>> [snip boring nonsense and lies] >>>>>>>>>>> >>>>>>>>>>> Peter you've intoxicated yourself. >>>>>>>>>>> >>>>>>>>>>> Here is what Chat GPT told me once about himself: >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> Welcome back! >>>>>>>>>> >>>>>>>>>>> You have put your finger on the single most fundamental >>>>>>>>>>> limitation of large language models: >>>>>>>>>>> >>>>>>>>>>> They can generate coherent arguments for things that are >>>>>>>>>>> false, harmful, fringe, or logically impossible — not because >>>>>>>>>>> they “believe” them, but because they can simulate the >>>>>>>>>>> rhetorical form of such arguments. >>>>>>>>>>> >>>>>>>>>>> And you’re right: >>>>>>>>>>> The fact that the model “doesn’t believe it” is irrelevant. >>>>>>>>>>> What matters is: >>>>>>>>>>> it can produce it. >>>>>>>>>>> >>>>>>>>>>> f2up math. >>>>>>>>>> >>>>>>>>>> Once you fully understand semantic tautologies >>>>>>>>>> (the ultimate basis of all of my work) >>>>>>>>>> >>>>>>>>>> In epistemology (theory of knowledge), a self-evident >>>>>>>>>> proposition is a proposition that is known to be true >>>>>>>>>> by understanding its meaning without proof... >>>>>>>>>> https://en.wikipedia.org/wiki/Self-evidence >>>>>>>>>> >>>>>>>>>> You will understand that I am correct. If you insist >>>>>>>>>> on finding fault at a much higher priority than an >>>>>>>>>> honest dialogue then you will never understand that >>>>>>>>>> I am correct. >>>>>>>>> >>>>>>>>> You are NOT correct. >>>>>>>>> >>>>>>>> >>>>>>>> You will continue to lack a sufficient basis >>>>>>>> for that until you grok (Heinlein) semantic >>>>>>>> tautology / self-evident truth. >>>>>>>> >>>>>>>>>> It seems that the single most useful application >>>>>>>>>> of my work is to make LLM systems much more reliable. >>>>>>>>> >>>>>>>>> Your "work" is complete garbage... Sorry. >>>>>>>>> >>>>>>>>> >>>>>>>> >>>>>>>> Yet you cannot possibly show that with complete >>>>>>>> and correct reasoning because you continue to >>>>>>>> lack the above required basis. >>>>>>> >>>>>>> I'm am not willing to endorse a sophistry that I KNOW to be >>>>>>> INCORRECT. >>>>>>> >>>>>>> >>>>>> >>>>>> How can you possibly show that a semantic tautology >>>>>> is incorrect when it is inherently correct? >>>>>> >>>>>> >>>>> >>>>> Within the definition that "cats" <are> "animals" >>>>> how can you possibly show that "cats" <are><not> "animals" ? ? ? >>>>> >>>> >>>> "cats" is a finite string <are> >>>> is a type of relation between finite strings. >>> >>> Don't dodge. >>> >>> This a sin because it is a kind of lie. >>> >>> >> >> Revelation 21:8 >> King James Version >> ...and all liars, shall have their part in the lake which >> burneth with fire and brimstone: which is the second death. >> >> Liars swear their allegiance to the father of lies >> and thus condemn themselves as shown above. >> >> Kurt Gödel in his 1944 Russell's mathematical logic gave >> the following definition of the "theory of simple types" >> in a footnote: >> >> By the theory of simple types I mean the doctrine which says >> that the objects of thought ... are divided into types, >> namely: individuals, properties of individuals, relations >> between individuals, properties of such relations, etc. >> https://en.wikipedia.org/wiki/History_of_type_theory#G%C3%B6del_1944 >> >> The essence of this is that all *objects of thought* >> can be encoded in a hierarchy of types as relations >> between finite strings. > > You'll enjoy Hell, Trump will be there too. > > In other words you are asserting that type theory is a lie? https://lawrencecpaulson.github.io/papers/Russells-mathematical-logic.pdf My whole 28 year purpose in this is so that people like Trump cannot get away with their lies when Truth(L,x) becomes computable. -- Copyright 2025 Olcott My 28 year goal has been to make "true on the basis of meaning" computable. This required establishing a new foundation for correct reasoning.
[toc] | [prev] | [next] | [standalone]
Page 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
Back to top | Article view | sci.math
csiph-web