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


Groups > comp.software-eng > #2472 > unrolled thread

Re: Halting Problem Final Conclusion [2021 update to my 2004 statement]

Started byolcott <NoOne@NoWhere.com>
First post2021-01-05 12:26 -0600
Last post2021-01-05 22:43 +0000
Articles 20 on this page of 113 — 4 participants

Back to article view | Back to comp.software-eng

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.


Contents

  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 12:26 -0600
    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 13:37 -0600
      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 21:15 +0000
        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 15:42 -0600
          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 22:24 +0000
            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-05 23:00 -0600
              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-06 07:55 +0000
                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-06 13:17 -0600
                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-06 21:48 +0000
                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-06 16:38 -0600
                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-07 05:28 +0000
                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Deceiver?) olcott <NoOne@NoWhere.com> - 2021-01-07 10:00 -0600
                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 13:41 -0600
                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 13:45 -0600
                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 18:11 -0600
                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 17:43 -0600
                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-08 11:47 -0600
                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-08 18:00 +0000
                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 11:40 -0600
                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 15:59 -0600
                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 21:53 -0600
                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 23:08 -0600
                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Jeff Barnett <jbb@notatt.com> - 2021-01-08 22:36 -0700
                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 05:39 +0000
                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 12:40 -0600
                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-09 16:03 -0600
                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 22:28 +0000
                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-09 16:51 -0600
                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 23:22 +0000
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-12 10:06 -0600
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:15 +0000
                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-12 12:07 -0600
                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 12:07 -0600
                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 12:18 -0600
                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 18:53 +0000
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 14:03 -0600
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 20:19 +0000
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis) olcott <NoOne@NoWhere.com> - 2021-01-11 20:46 -0600
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-01-11 22:23 -0800
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 09:36 -0600
                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 10:23 -0600
                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 11:06 -0600
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](decider defined) olcott <NoOne@NoWhere.com> - 2021-01-12 19:14 -0600
                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 11:00 -0600
                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 13:40 -0600
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](laser focused) olcott <NoOne@NoWhere.com> - 2021-01-12 18:32 -0600
                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](actual behavior) olcott <NoOne@NoWhere.com> - 2021-01-12 19:44 -0600
                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:27 +0000
                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) olcott <NoOne@NoWhere.com> - 2021-01-12 12:50 -0600
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 19:51 +0000
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) olcott <NoOne@NoWhere.com> - 2021-01-12 14:06 -0600
                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 09:36 -0600
                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 09:39 -0600
                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 10:33 -0600
                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 13:18 -0600
                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 16:31 -0600
                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 19:36 -0600
                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-10 02:10 +0000
                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 23:12 -0600
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-11 12:34 -0600
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-11 12:43 -0600
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 19:01 +0000
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 10:31 -0600
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:32 +0000
                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 12:59 -0600
                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 20:07 +0000
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 14:49 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 16:47 -0600
                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-01-12 14:50 -0800
                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 23:33 +0000
                                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 18:10 -0600
                                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-13 00:31 +0000
                                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:05 -0600
                                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 21:07 -0600
                                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-13 15:16 -0600
                                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-13 21:39 -0600
                                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-13 22:34 -0600
                                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 09:08 -0600
                                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 09:32 -0600
                                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 10:48 -0600
                                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-16 15:09 -0600
                                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 16:54 +0000
                                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 11:22 -0600
                                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 17:33 +0000
                                                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 12:10 -0600
                                                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 19:25 +0000
                                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 12:28 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 18:43 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:50 -0600
                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 00:39 -0600
                                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-13 11:10 +0000
                                              Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 14:53 -0600
                                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) olcott <NoOne@NoWhere.com> - 2021-01-13 15:27 -0600
                                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) olcott <NoOne@NoWhere.com> - 2021-01-13 16:22 -0600
                                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 09:23 -0600
                                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 17:10 +0000
                                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 11:26 -0600
                                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 11:25 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:53 -0600
                                Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 19:55 -0600
                                  Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 18:57 -0600
                                    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 21:21 -0600
                                      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-13 22:15 -0600
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 09:18 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 10:41 -0600
                                            Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 12:16 -0600
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) olcott <NoOne@NoWhere.com> - 2021-01-16 14:50 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) olcott <NoOne@NoWhere.com> - 2021-01-16 16:04 -0600
                                          Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-17 04:46 +0000
                                        Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-16 15:23 -0600
    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] (brain dead morons) olcott <NoOne@NoWhere.com> - 2021-01-05 16:03 -0600
    Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 16:10 -0600
      Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 22:43 +0000

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


#2581 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-16 15:09 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<rdqdnc6eJOG8y579nZ2dnUU7-c3NnZ2d@giganews.com>
In reply to#2569
On 1/14/2021 6:58 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 1/14/2021 10:00 AM, Richard Damon wrote:
>>> On 1/14/21 10:32 AM, olcott wrote:
> 
>>>> On 1/10/2021 9:09 AM, Ben Bacarisse wrote:
>>>>> Yes, except that the question "Does the simulation of the
>>>>> input have to be stopped to prevent its otherwise infinite
>>>>> execution" is, itself, the classical halting problem.
> 
>>>> Although the above question divides inputs into halting and not halting
>>>> when the original question:
>>>> Does the input halt on its input?
>>>>
>>>> is applied to a halt decider based on the above question it conflates
>>>> halting inputs with not-halting inputs and calls them both halting.
>>>>
>>>
>>> And you still don't understand and cherry pick comments out of context,
>>> showing yourself to be the cheat that you are.
>>>
>>> Ben was commenting that making the decision to REALLY be that otherwise
>>> infinite recursion will occur, you need to solve that actual halting
>>> problem,
>>
>> No he certainly did not mean that.
> 
> Yes I did.  Exactly that.

I do not have to freaking solve the halting problem to show that the 
conventional proofs are incorrect and you damn well know it.

Why lie?

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2570 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-14 16:54 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<20210114084604.3@kylheku.com>
In reply to#2564
On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
> On 1/14/2021 6:26 AM, Richard Damon wrote:
>> Except that (f) is not shown to be satisfied as some of the trace has
>> been omitted (the code starting at 0000066E and ending up at 0000084E.
>> 
>> (f) does NOT say only 'user' code, and is FALSE if modified to say that.
>> 
>> Your AXIOM is also not true in the general case, it presumes that
>> machine has no interrupts or traps that are able to affect the execution
>> of the program, and you 'global' decider system seems to have a trap
>> mechanism to let Halts know that it has detected 'infinite recursion',
>> that or Halts needs to have a direct conditional in it.
>> 
>> Since your proof is based on a false statement, it is unsound.
>> 
>
> The mistake that you continue to make over and over and over is that you 
> keep presuming that the question is: Does the input halt on its input?

Not at all!

Even with this compromised logic of tracing only selected instructions
from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
H_Hat) returns 0.

It makes no difference whether your machine assiduously analyzes all the
instructions, or whether you define Halts as
bool Halts(u32, u32) { return 0; }.
It's not going to return an answer which matches the H_Hat(H_Hat)
behavior.

And that is what is based on the so-called "incorrect question" (the
real halting problem instead of the strawman version).

What is being pointed out here is just a secondary, mostly irrelevant
way in which you are also dishonest/wrong, which ultimately makes no
difference.

You're not even able to analyze deeply enough to figure out which
criticisms of your ideas are related to adherence to correct formulation
of the halting problem, and which come from other facors.

-- 
TXR Programming Language: http://nongnu.org/txr

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


#2572 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-14 11:22 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<_qednbFqgr5z4J39nZ2dnUU7-N3NnZ2d@giganews.com>
In reply to#2570
On 1/14/2021 10:54 AM, Kaz Kylheku wrote:
> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>> On 1/14/2021 6:26 AM, Richard Damon wrote:
>>> Except that (f) is not shown to be satisfied as some of the trace has
>>> been omitted (the code starting at 0000066E and ending up at 0000084E.
>>>
>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that.
>>>
>>> Your AXIOM is also not true in the general case, it presumes that
>>> machine has no interrupts or traps that are able to affect the execution
>>> of the program, and you 'global' decider system seems to have a trap
>>> mechanism to let Halts know that it has detected 'infinite recursion',
>>> that or Halts needs to have a direct conditional in it.
>>>
>>> Since your proof is based on a false statement, it is unsound.
>>>
>>
>> The mistake that you continue to make over and over and over is that you
>> keep presuming that the question is: Does the input halt on its input?
> 
> Not at all!
> 
> Even with this compromised logic of tracing only selected instructions
> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
> H_Hat) returns 0.


As I have already said fifty times now when we put the halt decider in 
disabled mode where it only reports true when an input program has 
already halted on its own then every instance of the invocation of 
H_Hat(H_Hat) executes infinitely.

We have to determine that it executes infinitely analytically because it 
is impossible to wait until an eternity of time has completed.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2575 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-14 17:33 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<20210114092350.403@kylheku.com>
In reply to#2572
["Followup-To:" header set to comp.theory.]
On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
> On 1/14/2021 10:54 AM, Kaz Kylheku wrote:
>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/14/2021 6:26 AM, Richard Damon wrote:
>>>> Except that (f) is not shown to be satisfied as some of the trace has
>>>> been omitted (the code starting at 0000066E and ending up at 0000084E.
>>>>
>>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that.
>>>>
>>>> Your AXIOM is also not true in the general case, it presumes that
>>>> machine has no interrupts or traps that are able to affect the execution
>>>> of the program, and you 'global' decider system seems to have a trap
>>>> mechanism to let Halts know that it has detected 'infinite recursion',
>>>> that or Halts needs to have a direct conditional in it.
>>>>
>>>> Since your proof is based on a false statement, it is unsound.
>>>>
>>>
>>> The mistake that you continue to make over and over and over is that you
>>> keep presuming that the question is: Does the input halt on its input?
>> 
>> Not at all!
>> 
>> Even with this compromised logic of tracing only selected instructions
>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
>> H_Hat) returns 0.
>
>
> As I have already said fifty times now

Repetition does not help in logic.

P ^ P ^ ... ^ P is equiavlent to P.


> when we put the halt decider in 
> disabled mode

... we are changing an input, which means we have a different decider,
and since H_Hat is based on the decider, we have a different H_Hat.

Please bugger off, until your code properly has this input in the
parameter list, so that Halts is a three-place function, and H_Hat
a two-place function.

Note that Halts really needs to be a four-place function:

  bool Halts(u32 P, u32 I, bool inputDeciderMode, bool ownDeciderMode)

Halts should be capable of operating in one decider mode, while
analyzing H_Hat in a different decider mode.

Your system might not support that, in which case the three-argument
form is good enough. The top-level call to H_Hat or else to Halts
specifies the mode, which is then passed to all the child functions.

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


#2576 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-14 12:10 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<yfydnVLbTZlhFZ39nZ2dnUU7-Y_NnZ2d@giganews.com>
In reply to#2575
On 1/14/2021 11:33 AM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>> On 1/14/2021 10:54 AM, Kaz Kylheku wrote:
>>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/14/2021 6:26 AM, Richard Damon wrote:
>>>>> Except that (f) is not shown to be satisfied as some of the trace has
>>>>> been omitted (the code starting at 0000066E and ending up at 0000084E.
>>>>>
>>>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that.
>>>>>
>>>>> Your AXIOM is also not true in the general case, it presumes that
>>>>> machine has no interrupts or traps that are able to affect the execution
>>>>> of the program, and you 'global' decider system seems to have a trap
>>>>> mechanism to let Halts know that it has detected 'infinite recursion',
>>>>> that or Halts needs to have a direct conditional in it.
>>>>>
>>>>> Since your proof is based on a false statement, it is unsound.
>>>>>
>>>>
>>>> The mistake that you continue to make over and over and over is that you
>>>> keep presuming that the question is: Does the input halt on its input?
>>>
>>> Not at all!
>>>
>>> Even with this compromised logic of tracing only selected instructions
>>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
>>> H_Hat) returns 0.
>>
>>
>> As I have already said fifty times now
> 
> Repetition does not help in logic.
> 
> P ^ P ^ ... ^ P is equiavlent to P.
> 
> 
>> when we put the halt decider in
>> disabled mode
> 
> ... we are changing an input, which means we have a different decider,
> and since H_Hat is based on the decider, we have a different H_Hat.
> 
> Please bugger off, until your code properly has this input in the
> parameter list, so that Halts is a three-place function, and H_Hat
> a two-place function.
> 

So it is utterly beyond your imagination that there could be three 
different instances of a halt decider?

I swap between them using #define statements.

> Note that Halts really needs to be a four-place function:
> 
>    bool Halts(u32 P, u32 I, bool inputDeciderMode, bool ownDeciderMode)
> 

For the purpose of maximizing the effectiveness of communication we must 
minimize rather than maximize complexity.

> Halts should be capable of operating in one decider mode, while
> analyzing H_Hat in a different decider mode.
> 

I am not going to give Halts() a [God damned liar] mode.

> Your system might not support that, in which case the three-argument
> form is good enough. The top-level call to H_Hat or else to Halts
> specifies the mode, which is then passed to all the child functions.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2579 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-14 19:25 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<20210114105604.565@kylheku.com>
In reply to#2576
["Followup-To:" header set to comp.theory.]
On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
> On 1/14/2021 11:33 AM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/14/2021 10:54 AM, Kaz Kylheku wrote:
>>>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/14/2021 6:26 AM, Richard Damon wrote:
>>>>>> Except that (f) is not shown to be satisfied as some of the trace has
>>>>>> been omitted (the code starting at 0000066E and ending up at 0000084E.
>>>>>>
>>>>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that.
>>>>>>
>>>>>> Your AXIOM is also not true in the general case, it presumes that
>>>>>> machine has no interrupts or traps that are able to affect the execution
>>>>>> of the program, and you 'global' decider system seems to have a trap
>>>>>> mechanism to let Halts know that it has detected 'infinite recursion',
>>>>>> that or Halts needs to have a direct conditional in it.
>>>>>>
>>>>>> Since your proof is based on a false statement, it is unsound.
>>>>>>
>>>>>
>>>>> The mistake that you continue to make over and over and over is that you
>>>>> keep presuming that the question is: Does the input halt on its input?
>>>>
>>>> Not at all!
>>>>
>>>> Even with this compromised logic of tracing only selected instructions
>>>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
>>>> H_Hat) returns 0.
>>>
>>>
>>> As I have already said fifty times now
>> 
>> Repetition does not help in logic.
>> 
>> P ^ P ^ ... ^ P is equiavlent to P.
>> 
>> 
>>> when we put the halt decider in
>>> disabled mode
>> 
>> ... we are changing an input, which means we have a different decider,
>> and since H_Hat is based on the decider, we have a different H_Hat.
>> 
>> Please bugger off, until your code properly has this input in the
>> parameter list, so that Halts is a three-place function, and H_Hat
>> a two-place function.
>> 
>
> So it is utterly beyond your imagination that there could be three 
> different instances of a halt decider?

No, it isn't; I'm asking you above to make the instances clear via
parameters.

The article "a" in "a halt decider" refers to exactly one function.

The "instance" of a function isn't a function, it is a function
application.

A function denotes many possible computations, which are parametrized
using free variables known as the parameters.

We instantiate a computation by applying an argument to every one of the
parameters.

If we apply fewer arguments than there are parameters, that is called
a "partial application". The result of a partial application is a
function of the remaining arguments.

Partial application generates different functions for different
values of the applied arguments.

does not directly support run-time partial application, but you have
effectively done that manually by factoring the mode parameter into a
#define: you are then patially applying that parameter when building the
program. Depending on which value you apply, you get one of three
different Halst and H_Hat functions.  These are then fully
instantiated via parameters: (H_Hat) and (H_Hat, H_Hat).

> I swap between them using #define statements.

So you effectively have a three-parameter function. Two of the parameters
appear as formal parameters in the parameter list. The third one is a
#define flag.

This function has a vast number of instances, not only three.

Every different triplet that we choose <P, I, mode> creates a different
instance.

We are focused on three particular instances:

  Halts(H_Hat, H_Hat, mode_0) // does H_Hat(H_Hat, mode_0) halt?

  Halts(H_Hat, H_Hat, mode_1) // does H_Hat(H_Hat, mode_1) halt?

  Halts(H_Hat, H_Hat, mode_2) // does H_Hat(H_Hat, mode_1) halt?

Each one answers the question about a different, corresponding instance
of H_hat.

See? For each mode m, each decider instance Halts(H_Hat, H_Hat, m)
is concerned with a different H_Hat(H_Hat, m) instance.

Each instance of Halts either fails to terminate, or else
yields the wrong answer about its corresponding H_Hat instance.

Because the mode parameter is compile-time, the other instances of H_Hat
not being analyzed cannot even *exist* in the same program!

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


#2578 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-14 12:28 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity)
Message-ID<feSdnQMSptzGEJ39nZ2dnUU7-bHNnZ2d@giganews.com>
In reply to#2572
On 1/14/2021 11:58 AM, Richard Damon wrote:
> On 1/14/21 12:22 PM, olcott wrote:
>> On 1/14/2021 10:54 AM, Kaz Kylheku wrote:
>>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
> 
>>>>
>>>> The mistake that you continue to make over and over and over is that you
>>>> keep presuming that the question is: Does the input halt on its input?
>>>
>>> Not at all!
>>>
>>> Even with this compromised logic of tracing only selected instructions
>>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
>>> H_Hat) returns 0.
>>
>>
>> As I have already said fifty times now when we put the halt decider in
>> disabled mode where it only reports true when an input program has
>> already halted on its own then every instance of the invocation of
>> H_Hat(H_Hat) executes infinitely.
>>
>> We have to determine that it executes infinitely analytically because it
>> is impossible to wait until an eternity of time has completed.
>>
>>
> 
> Except that is the wrong test as it has now changed the program on the
> tape being evaluated, which isn't allowed.
> 

The test has not changed. The test is the same. The test will report: 
[the input must be aborted] whether or not the input is aborted.

If the input is not aborted and the input is infinitely recursive this 
proves to anyone that understands these things that the report of 
"otherwise" infinite recursion was necessarily correct.

If the input is not aborted then the input will be infinitely recursive:
~X then Y The input is <not> aborted and it <is> infinitely recursive.

The above utterly proves ~X then Y is true.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2545 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 18:43 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<v7OdnbR5Loe832PCnZ2dnUU7-SvNnZ2d@giganews.com>
In reply to#2538
On 1/12/2021 3:28 PM, Kaz Kylheku wrote:
> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
>> On 1/12/2021 2:07 PM, Kaz Kylheku wrote:
>>> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
>>> The pronoun "its" in (a) refers to two different Turing Machines, one
>>> which terminates (let's call it A) and one which exhibits infinite
>>> execution (B). These are necessarily different machines, because no TM
>>> both terminates and fails to terminate.
>>>
>>> What (a) says is 'The simulation of A has to be stopped to prevent
>>> the infinite execution of B'.
>>>
>>> Because A is stopped, it cannot be B, which has infinite execution.
>>
>> Any input meeting this criteria is input that would have infinite
>> execution if its simulation was not stopped.
> 
> "would have" means the same thing as "does not"!
> 
> "would have" means it "would have to be" a different TM.

A TM can be configured to stop the simulation of its input when its 
input would be otherwise infinitely recursive

OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR
OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR
OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR
OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR

A TM can be configured to NOT stop the simulation of its input when its 
input would be otherwise infinitely recursive, thus allowing it to be 
infinitely recursive.

When you evaluate the first half of a single sentence you do not 
evaluate the sentence correctly.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2550 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 20:50 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<ed2dnRQPFttmwmPCnZ2dnUU7-UXNnZ2d@giganews.com>
In reply to#2538
On 1/12/2021 8:28 PM, Richard Damon wrote:
> On 1/12/21 3:49 PM, olcott wrote:
>>
>> Any input meeting this criteria is input that would have infinite
>> execution if its simulation was not stopped.
>>
>> Infinite Recursion detection AXIOM (self-evident truth)
>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
>>
>> The way to prove that this is true is to perform an execution trace on
>> H_Hat() with the halt decider in disabled mode. There will also be a
>> full trace mode that shows the execution trace of all of operating
>> system code too.
>>
>> When you can look at the 100% complete execution trace and see that
>> there are no instructions in this trace that could possibly cause it to
>> stop, then it can be understood to be infinite.
>>
>> It is much much easier to come to a complete understanding of the above
>> Infinite Recursion detection AXIOM than it is to verify that thousands
>> of pages of x86 code specify infinite execution. None-the-less this
>> empirical proof will be available.
>>
>> Even the full execution trace of Halts() correctly deciding H_Hat() is
>> 297 pages long. This was greatly reduced to 297 pages by moving most
>> operating system functions into emulator code.
>>
>> The local halt decider is entirely in emulated code so every single step
>> of its execution can be seen. The global halt decider works best as an
>> x86utm operating system function so that it can easily watch everything.
>>
> Except that you never do provide a 100% trace of the execution because
> you omit some code that you classify as 'system' code.

I will have a mode where you can see all the system code. In that case 
less than one page of output becomes 297 pages.

> Turing Machines have no 'System' Code, and for your axiom to be true,
> (f) must include ALL code, AND the machine must not provide an interrupt
> or trap capability the the program has access to. I am sure that Halts
> fails to pass that test.
> 

When a freaking halt decider is examining the simulation of a program 
under test it does not have to examine its own code (it already knows 
what it does) or the code of the simulator. Both of these are out-of-scope.

In TM lingo this is a halt deciding UTM.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2553 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-13 00:39 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<IOudnUANZP0TCGPCnZ2dnUU7-XPNnZ2d@giganews.com>
In reply to#2550
On 1/12/2021 11:53 PM, André G. Isaak wrote:
> On 2021-01-12 19:50, olcott wrote:
>> On 1/12/2021 8:28 PM, Richard Damon wrote:
>>> On 1/12/21 3:49 PM, olcott wrote:
>>>>
>>>> Any input meeting this criteria is input that would have infinite
>>>> execution if its simulation was not stopped.
>>>>
>>>> Infinite Recursion detection AXIOM (self-evident truth)
>>>> (a) Within an execution trace
>>>> (b) The same function is called
>>>> (c) From the same machine address
>>>> (d) With the same data // Richard Damon credit
>>>> (e) A second time
>>>> (f) Without any control flow instructions inbetween
>>>>
>>>> The way to prove that this is true is to perform an execution trace on
>>>> H_Hat() with the halt decider in disabled mode. There will also be a
>>>> full trace mode that shows the execution trace of all of operating
>>>> system code too.
>>>>
>>>> When you can look at the 100% complete execution trace and see that
>>>> there are no instructions in this trace that could possibly cause it to
>>>> stop, then it can be understood to be infinite.
>>>>
>>>> It is much much easier to come to a complete understanding of the above
>>>> Infinite Recursion detection AXIOM than it is to verify that thousands
>>>> of pages of x86 code specify infinite execution. None-the-less this
>>>> empirical proof will be available.
>>>>
>>>> Even the full execution trace of Halts() correctly deciding H_Hat() is
>>>> 297 pages long. This was greatly reduced to 297 pages by moving most
>>>> operating system functions into emulator code.
>>>>
>>>> The local halt decider is entirely in emulated code so every single 
>>>> step
>>>> of its execution can be seen. The global halt decider works best as an
>>>> x86utm operating system function so that it can easily watch 
>>>> everything.
>>>>
>>> Except that you never do provide a 100% trace of the execution because
>>> you omit some code that you classify as 'system' code.
>>
>> I will have a mode where you can see all the system code. In that case 
>> less than one page of output becomes 297 pages.
>>
>>> Turing Machines have no 'System' Code, and for your axiom to be true,
>>> (f) must include ALL code, AND the machine must not provide an interrupt
>>> or trap capability the the program has access to. I am sure that Halts
>>> fails to pass that test.
>>>
>>
>> When a freaking halt decider is examining the simulation of a program 
>> under test it does not have to examine its own code (it already knows 
>> what it does) or the code of the simulator. Both of these are 
>> out-of-scope.
> 
> 
> Except that all of that code is also part of H_Hat, the program under 
> test. Halts() isn't expected to examine its own code. It is, however, 
> required to examine *all* of the code of its input program, including 
> any code which might be identical to code found in Halts().

The advantage to a halt decider that simulates its input is only code 
that is reached in the execution trace is examined. Because the call to 
Halts() from H_Hat() is either infinitely recursive or aborted in both 
of these two possible cases it never returns any value to H_Hat() thus 
H_Hat() is unable to take either one of the two paths based on a return 
value from Halts().

> 
> You keep forgetting that in the Linz proof, H_Hat is created by making a 
> *copy* of Halts(). 

I do not keep forgetting that. The Sipser proof doesn't do it that way 
so I kept the common: "do the opposite of whatever the halt decider 
decides" basis of Sipser, Linz and Kozen and discarded some of the 
aspects where they diverge.

My proof has the simplest possible instance of the key
"do the opposite of whatever the halt decider decides"
basis of all of the conventional proofs.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2554 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-13 11:10 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<20210113025715.448@kylheku.com>
In reply to#2553
On 2021-01-13, olcott <NoOne@NoWhere.com> wrote:
> The advantage to a halt decider that simulates its input is only code 
> that is reached in the execution trace is examined. Because the call to 
> Halts() from H_Hat() is either infinitely recursive or aborted in both 
> of these two possible cases it never returns any value to H_Hat() thus 
> H_Hat() is unable to take either one of the two paths based on a return 
> value from Halts().

Sheer nonsense. If H_Hat(H_Hat) is directly called from main, Halts will
return 0 to it, and it will promptly terminate. Only the H_Hat calls in
the simulation have no chance to terminate because the simulation is
stopped short before the Halts simulations return 0 to them.

  On 2021-01-10, olcott <NoOne@NoWhere.com> wrote:
  > On 1/9/2021 8:10 PM, Kaz Kylheku wrote:
  >> The inner Halts is looking for the same terminating condition, but since
  >> it is nested, it has no chance to get that far. The outer-most, oldest
  >> simulation terminates everything first.
  >> 
  >> Botom line, 0 is the wrong answer: H_Hat(H_Hat) halts. 
  >
  > It is only the wrong answer if we are asking the question:
  > Does the input halt on its input?

-- 
TXR Programming Language: http://nongnu.org/txr

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


#2555 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-13 14:53 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<0vydnZ1FWeIywGLCnZ2dnUU7-WXNnZ2d@giganews.com>
In reply to#2553
On 1/13/2021 7:21 AM, Malcolm McLean wrote:
> On Wednesday, 13 January 2021 at 12:49:21 UTC, Richard Damon wrote:
>>
>> Maybe you should also read that article where it talks about a program
>> taking its representation as its input, as you don't seem to understand
>> that as well.
>>
> That's certainly an issue with the DebugTrace.
> 

The program <is> its x86 configuration.
I have never show the actual interface to DebugTrace() because it 
actually requires many more details that would only be confusing when 
the goal is explaining the gist of what it does.

> Halts takes P and I. P is a Turing machine description in some notation,
> and I is any sort of input on a tape with some alphabet.
>   
> However PO uses machine code as the Turing machine description, and
> also for I. So P becomes a function pointer that can be called. 

I wanted to make it as much as possible as one UTM simulating the Turing 
Machine description of another UTM so P is not a function pointer, it is 
a raw machine address that is manually converted into a virtual machine 
pointer.

> It's not
> clear exactly what is being done, but Halts isn't allowed to do this. It is
> allowed to simulate P, but then it has no way of knowing that P contains
> a call to Halts. In fact, in Linz's H_Hat, there is no call H, but there is a
> copy made of the embedded H as part of the copying of H_Hat's
> input. If H emulates P, as is reasonable, you will get another copy of
> H_Hat made, and then maybe an infinite accumulation of them, 

Yes I wrote about this back in 2017 and earlier in 2016.

Infinitely Recursive input on HP Proofs
https://groups.google.com/g/comp.theory/c/NcFS02hKs1U/m/dhNDYvhFAAAJ

> but
> each copy will be concatenated on the tape, physically distinct. So
> detecting infinite recursion by looking for calls to the same address won't
> work.
> 

By proving that the simplest possible example of the:
"Do the opposite of whatever the halt decider decides"
basis of all the conventional HP undecidability proofs
is decidable all of these proof are refuted.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2557 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-13 15:27 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things)
Message-ID<EK-dneJgNt8l-GLCnZ2dnUU7-V3NnZ2d@giganews.com>
In reply to#2555
On 1/13/2021 2:59 PM, Kaz Kylheku wrote:
> On 2021-01-13, olcott <NoOne@NoWhere.com> wrote:
>> On 1/13/2021 7:21 AM, Malcolm McLean wrote:
>>> On Wednesday, 13 January 2021 at 12:49:21 UTC, Richard Damon wrote:
>>>>
>>>> Maybe you should also read that article where it talks about a program
>>>> taking its representation as its input, as you don't seem to understand
>>>> that as well.
>>>>
>>> That's certainly an issue with the DebugTrace.
>>>
>>
>> The program <is> its x86 configuration.
>> I have never show the actual interface to DebugTrace() because it
>> actually requires many more details that would only be confusing when
>> the goal is explaining the gist of what it does.
> 
> You're not very good at explaining your stuff.
> 
There is a very good chance that is true.

> If your goal really is explaining, you are failing miserably.
> 
I am doing the best that I can. My code explains itself.

> You should write a coherent, detailed paper, with diagrams which are as
> accurate as possible, accurate code and pseudo code, and carefully
> written descriptions of everything.
> 

I first must make sure that people can understand the gist of what I am 
saying.

> Nobody can reconstruct what you're doing from the voluminous Usenet
> postings.
> 

I have encoded Halts() such that it correctly decides not halting for 
H_Hat().

void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Would_Halt =", Input_Would_Halt);
}

> For instance, I think understand the bulk of it, but I could not point a
> third person to a single source of reference material.
> 
> Were you never required to document anything in your entire career?
> 

The code totally explains itself one you understand that this is true:

Infinite Recursion detection AXIOM (self-evident truth)
(a) Within an execution trace
(b) The same function is called
(c) From the same machine address
(d) With the same data // Richard Damon credit
(e) A second time
(f) Without any control flow instructions inbetween

Actually you don't even need to look at the code as soon as you 
understand that the above is true and examine the execution trace of 
H_Hat() you can immediately comprehend that Halts() can easily correctly 
decide not halting on H_Hat().


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2558 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-13 16:22 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things)
Message-ID<sOWdne9KD7om72LCnZ2dnUU7-RnNnZ2d@giganews.com>
In reply to#2557
On 1/13/2021 3:38 PM, Kaz Kylheku wrote:
> On 2021-01-13, olcott <NoOne@NoWhere.com> wrote:
>> On 1/13/2021 2:59 PM, Kaz Kylheku wrote:
>>> On 2021-01-13, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/13/2021 7:21 AM, Malcolm McLean wrote:
>>>>> On Wednesday, 13 January 2021 at 12:49:21 UTC, Richard Damon wrote:
>>>>>>
>>>>>> Maybe you should also read that article where it talks about a program
>>>>>> taking its representation as its input, as you don't seem to understand
>>>>>> that as well.
>>>>>>
>>>>> That's certainly an issue with the DebugTrace.
>>>>>
>>>>
>>>> The program <is> its x86 configuration.
>>>> I have never show the actual interface to DebugTrace() because it
>>>> actually requires many more details that would only be confusing when
>>>> the goal is explaining the gist of what it does.
>>>
>>> You're not very good at explaining your stuff.
>>>
>> There is a very good chance that is true.
>>
>>> If your goal really is explaining, you are failing miserably.
>>>
>> I am doing the best that I can. My code explains itself.
> 
> That is possible, but you've revealed very, very little of it.
> 
> Those revelations are scattered throughout numerous postings in
> obscure newsgroups in an obscure Usenet.
> 
> Currently code that explains itself is something that
> 
> 1. Someone can clone from a remote git repository hosted somewhere.
> Or at least a tarball.
> 
> 2. Has build instructions that can be successfully followed to
> get the software buitl.
> 
> 3. Test cases or instructions: this is how you run it.
> 

Yes I am working towards that.
I have all three modes fully operational.

>>> You should write a coherent, detailed paper, with diagrams which are as
>>> accurate as possible, accurate code and pseudo code, and carefully
>>> written descriptions of everything.
>>>
>>
>> I first must make sure that people can understand the gist of what I am
>> saying.
> 
> See, there is the problem. You are confusing understanding and
> agreement.

If you understand that 2 + 3 = 5 is necessarily true then you 
necessarily agree that it is true because that is the way that logical 
necessity works. It is the exact same thing with my proof.

> No matter how much understanding people show of your nested simulation
> constraption, you believe that they are not getting the gist of it
> if they don't agree that you have refuted a proof.
> 

With logical necessity one either agrees or one fails to understand.

> That is an irrational standard just for the purpose of obtaining
> a check that people are grokking the idea, so that you can then
> gather it into a better piece of documentation.
> 

The first priority is to get the code as clean as possible.
The next priority is to document the code the way that you suggested.
The next priority is to write an academic paper based on the code.
The next priority is to get the academic paper and the code reviewed by 
computer scientists in the field.

The final priority is to strive to get the paper based on the code 
published.

> "People must totally agree with my ideas and results in an ad-hoc,
> piecewise presentation on Usenet, before I will document them properly
> in a coherent paper, accompanied by downloadable, buildable code."
> 

If you would very carefully examine this execution trace:

Output_Debug_Trace() [0001112e]  size(124)  capacity(65536)
[0000087e](01)  55                  push ebp
[0000087f](02)  8bec                mov ebp,esp
[00000881](01)  51                  push ecx
[00000882](05)  684e080000          push 0000084e
[00000887](05)  684e080000          push 0000084e
[0000088c](05)  e8ddfdffff          call 0000066e  ;CALL Halts(H_Hat, H_Hat)
[0000084e](01)  55                  push ebp
[0000084f](02)  8bec                mov ebp,esp
[00000851](01)  51                  push ecx
[00000852](03)  8b4508              mov eax,[ebp+08]
[00000855](01)  50                  push eax
[00000856](03)  8b4d08              mov ecx,[ebp+08]
[00000859](01)  51                  push ecx
[0000085a](05)  e80ffeffff          call 0000066e  ;CALL Halts(H_Hat, H_Hat)
[0000084e](01)  55                  push ebp
[0000084f](02)  8bec                mov ebp,esp
[00000851](01)  51                  push ecx
[00000852](03)  8b4508              mov eax,[ebp+08]
[00000855](01)  50                  push eax
[00000856](03)  8b4d08              mov ecx,[ebp+08]
[00000859](01)  51                  push ecx
[0000085a](05)  e80ffeffff          call 0000066e  ;CALL Halts(H_Hat, H_Hat)

With this axiom:

Infinite Recursion detection AXIOM (self-evident truth)
(a) Within an execution trace
(b) The same function is called
(c) From the same machine address
(d) With the same data // Richard Damon credit
(e) A second time
(f) Without any control flow instructions inbetween

paying as much attention as if I was a famous computer scientist that is 
probably correct then it would be totally obvious that I am correct.




-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2566 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-14 09:23 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)
Message-ID<VI2dnYlNi4Ri_J39nZ2dnUU7-fnNnZ2d@giganews.com>
In reply to#2555
On 1/14/2021 9:14 AM, Andy Walker wrote:
> On 13/01/2021 20:53, olcott wrote:
>> By proving that the simplest possible example of the:
>> "Do the opposite of whatever the halt decider decides"
>> basis of all the conventional HP undecidability proofs
>> is decidable all of these proof are refuted.
> 
>      ???  No-one doubts that the "Do the opposite ..." instance
> is decidable.  The point is that it is decided incorrectly by the
> [purported] halt decider under test*.  That is enough to show the
> undecidability of the HP.  What other [claimed] halt deciders or
> simulators or ... do, whether to this instance or any other, is
> irrelevant.
> 

The mistake that you continue to make over and over and over is that you 
keep presuming that the question is: Does the input halt on its input?

I have corrected people on this many times and every time they short 
circuit to the same mistake.

When we ask the question: Would the input program on its input be 
infinitely recursive if this infinite recursion was not stopped?

the code that stops the otherwise infinite recursion is not part of the 
code that is under test because this code is never reached (thus not in 
the execution trace) until after the decision on the program under test 
has already been made.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2571 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-14 17:10 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)
Message-ID<20210114085532.434@kylheku.com>
In reply to#2566
["Followup-To:" header set to comp.theory.]
On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
> On 1/14/2021 9:14 AM, Andy Walker wrote:
>> On 13/01/2021 20:53, olcott wrote:
>>> By proving that the simplest possible example of the:
>>> "Do the opposite of whatever the halt decider decides"
>>> basis of all the conventional HP undecidability proofs
>>> is decidable all of these proof are refuted.
>> 
>>      ???  No-one doubts that the "Do the opposite ..." instance
>> is decidable.  The point is that it is decided incorrectly by the
>> [purported] halt decider under test*.  That is enough to show the
>> undecidability of the HP.  What other [claimed] halt deciders or
>> simulators or ... do, whether to this instance or any other, is
>> irrelevant.
>> 
>
> The mistake that you continue to make over and over and over is that you 
> keep presuming that the question is: Does the input halt on its input?
>
> I have corrected people on this many times and every time they short 
> circuit to the same mistake.

I do not accept any other question. I understand the other question
and I understand why you're insisting on it. Taken by itself, it is a
poor definition of the halting problem.

More importantly to your work, it doesn't match the halting problem.

> When we ask the question: Would the input program on its input be 
> infinitely recursive if this infinite recursion was not stopped?

Nobody who knows a thing or two about mathematic or logic will accept
this kind of moronic sentence. You will not convince anyone who is
not crazy or stupid, like yourself.

The proposed question is exactly like asking "would the number 3 still
be odd if we simulated it in binary, and masked out its bottom bit?"

You know that Usenet tolerates has crazy and stupid people, which is why
you are presenting your ideas here. This environment both allows you
to persist (you would be banned in any modern Internet forum)
and gives you a fighting chance at finding a few other crazy/stupid
people who will nod their heads to your ideas, and accept your
crazy redefined questions and the whole thing.

When we ask this question, we must akcnowledge that we are doing one of
three things:

1) Using very sloppy, informal language to try to say exactly the same
   thing as the question in the real halting problem.

2) Playing word semantic games that perpetrate equivocation,
   because we have in mind a particular simulation apparatus in
   which functions hange their behavior based on a hidden "mode"
   input, so that a function's recursion is *acually* stopped, yet we
   continue to insist that it's the same function due to having the
   same machine code and same inputs (other than that mode input).

3) Naively saying something completely stupid, like "would the number 3
   still be odd if we simulated it in binary and cleared the LSB."

-- 
TXR Programming Language: http://nongnu.org/txr

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


#2574 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-14 11:26 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)
Message-ID<_qednbNqgr4w4539nZ2dnUU7-N2dnZ2d@giganews.com>
In reply to#2571
On 1/14/2021 11:10 AM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
>> On 1/14/2021 9:14 AM, Andy Walker wrote:
>>> On 13/01/2021 20:53, olcott wrote:
>>>> By proving that the simplest possible example of the:
>>>> "Do the opposite of whatever the halt decider decides"
>>>> basis of all the conventional HP undecidability proofs
>>>> is decidable all of these proof are refuted.
>>>
>>>       ???  No-one doubts that the "Do the opposite ..." instance
>>> is decidable.  The point is that it is decided incorrectly by the
>>> [purported] halt decider under test*.  That is enough to show the
>>> undecidability of the HP.  What other [claimed] halt deciders or
>>> simulators or ... do, whether to this instance or any other, is
>>> irrelevant.
>>>
>>
>> The mistake that you continue to make over and over and over is that you
>> keep presuming that the question is: Does the input halt on its input?
>>
>> I have corrected people on this many times and every time they short
>> circuit to the same mistake.
> 
> I do not accept any other question. 
On 1/10/2021 9:09 AM, Ben Bacarisse wrote:
 > ... the question "Does the simulation of the
 > input have to be stopped to prevent its otherwise infinite
 > execution" is, itself, the classical halting problem.

Although the above question divides inputs into halting and not halting 
when the original question:
Does the input halt on its input?

is applied to a halt decider based on the above question it conflates 
halting inputs with not-halting inputs and calls them both halting.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2573 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-14 11:25 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT)
Message-ID<_qednbBqgr7z4539nZ2dnUU7-N2dnZ2d@giganews.com>
In reply to#2566
On 1/14/2021 11:06 AM, Andy Walker wrote:
> On 14/01/2021 15:23, olcott wrote:
>>>> By proving that the simplest possible example of the:
>>>> "Do the opposite of whatever the halt decider decides"
>>>> basis of all the conventional HP undecidability proofs
>>>> is decidable all of these proof are refuted.
>>>      ???  No-one doubts that the "Do the opposite ..." instance
>>> is decidable.  The point is that it is decided incorrectly by the
>>> [purported] halt decider under test*.  That is enough to show the
>>> undecidability of the HP.  What other [claimed] halt deciders or
>>> simulators or ... do, whether to this instance or any other, is
>>> irrelevant.
>> The mistake that you continue to make over and over and over is that
>> you keep presuming that the question is: Does the input halt on its
>> input?
> 
>      Any other question is either equivalent to that one or is
> not of any relevance whatsoever to the HP.  

On 1/10/2021 9:09 AM, Ben Bacarisse wrote:
 > ... the question "Does the simulation of the
 > input have to be stopped to prevent its otherwise infinite
 > execution" is, itself, the classical halting problem.

Although the above question divides inputs into halting and not halting 
when the original question:
Does the input halt on its input?

is applied to a halt decider based on the above question it conflates 
halting inputs with not-halting inputs and calls them both halting.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2551 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 20:53 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<ed2dnRcPFts5_WPCnZ2dnUU7-UWdnZ2d@giganews.com>
In reply to#2538
On 1/12/2021 8:28 PM, Richard Damon wrote:
> On 1/12/21 3:49 PM, olcott wrote:
>>
>> Any input meeting this criteria is input that would have infinite
>> execution if its simulation was not stopped.
>>
>> Infinite Recursion detection AXIOM (self-evident truth)
>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
>>
>> The way to prove that this is true is to perform an execution trace on
>> H_Hat() with the halt decider in disabled mode. There will also be a
>> full trace mode that shows the execution trace of all of operating
>> system code too.
>>
>> When you can look at the 100% complete execution trace and see that
>> there are no instructions in this trace that could possibly cause it to
>> stop, then it can be understood to be infinite.
>>
>> It is much much easier to come to a complete understanding of the above
>> Infinite Recursion detection AXIOM than it is to verify that thousands
>> of pages of x86 code specify infinite execution. None-the-less this
>> empirical proof will be available.
>>
>> Even the full execution trace of Halts() correctly deciding H_Hat() is
>> 297 pages long. This was greatly reduced to 297 pages by moving most
>> operating system functions into emulator code.
>>
>> The local halt decider is entirely in emulated code so every single step
>> of its execution can be seen. The global halt decider works best as an
>> x86utm operating system function so that it can easily watch everything.
>>
> Except that you never do provide a 100% trace of the execution because
> you omit some code that you classify as 'system' code.
> 

The full execution trace becomes 297 pages of output.

> Turing Machines have no 'System' Code, and for your axiom to be true,
> (f) must include ALL code, AND the machine must not provide an interrupt
> or trap capability the the program has access to. I am sure that Halts
> fails to pass that test.
> 

When a freaking halt decider is examining the simulation of a program 
under test it does not have to examine its own code (it already knows 
what it does) or the code of the simulator. Both of these are out-of-scope.

In TM lingo this is a halt deciding UTM.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


#2548 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 19:55 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<Sb6dnVbseZ6HzmPCnZ2dnUU7-cnNnZ2d@giganews.com>
In reply to#2511
On 1/12/2021 7:20 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 1/10/2021 9:09 AM, Ben Bacarisse wrote:
> <cut>
>>> Yes, except that the question "Does the simulation of the input have to
>>> be stopped to prevent its otherwise infinite execution" is, itself, the
>>> classical halting problem.
>>
>> This is one of the very rare times that you have ever agreed with me
>> on a material fact.
> 
> Not a very useful agreement unless you also agree that you can't have
> code that can make this determination in the general case.  

If we hypothetically assume that the conventional halting problem 
undecidability proofs have been refuted that would seem to make the 
halting problem an open question again.

> Sometimes
> you imply that you do, and sometimes you imply that you don't.  We'll
> never have a definitive claim because flip-flopping (and never posting
> code that would settle the matter), is how you keep the chat going.
> 

I do not have any definitive claim on any open question.

> It is, however, a matter of fact that you can't have an algorithm that
> can determine if the simulation of a TM (or TM-equivalent) computation
> is infinite.  Do you agree with me on that one as well?
> 

My laser focus is only on the one single aspect of the conventional 
halting problem undecidability proofs

correctly deciding the simplest possible case of the
"do the opposite of whatever the halt decider decides"
common basis of all these proofs.

I am NOT willing to accept:
OK you refuted these proofs but that does not count for anything at all 
until you totally solve the actual halting problem itself.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

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


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

Back to top | Article view | comp.software-eng


csiph-web