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 1 of 6  [1] 2 3 4 5 6  Next page →


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-05 12:26 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement]
Message-ID<6MydnSUEIKOgMmnCnZ2dnUU7-R3NnZ2d@giganews.com>
On 1/5/2021 11:01 AM, André G. Isaak wrote:
> On 2021-01-04 20:46, olcott wrote:
>> On 1/4/2021 9:39 PM, André G. Isaak wrote:
>>> On 2021-01-04 19:49, olcott wrote:
>>>> On 1/4/2021 8:52 AM, Andy Walker wrote:
>>>>> On 04/01/2021 12:10, Richard Damon wrote:
>>>>>> So if detecting the recursion can't be done, then part of PO's 
>>>>>> trick is
>>>>>> the passing of pointer to functions as an address rather than 
>>>>>> actually
>>>>>> passing an input 'tape'. This allows him to trivially solve the
>>>>>> recursion detection.
>>>>>
>>>>>      No, that isn't, in itself, a "trick".  After all, we don't
>>>>> expect a compiler to make extra copies of the function code whenever
>>>>> a function is called.  A TM has access to the same methods that a
>>>>> real computer has for enabling function calls and recursion -- stash
>>>>> away return addresses, stack parameters, put return values onto the
>>>>> stack, blah-de-blah. ...
>>>>>
>>>>
>>>> Thanks for adding some real software engineering to this dialogue.
>>>>
>>>>>> This says that the REAL problem with his proof is that his 'UTM' 
>>>>>> doesn't
>>>>>> fully support the operation of 'make a copy of the input', and 
>>>>>> thus is
>>>>>> shown to not be a Turing Complete environment.
>>>>>
>>>>>      ... The real problems are (a) recursion is not the only way
>>>>> a program can fail to halt; 
>>>>
>>>> I don't have to solve the halting problem to refute the conventional 
>>>> proofs. My system already detects some cases of infinte loops.
>>>>
>>>>> and (b) PO's recursion detection works
>>>>> only in very trivial cases.  Oh, and of course 
>>>>
>>>> No sense making the system more elaborate than required to refute 
>>>> the conventional proofs. This would only confuse people making it 
>>>> more difficult for them to see that I refuted the conventional proofs.
>>>>
>>>>> (c) the fact that his
>>>>> "H_hat" doesn't [yet] correspond to his "H" in the correct way; 
>>>>
>>>> Bullshit. My Halts() corresponds to my H_Hat() in the simplest "do 
>>>> the opposite of whatever the halt decider decides" template that all 
>>>> the conventional halting problem proofs are based on.
>>>
>>> The problem is that your Halts() function isn't the totality of your 
>>> decider. It's simply a function -- you have all this other 'global' 
>>> code which you haven't ever shown which somehow wraps itself around 
>>> main. Your H_Hat has to be derived from *that* code, not from the 
>>> Halts() function.
>>>
>>> André
>>
>> All this code is finally working correctly now.
>> It is not as you describe.
> 
> Since you've never provided the code, all we have to go on is your 
> descriptions. If it is not as I describe, then perhaps you can describe 
> how it actually is. In particular, what is the difference between your 
> 'global' and 'local' decider and why is it necessary to make such a 
> distinction in the first place. We don't make such a distinction for any 
> other mathematical function such as sqrt(), so why does Halts() require 
> this?
> 
> André
> 

The key reason why I need three halt deciding modes is so that people 
can see the nuanced details of what is really going on with this case:

int main()
{
   H_Hat((u32)H_Hat);
}

I am focusing my attention on completing the code because the code 
speaks for itself.

-- 
Copyright 2021 Pete Olcott

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

[toc] | [next] | [standalone]


#2473

Fromolcott <NoOne@NoWhere.com>
Date2021-01-05 13:37 -0600
Message-ID<m5OdndGhUYyPXWnCnZ2dnUU7-c_NnZ2d@giganews.com>
In reply to#2472
On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>> The key reason why I need three halt deciding modes is so that people
>> can see the nuanced details of what is really going on with this case:
> 
> Your results are invalid if you don't follow these requirements,
> (and possibly even if you do):
> 

The above statement is moronically stupid when understood within this 
context:

Without (the mandatory prerequisite of) carefully studying the full 
execution trace of this code:

int main()
{
   H_Hat((u32)H_Hat);
   HALT
}

in all three halt decider modes: {disabled, local, global}

while carefully looking for any error and finding none:
The above statement is moronically stupid




It is just as stupid as counting as evidence the effect of the damned 
lies of a God damned liar that there was any actual discrepancies with 
integrity of the presidential election.

Trump knows damn well the any president with approval ratings 
consistently under water by a large margin defines "election loser" in a 
Democracy.

https://projects.fivethirtyeight.com/trump-approval-ratings/

-- 
Copyright 2021 Pete Olcott

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

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


#2474

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-05 21:15 +0000
Message-ID<20210105130908.810@kylheku.com>
In reply to#2473
["Followup-To:" header set to comp.theory.]
On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>> The key reason why I need three halt deciding modes is so that people
>>> can see the nuanced details of what is really going on with this case:
>> 
>> Your results are invalid if you don't follow these requirements,
>> (and possibly even if you do):
>> 
>
> The above statement is moronically stupid when understood within this 
> context:

Note that I included the part in parentheses due to my lingering
suspicion that you don't understand logical if/then conditionals.

I'm emphasizing that the requirements I stated are necessary, not
sufficient.

> Without (the mandatory prerequisite of) carefully studying the full 
> execution trace of this code:
>
> int main()
> {
>    H_Hat((u32)H_Hat);
>    HALT
> }
>
> in all three halt decider modes: {disabled, local, global}
>
> while carefully looking for any error and finding none:
> The above statement is moronically stupid

But the statement along with the requirements it refers to is not in
confict with what you're saying here.

The first requirement just says: you can't interpret the traces
under one mode (e.g. local) as pertaining to the halting of
H_Hat(H_Hat) in any other mode (e.g. disabled).

Study all the traces you want; just don't mix modes.

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

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


#2475

Fromolcott <NoOne@NoWhere.com>
Date2021-01-05 15:42 -0600
Message-ID<vZadnfU_JNnDQGnCnZ2dnUU7-KvNnZ2d@giganews.com>
In reply to#2474
On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>> The key reason why I need three halt deciding modes is so that people
>>>> can see the nuanced details of what is really going on with this case:
>>>
>>> Your results are invalid if you don't follow these requirements,
>>> (and possibly even if you do):
>>>
>>
>> The above statement is moronically stupid when understood within this
>> context:
> 
> Note that I included the part in parentheses due to my lingering
> suspicion that you don't understand logical if/then conditionals.
> 
> I'm emphasizing that the requirements I stated are necessary, not
> sufficient.
> 
>> Without (the mandatory prerequisite of) carefully studying the full
>> execution trace of this code:
>>
>> int main()
>> {
>>     H_Hat((u32)H_Hat);
>>     HALT
>> }
>>
>> in all three halt decider modes: {disabled, local, global}
>>
>> while carefully looking for any error and finding none:
>> The above statement is moronically stupid
> 
> But the statement along with the requirements it refers to is not in
> confict with what you're saying here.
> 
> The first requirement just says: you can't interpret the traces
> under one mode (e.g. local) as pertaining to the halting of
> H_Hat(H_Hat) in any other mode (e.g. disabled).
> 
> Study all the traces you want; just don't mix modes.
> 

When the execution trace of this code:
(full source code provided)

int main()
{
   H_Hat((u32)H_Hat);
}

Is carefully examined looking for coding or logic errors then the 
non-existence of coding or logic errors proves that the halt decider 
does decide the above code correctly as infinitely recursive in global 
mode and the input to H_Hat() as infinitely recursive in local mode.

Without having the full (hundreds of pages) of execution trace and all 
the source code the correct assessment of the halt decider's decision is 
over everyone's head.

People may still "believe" that the halt decider decides inconsistently 
yet the fact that it is impossible to point to any logic or coding error
(because none exist) proves that this belief is vacuous.

-- 
Copyright 2021 Pete Olcott

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

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


#2478

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-05 22:24 +0000
Message-ID<20210105140850.684@kylheku.com>
In reply to#2475
["Followup-To:" header set to comp.theory.]
On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>> The key reason why I need three halt deciding modes is so that people
>>>>> can see the nuanced details of what is really going on with this case:
>>>>
>>>> Your results are invalid if you don't follow these requirements,
>>>> (and possibly even if you do):
>>>>
>>>
>>> The above statement is moronically stupid when understood within this
>>> context:
>> 
>> Note that I included the part in parentheses due to my lingering
>> suspicion that you don't understand logical if/then conditionals.
>> 
>> I'm emphasizing that the requirements I stated are necessary, not
>> sufficient.
>> 
>>> Without (the mandatory prerequisite of) carefully studying the full
>>> execution trace of this code:
>>>
>>> int main()
>>> {
>>>     H_Hat((u32)H_Hat);
>>>     HALT
>>> }
>>>
>>> in all three halt decider modes: {disabled, local, global}
>>>
>>> while carefully looking for any error and finding none:
>>> The above statement is moronically stupid
>> 
>> But the statement along with the requirements it refers to is not in
>> confict with what you're saying here.
>> 
>> The first requirement just says: you can't interpret the traces
>> under one mode (e.g. local) as pertaining to the halting of
>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>> 
>> Study all the traces you want; just don't mix modes.
>> 
>
> When the execution trace of this code:
> (full source code provided)
>
> int main()
> {
>    H_Hat((u32)H_Hat);
> }
>
> Is carefully examined looking for coding or logic errors then the 
> non-existence of coding or logic errors proves that the halt decider 
> does decide the above code correctly as infinitely recursive in global 
> mode and the input to H_Hat() as infinitely recursive in local mode.

H_Hat isn't infinitely recursive in local mode, because Halts isn't.
So the decision is wrong.

Halts isn't recursive because it makes a decision: it stops and
returns a value.

What the program is saying is that a different H_Hat(H_Hat) is
infinitely recursive: a H_Hat(H_Hat) running in disabled mode.

The decision is correct that way, but it doesn't invalidate any proof,
because the required self-reference is not replicated.

The decider which is saying that the disabled-mode H_Hat(H_Hat)
fails to halt is not the decider which that H_Hat(H_Hat) calls.

The disabled-mode H_Hat(H_Hat) call invokes the disabled-mode
Halts(P, P).

The local-mode Halts(H_Hat, H_Hat) returns 0, indicating that
the disabled-mode H_Hat(H_Hat) fails to halt.

The local-mode Halts is different from the disabled-mode halts.  It may
be the same compiled code, but the machine it runs on has different
behavior in its instruction set, such that what looks like exactly the
same function call can return in one mode, or fail to return in the
other.

The proof doesn't say H_Hat(H_Hat) cannot be decided absolutely,
but only by that specific decider: the exact same one that H_Hat
integrates and calls.

> Without having the full (hundreds of pages) of execution trace and all 
> the source code the correct assessment of the halt decider's decision is 
> over everyone's head.

Nope; it's *because* you have that execution trace that it's over your
own head, and nobody else's.

You've confused and bamboozled ourself with your own program.

> People may still "believe" that the halt decider decides inconsistently 
> yet the fact that it is impossible to point to any logic or coding error
> (because none exist) proves that this belief is vacuous.

I believe that what I understand to be the "local" and "disabled" modes
allow (or can do so, in any case) the Halt decider to be a function
which consistently returns a value based only on its two arguments
(which are immutable code).

You've not demonstrated any traces from a single program, all operating
in the same mode, which shows that H_Hat(H_Hat) actually behaves in the
way that Halts(H_Hat, H_Hat) decides.

I.e.

1. Call Halts(H_Hat, H_Hat), and log the return value on ouput.
2. Then call H_Hat(H_Hat). Also inside that function, log the value *it*
   obtains from Halts(P, P), before doing anything else, to confirm it
   is getting the same one.
3. Also include a debug trace after the call to H_Hat(H_Hat) to positively
   confirm if/when it terminates.

I posted such a program several times, but you refused to try it.

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-05 23:00 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<KdKdnRiWV4Zn3mjCnZ2dnUU7-S3NnZ2d@giganews.com>
In reply to#2478
On 1/5/2021 5:52 PM, Kaz Kylheku wrote:
> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>> On 1/5/2021 4:24 PM, Kaz Kylheku wrote:
>>> ["Followup-To:" header set to comp.theory.]
>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>>>>> ["Followup-To:" header set to comp.theory.]
>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> The key reason why I need three halt deciding modes is so that people
>>>>>>>> can see the nuanced details of what is really going on with this case:
>>>>>>>
>>>>>>> Your results are invalid if you don't follow these requirements,
>>>>>>> (and possibly even if you do):
>>>>>>>
>>>>>>
>>>>>> The above statement is moronically stupid when understood within this
>>>>>> context:
>>>>>
>>>>> Note that I included the part in parentheses due to my lingering
>>>>> suspicion that you don't understand logical if/then conditionals.
>>>>>
>>>>> I'm emphasizing that the requirements I stated are necessary, not
>>>>> sufficient.
>>>>>
>>>>>> Without (the mandatory prerequisite of) carefully studying the full
>>>>>> execution trace of this code:
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>       H_Hat((u32)H_Hat);
>>>>>>       HALT
>>>>>> }
>>>>>>
>>>>>> in all three halt decider modes: {disabled, local, global}
>>>>>>
>>>>>> while carefully looking for any error and finding none:
>>>>>> The above statement is moronically stupid
>>>>>
>>>>> But the statement along with the requirements it refers to is not in
>>>>> confict with what you're saying here.
>>>>>
>>>>> The first requirement just says: you can't interpret the traces
>>>>> under one mode (e.g. local) as pertaining to the halting of
>>>>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>>>>
>>>>> Study all the traces you want; just don't mix modes.
>>>>>
>>>>
>>>> When the execution trace of this code:
>>>> (full source code provided)
>>>>
>>>> int main()
>>>> {
>>>>      H_Hat((u32)H_Hat);
>>>> }
>>>>
>>>> Is carefully examined looking for coding or logic errors then the
>>>> non-existence of coding or logic errors proves that the halt decider
>>>> does decide the above code correctly as infinitely recursive in global
>>>> mode and the input to H_Hat() as infinitely recursive in local mode.
>>>
>>> H_Hat isn't infinitely recursive in local mode, because Halts isn't.
>>> So the decision is wrong.
>> You might be bright enough to understand what pathological
>> self-reference is, how it screws up reasoning, and how it can be overcome.
> 
> The self-reference in the halting proofs isn't pathological. It is midly
> ironic, at best. And in fact, I will argue that it isn't self-reference.


// P is the machine address of H_Hat()
void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

Here is a multiple choice question for you please don't pull the same 
dishonest dodge crap that Ben does:

Is the value that Halts() can correctly return to H_Hat()
(a) true
(b) false
(c) neither true nor false

Although you can provide commentary after your multiple choice 
selection, failing to choose one of the three options above will cause 
me to conclude that you are deceitful and no longer worth my time.



-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-06 07:55 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<20210105211352.322@kylheku.com>
In reply to#2480
["Followup-To:" header set to comp.theory.]
On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
> On 1/5/2021 5:52 PM, Kaz Kylheku wrote:
>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/5/2021 4:24 PM, Kaz Kylheku wrote:
>>>> ["Followup-To:" header set to comp.theory.]
>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> The key reason why I need three halt deciding modes is so that people
>>>>>>>>> can see the nuanced details of what is really going on with this case:
>>>>>>>>
>>>>>>>> Your results are invalid if you don't follow these requirements,
>>>>>>>> (and possibly even if you do):
>>>>>>>>
>>>>>>>
>>>>>>> The above statement is moronically stupid when understood within this
>>>>>>> context:
>>>>>>
>>>>>> Note that I included the part in parentheses due to my lingering
>>>>>> suspicion that you don't understand logical if/then conditionals.
>>>>>>
>>>>>> I'm emphasizing that the requirements I stated are necessary, not
>>>>>> sufficient.
>>>>>>
>>>>>>> Without (the mandatory prerequisite of) carefully studying the full
>>>>>>> execution trace of this code:
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>       H_Hat((u32)H_Hat);
>>>>>>>       HALT
>>>>>>> }
>>>>>>>
>>>>>>> in all three halt decider modes: {disabled, local, global}
>>>>>>>
>>>>>>> while carefully looking for any error and finding none:
>>>>>>> The above statement is moronically stupid
>>>>>>
>>>>>> But the statement along with the requirements it refers to is not in
>>>>>> confict with what you're saying here.
>>>>>>
>>>>>> The first requirement just says: you can't interpret the traces
>>>>>> under one mode (e.g. local) as pertaining to the halting of
>>>>>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>>>>>
>>>>>> Study all the traces you want; just don't mix modes.
>>>>>>
>>>>>
>>>>> When the execution trace of this code:
>>>>> (full source code provided)
>>>>>
>>>>> int main()
>>>>> {
>>>>>      H_Hat((u32)H_Hat);
>>>>> }
>>>>>
>>>>> Is carefully examined looking for coding or logic errors then the
>>>>> non-existence of coding or logic errors proves that the halt decider
>>>>> does decide the above code correctly as infinitely recursive in global
>>>>> mode and the input to H_Hat() as infinitely recursive in local mode.
>>>>
>>>> H_Hat isn't infinitely recursive in local mode, because Halts isn't.
>>>> So the decision is wrong.
>>> You might be bright enough to understand what pathological
>>> self-reference is, how it screws up reasoning, and how it can be overcome.
>> 
>> The self-reference in the halting proofs isn't pathological. It is midly
>> ironic, at best. And in fact, I will argue that it isn't self-reference.
>
>
> // P is the machine address of H_Hat()
> void H_Hat(u32 P)
> {
>    u32 Input_Halts = Halts(P, P);
>    if (Input_Halts)
>      HERE: goto HERE;
>    return;
> }
>
> Here is a multiple choice question for you please don't pull the same 
> dishonest dodge crap that Ben does:

> "Is the value that Halts() can correctly return to H_Hat()"

(for P = H_Hat, of course)

> (a) true
> (b) false
> (c) neither true nor false

It has to be (c).

A definition of Halts that returns a correct value doesn't exist.

A function that doesn't exist doesn't return anything.

That eliminates (a) and (b).

(c) can be interpretated as re-iterating the fact that (a) and (b)
are eliminated, which makes (c) true.  A function that doesn't exist
returns neither true nor false.

This is exactly the same as:

"Is the camel which can climb a tree ..."

  (a) dromedary
  (b) bactrian
  (c) neither dromedary nor bactrian

The answer has to be (c).

(c) is the only choice which is consistent with there there not existing
a tree-climbing camel. If something can climb a tree, it is not a camel;
if it is not a camel, it is neither bactrian nor dromedary.

If there is any pathology, it's coming from the question, not from
the domain of discourse.

The question is pathological because he way it is worded suggests that
there exists a camel which can climb a tree, and inquires about that
camel's properties, but a nonexistent object has no properties to speak
of. The elements of a set individually have properties. An empty set has
no elements and so no objects with properties.

Likewise, your question is pathological in the same way because it
suggests that a Halts definition exists which returns a correct value,
and then it asks about its Boolean property: which of the two values
that is.

The pathology is introduced by the way you chose to ask the question,
not by the the problem domain itself. The problem domain contains no
such question in that form.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-06 13:17 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<V_SdnRraJbxfkWvCnZ2dnUU7-XHNnZ2d@giganews.com>
In reply to#2481
On 1/6/2021 1:55 AM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>> On 1/5/2021 5:52 PM, Kaz Kylheku wrote:
>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/5/2021 4:24 PM, Kaz Kylheku wrote:
>>>>> ["Followup-To:" header set to comp.theory.]
>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> The key reason why I need three halt deciding modes is so that people
>>>>>>>>>> can see the nuanced details of what is really going on with this case:
>>>>>>>>>
>>>>>>>>> Your results are invalid if you don't follow these requirements,
>>>>>>>>> (and possibly even if you do):
>>>>>>>>>
>>>>>>>>
>>>>>>>> The above statement is moronically stupid when understood within this
>>>>>>>> context:
>>>>>>>
>>>>>>> Note that I included the part in parentheses due to my lingering
>>>>>>> suspicion that you don't understand logical if/then conditionals.
>>>>>>>
>>>>>>> I'm emphasizing that the requirements I stated are necessary, not
>>>>>>> sufficient.
>>>>>>>
>>>>>>>> Without (the mandatory prerequisite of) carefully studying the full
>>>>>>>> execution trace of this code:
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>        H_Hat((u32)H_Hat);
>>>>>>>>        HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>> in all three halt decider modes: {disabled, local, global}
>>>>>>>>
>>>>>>>> while carefully looking for any error and finding none:
>>>>>>>> The above statement is moronically stupid
>>>>>>>
>>>>>>> But the statement along with the requirements it refers to is not in
>>>>>>> confict with what you're saying here.
>>>>>>>
>>>>>>> The first requirement just says: you can't interpret the traces
>>>>>>> under one mode (e.g. local) as pertaining to the halting of
>>>>>>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>>>>>>
>>>>>>> Study all the traces you want; just don't mix modes.
>>>>>>>
>>>>>>
>>>>>> When the execution trace of this code:
>>>>>> (full source code provided)
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>       H_Hat((u32)H_Hat);
>>>>>> }
>>>>>>
>>>>>> Is carefully examined looking for coding or logic errors then the
>>>>>> non-existence of coding or logic errors proves that the halt decider
>>>>>> does decide the above code correctly as infinitely recursive in global
>>>>>> mode and the input to H_Hat() as infinitely recursive in local mode.
>>>>>
>>>>> H_Hat isn't infinitely recursive in local mode, because Halts isn't.
>>>>> So the decision is wrong.
>>>> You might be bright enough to understand what pathological
>>>> self-reference is, how it screws up reasoning, and how it can be overcome.
>>>
>>> The self-reference in the halting proofs isn't pathological. It is midly
>>> ironic, at best. And in fact, I will argue that it isn't self-reference.
>>
>>
>> // P is the machine address of H_Hat()
>> void H_Hat(u32 P)
>> {
>>     u32 Input_Halts = Halts(P, P);
>>     if (Input_Halts)
>>       HERE: goto HERE;
>>     return;
>> }
>>
>> Here is a multiple choice question for you please don't pull the same
>> dishonest dodge crap that Ben does:
> 
>> "Is the value that Halts() can correctly return to H_Hat()"
> 
> (for P = H_Hat, of course)
> 
>> (a) true
>> (b) false
>> (c) neither true nor false
> 
> It has to be (c).
> 
> A definition of Halts that returns a correct value doesn't exist.
> 
> A function that doesn't exist doesn't return anything.
> 
> That eliminates (a) and (b).
> 
> (c) can be interpretated as re-iterating the fact that (a) and (b)
> are eliminated, which makes (c) true.  A function that doesn't exist
> returns neither true nor false.
> 
> This is exactly the same as:
> 
> "Is the camel which can climb a tree ..."
> 
>    (a) dromedary
>    (b) bactrian
>    (c) neither dromedary nor bactrian
> 
> The answer has to be (c).
> 

Great! Now when I define my terms it will be easier to see what I mean:

Pathological Self-Reference(Olcott 2004)
is defined as the case where a
(a) declarative sentence,
(b) polar question,
(c) logical proposition
cannot be resolved to yes/no true/false because of self-reference.

When we ask the polar question:
What Boolean value can Halts() correctly return to H_Hat()
we see that this question has Pathological Self-Reference(Olcott 2004).

> (c) is the only choice which is consistent with there there not existing
> a tree-climbing camel. If something can climb a tree, it is not a camel;
> if it is not a camel, it is neither bactrian nor dromedary.
> 
> If there is any pathology, it's coming from the question, not from
> the domain of discourse.
> 

 >> // P is the machine address of H_Hat()
 >> void H_Hat(u32 P)
 >> {
 >>     u32 Input_Halts = Halts(P, P);
 >>     if (Input_Halts)
 >>       HERE: goto HERE;
 >>     return;
 >> }

The question is hard-wired into the conventional undecidability proof 
trick of "do the opposite of whatever the halt decider decides"

Now we construct a new Turing machine D with H as a subroutine. This new 
TM calls H to determine what M does when the input to M is its own 
description (M). Once D has determined this information, it does the 
opposite. That is, it rejects if M accepts and accepts if M does not 
accept. http://www.liarparadox.org/sipser_165.pdf

Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company (165-167)

> The question is pathological because he way it is worded suggests that
> there exists a camel which can climb a tree, and inquires about that

"do the opposite of whatever the halt decider decides" as an integral 
aspect of the undecidability proof places Pathological 
Self-Reference(Olcott 2004) as an integral part of this proof itself.

> camel's properties, but a nonexistent object has no properties to speak
> of. The elements of a set individually have properties. An empty set has
> no elements and so no objects with properties.
> 
> Likewise, your question is pathological in the same way because it
> suggests that a Halts definition exists which returns a correct value,
> and then it asks about its Boolean property: which of the two values
> that is.
> 

When we consider which of the two values that Halts() can return to 
H_Hat() the correct answer is neither because the invocation of Halts() 
by H_Hat() would be infinitely recursive if Halts() did not abort this 
invocation.

There is never ever any case where any function can ever correctly 
return a value to its infinitely recursive invocation, not even if we 
sprinkle magic fairy dust.

Although a decider must always eventually indicate a decision it is not
required to return a result to every caller. That so many people in this 
forum seemed to think otherwise seems quite nuts. They might as well 
have said that all infinite loops only iterate ten times.

     The term decider doesn't really have a standard meaning.
     In fact, it is lamentable that Sipser chose the terms
     decider and recognizer, since they seem to confuse students.

     Yuval Filmus
     Assistant Professor in the Henry and Marilyn Taub Department
     of Computer Science at the Technion – Israel Institute of
     Technology.

     https://cs.stackexchange.com/questions/84433/what-is-decider

> The pathology is introduced by the way you chose to ask the question,
> not by the the problem domain itself. The problem domain contains no
> such question in that form.
> 

The question is hard-wired into the conventional undecidability proof 
trick of "do the opposite of whatever the halt decider decides"

-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-06 21:48 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<20210106132650.676@kylheku.com>
In reply to#2482
On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
> Great! Now when I define my terms it will be easier to see what I mean:
>
> Pathological Self-Reference(Olcott 2004)
> is defined as the case where a
> (a) declarative sentence,
> (b) polar question,
> (c) logical proposition
> cannot be resolved to yes/no true/false because of self-reference.

Suit yourself.

> When we ask the polar question:
> What Boolean value can Halts() correctly return to H_Hat()

Nobody is asking that question though; that's a loaded question you
invented, similar to "have you stopped beating your wife".

The correct question is: "does there exist a function Halts which can
be embedded into H_Hat, and return a correct value when P = H_Hat?"
That question has a straightforward "no" answer.

Just like "does there exist a tree-climbing camel?"

Moreover, if Halts returns, it has a stable true or false value.

Whether or not H_Hat(H_hat) halts or not is also determined as true or
false.

So this has nothing to do with a self-referential logical proposition
whose Boolean value cannot be established. No logical propositions are
being abused in any way, like in the Liar Paradox.

> we see that this question has Pathological Self-Reference(Olcott 2004).

All you have done is invent an idiotically worded question,
equivalent to "is a nonexistent camel bactrian or dromedary"?

No such question is used in serious literature about the halting
problem.

Nobody calling themselves a mathematician would blab about what
a function "can" return. Functions only denote mappings from inputs to
outputs; there is no "can" or "cannot".

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-06 16:38 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<c-qdnTCYheVFpmvCnZ2dnUU7-UvNnZ2d@giganews.com>
In reply to#2483
On 1/6/2021 3:48 PM, Kaz Kylheku wrote:
> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>> Great! Now when I define my terms it will be easier to see what I mean:
>>
>> Pathological Self-Reference(Olcott 2004)
>> is defined as the case where a
>> (a) declarative sentence,
>> (b) polar question,
>> (c) logical proposition
>> cannot be resolved to yes/no true/false because of self-reference.
> 
> Suit yourself.
> 
>> When we ask the polar question:
>> What Boolean value can Halts() correctly return to H_Hat()
> 
> Nobody is asking that question though; that's a loaded question you
> invented, similar to "have you stopped beating your wife".
> 
> The correct question is: "does there exist a function Halts which can
> be embedded into H_Hat, and return a correct value when P = H_Hat?"
> That question has a straightforward "no" answer.
> 
> Just like "does there exist a tree-climbing camel?"
> 
> Moreover, if Halts returns, it has a stable true or false value.
> 
> Whether or not H_Hat(H_hat) halts or not is also determined as true or
> false.
> 
> So this has nothing to do with a self-referential logical proposition
> whose Boolean value cannot be established. No logical propositions are
> being abused in any way, like in the Liar Paradox.
> 
>> we see that this question has Pathological Self-Reference(Olcott 2004).
> 
> All you have done is invent an idiotically worded question,
> equivalent to "is a nonexistent camel bactrian or dromedary"?
> 
> No such question is used in serious literature about the halting
> problem.
> 
> Nobody calling themselves a mathematician would blab about what
> a function "can" return. Functions only denote mappings from inputs to
> outputs; there is no "can" or "cannot".
> 


The question is hard-wired into the conventional undecidability proof 
trick of

"do the opposite of whatever the halt decider decides"
"do the opposite of whatever the halt decider decides"
"do the opposite of whatever the halt decider decides"
"do the opposite of whatever the halt decider decides"
"do the opposite of whatever the halt decider decides"

Now we construct a new Turing machine D with H as a subroutine. This new 
TM calls H to determine what M does when the input to M is its own 
description (M). Once D has determined this information, it does the 
opposite. That is, it rejects if M accepts and accepts if M does not 
accept. http://www.liarparadox.org/sipser_165.pdf
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company (165-167)

This makes all the conventional HP undecidability proofs based on 
Pathological Self-Reference(Olcott 2004)

This makes all the conventional HP undecidability proofs based on 
Pathological Self-Reference(Olcott 2004)

This makes all the conventional HP undecidability proofs based on 
Pathological Self-Reference(Olcott 2004)

This makes all the conventional HP undecidability proofs based on 
Pathological Self-Reference(Olcott 2004)

This makes all the conventional HP undecidability proofs based on 
Pathological Self-Reference(Olcott 2004)

-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-07 05:28 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<20210106145623.388@kylheku.com>
In reply to#2484
On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
> The question is hard-wired into the conventional undecidability proof 
> trick of

No, it isn't. Not any more than the "have you stopped beating your wife"
question is hard-wired into the psychology of marriage.

It's just nonsense that you're insisting on.

Nobody in their right mind asks whether a function that doesn't exist
returns true or false, or whether a nonexistent camel is dromedary or
bactrian, or whether someone not known to beat their wife (or not even
married) has stopped beating their wife.

Pretending that the phrase "nonexistent function" refers to a real
object, which has to have real properties (like returning true or
false) is just word semantic nonsense.

It's purely a verbal construct you've come up with.

You've confused map and territory. The map you're choosing to view the
territory and explain it to yourself is incorrect and pathological, not
the territory.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-07 10:00 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Deceiver?)
Message-ID<NfednYH41NqNrWrCnZ2dnUU7-VXNnZ2d@giganews.com>
In reply to#2485
On 1/6/2021 11:28 PM, Kaz Kylheku wrote:
> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>> The question is hard-wired into the conventional undecidability proof
>> trick of
> 
> No, it isn't. Not any more than the "have you stopped beating your wife"
> question is hard-wired into the psychology of marriage.
> 

Choosing to interpret [the logical law of polar questions] as pertaining 
to psychology of marriage instead of the formal semantics of natural 
language is the same king of intentionally deceiptful crap that Ben 
always pulls.

Have you decided to become a God damned liar?

sci.lang
Peter Olcott
Feb 20, 2015, 11:38:48 AM

The logical law of polar questions

When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.

All polar questions (including incorrect polar questions)
have exactly one answer from the following:
1) No
2) Yes
3) Neither // Only applies to incorrect polar questions

As far as I know I am the original discoverer of the
above logical law, thus copyright 2015 by Peter Olcott.

Permission to copy and freely distribute the above
is hereby granted as long as it is distributed in
its entirely including this license agreement.

https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ

> It's just nonsense that you're insisting on.
> 
> Nobody in their right mind asks whether a function that doesn't exist
> returns true or false, or whether a nonexistent camel is dromedary or
> bactrian, or whether someone not known to beat their wife (or not even
> married) has stopped beating their wife.

By your same screwy reasoning no one would ever talk about the liar 
paradox because the fact that it is not true causes it to cease to exist.

Pathological Self-Reference(Olcott 2004)
is defined as the case where a
(a) declarative sentence,
(b) polar question,
(c) logical proposition
cannot be resolved to yes/no true/false because of self-reference.

The above phenomenon does not cause expressions of formal or natural 
language to cease to exist, it causes them to be logically incoherent.

> Pretending that the phrase "nonexistent function" refers to a real
> object, which has to have real properties (like returning true or
> false) is just word semantic nonsense.

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

When math looks at the halting problem counter example within 
existential quantification math concludes that there is no mathematical 
mapping from the above invocation of Halts() to a return value to 
H_Hat() of true or false.

Pathological Self-Reference(Olcott 2004)
Explains why no such mapping exists.

The great error in your analysis is conflating the technical term of the 
art of existential quantification with the common meaning of the term 
existence. Gullible people would be fooled by such a ruse. Ben tried 
this same deceptive crap.

When math says that a function does not exist math is only saying that a 
specific mathematical mapping does not exist.

When we know this and avoid the fallacy of equivocation error thenn 
(then and only then) we can ask: What prevents the mathematical mapping 
from existing?

The answer to this question is that the logical incoherence of
Pathological Self-Reference(Olcott 2004) prevents the mapping from 
existing.

> It's purely a verbal construct you've come up with.
> 
> You've confused map and territory. The map you're choosing to view the
> territory and explain it to yourself is incorrect and pathological, not
> the territory.



-- 
Copyright 2021 Pete Olcott

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

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


#2487 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-07 13:41 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)
Message-ID<KPGdnTx3ipdh_mrCnZ2dnUU7-e3NnZ2d@giganews.com>
In reply to#2485
On 1/7/2021 1:25 PM, André G. Isaak wrote:
> On 2021-01-07 12:05, olcott wrote:
>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>
>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>> The question is hard-wired into the conventional undecidability proof
>>>>> trick of
>>>>
>>>> No, it isn't. Not any more than the "have you stopped beating your 
>>>> wife"
>>>> question is hard-wired into the psychology of marriage.
>>>>
>>>> It's just nonsense that you're insisting on.
>>>>
>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>> married) has stopped beating their wife.
>>>>
>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>> object, which has to have real properties (like returning true or
>>>> false) is just word semantic nonsense.
>>>
>>> The trouble PO has is that "the function" clearly exists.  He's written
>>> it, and he can see that neither return value can be right.
>>>
>>> Don't get me wrong -- I do understand what you are saying.  "The
>>> function" that does not exist is a correct halt decider (that's the CS
>>> point of view) but PO is thinking like an engineer.  He has actual code.
>>> For him "the function" is that real, actual code and, at some level, it
>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>> cases.  But he can now see that this bug can't be fixed.  To an
>>> engineer, an unfixable bug means there is something wrong with the
>>> specification.
>>>
>>> This is why I hate the argument that Linz presents, even if he does so
>>> only for historical interest.  To engineers (and most software people
>>> have been taught to think like engineers) the "assume H is a halt
>>> decider" style of proof makes it simply too easy to think that there's a
>>> function with an, apparently, unfixable bug.  A class of engineers will
>>> spend a lot of time trying to fix the bug and, failing that, try to find
>>> out what's wrong with the specification.
>>>
>>> The other proof in Linz is also problematic for a class of engineers
>>> because it is so abstract.  Like a lot of mathematical proofs it's hard
>>> to see how it explains the "why".  It's just a bald fact -- a halt
>>> decider would contradict theorem 11.5 (or whatever).  That's why I
>>> preferred the diagonal argument: every TM computes a function (sometimes
>>> a partial one) but every TM has the property that the function it
>>> computes is not the halting function.  Nothing nonexistent is ever
>>> imagined, we simply learn something universal about TMs.
>>>
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Halts(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> The diagonal argument only shows that neither true nor false is a 
>> correct value that Halts() can return to H_Hat().
>>
>> This shallow analysis utterly ignores the possibility that H_Hat() can 
>> be correctly decided by aborting the simulation of H_Hat before 
>> Halts() returns any value to H_Hat() on the basis that the H_Hat() 
>> invocation of Halts() would otherwise be infinitely recursive if 
>> Halts() did not stop simulating it.
>>
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>  > A computation that would not halt if its simulation were not
>>  > halted is indeed a non-halting computation.
>>
>>
>> int main()
>> {
>>    u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>> }
>>
>> What is decider?
>>
>> The term decider doesn't really have a standard meaning.
>> In fact, it is lamentable that Sipser chose the terms decider
>> and recognizer, since they seem to confuse students.
>>
>> Intuitively, a decider should be a Turing machine that given
>> an input, halts and either accepts or rejects, relaying its
>> answer in one of many equivalent ways, such as halting
>> at an ACCEPT or REJECT state, or leaving its answer on
>> the output tape.
>>
>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>> Assistant Professor in the Henry and Marilyn
>> Taub Department of Computer Science at the
>> Technion – Israel Institute of Technology.
>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>
>> The above proves that your stupid idea that a decider must return a
>> value to its every invocation is just as dishonest as many of the
>> things that you say. A decider must eventually halt in an accept
>> or reject state, yet is never required to return any value to it
>> otherwise infinite invocation.
> 
> You've cited this particular website on numerous occasions but you don't 
> seem to understand what is being said in it. The author is pointing to 
> an ambiguity in the *type* of value which a decider returns. There is no 
> disagreement whatsoever over the fact that a decider is defined as a TM 
> which *always* halts and returns a value. The only ambiguity which is 
> being addressed here is whether that value should be limited to true or 
> false.
> 



> Any TM which can possibly enter an infinite loop or infinite recursion 
> and which thus sometimes fails to return an answer is *not* a decider by 
> any definition.
> 
> André
> 

Yet this code <is> a decider for H_Hat() even though it never returns 
any value to 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);
}

I finally got rid of the need for this instruction:
   #define HALT __asm hlt

I had initially needed it as a part of my context switching protocol.
I still use it internally to indicate the end of a simulation.


-- 
Copyright 2021 Pete Olcott

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

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


#2488 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-07 13:45 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)
Message-ID<B-Cdnazixp54-WrCnZ2dnUU7-V3NnZ2d@giganews.com>
In reply to#2487
On 1/7/2021 1:41 PM, olcott wrote:
> On 1/7/2021 1:25 PM, André G. Isaak wrote:
>> On 2021-01-07 12:05, olcott wrote:
>>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>
>>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The question is hard-wired into the conventional undecidability proof
>>>>>> trick of
>>>>>
>>>>> No, it isn't. Not any more than the "have you stopped beating your 
>>>>> wife"
>>>>> question is hard-wired into the psychology of marriage.
>>>>>
>>>>> It's just nonsense that you're insisting on.
>>>>>
>>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>>> married) has stopped beating their wife.
>>>>>
>>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>>> object, which has to have real properties (like returning true or
>>>>> false) is just word semantic nonsense.
>>>>
>>>> The trouble PO has is that "the function" clearly exists.  He's written
>>>> it, and he can see that neither return value can be right.
>>>>
>>>> Don't get me wrong -- I do understand what you are saying.  "The
>>>> function" that does not exist is a correct halt decider (that's the CS
>>>> point of view) but PO is thinking like an engineer.  He has actual 
>>>> code.
>>>> For him "the function" is that real, actual code and, at some level, it
>>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>>> cases.  But he can now see that this bug can't be fixed.  To an
>>>> engineer, an unfixable bug means there is something wrong with the
>>>> specification.
>>>>
>>>> This is why I hate the argument that Linz presents, even if he does so
>>>> only for historical interest.  To engineers (and most software people
>>>> have been taught to think like engineers) the "assume H is a halt
>>>> decider" style of proof makes it simply too easy to think that 
>>>> there's a
>>>> function with an, apparently, unfixable bug.  A class of engineers will
>>>> spend a lot of time trying to fix the bug and, failing that, try to 
>>>> find
>>>> out what's wrong with the specification.
>>>>
>>>> The other proof in Linz is also problematic for a class of engineers
>>>> because it is so abstract.  Like a lot of mathematical proofs it's hard
>>>> to see how it explains the "why".  It's just a bald fact -- a halt
>>>> decider would contradict theorem 11.5 (or whatever).  That's why I
>>>> preferred the diagonal argument: every TM computes a function 
>>>> (sometimes
>>>> a partial one) but every TM has the property that the function it
>>>> computes is not the halting function.  Nothing nonexistent is ever
>>>> imagined, we simply learn something universal about TMs.
>>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Input_Halts = Halts(P, P);
>>>    if (Input_Halts)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> The diagonal argument only shows that neither true nor false is a 
>>> correct value that Halts() can return to H_Hat().
>>>
>>> This shallow analysis utterly ignores the possibility that H_Hat() 
>>> can be correctly decided by aborting the simulation of H_Hat before 
>>> Halts() returns any value to H_Hat() on the basis that the H_Hat() 
>>> invocation of Halts() would otherwise be infinitely recursive if 
>>> Halts() did not stop simulating it.
>>>
>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>  > A computation that would not halt if its simulation were not
>>>  > halted is indeed a non-halting computation.
>>>
>>>
>>> int main()
>>> {
>>>    u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>> }
>>>
>>> What is decider?
>>>
>>> The term decider doesn't really have a standard meaning.
>>> In fact, it is lamentable that Sipser chose the terms decider
>>> and recognizer, since they seem to confuse students.
>>>
>>> Intuitively, a decider should be a Turing machine that given
>>> an input, halts and either accepts or rejects, relaying its
>>> answer in one of many equivalent ways, such as halting
>>> at an ACCEPT or REJECT state, or leaving its answer on
>>> the output tape.
>>>
>>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>>> Assistant Professor in the Henry and Marilyn
>>> Taub Department of Computer Science at the
>>> Technion – Israel Institute of Technology.
>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>
>>> The above proves that your stupid idea that a decider must return a
>>> value to its every invocation is just as dishonest as many of the
>>> things that you say. A decider must eventually halt in an accept
>>> or reject state, yet is never required to return any value to it
>>> otherwise infinite invocation.
>>
>> You've cited this particular website on numerous occasions but you 
>> don't seem to understand what is being said in it. The author is 
>> pointing to an ambiguity in the *type* of value which a decider 
>> returns. There is no disagreement whatsoever over the fact that a 
>> decider is defined as a TM which *always* halts and returns a value. 
>> The only ambiguity which is being addressed here is whether that value 
>> should be limited to true or false.
>>
> 
> 
> 
>> Any TM which can possibly enter an infinite loop or infinite recursion 
>> and which thus sometimes fails to return an answer is *not* a decider 
>> by any definition.
>>
>> André
>>
> 
> Yet this code <is> a decider for H_Hat() even though it never returns 
> any value to 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);
> }
> 

Output_Decoded_Instructions_from_address_list() [000211b6]  size(64) 
capacity(4096)
***[0000088a](01)  55                  push ebp
***[0000088b](02)  8bec                mov ebp,esp
***[0000088d](01)  51                  push ecx
***[0000088e](03)  8b4508              mov eax,[ebp+08]
***[00000891](01)  50                  push eax
***[00000892](03)  8b4d08              mov ecx,[ebp+08]
***[00000895](01)  51                  push ecx
***[00000896](05)  e8dffdffff          call 0000067a
***[0000088a](01)  55                  push ebp
***[0000088b](02)  8bec                mov ebp,esp
***[0000088d](01)  51                  push ecx
***[0000088e](03)  8b4508              mov eax,[ebp+08]
***[00000891](01)  50                  push eax
***[00000892](03)  8b4d08              mov ecx,[ebp+08]
***[00000895](01)  51                  push ecx
***[00000896](05)  e8dffdffff          call 0000067a
...[000008cd](03)  83c408              add esp,+08
...[000008d0](03)  8945fc              mov [ebp-04],eax
...[000008d3](03)  8b45fc              mov eax,[ebp-04]
...[000008d6](01)  50                  push eax
...[000008d7](05)  6827030000          push 00000327
Input_Would_Halt = 0
[000008dc](05)  e879faffff          call 0000035a
...[000008e1](03)  83c408              add esp,+08
...[000008e4](02)  33c0                xor eax,eax
...[000008e6](02)  8be5                mov esp,ebp
...[000008e8](01)  5d                  pop ebp




-- 
Copyright 2021 Pete Olcott

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

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


#2490 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-07 18:11 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)
Message-ID<2YidnV3DcNuGPmrCnZ2dnUU7-L3NnZ2d@giganews.com>
In reply to#2487
On 1/7/2021 5:45 PM, Richard Damon wrote:
> On 1/7/21 2:41 PM, olcott wrote:
>> On 1/7/2021 1:25 PM, André G. Isaak wrote:
>>> On 2021-01-07 12:05, olcott wrote:
>>>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>>
>>>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> The question is hard-wired into the conventional undecidability proof
>>>>>>> trick of
>>>>>>
>>>>>> No, it isn't. Not any more than the "have you stopped beating your
>>>>>> wife"
>>>>>> question is hard-wired into the psychology of marriage.
>>>>>>
>>>>>> It's just nonsense that you're insisting on.
>>>>>>
>>>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>>>> married) has stopped beating their wife.
>>>>>>
>>>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>>>> object, which has to have real properties (like returning true or
>>>>>> false) is just word semantic nonsense.
>>>>>
>>>>> The trouble PO has is that "the function" clearly exists.  He's written
>>>>> it, and he can see that neither return value can be right.
>>>>>
>>>>> Don't get me wrong -- I do understand what you are saying.  "The
>>>>> function" that does not exist is a correct halt decider (that's the CS
>>>>> point of view) but PO is thinking like an engineer.  He has actual
>>>>> code.
>>>>> For him "the function" is that real, actual code and, at some level, it
>>>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>>>> cases.  But he can now see that this bug can't be fixed.  To an
>>>>> engineer, an unfixable bug means there is something wrong with the
>>>>> specification.
>>>>>
>>>>> This is why I hate the argument that Linz presents, even if he does so
>>>>> only for historical interest.  To engineers (and most software people
>>>>> have been taught to think like engineers) the "assume H is a halt
>>>>> decider" style of proof makes it simply too easy to think that
>>>>> there's a
>>>>> function with an, apparently, unfixable bug.  A class of engineers will
>>>>> spend a lot of time trying to fix the bug and, failing that, try to
>>>>> find
>>>>> out what's wrong with the specification.
>>>>>
>>>>> The other proof in Linz is also problematic for a class of engineers
>>>>> because it is so abstract.  Like a lot of mathematical proofs it's hard
>>>>> to see how it explains the "why".  It's just a bald fact -- a halt
>>>>> decider would contradict theorem 11.5 (or whatever).  That's why I
>>>>> preferred the diagonal argument: every TM computes a function
>>>>> (sometimes
>>>>> a partial one) but every TM has the property that the function it
>>>>> computes is not the halting function.  Nothing nonexistent is ever
>>>>> imagined, we simply learn something universal about TMs.
>>>>>
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>>     u32 Input_Halts = Halts(P, P);
>>>>     if (Input_Halts)
>>>>       HERE: goto HERE;
>>>>     return;
>>>> }
>>>>
>>>> The diagonal argument only shows that neither true nor false is a
>>>> correct value that Halts() can return to H_Hat().
>>>>
>>>> This shallow analysis utterly ignores the possibility that H_Hat()
>>>> can be correctly decided by aborting the simulation of H_Hat before
>>>> Halts() returns any value to H_Hat() on the basis that the H_Hat()
>>>> invocation of Halts() would otherwise be infinitely recursive if
>>>> Halts() did not stop simulating it.
>>>>
>>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>>   > A computation that would not halt if its simulation were not
>>>>   > halted is indeed a non-halting computation.
>>>>
>>>>
>>>> int main()
>>>> {
>>>>     u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>> }
>>>>
>>>> What is decider?
>>>>
>>>> The term decider doesn't really have a standard meaning.
>>>> In fact, it is lamentable that Sipser chose the terms decider
>>>> and recognizer, since they seem to confuse students.
>>>>
>>>> Intuitively, a decider should be a Turing machine that given
>>>> an input, halts and either accepts or rejects, relaying its
>>>> answer in one of many equivalent ways, such as halting
>>>> at an ACCEPT or REJECT state, or leaving its answer on
>>>> the output tape.
>>>>
>>>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>>>> Assistant Professor in the Henry and Marilyn
>>>> Taub Department of Computer Science at the
>>>> Technion – Israel Institute of Technology.
>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>
>>>> The above proves that your stupid idea that a decider must return a
>>>> value to its every invocation is just as dishonest as many of the
>>>> things that you say. A decider must eventually halt in an accept
>>>> or reject state, yet is never required to return any value to it
>>>> otherwise infinite invocation.
>>>
>>> You've cited this particular website on numerous occasions but you
>>> don't seem to understand what is being said in it. The author is
>>> pointing to an ambiguity in the *type* of value which a decider
>>> returns. There is no disagreement whatsoever over the fact that a
>>> decider is defined as a TM which *always* halts and returns a value.
>>> The only ambiguity which is being addressed here is whether that value
>>> should be limited to true or false.
>>>
>>
>>
>>
>>> Any TM which can possibly enter an infinite loop or infinite recursion
>>> and which thus sometimes fails to return an answer is *not* a decider
>>> by any definition.
>>>
>>> André
>>>
>>
>> Yet this code <is> a decider for H_Hat() even though it never returns
>> any value to 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);
>> }
>>
>> I finally got rid of the need for this instruction:
>>    #define HALT __asm hlt
>>
>> I had initially needed it as a part of my context switching protocol.
>> I still use it internally to indicate the end of a simulation.
>>
> 
> But if it represents the equivalent of the Turing Machine H, and H_Hat
> represents the Linz H^, then Halts MUST return that same value to H_Hat,
> or the equivelence was done wrong, or Halts doesn't actually return its
> value.
> 

Not at all. All the proofs simply fail to consider that when the halt 
decider bases its decision on simulating its input that this halt 
decider must stop simulating H_Hat() before ever returning a value to 
H_Hat().


That you cannot seem to understand that there is never ever any case 
where the otherwise infinite invocation of a function can ever return a 
value to its caller makes me think that something is seriously wrong 
with your brain.


It is like you are thinking that once in a while there is a case where a 
baby kitten really is a type of office building. **

** conventional meaning of the terms.


-- 
Copyright 2021 Pete Olcott

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

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


#2489 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-07 17:43 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)
Message-ID<XoudnSykpY8oAWrCnZ2dnUU7-YPNnZ2d@giganews.com>
In reply to#2485
On 1/7/2021 1:59 PM, Kaz Kylheku wrote:
> On 2021-01-07, olcott <NoOne@NoWhere.com> wrote:
>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>
>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>> The question is hard-wired into the conventional undecidability proof
>>>>> trick of
>>>>
>>>> No, it isn't. Not any more than the "have you stopped beating your wife"
>>>> question is hard-wired into the psychology of marriage.
>>>>
>>>> It's just nonsense that you're insisting on.
>>>>
>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>> married) has stopped beating their wife.
>>>>
>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>> object, which has to have real properties (like returning true or
>>>> false) is just word semantic nonsense.
>>>
>>> The trouble PO has is that "the function" clearly exists.  He's written
>>> it, and he can see that neither return value can be right.
>>>
>>> Don't get me wrong -- I do understand what you are saying.  "The
>>> function" that does not exist is a correct halt decider (that's the CS
>>> point of view) but PO is thinking like an engineer.  He has actual code.
>>> For him "the function" is that real, actual code and, at some level, it
>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>> cases.  But he can now see that this bug can't be fixed.  To an
>>> engineer, an unfixable bug means there is something wrong with the
>>> specification.
>>>
>>> This is why I hate the argument that Linz presents, even if he does so
>>> only for historical interest.  To engineers (and most software people
>>> have been taught to think like engineers) the "assume H is a halt
>>> decider" style of proof makes it simply too easy to think that there's a
>>> function with an, apparently, unfixable bug.  A class of engineers will
>>> spend a lot of time trying to fix the bug and, failing that, try to find
>>> out what's wrong with the specification.
>>>
>>> The other proof in Linz is also problematic for a class of engineers
>>> because it is so abstract.  Like a lot of mathematical proofs it's hard
>>> to see how it explains the "why".  It's just a bald fact -- a halt
>>> decider would contradict theorem 11.5 (or whatever).  That's why I
>>> preferred the diagonal argument: every TM computes a function (sometimes
>>> a partial one) but every TM has the property that the function it
>>> computes is not the halting function.  Nothing nonexistent is ever
>>> imagined, we simply learn something universal about TMs.
>>>
>>
>> void H_Hat(u32 P)
>> {
>>     u32 Input_Halts = Halts(P, P);
>>     if (Input_Halts)
>>       HERE: goto HERE;
>>     return;
>> }
>>
>> The diagonal argument only shows that neither true nor false is a
>> correct value that Halts() can return to H_Hat().
> 
> It shows no such thing; the language you are using here is ill-formed.
> 
> The correct language is that exists no definition of Halts which returns
> the correct value (when P = H_Hat, don't forget that).
> 
It is you that is forgetting not me.

In the following code Halts() DOES do return the correct value, it 
simply doesn't return it to 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);
}


_H_Hat()
[0000088a](01)  55                  push ebp
[0000088b](02)  8bec                mov ebp,esp
[0000088d](01)  51                  push ecx
[0000088e](03)  8b4508              mov eax,[ebp+08]
[00000891](01)  50                  push eax
[00000892](03)  8b4d08              mov ecx,[ebp+08]
[00000895](01)  51                  push ecx
[00000896](05)  e8dffdffff          call 0000067a
[0000089b](03)  83c408              add esp,+08
[0000089e](03)  8945fc              mov [ebp-04],eax
[000008a1](04)  837dfc00            cmp dword [ebp-04],+00
[000008a5](02)  7402                jz 000008a9
[000008a7](02)  ebfe                jmp 000008a7
[000008a9](02)  8be5                mov esp,ebp
[000008ab](01)  5d                  pop ebp
[000008ac](01)  c3                  ret

_main()
[000008ba](01)  55                  push ebp
[000008bb](02)  8bec                mov ebp,esp
[000008bd](01)  51                  push ecx
[000008be](05)  688a080000          push 0000088a
[000008c3](05)  688a080000          push 0000088a
[000008c8](05)  e8adfdffff          call 0000067a
[000008cd](03)  83c408              add esp,+08
[000008d0](03)  8945fc              mov [ebp-04],eax
[000008d3](03)  8b45fc              mov eax,[ebp-04]
[000008d6](01)  50                  push eax
[000008d7](05)  6827030000          push 00000327
[000008dc](05)  e879faffff          call 0000035a
[000008e1](03)  83c408              add esp,+08
[000008e4](02)  33c0                xor eax,eax
[000008e6](02)  8be5                mov esp,ebp
[000008e8](01)  5d                  pop ebp
[000008e9](01)  c3                  ret

***[0000088a](01)  55                  push ebp
***[0000088b](02)  8bec                mov ebp,esp
***[0000088d](01)  51                  push ecx
***[0000088e](03)  8b4508              mov eax,[ebp+08]
***[00000891](01)  50                  push eax
***[00000892](03)  8b4d08              mov ecx,[ebp+08]
***[00000895](01)  51                  push ecx
***[00000896](05)  e8dffdffff          call 0000067a
***[0000088a](01)  55                  push ebp
***[0000088b](02)  8bec                mov ebp,esp
***[0000088d](01)  51                  push ecx
***[0000088e](03)  8b4508              mov eax,[ebp+08]
***[00000891](01)  50                  push eax
***[00000892](03)  8b4d08              mov ecx,[ebp+08]
***[00000895](01)  51                  push ecx
***[00000896](05)  e8dffdffff          call 0000067a
...[000008cd](03)  83c408              add esp,+08
...[000008d0](03)  8945fc              mov [ebp-04],eax
...[000008d3](03)  8b45fc              mov eax,[ebp-04]
...[000008d6](01)  50                  push eax
...[000008d7](05)  6827030000          push 00000327
Input_Would_Halt = 0
[000008dc](05)  e879faffff          call 0000035a
...[000008e1](03)  83c408              add esp,+08
...[000008e4](02)  33c0                xor eax,eax
...[000008e6](02)  8be5                mov esp,ebp
...[000008e8](01)  5d                  pop ebp



-- 
Copyright 2021 Pete Olcott

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

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


#2492 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-08 11:47 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)
Message-ID<KtydnXnOSf0CB2XCnZ2dnUU7-XPNnZ2d@giganews.com>
In reply to#2489
On 1/7/2021 6:59 PM, Kaz Kylheku wrote:
> On 2021-01-07, olcott <NoOne@NoWhere.com> wrote:
>> On 1/7/2021 1:59 PM, Kaz Kylheku wrote:
>>> It shows no such thing; the language you are using here is ill-formed.
>>>
>>> The correct language is that exists no definition of Halts which returns
>>> the correct value (when P = H_Hat, don't forget that).
>>>
>> It is you that is forgetting not me.
>>
>> In the following code Halts() DOES do return the correct value, it
>> simply doesn't return it to H_Hat().
> 
> I'm afraid that is not valid. A function returns the value implied
> by its arguments, regardless of any context.
> 

Like Ben is saying I am talking from a software engineering perspective 
where every single detail is explicitly encoded and nothing is simply 
assumed away.

To say that from a software engineering perspective that there are times 
when a software function returns a value to its otherwise infinite 
invocation is just like saying that there are times when a baby kitten 
really is a type of office building. **

** Within the conventional meaning of the terms "kitten" and "office 
building".

-- 
Copyright 2021 Pete Olcott

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

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


#2493 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-08 18:00 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?)
Message-ID<20210108095829.941@kylheku.com>
In reply to#2492
["Followup-To:" header set to comp.theory.]
On 2021-01-08, olcott <NoOne@NoWhere.com> wrote:
> On 1/7/2021 6:59 PM, Kaz Kylheku wrote:
>> On 2021-01-07, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/7/2021 1:59 PM, Kaz Kylheku wrote:
>>>> It shows no such thing; the language you are using here is ill-formed.
>>>>
>>>> The correct language is that exists no definition of Halts which returns
>>>> the correct value (when P = H_Hat, don't forget that).
>>>>
>>> It is you that is forgetting not me.
>>>
>>> In the following code Halts() DOES do return the correct value, it
>>> simply doesn't return it to H_Hat().
>> 
>> I'm afraid that is not valid. A function returns the value implied
>> by its arguments, regardless of any context.
>> 
>
> Like Ben is saying I am talking from a software engineering perspective 
> where every single detail is explicitly encoded and nothing is simply 
> assumed away.

You're deliberately refusing to test your code in obvious ways and
provide the results. You cannot call yourself an engineer, therefore.
In the context of an engineering organization, you belong in sales and
marketing.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-08 11:40 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<Jo6dnSEyULCJBGXCnZ2dnUU7-e_NnZ2d@giganews.com>
In reply to#2482
On 1/6/2021 9:20 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 1/6/2021 7:00 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> When we consider which of the two values that Halts() can return to
>>>> H_Hat() the correct answer is neither because the invocation of
>>>> Halts() by H_Hat() would be infinitely recursive if Halts() did not
>>>> abort this invocation.
>>>
>>> Not so long ago you said:
>>>
>>> | I have proven that this argument is not valid by making an H that
>>> | decides (Ĥ, Ĥ).
>>>
>>> Causing me to check, and you to confirm (albeit rather evasively):
>>>
>>> || What is the decision -- halts, or does not halt?
>>> | Yes it is one of those.
>>>
>>> || Do you claim that the decision is the correct one?
>>> | It is easily verifiably correct.
>>>
>>> So what is the easily verifiably correct, halts or does not halt
>>> decision that H gave for (Ĥ, Ĥ) back then?
> 
> No answer?
> 
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>> A computation that would not halt if its simulation were not
>>> halted is indeed a non-halting computation.
> 
> This is not an answer -- it's barely more than a tautology.  What is the
> correct halts/not halts answer you calmed you got from H for (Ĥ, Ĥ)?
> 
> I don't expect an answer.  But your not answering will help people to
> understand how evasive you are.
> 
> Here's the real explanation (that you cut):
> 
> The (current) resolution to these apparently contradictory remarks is
> that there are two algorithms both called Halts (or H).  The one called
> from or used by H_Hat (or Ĥ) does not answer, and the other does.  

It would be incorrect for me to answer questions that are based on 
fundamental false assumptions until after all these false assumptions 
are first corrected.

Since I have already corrected these fundamental false assumptions many 
times it seems question obvious that you have no interest in the actual 
truth.

The fundamental false assumption that you make in your above paragraph 
is that there is more than one halting algorithm. As I have said many 
many times:

there is only a single instance of the machine language of the local 
halt decider

there is only a single instance of the machine language of the local 
halt decider

there is only a single instance of the machine language of the local 
halt decider

Is it that you are too stupid to get this?
Are you too dishonest to get this?
Do you have actual brain damage such as dementia?

As soon as you acknowledge:

there is only a single instance of the machine language of the local 
halt decider

We can move on to the next point.


-- 
Copyright 2021 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-08 15:59 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<ceudndzElfdHSGXCnZ2dnUU7-XHNnZ2d@giganews.com>
In reply to#2491
On 1/8/2021 3:34 PM, André G. Isaak wrote:
> On 2021-01-08 10:40, olcott wrote:
>> On 1/6/2021 9:20 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 1/6/2021 7:00 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> When we consider which of the two values that Halts() can return to
>>>>>> H_Hat() the correct answer is neither because the invocation of
>>>>>> Halts() by H_Hat() would be infinitely recursive if Halts() did not
>>>>>> abort this invocation.
>>>>>
>>>>> Not so long ago you said:
>>>>>
>>>>> | I have proven that this argument is not valid by making an H that
>>>>> | decides (Ĥ, Ĥ).
>>>>>
>>>>> Causing me to check, and you to confirm (albeit rather evasively):
>>>>>
>>>>> || What is the decision -- halts, or does not halt?
>>>>> | Yes it is one of those.
>>>>>
>>>>> || Do you claim that the decision is the correct one?
>>>>> | It is easily verifiably correct.
>>>>>
>>>>> So what is the easily verifiably correct, halts or does not halt
>>>>> decision that H gave for (Ĥ, Ĥ) back then?
>>>
>>> No answer?
>>>
>>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>>> A computation that would not halt if its simulation were not
>>>>> halted is indeed a non-halting computation.
>>>
>>> This is not an answer -- it's barely more than a tautology.  What is the
>>> correct halts/not halts answer you calmed you got from H for (Ĥ, Ĥ)?
>>>
>>> I don't expect an answer.  But your not answering will help people to
>>> understand how evasive you are.
>>>
>>> Here's the real explanation (that you cut):
>>>
>>> The (current) resolution to these apparently contradictory remarks is
>>> that there are two algorithms both called Halts (or H).  The one called
>>> from or used by H_Hat (or Ĥ) does not answer, and the other does. 
>>
>> It would be incorrect for me to answer questions that are based on 
>> fundamental false assumptions until after all these false assumptions 
>> are first corrected.
>>
>> Since I have already corrected these fundamental false assumptions 
>> many times it seems question obvious that you have no interest in the 
>> actual truth.
>>
>> The fundamental false assumption that you make in your above paragraph 
>> is that there is more than one halting algorithm. As I have said many 
>> many times:
>>
>> there is only a single instance of the machine language of the local 
>> halt decider
> 
> Which means that your Halts() and your H_Hat() do not stand in the same 
> relation as Linz's H and H_Hat, and therefore your program has nothing 
> to say about this proof.
> 
> André
> 

The key thing (that I have said far too many times) is that it does have 
the exact same "do the opposite of whatever the halt decider decides" 
that is the key basis of all of the conventional proofs.

    Now we construct a new Turing machine D with H as a
    subroutine. This new TM calls H to determine what M
    does when the input to M is its own description <M>.
    Once D has determined this information,

    it does the opposite. That is, it rejects if M accepts
    and accepts if M does not accept.

    (Sipser 1997) http://www.liarparadox.org/sipser_165.pdf

Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company (165-167)

BECAUSE I HAVE REFUTED THE KEY BASIS OF ALL OF THESE PROOFS I HAVE 
REFUTED ALL OF THESE PROOFS.


-- 
Copyright 2021 Pete Olcott

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

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


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

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


csiph-web