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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-08 21:53 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<j72dnd1VRbFYtWTCnZ2dnUU7-N3NnZ2d@giganews.com>
In reply to#2491
On 1/8/2021 9:31 PM, Kaz Kylheku wrote:
> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote:
>>> You have explained, clearly, the ways in which the two algorithms
>>> differ: one is a simulation that does not return a value, the other is a
>>> partial simulation that does.  I can't see why you want to deny this
>>> now.  It the core of the ruse you are trying to pull.
>>
>> How can you say something as stupid as this knowing that I have
>> repeatedly told you many times that there is only one single instance of
>> the machine code?
> 
> Pretending that some block of machine code is the same program, when
> it's being run run using three subtle variations of instruction set

This is not what he is freaking talking about. The same code that you 
confirmed is correct is the code that he is talking about.

The local halt deciding mode does not return a value to its otherwise 
infinite invocation yet does return a value to main().

The only thing that Ben has said that has been useful is explaining to 
you that I am looking at things from the software engineering 
perspective of actual fully operational code.




-- 
Copyright 2021 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-08 23:08 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<662dnbHS7bnxp2TCnZ2dnUU7-enNnZ2d@giganews.com>
In reply to#2495
On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>> On 1/8/2021 9:31 PM, Kaz Kylheku wrote:
>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote:
>>>>> You have explained, clearly, the ways in which the two algorithms
>>>>> differ: one is a simulation that does not return a value, the other is a
>>>>> partial simulation that does.  I can't see why you want to deny this
>>>>> now.  It the core of the ruse you are trying to pull.
>>>>
>>>> How can you say something as stupid as this knowing that I have
>>>> repeatedly told you many times that there is only one single instance of
>>>> the machine code?
>>>
>>> Pretending that some block of machine code is the same program, when
>>> it's being run run using three subtle variations of instruction set
>>
>> This is not what he is freaking talking about. The same code that you
>> confirmed is correct is the code that he is talking about.
>>
>> The local halt deciding mode does not return a value to its otherwise
>> infinite invocation yet does return a value to main().
> 
> Not been shown. You've only give execution traces of this that do not
> reveal the return values of Halts, in programs that do not call
> H_Hat(H_Hat) from main to see whether it halts or not.
> 

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


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

We can see that the halt decider did correctly decide that the prior 
invocation was infinitely recursive on the basis of:
(a) The same function is called
(b) From the same machine address
(c) With the same data  // Richard Damon credit
(c) A second time
(d) Without any control flow instructions inbetween

...[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]


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

FromJeff Barnett <jbb@notatt.com>
Date2021-01-08 22:36 -0700
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<rtbfcd$a3r$1@dont-email.me>
In reply to#2496
On 1/8/2021 10:08 PM, olcott wrote:
> On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/8/2021 9:31 PM, Kaz Kylheku wrote:
>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote:
>>>>>> You have explained, clearly, the ways in which the two algorithms
>>>>>> differ: one is a simulation that does not return a value, the 
>>>>>> other is a
>>>>>> partial simulation that does.  I can't see why you want to deny this
>>>>>> now.  It the core of the ruse you are trying to pull.
>>>>>
>>>>> How can you say something as stupid as this knowing that I have
>>>>> repeatedly told you many times that there is only one single 
>>>>> instance of
>>>>> the machine code?
>>>>
>>>> Pretending that some block of machine code is the same program, when
>>>> it's being run run using three subtle variations of instruction set
>>>
>>> This is not what he is freaking talking about. The same code that you
>>> confirmed is correct is the code that he is talking about.
>>>
>>> The local halt deciding mode does not return a value to its otherwise
>>> infinite invocation yet does return a value to main().
>>
>> Not been shown. You've only give execution traces of this that do not
>> reveal the return values of Halts, in programs that do not call
>> H_Hat(H_Hat) from main to see whether it halts or not.
>>
> 
> 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
> 
> 
> 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
> 
> We can see that the halt decider did correctly decide that the prior 
> invocation was infinitely recursive on the basis of:
> (a) The same function is called
> (b) From the same machine address
> (c) With the same data  // Richard Damon credit
> (c) A second time
> (d) Without any control flow instructions inbetween
> 
> ...[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

You use that simulator to generate rolls of toilet paper. And like 
toilet paper, the value depends on the quantity and "quality" of what's 
in the user. Given what I've deduced about you, the trace is invaluable. 
Don't bother sharing it with the group, save it an improve your private 
fortunes. Without a job or an prospects, its your only path to financial 
independence. And just think - the simulator was free.
-- 
Jeff Barnett

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-09 05:39 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<20210108213007.443@kylheku.com>
In reply to#2496
["Followup-To:" header set to comp.theory.]
On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
> On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/8/2021 9:31 PM, Kaz Kylheku wrote:
>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote:
>>>>>> You have explained, clearly, the ways in which the two algorithms
>>>>>> differ: one is a simulation that does not return a value, the other is a
>>>>>> partial simulation that does.  I can't see why you want to deny this
>>>>>> now.  It the core of the ruse you are trying to pull.
>>>>>
>>>>> How can you say something as stupid as this knowing that I have
>>>>> repeatedly told you many times that there is only one single instance of
>>>>> the machine code?
>>>>
>>>> Pretending that some block of machine code is the same program, when
>>>> it's being run run using three subtle variations of instruction set
>>>
>>> This is not what he is freaking talking about. The same code that you
>>> confirmed is correct is the code that he is talking about.
>>>
>>> The local halt deciding mode does not return a value to its otherwise
>>> infinite invocation yet does return a value to main().
>> 
>> Not been shown. You've only give execution traces of this that do not
>> reveal the return values of Halts, in programs that do not call
>> H_Hat(H_Hat) from main to see whether it halts or not.
>> 
>
> void H_Hat(u32 P)

Yes, that's exactly the inadequate program I'm talking about, with the
inadequate trace.

> {
>    u32 Input_Halts = Halts(P, P);

Does this Halts return? What is the value, if it does? That would be
good to know.

>    if (Input_Halts)
>      HERE: goto HERE;
>    return;
> }

The main problem is: why isn't H_Hat((u32) H_Hat) called from main to
see what value, if any, it obtains from Halts, and whether or not it
terminates?
>
> int main()
> {
>    u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>    Output("Input_Would_Halt =", Input_Would_Halt);
> }

[ ... ]

> We can see that the halt decider did correctly decide that the prior 
> invocation was infinitely recursive on the basis of:

There is no reason to believe that this decision is correct, due to
missing information.

The program doesn't call H_Hat((u32) H_Hat) to show that this call fails
to terminate, as the decider indicates.


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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-09 12:40 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?)
Message-ID<KbednUEZicw9ZWTCnZ2dnUU7-a3NnZ2d@giganews.com>
In reply to#2498
On 1/9/2021 12:24 PM, Kaz Kylheku wrote:
> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>> On 1/9/2021 11:30 AM, Ben Bacarisse wrote:
>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>
>>>> ["Followup-To:" header set to comp.theory.]
>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>> <cut>
>>>>>>> The local halt deciding mode does not return a value to its otherwise
>>>>>>> infinite invocation yet does return a value to main().
>>>>>>
>>>>>> Not been shown. You've only give execution traces of this that do not
>>>>>> reveal the return values of Halts, in programs that do not call
>>>>>> H_Hat(H_Hat) from main to see whether it halts or not.
>>>>>>
>>>>>
>>>>> void H_Hat(u32 P)
>>>>
>>>> Yes, that's exactly the inadequate program I'm talking about, with the
>>>> inadequate trace.
>>>>
>>>>> {
>>>>>      u32 Input_Halts = Halts(P, P);
>>>>
>>>> Does this Halts return? What is the value, if it does? That would be
>>>> good to know.
>>>
>>> When H_Hat is called as H_Hat(H_Hat), the call to Halts in H_Hat does
>>> not return, making H_Hat(H_Hat) a non-terminating computation.
>>
>> When this same computation is executed in a simulator the Halt decider
>> determines that the exectution trace of H_Hat() meets this specification:
> 
> None of your programs give evidence for this statement. H_Hat(H_Hat)
> is a non-terminating computation only in the free-running "disabled"
> mode of your simulator (the detection of runaway recursion is disabled).
> In the other modes, it is a terminating computation.

If you are actually paying attention to what I am saying and not simply 
searching for some excuse for a rebuttal on the basis of your deeply 
held belief that must be wrong you would realize that this axiom is 
correct:

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


-- 
Copyright 2021 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-09 16:03 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<G5KdnVmRX4mhtWfCnZ2dnUU7-bXNnZ2d@giganews.com>
In reply to#2502
On 1/9/2021 3:46 PM, Mr Flibble wrote:
> On 09/01/2021 21:25, olcott wrote:
>> On 1/9/2021 2:07 PM, Kaz Kylheku wrote:
>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/9/2021 12:24 PM, Kaz Kylheku wrote:
>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 1/9/2021 11:30 AM, Ben Bacarisse wrote:
>>>>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>>>>
>>>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
>>>>>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> <cut>
>>>>>>>>>>> The local halt deciding mode does not return a value to its 
>>>>>>>>>>> otherwise
>>>>>>>>>>> infinite invocation yet does return a value to main().
>>>>>>>>>>
>>>>>>>>>> Not been shown. You've only give execution traces of this that 
>>>>>>>>>> do not
>>>>>>>>>> reveal the return values of Halts, in programs that do not call
>>>>>>>>>> H_Hat(H_Hat) from main to see whether it halts or not.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>
>>>>>>>> Yes, that's exactly the inadequate program I'm talking about, 
>>>>>>>> with the
>>>>>>>> inadequate trace.
>>>>>>>>
>>>>>>>>> {
>>>>>>>>>       u32 Input_Halts = Halts(P, P);
>>>>>>>>
>>>>>>>> Does this Halts return? What is the value, if it does? That 
>>>>>>>> would be
>>>>>>>> good to know.
>>>>>>>
>>>>>>> When H_Hat is called as H_Hat(H_Hat), the call to Halts in H_Hat 
>>>>>>> does
>>>>>>> not return, making H_Hat(H_Hat) a non-terminating computation.
>>>>>>
>>>>>> When this same computation is executed in a simulator the Halt 
>>>>>> decider
>>>>>> determines that the exectution trace of H_Hat() meets this 
>>>>>> specification:
>>>>>
>>>>> None of your programs give evidence for this statement. H_Hat(H_Hat)
>>>>> is a non-terminating computation only in the free-running "disabled"
>>>>> mode of your simulator (the detection of runaway recursion is 
>>>>> disabled).
>>>>> In the other modes, it is a terminating computation.
>>>>
>>>> If you are actually paying attention to what I am saying and not simply
>>>
>>> I don't care about what you're saying; I'm pointing to what your *code*
>>> *isn't* saying.
>>
>> Infinite Recursion detection AXIOM
>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
> 
> Most algorithms of interest do have control flow instructions so I 
> repeat: what you are banging on about is of little interest to anybody 
> and has no bearing on the Halting Problem itself as defined.
> 
> /Flibble
> 

By showing how the simplest form of how the:
"Do the opposite of whatever the halt decider decides"
basis of all the conventional halting problem undecidability
proofs is correctly decided as non-halting I have refuted
the basis of all of these 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)



-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-09 22:28 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<20210109142146.694@kylheku.com>
In reply to#2504
["Followup-To:" header set to comp.theory.]
On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
> On 1/9/2021 3:46 PM, Mr Flibble wrote:
>> On 09/01/2021 21:25, olcott wrote:
>>> On 1/9/2021 2:07 PM, Kaz Kylheku wrote:
>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/9/2021 12:24 PM, Kaz Kylheku wrote:
>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 1/9/2021 11:30 AM, Ben Bacarisse wrote:
>>>>>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>>>>>
>>>>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
>>>>>>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> <cut>
>>>>>>>>>>>> The local halt deciding mode does not return a value to its 
>>>>>>>>>>>> otherwise
>>>>>>>>>>>> infinite invocation yet does return a value to main().
>>>>>>>>>>>
>>>>>>>>>>> Not been shown. You've only give execution traces of this that 
>>>>>>>>>>> do not
>>>>>>>>>>> reveal the return values of Halts, in programs that do not call
>>>>>>>>>>> H_Hat(H_Hat) from main to see whether it halts or not.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>
>>>>>>>>> Yes, that's exactly the inadequate program I'm talking about, 
>>>>>>>>> with the
>>>>>>>>> inadequate trace.
>>>>>>>>>
>>>>>>>>>> {
>>>>>>>>>>       u32 Input_Halts = Halts(P, P);
>>>>>>>>>
>>>>>>>>> Does this Halts return? What is the value, if it does? That 
>>>>>>>>> would be
>>>>>>>>> good to know.
>>>>>>>>
>>>>>>>> When H_Hat is called as H_Hat(H_Hat), the call to Halts in H_Hat 
>>>>>>>> does
>>>>>>>> not return, making H_Hat(H_Hat) a non-terminating computation.
>>>>>>>
>>>>>>> When this same computation is executed in a simulator the Halt 
>>>>>>> decider
>>>>>>> determines that the exectution trace of H_Hat() meets this 
>>>>>>> specification:
>>>>>>
>>>>>> None of your programs give evidence for this statement. H_Hat(H_Hat)
>>>>>> is a non-terminating computation only in the free-running "disabled"
>>>>>> mode of your simulator (the detection of runaway recursion is 
>>>>>> disabled).
>>>>>> In the other modes, it is a terminating computation.
>>>>>
>>>>> If you are actually paying attention to what I am saying and not simply
>>>>
>>>> I don't care about what you're saying; I'm pointing to what your *code*
>>>> *isn't* saying.
>>>
>>> Infinite Recursion detection AXIOM
>>> (a) Within an execution trace
>>> (b) The same function is called
>>> (c) From the same machine address
>>> (d) With the same data // Richard Damon credit
>>> (e) A second time
>>> (f) Without any control flow instructions inbetween
>> 
>> Most algorithms of interest do have control flow instructions so I 
>> repeat: what you are banging on about is of little interest to anybody 
>> and has no bearing on the Halting Problem itself as defined.
>> 
>> /Flibble
>> 
>
> By showing how the simplest form of how the:
> "Do the opposite of whatever the halt decider decides"
> basis of all the conventional halting problem undecidability
> proofs is correctly decided as non-halting I have refuted
> the basis of all of these proofs.

You have not; your program indicates that H_Hat(H_Hat) fails to
terminate, yet in fact there is every reason to believe that
that expression terminates.

ALl you have to do is add this to the end of your main():

    ...
    H_Hat((u32) H_Hat);
    Output("H_Hat(H_Hat) terminated!");
    return 0
  }

Until shown otherwise, I believe that output will be:

  Input_Halts = 0
  H_Hat(H_Hat) terminated!

whereby the Input_Halts = 0 value is shown to be wrong.0

I also suspect you've tried this program, but you cannot bring yourself
to post the results.

Your vehement refusal to post the results, and your evasive answers with
regard to this entire topic, speak volumes.


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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-09 16:51 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<IrednezMZ9H9rmfCnZ2dnUU7-R_NnZ2d@giganews.com>
In reply to#2502
On 1/9/2021 4:20 PM, Kaz Kylheku wrote:
> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>> On 1/9/2021 2:07 PM, Kaz Kylheku wrote:
>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/9/2021 12:24 PM, Kaz Kylheku wrote:
>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 1/9/2021 11:30 AM, Ben Bacarisse wrote:
>>>>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>>>>
>>>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 1/8/2021 10:39 PM, Kaz Kylheku wrote:
>>>>>>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> <cut>
>>>>>>>>>>> The local halt deciding mode does not return a value to its otherwise
>>>>>>>>>>> infinite invocation yet does return a value to main().
>>>>>>>>>>
>>>>>>>>>> Not been shown. You've only give execution traces of this that do not
>>>>>>>>>> reveal the return values of Halts, in programs that do not call
>>>>>>>>>> H_Hat(H_Hat) from main to see whether it halts or not.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>
>>>>>>>> Yes, that's exactly the inadequate program I'm talking about, with the
>>>>>>>> inadequate trace.
>>>>>>>>
>>>>>>>>> {
>>>>>>>>>        u32 Input_Halts = Halts(P, P);
>>>>>>>>
>>>>>>>> Does this Halts return? What is the value, if it does? That would be
>>>>>>>> good to know.
>>>>>>>
>>>>>>> When H_Hat is called as H_Hat(H_Hat), the call to Halts in H_Hat does
>>>>>>> not return, making H_Hat(H_Hat) a non-terminating computation.
>>>>>>
>>>>>> When this same computation is executed in a simulator the Halt decider
>>>>>> determines that the exectution trace of H_Hat() meets this specification:
>>>>>
>>>>> None of your programs give evidence for this statement. H_Hat(H_Hat)
>>>>> is a non-terminating computation only in the free-running "disabled"
>>>>> mode of your simulator (the detection of runaway recursion is disabled).
>>>>> In the other modes, it is a terminating computation.
>>>>
>>>> If you are actually paying attention to what I am saying and not simply
>>>
>>> I don't care about what you're saying; I'm pointing to what your *code*
>>> *isn't* saying.
>>
>> Infinite Recursion detection AXIOM
> 
> AXIOM means "please accept this without proof"; that doesn't fly.
> 

Another definition of the term "axiom" is "self-evident truth" which is 
any statement that can be known to be true on the basis of its meaning.
This is the definition that I am referring to.

>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
>>
>> The execution trace of H_Hat() proves that H_Hat() meets the above
>> specification therefore proving that H_Hat can be correctly decided as
>> not halting on this basis without needing to look at the source code.
> 
> There is no dispute that it can be decided; it is a waste of time
> to show that.

Then it logically follows that you agree with I refuted the basis of all 
of the conventional halting problem proofs:

By showing how the simplest form of how the:
"Do the opposite of whatever the halt decider decides"
basis of all the conventional halting problem undecidability
proofs is correctly decided as non-halting I have refuted
the basis of all of these 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)


> You're not showing that can be decided by Halts(H_Hat, H_Hat), in the
> same program, under the same mode of interpreting the ostensibly x86
> instruction set.

Sure I am right Here:

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

int main()
{
// This proves that H_Hat is called with itself as input
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);

   Output("Input_Would_Halt =", Input_Would_Halt);
}

Output_Debug_Trace() [000111ae]  size(124)  capacity(65536)
[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   	;CALL [0000067a]
This is where Halts() is invoked with the machine address of H_Hat() 
shown in by push 0000088a, push 0000088a.

[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   	;CALL [0000067a]

The stack push code preceding the call from H_Hat() to Halts() above 
indicates that H_Hat() is calling Halts() with two copies of its own 
input parameter [ebp+08].

[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   	;CALL [0000067a]
This is where non-halting is decided on the above basis of
the Infinite Recursion detection AXIOM.

[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

This is where non-halting is output
[000008dc](05)  e879faffff          call 0000035a   	;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


> That is what the proof says. The proof doesn't present a test case as
> being absolutely undecidable, but a test case that is not decided
> correctly by a particular decider.

The proof says that Halts() cannot decide H_Hat() so when I show how 
Halts() decides H_Hat() the proof is refuted.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-09 23:22 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<20210109150456.59@kylheku.com>
In reply to#2507
On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>> AXIOM means "please accept this without proof"; that doesn't fly.
>> 
>
> Another definition of the term "axiom" is "self-evident truth" which is 

No, there isn't. I do not accept this.

For instance, we can add at least three different axioms to four-axiom
geometry to produce different geometries.

You might think that it's "self evident" that two parallel lines (according
to the test that they intersect a third line at the same angle and
orienation) do not meet. It turns out not to be the case.

> any statement that can be known to be true on the basis of its meaning.
> This is the definition that I am referring to.
>
>>> (a) Within an execution trace
>>> (b) The same function is called
>>> (c) From the same machine address
>>> (d) With the same data // Richard Damon credit
>>> (e) A second time
>>> (f) Without any control flow instructions inbetween
>>>
>>> The execution trace of H_Hat() proves that H_Hat() meets the above
>>> specification therefore proving that H_Hat can be correctly decided as
>>> not halting on this basis without needing to look at the source code.
>> 
>> There is no dispute that it can be decided; it is a waste of time
>> to show that.
>
> Then it logically follows that you agree with I refuted the basis of all 
> of the conventional halting problem proofs:

No it doesn't, because the proofs do not make the claim that the halting
of some specific machine/function is absolutely undecidable.

If you refute a claim that a proof does not make, you don't speak to
the proof.

>> You're not showing that can be decided by Halts(H_Hat, H_Hat), in the
>> same program, under the same mode of interpreting the ostensibly x86
>> instruction set.
>
> Sure I am right Here:
>
> void H_Hat(u32 P)
> {
>    u32 Input_Halts = Halts(P, P);
>    if (Input_Halts)
>      HERE: goto HERE;
>    return;
> }

This function is never called, so we have no idea whether it terminates
or not.

>
> int main()
> {
> // This proves that H_Hat is called with itself as input
>    u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>
>    Output("Input_Would_Halt =", Input_Would_Halt);
> }

> This is where Halts() is invoked with the machine address of H_Hat() 
> shown in by push 0000088a, push 0000088a.

Not disputed in any way.
>
> [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   	;CALL [0000067a]
>
> The stack push code preceding the call from H_Hat() to Halts() above 
> indicates that H_Hat() is calling Halts() with two copies of its own 
> input parameter [ebp+08].

If so, this is a simulated H_Hat, not a direct call from main to H_Hat.
No such direct call is performed by the program.

The simulated H_Hat is a different function from a top-level H_Hat.

It is different because it is wrapped in one more level of simulation.

Different levels of simulation are not equivalent in this execution model.

Anyway, within every simulation level, that level's simulated Halts is
wrong about that level's simulated H_Hat(H_Hat).

And, likewise, the top-level Halts is wrong about the top-level
H_Hat(H_Hat). And that is the one and only thing which matters.

>> That is what the proof says. The proof doesn't present a test case as
>> being absolutely undecidable, but a test case that is not decided
>> correctly by a particular decider.
>
> The proof says that Halts() cannot decide H_Hat() so when I show how 
> Halts() decides H_Hat() the proof is refuted.

The proof does not say that Halts cannot run a simulation inside of
which all sorts of nonsense happens, like a simulated H_Hat(H_Hat)
behaving differently from the real H_Hat(H_Hat), or being stopped in its
tracks or whatever.

The whole simulation is a nested function, and all that matters is what
it returns, and how that relates to what the real H_Hat(H_Hat) does
outside of any simulation.

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 10:06 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<sdmdna3UraSKVGDCnZ2dnUU7-YfNnZ2d@giganews.com>
In reply to#2508
On 1/9/2021 5:22 PM, Kaz Kylheku wrote:
> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>> AXIOM means "please accept this without proof"; that doesn't fly.
>>>
>>
>> Another definition of the term "axiom" is "self-evident truth" which is
> 
> No, there isn't. I do not accept this.
> 

That is the great thing about Truth, it remains true even if you 
disagree. The only actual alternative truth is LIES.

2: an established rule or principle or a self-evident truth
https://www.merriam-webster.com/dictionary/axiom

In epistemology (theory of knowledge), a self-evident proposition is a 
proposition that is known to be true by understanding its meaning
https://en.wikipedia.org/wiki/Self-evidence

> For instance, we can add at least three different axioms to four-axiom
> geometry to produce different geometries.

That is the problem with the way that natural language assigns different 
meanings to the same word. I am not referring to that meaning.


> You might think that it's "self evident" that two parallel lines (according
> to the test that they intersect a third line at the same angle and
> orienation) do not meet. It turns out not to be the case.
> 
>> any statement that can be known to be true on the basis of its meaning.
>> This is the definition that I am referring to.
>>
>>>> (a) Within an execution trace
>>>> (b) The same function is called
>>>> (c) From the same machine address
>>>> (d) With the same data // Richard Damon credit
>>>> (e) A second time
>>>> (f) Without any control flow instructions inbetween
>>>>
>>>> The execution trace of H_Hat() proves that H_Hat() meets the above
>>>> specification therefore proving that H_Hat can be correctly decided as
>>>> not halting on this basis without needing to look at the source code.
>>>
>>> There is no dispute that it can be decided; it is a waste of time
>>> to show that.
>>
>> Then it logically follows that you agree with I refuted the basis of all
>> of the conventional halting problem proofs:
> 
> No it doesn't, because the proofs do not make the claim that the halting
> of some specific machine/function is absolutely undecidable.
> 

All the conventional proofs agree that undecidability is based on an 
input to the halt decider that does the opposite of whatever the halt 
decider decides. When I show how this same configuration can be decided 
I have refuted the basis of all of these proofs.

> If you refute a claim that a proof does not make, you don't speak to
> the proof.
> 
>>> You're not showing that can be decided by Halts(H_Hat, H_Hat), in the
>>> same program, under the same mode of interpreting the ostensibly x86
>>> instruction set.
>>
>> Sure I am right Here:
>>
>> void H_Hat(u32 P)
>> {
>>     u32 Input_Halts = Halts(P, P);
>>     if (Input_Halts)
>>       HERE: goto HERE;
>>     return;
>> }
> 
> This function is never called, so we have no idea whether it terminates
> or not.
> 
>>
>> int main()
>> {
>> // This proves that H_Hat is called with itself as input
>>     u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>
>>     Output("Input_Would_Halt =", Input_Would_Halt);
>> }
> 
>> This is where Halts() is invoked with the machine address of H_Hat()
>> shown in by push 0000088a, push 0000088a.
> 
> Not disputed in any way.
>>
>> [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   	;CALL [0000067a]
>>
>> The stack push code preceding the call from H_Hat() to Halts() above
>> indicates that H_Hat() is calling Halts() with two copies of its own
>> input parameter [ebp+08].
> 
> If so, this is a simulated H_Hat, not a direct call from main to H_Hat.
> No such direct call is performed by the program.
> 
> The simulated H_Hat is a different function from a top-level H_Hat.
> 
> It is different because it is wrapped in one more level of simulation.
> 
> Different levels of simulation are not equivalent in this execution model.
> 
> Anyway, within every simulation level, that level's simulated Halts is
> wrong about that level's simulated H_Hat(H_Hat).

You continue to make this utterly baseless claim.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-12 17:15 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<20210112082043.695@kylheku.com>
In reply to#2523
On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
> On 1/9/2021 5:22 PM, Kaz Kylheku wrote:
>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>> AXIOM means "please accept this without proof"; that doesn't fly.
>>>>
>>>
>>> Another definition of the term "axiom" is "self-evident truth" which is
>
>> For instance, we can add at least three different axioms to four-axiom
>> geometry to produce different geometries.
>
> That is the problem with the way that natural language assigns different 
> meanings to the same word. I am not referring to that meaning.

That meaning is the only one we should be using in a newsgroup like
comp.theory, if we're discussing anything topical.

It appears as (1) in that same Merriam-Webster entry you cited,
and you should not even be using that in the first place for formal
terms, but a dictionary of mathematics or logic.

I would myself never use "axiom" other than as the formal term in logic,
in any context whatsoever. If I intended to say "self-evident", I would
use "self-evident".

>> If so, this is a simulated H_Hat, not a direct call from main to H_Hat.
>> No such direct call is performed by the program.
>> 
>> The simulated H_Hat is a different function from a top-level H_Hat.
>> 
>> It is different because it is wrapped in one more level of simulation.
>> 
>> Different levels of simulation are not equivalent in this execution model.
>> 
>> Anyway, within every simulation level, that level's simulated Halts is
>> wrong about that level's simulated H_Hat(H_Hat).
>
> You continue to make this utterly baseless claim.

You are utterly lying. I wrote the above several days ago. Hours after
that, I posted a self-follow-up in which I noted that it was mistaken,
and corrected it.  Here is a snippet from the follow-up:

    On 2021-01-09, Kaz Kylheku <563-365-8930@kylheku.com> wrote:
    >On 2021-01-09, Kaz Kylheku <563-365-8930@kylheku.com> wrote:
    >> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
    >>> The stack push code preceding the call from H_Hat() to Halts() above
    >>> indicates that H_Hat() is calling Halts() with two copies of its own
    >>> input parameter [ebp+08].
    >>
    >> If so, this is a simulated H_Hat, not a direct call from main to H_Hat.
    >> No such direct call is performed by the program.
    >>
    >> The simulated H_Hat is a different function from a top-level H_Hat.
    >
    > Sorry, I spoke incorrectly here. Here is the right view.
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

It's now three days after both these articles. You've chosen to reply to first,
specifically quoting text which I retracted and corrected in the second, and
insisting that I'm continuing to make that claim.

You are clearly unfit for civilized discussion.

What I'm wrong about is that they are different functions; the correct view is
that the nestings are in fact the same. Each one executes the same logic on the
same inputs, which wants to terminate the recursion in three (or whatever
number) of levels.

So in fact at each simulation level H_Hat(H_Hat) is headed for termination;
it's just that only the direct, top-level call to H_Hat(H_Hat) actually
terminates. The simulated ones are aborted before reaching termination, because
the most ancestral simulation level clips the number of recursion levels
available to the nestings.

You've already admitted that a H_Hat(H_Hat) in fact terminates, though
you refuse to actually provide an execution trace which confirms it
(probably due to understandable embarassement or whatever).

I suspect you didn't try it yourself and were caught by surprise, having
believed that H_Hat(H_Hat) does not halt.

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

I.e. if the Halts(H_Hat, H_Hat) call has the meaning "does the input halt on
its input" then 0 is the wrong answer.  That meaning is the definition of a
halting decider, so if it gets the wrong answer, the function is not a deciding
the halting of the input.

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 12:07 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<gtSdnUJT2OoYeGDCnZ2dnUU7-cnNnZ2d@giganews.com>
In reply to#2528
On 1/12/2021 12:01 PM, Richard Damon wrote:
> On 1/12/21 12:50 PM, olcott wrote:
>> On 1/12/2021 11:15 AM, Kaz Kylheku wrote:
>>> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/9/2021 5:22 PM, Kaz Kylheku wrote:
>>>>> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> AXIOM means "please accept this without proof"; that doesn't fly.
>>>>>>>
>>>>>>
>>>>>> Another definition of the term "axiom" is "self-evident truth"
>>>>>> which is
>>>>
>>>>> For instance, we can add at least three different axioms to four-axiom
>>>>> geometry to produce different geometries.
>>>>
>>>> That is the problem with the way that natural language assigns different
>>>> meanings to the same word. I am not referring to that meaning.
>>>
>>> That meaning is the only one we should be using in a newsgroup like
>>> comp.theory, if we're discussing anything topical.
>>>
>>> It appears as (1) in that same Merriam-Webster entry you cited,
>>> and you should not even be using that in the first place for formal
>>> terms, but a dictionary of mathematics or logic.
>>>
>>> I would myself never use "axiom" other than as the formal term in logic,
>>> in any context whatsoever. If I intended to say "self-evident", I would
>>> use "self-evident".
>>>
>>
>> I don't think that the is any other commonly understood term that means:
>> [can very verified as completely true entirely based on its meaning]
>> besides axiom.
>>
> 
> Except for the fact that few just plain statements would qualify for
> that. You do have things like Tautologies, which sort of meet that
> definition.
> 
> The  biggest issue is that you are using ot on things that perhaps may
> seem true to you, but others don't accept it because you are using some
> 'off' meanings in your words.
> 
> 
>>>>> If so, this is a simulated H_Hat, not a direct call from main to H_Hat.
>>>>> No such direct call is performed by the program.
>>>>>
>>>>> The simulated H_Hat is a different function from a top-level H_Hat.
>>>>>
>>>>> It is different because it is wrapped in one more level of simulation.
>>>>>
>>>>> Different levels of simulation are not equivalent in this execution
>>>>> model.
>>>>>
>>>>> Anyway, within every simulation level, that level's simulated Halts is
>>>>> wrong about that level's simulated H_Hat(H_Hat).
>>>>
>>>> You continue to make this utterly baseless claim.
>>>
>>> You are utterly lying. I wrote the above several days ago. Hours after
>>> that, I posted a self-follow-up in which I noted that it was mistaken,
>>> and corrected it.  Here is a snippet from the follow-up:
>>
>> I am not lying, although I admit that (especially in your case)** I may
>> have been mistaken. I generally totally ignore at least half of the
>> replies so that I can focus more time on the software development aspect
>> of this.
>>
>> ** You are one of the most honest reviewers.
>>
>>>       On 2021-01-09, Kaz Kylheku <563-365-8930@kylheku.com> wrote:
>>>       >On 2021-01-09, Kaz Kylheku <563-365-8930@kylheku.com> wrote:
>>>       >> On 2021-01-09, olcott <NoOne@NoWhere.com> wrote:
>>>       >>> The stack push code preceding the call from H_Hat() to
>>> Halts() above
>>>       >>> indicates that H_Hat() is calling Halts() with two copies of
>>> its own
>>>       >>> input parameter [ebp+08].
>>>       >>
>>>       >> If so, this is a simulated H_Hat, not a direct call from main
>>> to H_Hat.
>>>       >> No such direct call is performed by the program.
>>>       >>
>>>       >> The simulated H_Hat is a different function from a top-level
>>> H_Hat.
>>>       >
>>>       > Sorry, I spoke incorrectly here. Here is the right view.
>>>         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>>
>>> It's now three days after both these articles. You've chosen to reply
>>> to first,
>>> specifically quoting text which I retracted and corrected in the
>>> second, and
>>> insisting that I'm continuing to make that claim.
>>>
>>> You are clearly unfit for civilized discussion.
>>>
>>> What I'm wrong about is that they are different functions; the correct
>>> view is
>>> that the nestings are in fact the same. Each one executes the same
>>> logic on the
>>> same inputs, which wants to terminate the recursion in three (or whatever
>>> number) of levels.
>>>
>>> So in fact at each simulation level H_Hat(H_Hat) is headed for
>>> termination;
>>> it's just that only the direct, top-level call to H_Hat(H_Hat) actually
>>> terminates. The simulated ones are aborted before reaching
>>> termination, because
>>> the most ancestral simulation level clips the number of recursion levels
>>> available to the nestings.
>>>
>>
>> Summing this up in simpler terms the Halt decider stops simulating its
>> input at the very first point in the execution trace where it can
>> correctly decide that its input would not otherwise stop executing.
>>
>>> You've already admitted that a H_Hat(H_Hat) in fact terminates, though
>>> you refuse to actually provide an execution trace which confirms it
>>> (probably due to understandable embarassement or whatever).
>>>
>>
>> I have provided the full execution trace of all of the user code if the
>> invocation of:
>>
>> 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);
>> }
>>
>> The key aspect of this that I have been showing for the longest time is
>> the sequence of the execution trace that proves that H_Hat() meets the
>> Infinite Recursion detection criteria:
>>
>> Output_Debug_Trace() [0001112e]  size(124)  capacity(65536)
>> [0000087e](01)  55                  push ebp
>> [0000087f](02)  8bec                mov ebp,esp
>> [00000881](01)  51                  push ecx
>> [00000882](05)  684e080000          push 0000084e
>> [00000887](05)  684e080000          push 0000084e
>> [0000088c](05)  e8ddfdffff          call 0000066e ; call Halts(H_Hat,H_Hat)
>> [0000084e](01)  55                  push ebp
>> [0000084f](02)  8bec                mov ebp,esp
>> [00000851](01)  51                  push ecx
>> [00000852](03)  8b4508              mov eax,[ebp+08]
>> [00000855](01)  50                  push eax
>> [00000856](03)  8b4d08              mov ecx,[ebp+08]
>> [00000859](01)  51                  push ecx
>> [0000085a](05)  e80ffeffff          call 0000066e ; call Halts(H_Hat,H_Hat)
>> [0000084e](01)  55                  push ebp
>> [0000084f](02)  8bec                mov ebp,esp
>> [00000851](01)  51                  push ecx
>> [00000852](03)  8b4508              mov eax,[ebp+08]
>> [00000855](01)  50                  push eax
>> [00000856](03)  8b4d08              mov ecx,[ebp+08]
>> [00000859](01)  51                  push ecx
>> [0000085a](05)  e80ffeffff          call 0000066e  ; call
>> Halts(H_Hat,H_Hat)
>>
>> Infinite Recursion detection AXIOM
>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
>>
>> It can be verified entirely on the basis of its meaning that all of the
>> above is necessarily true. That all of the above is necessarily true is
>> complete proof that Halts() does decide H_Hat() correctly.
>>
>> Any disagreement that all of the above is necessarily true without
>> pointing out any specific error in any of the above will be construed as
>> dishonesty. What I mean by dishonesty is the intentional divergence away
>> from an honest dialogue.
>>
> 
> Except, by your own statement this is NOT a complete trace, but is only
> of 'user code'. 

And I have totally explained this to you so many times that you seem 
just too stupid to get it.

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





-- 
Copyright 2021 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-11 12:07 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<DpadnQimIKJKDmHCnZ2dnUU7-QPNnZ2d@giganews.com>
In reply to#2502
On 1/10/2021 7:01 PM, Jeff Barnett wrote:
> On 1/10/2021 3:27 PM, olcott wrote:
>> On 1/10/2021 4:04 PM, Chris M. Thomasson wrote:
>>> On 1/9/2021 1:46 PM, Mr Flibble wrote:
>>> [...]
>>>> Most algorithms of interest do have control flow instructions so I 
>>>> repeat: what you are banging on about is of little interest to 
>>>> anybody and has no bearing on the Halting Problem itself as defined.
>>>
>>> Indeed. I expect any so-called "halt decider" to be able to tell me 
>>> if the following simple function ever returns a result:
>>>
>>> bool foobar()
>>> {
>>>    unsigned long n = 1000;
>>>
>>>    for (unsigned long i = 0; i < n; ++i)
>>>    {
>>>      if (i > n / 2) i = 0;
>>>    }
>>>
>>>    return true;
>>> }
>>>
>>> Just a simple case... ;^)
>>
>> If you expect this then you have not bothered to pay any freaking 
>> attention at all.
>>
>> I am only refuting all of the conventional proofs because I can do 
>> this in finite time. Once I had the design this took two years to 
>> complete.
>> It took 14 years to complete the design.
>>
>> I am not attempting to make a universal halt decider because this 
>> cannot be done in less than 100 man years.
> 
> All your reply shows is that you either don't bother to read or don't 
> understand what you read. 

Once I determine that a point is off topic I don't waste my time on it.
The above code is not an example of the conventional halting problem 
undecidability proof:

"Do the opposite of whatever the halt decider decides"

Therefore as soon as I know this I can say it is off topic.


-- 
Copyright 2021 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-11 12:18 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<5dqdncjjs8_2C2HCnZ2dnUU7-anNnZ2d@giganews.com>
In reply to#2502
On 1/10/2021 9:08 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 1/10/21 8:01 PM, Jeff Barnett wrote:
>>> On 1/10/2021 3:27 PM, olcott wrote:
>>>> On 1/10/2021 4:04 PM, Chris M. Thomasson wrote:
>>>>> On 1/9/2021 1:46 PM, Mr Flibble wrote:
>>>>> [...]
>>>>>> Most algorithms of interest do have control flow instructions so I
>>>>>> repeat: what you are banging on about is of little interest to
>>>>>> anybody and has no bearing on the Halting Problem itself as defined.
>>>>>
>>>>> Indeed. I expect any so-called "halt decider" to be able to tell me
>>>>> if the following simple function ever returns a result:
>>>>>
>>>>> bool foobar()
>>>>> {
>>>>>     unsigned long n = 1000;
>>>>>
>>>>>     for (unsigned long i = 0; i < n; ++i)
>>>>>     {
>>>>>       if (i > n / 2) i = 0;
>>>>>     }
>>>>>
>>>>>     return true;
>>>>> }
>>>>>
>>>>> Just a simple case... ;^)
>>>>
>>>> If you expect this then you have not bothered to pay any freaking
>>>> attention at all.
>>>>
>>>> I am only refuting all of the conventional proofs because I can do
>>>> this in finite time. Once I had the design this took two years to
>>>> complete.
>>>> It took 14 years to complete the design.
>>>>
>>>> I am not attempting to make a universal halt decider because this
>>>> cannot be done in less than 100 man years.
>>>
>>> All your reply shows is that you either don't bother to read or don't
>>> understand what you read. Never mind, it's surely both. So your
>>> misunderstanding leads you to disagree with "Indeed. I expect any
>>> so-called `halt decider' to be able to tell me if  the following simple
>>> function ever returns a result: etc." Really? After two decades you
>>> don't know what a halt decider is? Oh, I forgot - you don't do you. Do
>>> you think you own the newsgroup or thread? Wrong again. As usual, you
>>> just soiled your panties while typing without thinking or understanding.
>>> You really should give it a rest. Idiot.
>>
>> Actually, if if you are careful about reading all of what Peter Olcott
>> has written, he actually doesn't claim that he a very good Halt Detector
>> at all, but only that it is just smart enough to handle H_Hat.
> 
> A while back I asked:
> 
> || Recent posts have said that you really do claim to have a halting
> || decider.  Have you extended your claim or was that a
> || misunderstanding?
> 
> and PO replied:
> 
> | I really do have a halting decider.
> 
> Of course, words are just putty in PO's hands, so maybe he just meant
> that he really does have an electric toothbrush.  We may never know.
> 

A halt decider for a specifically defined pattern of inputs is another 
correct way of saying that I have a partial halt decider.

I have a halt decider for the simplest pattern of the conventional 
halting problem undecidability proof:
"do the opposite of whatever the halt decider decides" pattern.

This partial halt decider also correctly decides a specifically defined 
pattern of infinite loops.



-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-11 18:53 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<20210111102724.920@kylheku.com>
In reply to#2513
On 2021-01-11, olcott <NoOne@NoWhere.com> wrote:
> A halt decider for a specifically defined pattern of inputs is another 
> correct way of saying that I have a partial halt decider.

A function/machine has to correctly decide only one input case to be
a partial decider.

I also have a partial decider:

  bool Halts(u32 P, u32 I)
  {
     return true;
  }

This correctly decides precisely that subset of P(I) pairs that happen
to halt.

The proof that you're trying to invalidate says, basically this:

  "All we can have is partial deciders; we cannot have a total one."

Therefore, someone claiming "I have a partial decider" does not put a
dent in the proof.

> I have a halt decider for the simplest pattern of the conventional 
> halting problem undecidability proof:
> "do the opposite of whatever the halt decider decides" pattern.

No you don't. You admitted that your Halts(H_Hat, H_Hat) returns 0
in a program in which that is the wrong answer because H_Hat(H_Hat)
returns:

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

I.e. you admit that your halting decider gives the wrong answer under
the standard halting problem definition; to fix this, you are insising
that everyone accept some alternative formulation of the problem,
rather than to try to fix the code.

Under that alternative formulation, you are asking your interlocutors to
interpret the 0 result of your Halts call as pertaining to a free-running
H_Hat in which runaway recursion is not being prevented. (I.e. that H_Hat
which "needs" to have its simulation aborted in order to prevent
indefinite execution).

The problem is, that's not the H_Hat which it has been handed as input.
It is being handed the recursion-prevented version of H_Hat.
That H_Hat does not require to be aborted in order to prevent its
indefinite execution; it does not have indefinite execution!

It is not reasonable to demand that the decider's result speaks about
the free-running H_Hat, when the decider has been handed the
recursion-prevented H_Hat as input!

On Usenet, you may eventually find a handful of kooks who will serve as
your echo chamber and accept your wacky conditions.

But your aim is to go to academia with this after validating on Usenet,
in which case that is a poor plan. Nobody in CS/Math academia will
accept your ridiculous redefinition of the halting problem criteria.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-01-11 14:03 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<AsCdnfCeE5eHMmHCnZ2dnUU7-aOdnZ2d@giganews.com>
In reply to#2516
On 1/11/2021 2:01 PM, Kaz Kylheku wrote:
> On 2021-01-11, olcott <NoOne@NoWhere.com> wrote:
>> On 1/11/2021 12:53 PM, Kaz Kylheku wrote:
>>> On 2021-01-11, olcott <NoOne@NoWhere.com> wrote:
>>>> A halt decider for a specifically defined pattern of inputs is another
>>>> correct way of saying that I have a partial halt decider.
>>>
>>> A function/machine has to correctly decide only one input case to be
>>> a partial decider.
>>>
>>> I also have a partial decider:
>>>
>>>     bool Halts(u32 P, u32 I)
>>>     {
>>>        return true;
>>>     }
>>>
>>> This correctly decides precisely that subset of P(I) pairs that happen
>>> to halt.
>>>
>>> The proof that you're trying to invalidate says, basically this:
>>>
>>>     "All we can have is partial deciders; we cannot have a total one."
>>>
>>
>> I am not saying that we cannot have a total halt decider.
> 
> Well, no; you're saying you have a partial decider.
> 
> The proofs say that you cannot have a total decider.

And I keep showing how the proofs are wrong and instead of trying to 
find any error in what I say you simply ignore what I say and repeat the 
same things that I have already fully refuted.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-01-11 20:19 +0000
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ]
Message-ID<20210111121717.822@kylheku.com>
In reply to#2518
["Followup-To:" header set to comp.theory.]
On 2021-01-11, olcott <NoOne@NoWhere.com> wrote:
> On 1/11/2021 2:01 PM, Kaz Kylheku wrote:
>> On 2021-01-11, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/11/2021 12:53 PM, Kaz Kylheku wrote:
>>>> On 2021-01-11, olcott <NoOne@NoWhere.com> wrote:
>>>>> A halt decider for a specifically defined pattern of inputs is another
>>>>> correct way of saying that I have a partial halt decider.
>>>>
>>>> A function/machine has to correctly decide only one input case to be
>>>> a partial decider.
>>>>
>>>> I also have a partial decider:
>>>>
>>>>     bool Halts(u32 P, u32 I)
>>>>     {
>>>>        return true;
>>>>     }
>>>>
>>>> This correctly decides precisely that subset of P(I) pairs that happen
>>>> to halt.
>>>>
>>>> The proof that you're trying to invalidate says, basically this:
>>>>
>>>>     "All we can have is partial deciders; we cannot have a total one."
>>>>
>>>
>>> I am not saying that we cannot have a total halt decider.
>> 
>> Well, no; you're saying you have a partial decider.
>> 
>> The proofs say that you cannot have a total decider.
>
> And I keep showing how the proofs are wrong and instead of trying to 

No, you keep jumping up and down about how he proofs are *wrongly
defined*, which is different from bneing wrong.

It's obvious that you accept the proofs as being deducively correct in
their conclusion with regard to the original non-strawman halting
problem.

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


#2520 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-11 20:46 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis)
Message-ID<6vidnRnH-vrikGDCnZ2dnUU7-XednZ2d@giganews.com>
In reply to#2516
On 1/11/2021 6:49 PM, Richard Damon wrote:
> On 1/11/21 6:46 PM, olcott wrote:
>> On 1/11/2021 5:10 PM, Richard Damon wrote:
>>> On 1/11/21 2:54 PM, olcott wrote:
>>>> On 1/11/2021 12:53 PM, Kaz Kylheku wrote:
>>>>
>>>>> I.e. you admit that your halting decider gives the wrong answer under
>>>>> the standard halting problem definition; to fix this, you are insising
>>>>> that everyone accept some alternative formulation of the problem,
>>>> Does the input halt on its input?
>>>> is a standard part of the halting problem undecidability proofs
>>>> IT IS NOT A STANDARD PART OF THE ACTUAL HALTING PROBLEM ITSELF.
>>>>
>>>> The halting problem itself
>>>> IS ONLY CONCERNED WITH DIVIDING INPUTS INTO HALTING AND NON HALTING.
>>>>
>>>> Does the simulation of the input have to be stopped to prevent its
>>>> otherwise infinite execution?
>>>>
>>>> Does divide inputs into halting and not-halting.
>>>>
>>>>
>>> FALSE.
>>>
>>> Can you provide any reputable source that says that the Halting Problem
>>> of classical mathematics/Computer Science is based on anything other
>>> than what the machine, whose representation is provided as the input,
>>> would actually do?
>>>
>>
>> Because H_Hat() meets the "Infinite Recursion detection" criteria it can
>> be verified that H_Hat() would actually never halt unless its simulation
>> is stopped.
> 
> Ok, I take the answer to be no.
> 
> You mean your incorrectly applied condition (because the code fails to
> meet your requirement (f) becuase there IS condtrol flow inside Halts
> which is betweent the two calls.
When a judge decides whether or not a defendant is guilty the judge is a 
separate and distinct entity from the defendant.

In this same way the halt decider and the simulator are separate and 
distinct entities from the program under test.


-- 
Copyright 2021 Pete Olcott

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

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


#2521 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis)

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-01-11 22:23 -0800
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis)
Message-ID<rtjf89$1abk$1@gioia.aioe.org>
In reply to#2520
On 1/11/2021 6:46 PM, olcott wrote:
> On 1/11/2021 6:49 PM, Richard Damon wrote:
>> On 1/11/21 6:46 PM, olcott wrote:
>>> On 1/11/2021 5:10 PM, Richard Damon wrote:
>>>> On 1/11/21 2:54 PM, olcott wrote:
>>>>> On 1/11/2021 12:53 PM, Kaz Kylheku wrote:
>>>>>
>>>>>> I.e. you admit that your halting decider gives the wrong answer under
>>>>>> the standard halting problem definition; to fix this, you are 
>>>>>> insising
>>>>>> that everyone accept some alternative formulation of the problem,
>>>>> Does the input halt on its input?
>>>>> is a standard part of the halting problem undecidability proofs
>>>>> IT IS NOT A STANDARD PART OF THE ACTUAL HALTING PROBLEM ITSELF.
>>>>>
>>>>> The halting problem itself
>>>>> IS ONLY CONCERNED WITH DIVIDING INPUTS INTO HALTING AND NON HALTING.
>>>>>
>>>>> Does the simulation of the input have to be stopped to prevent its
>>>>> otherwise infinite execution?
>>>>>
>>>>> Does divide inputs into halting and not-halting.
>>>>>
>>>>>
>>>> FALSE.
>>>>
>>>> Can you provide any reputable source that says that the Halting Problem
>>>> of classical mathematics/Computer Science is based on anything other
>>>> than what the machine, whose representation is provided as the input,
>>>> would actually do?
>>>>
>>>
>>> Because H_Hat() meets the "Infinite Recursion detection" criteria it can
>>> be verified that H_Hat() would actually never halt unless its simulation
>>> is stopped.
>>
>> Ok, I take the answer to be no.
>>
>> You mean your incorrectly applied condition (because the code fails to
>> meet your requirement (f) becuase there IS condtrol flow inside Halts
>> which is betweent the two calls.
> When a judge decides whether or not a defendant is guilty the judge is a 
> separate and distinct entity from the defendant.


Yeah, and the judge can be drunk! lol, are you kidding me?

https://youtu.be/0iTR28UKgy4?t=74


> 
> In this same way the halt decider and the simulator are separate and 
> distinct entities from the program under test.
> 
> 

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


#2522 — Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head)

Fromolcott <NoOne@NoWhere.com>
Date2021-01-12 09:36 -0600
SubjectRe: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head)
Message-ID<M9SdnTVHWseOX2DCnZ2dnUU7-UnNnZ2d@giganews.com>
In reply to#2520
On 1/11/2021 9:32 PM, Richard Damon wrote:
> On 1/11/21 9:46 PM, olcott wrote:
>> On 1/11/2021 6:49 PM, Richard Damon wrote:
>>> On 1/11/21 6:46 PM, olcott wrote:
>>>>
>>>> Because H_Hat() meets the "Infinite Recursion detection" criteria it can
>>>> be verified that H_Hat() would actually never halt unless its simulation
>>>> is stopped.
>>>
>>> Ok, I take the answer to be no.
>>>
>>> You mean your incorrectly applied condition (because the code fails to
>>> meet your requirement (f) becuase there IS condtrol flow inside Halts
>>> which is betweent the two calls.
>> When a judge decides whether or not a defendant is guilty the judge is a
>> separate and distinct entity from the defendant.
>>
>> In this same way the halt decider and the simulator are separate and
>> distinct entities from the program under test.
>>
>>
> 
> But if the Judge himself helped commit the crime, then he can also be
> found to be guilty of it.
> 
> IF the program under test uses the Halt Decider, that that instance of
> the Halt Decider is also responsible for its actions. >


If you cannot point out any specific error in the following yet still 
disagree with it that would be evidence that it is over your head or 
evidence that your review is biased.

An unbiased review would never disagree with anything without pointing 
out a specific error basis for this disagreement.

(1) It is never true that the infinite invocation of a function would 
ever return a value to its caller.

(2) This same rule applies to the otherwise infinite invocation of a 
function where the only reason that the invocation is not infinite is 
that the caller has been aborted.

(3) Because H_Hat() invocation of Halts() is the second case above and
thus does not return any value to H_Hat() then the behavior of H_Hat() 
is not effected by the behavior of this invocation of Halts().






-- 
Copyright 2021 Pete Olcott

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

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


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

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


csiph-web