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


Groups > comp.theory > #24537 > unrolled thread

Architectural design of a halting problem solution

Started byolcott <NoOne@NoWhere.com>
First post2020-10-27 14:30 -0500
Last post2020-10-29 19:40 +0100
Articles 20 on this page of 145 — 15 participants

Back to article view | Back to comp.theory


Contents

  Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 14:30 -0500
    Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 13:46 -0600
      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 15:02 -0500
    Re: Architectural design of a halting problem solution Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 20:03 +0000
      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 15:13 -0500
        Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 14:34 -0600
          Re: Architectural design of a halting problem solution Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 21:11 +0000
            Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:27 -0500
              Re: Architectural design of a halting problem solution Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 21:33 +0000
                Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:57 -0500
              Re: Architectural design of a halting problem solution Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 14:44 -0700
                Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:54 -0500
                  Re: Architectural design of a halting problem solution Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 15:07 -0700
                    Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 18:43 -0500
              Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-27 21:45 -0400
                Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 21:28 -0500
                  Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-27 22:48 -0400
                    Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 21:55 -0500
                      Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-28 09:04 -0400
                        Re: Architectural design of a halting problem solution Mostowski Collapse <janburse@fastmail.fm> - 2020-10-28 14:13 +0100
                          Re: Architectural design of a halting problem solution David Brown <david.brown@hesbynett.no> - 2020-10-28 15:12 +0100
                        Re: Architectural design of a halting problem solution Mostowski Collapse <janburse@fastmail.fm> - 2020-10-28 14:13 +0100
                        Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 18:18 -0500
              Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-28 09:38 +0000
                Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 17:54 -0500
                  Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-29 06:59 +0000
                    Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 07:28 -0500
                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 07:35 -0500
          Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:23 -0500
            Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 22:49 -0600
              Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 00:05 -0500
                Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 23:25 -0600
                  Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 00:31 -0500
                    Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 23:55 -0600
                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 17:50 -0500
                        Re: Architectural design of a halting problem solution Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 23:27 +0000
                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 21:09 -0500
                        Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 00:45 -0600
                          Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 07:18 -0500
                            Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 07:30 -0600
                              Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 11:05 -0500
                                Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 10:55 -0600
                                  Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 12:52 -0500
                                    Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 11:58 -0600
                                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 13:25 -0500
                                        Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 12:56 -0600
                                          Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 14:13 -0500
                                            Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 13:50 -0600
                                              Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 15:18 -0500
                                                Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 14:52 -0600
                                                  Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 16:18 -0500
                                                    Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-30 08:53 -0600
                                                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-30 10:55 -0500
                                                        Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-31 08:28 -0600
                                                          Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 09:53 -0500
                                                            Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-31 09:23 -0600
                                                              Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 10:35 -0500
                                                                Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-31 09:44 -0600
                                                                  Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 11:03 -0500
                                                                    Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-11-01 07:46 -0700
                                                                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-11-01 12:12 -0600
                                                                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-11-01 12:45 -0600
                                                                Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 14:46 -0400
                                                                  Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 13:57 -0500
                                                                    Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 16:00 -0400
                                                                      Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 15:34 -0500
                                                                        Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 15:42 -0500
                                                                          Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-31 21:07 +0000
                                                                            Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 16:19 -0500
                                                                              Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-31 21:33 +0000
                                                                                Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 16:50 -0500
                                                                                  Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 18:31 -0400
                                                                                    Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:50 -0500
                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 19:53 -0400
                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 19:19 -0500
                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 21:19 -0400
                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 22:22 -0400
                                                                                              Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 21:36 -0500
                                                                                              Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 22:18 -0500
                                                                                                Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 08:19 -0500
                                                                                                  Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 08:40 -0600
                                                                                                    Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-01 16:11 +0000
                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:18 -0600
                                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-01 19:50 +0000
                                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 14:09 -0600
                                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 14:38 -0600
                                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-01 21:32 +0000
                                                                                                              Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 15:54 -0600
                                                                                                                Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 00:46 +0000
                                                                                                                  Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:05 -0600
                                                                                                                    Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:10 -0600
                                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 21:57 -0500
                                                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:33 -0600
                                                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-02 08:53 -0500
                                                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 08:04 -0600
                                                                                                                              Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-02 10:45 -0500
                                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 03:00 +0000
                                                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:32 -0600
                                                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 20:55 +0000
                                                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 15:20 -0600
                                                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 16:20 -0600
                                                                                                                    Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 01:16 +0000
                                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:28 -0600
                                                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 03:15 +0000
                                                                                                                          Re: Architectural design of a halting problem solution [ Adaptation of Ben's code simplifications ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:20 -0600
                                                                                                                    Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-02 03:02 +0000
                                                                                                                      Re: Architectural design of a halting problem solution [ one paragraph says it all ] olcott <NoOne@NoWhere.com> - 2020-11-01 21:55 -0600
                                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:25 -0600
                                                                                                                Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-02 02:45 +0000
                                                                                                                  Re: Architectural design of a halting problem solution [ non halting behavior detected ] olcott <NoOne@NoWhere.com> - 2020-11-01 23:14 -0600
                                                                                                                Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-02 03:12 -0800
                                                                                                                  Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] André G. Isaak <agisaak@gm.invalid> - 2020-11-02 04:52 -0700
                                                                                                                    Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 08:01 -0600
                                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] André G. Isaak <agisaak@gm.invalid> - 2020-11-02 08:12 -0700
                                                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-02 10:23 -0500
                                                                                                                  Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 07:58 -0600
                                                                                                      Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 14:02 -0600
                                                                                                        Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 17:52 -0500
                                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 17:59 -0600
                                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 21:38 -0500
                                                                                                              Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 21:05 -0600
                                                                                                          Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-02 00:17 +0000
                                                                                                            Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:53 -0600
                                                                                  Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-11-01 08:29 +0000
                                                                          Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 18:28 -0400
                                                                            Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 17:42 -0500
                                                                        Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 15:47 -0500
                                  Re: Architectural design of a halting problem solution Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-29 13:13 -0700
                                    Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 14:46 -0600
                            Re: Architectural design of a halting problem solution Andy Walker <anw@cuboid.co.uk> - 2020-10-29 14:41 +0000
                              Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 10:29 -0500
    Re: Architectural design of a halting problem solution Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 04:17 +0000
    Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 14:00 +0100
      Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2020-10-29 08:48 -0600
        Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-29 15:17 +0000
          Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) olcott <NoOne@NoWhere.com> - 2020-10-29 11:13 -0500
            Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-29 16:39 +0000
          Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Manfred <noname@add.invalid> - 2020-10-29 19:20 +0100
            Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-29 18:55 +0000
              Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) David Brown <david.brown@hesbynett.no> - 2020-10-30 11:02 +0100
                Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 10:52 +0000
                  Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Jorgen Grahn <grahn+nntp@snipabacken.se> - 2020-10-30 19:47 +0000
                Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Ralf Goertz <me@myprovider.invalid> - 2020-10-30 12:55 +0100
                Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-30 16:33 +0000
    Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 19:40 +0100

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


#24847 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-02 16:20 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<cv2dnZLfZdqpGz3CnZ2dnUU7-T_NnZ2d@giganews.com>
In reply to#24845
On 11/2/2020 2:55 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/1/2020 9:00 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 7:05 PM, olcott wrote:
>>>>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>>>>> Although there's lots in you recent responses that I could comment
>>>>>>>> on, perhaps one way forward would be for you to explain how you
>>>>>>>> expect a trace to verify
>>>>>>>>
>>>>>>>>       "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>>>>       parameter /would/ never halt /unless/ its execution is terminated"
>>>>>>>
>>>>>>> The sounds like an excellent way to proceed.
>>>>>>>
>>>>>>>> Note the "correctly" - that implies you must have a definition of
>>>>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>>>>> <cut>
>>>>>>> When this function:
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>>>
>>>>>>> operates correctly then it
>>>>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>>>>
>>>>>>> It is utterly ridiculous that you have had such a very difficult time
>>>>>>> with that part.  Perhaps you have lots and lots of experience with
>>>>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>>>>> that the best function names precisely describe exactly what the
>>>>>>> function does.
>>>>>>
>>>>>> Never returning either true or false is consistent with this function's
>>>>>> name.
>>>>>>
>>>>>> Returning false for a non-halting computation what was not detected to be
>>>>>> non-halting is consistent with this function's name.
>>>>>>
>>>>>> Other instances where the name is vague are also arguable, but less
>>>>>> obviously so.
>>>>>>
>>>>>> Maybe you meant to call it
>>>>>>
>>>>>>      True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>>>>
>>>>>> Probably not, because you must be trying to sneak some incorrect
>>>>>> decisions past your readers by using your bad name.
>>>>>>
>>>>>
>>>>> If your suggestion would work (and it might) then we could go all the
>>>>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>>>>
>>>>> Stops executing and Accepts any and all non-halting inputs and
>>>>> Rejects any and all halting inputs as soon as they halt.
>>>>
>>>> So as I have already said very many times in very many ways if we
>>>> define the halt decider as a non-halting decider that only makes its
>>>> non-halting decision after the execution of its input is terminated
>>>> ...
>>>>
>>>> then the halting problem trick of defining an input that
>>>> "Does the opposite of whatever the halt decider decides"
>>>>
>>>> has been utterly defeated and the halting problem is no longer proven
>>>> to be undecidable.
>>>
>>> This is a separate bit of nonsense, unconnected to the vague name you
>>> gave your function.  Whether p(i) is or is not a halting computation is
>>> independent of when (or even if) it is run.
>>>
>>> A function that looks like this:
>>>
>>> void huh?(i)
>>> {
>>>     if True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(i, i)
>>>     then skip
>>>     else while true do skip od
>>> }
>>>
>>> will, were it to exist, be a problem for this function call:
>>>
>>>     True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>>
>>> if that function has to live up to it's long name.  This problem is
>>> unrelated to how the long-named function does it's work.  It need not
>>> emulate the computation huh?(huh?) at all, but if it does, it can't
>>> emulate the computation exactly, because that exact emulation may not
>>> terminate.  But however it decides that it either can't or shouldn't or
>>> needn't continue with the emulation the basic logic is unchanged.  If
>>>
>>>     True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>>
>>> is true, huh?(huh?) is a halting computation, and if
>>>
>>>     True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>>
>>> is false, huh?(huh?) is a non-halting computation.
>>>
>>>
>>> Just for the hell of it I'm going to show you the key part of an
>>> argument that does not rely on assuming a non-existent function.
>>> Instead the conclusion of reached by reasoning about the properties of a
>>> particular expression in the language.
>>>
>>> Consider the higher-order function
>>>
>>> void p(d, i)
>>> {
>>>      if d(i, i)
>>>      then skip
>>>      else while true do skip od
>>> }
>>>
>>> with a function argument such that the partial application p(f) is the
>>> one-argument function that uses some function f to decide whether to halt
>>> or not.  Now consider the expression f(p(f), p(f)).  This is the
>>> condition that is tested in the 'if' of the computation p(f, p(f)).
>>>
>>> No matter what the function f is, if the expression f(p(f), p(f)) is
>>> either true, false or it has no value because it is itself a non-halting
>>> computation.
>>>
>>> If f(p(f), p(f)) is true, then the computation p(f, p(f)) is a halting
>>> one, and if f(p(f), p(f)) is false or has no value due to being itself a
>>> non-halting computation, then p(f, p(f)) is a non-halting computation.
>>>
>>> In other words, if the language is expressive enough to write the
>>> function p, it can't be used to write a non-halting decider.
>>>
>>> (Obviously a similar argument shows that no function written in this
>>> language can be a halt decider, but you flipped over to considering
>>> non-halting deciders, so I did as well.)
>>>
>>
>>
>> void Halts_Fooler(u32 P)
>> {
>>    if (Halts(P, P))
>>      HERE: goto HERE;
>>    else
>>      HALT
>> }
>>
>>
>> bool Halts(u32 P, u32 I)
>> {
>>    if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>      return false // Non halting behavior detected
>>    else
>>      return true; // Input has already halted
>> }
>>
>> When the halt decider does not makes its halting decision until after
>> the input program has stopped running then the conventional halting
>> problem trick: "Do the opposite of whatever the halt decider decides"
>> cannot possibly make halting undecidable.
> 
> This fails for the reasons that I and other have pointed out.  You
> appear now to be in output only mode.  Not only that, it's cut and paste
> output.
> 

No one can possibly describe all of the details of any execution trace 
that shows that I am wrong and no one even attempted this.

All of the rebuttals ignored this impossibly false statement:
All of the rebuttals ignored this impossibly false statement:
All of the rebuttals ignored this impossibly false statement:
All of the rebuttals ignored this impossibly false statement:

If Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
aborts the execution of its input because its input would not otherwise 
ever terminate THIS CONCLUSIVELY PROVES THAT ITS DECISION IS CORRECT !



-- 
Copyright 2020 Pete Olcott

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

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


#24809 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-02 01:16 +0000
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<87y2jktv68.fsf@bsb.me.uk>
In reply to#24807
olcott <NoOne@NoWhere.com> writes:

> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>> Although there's lots in you recent responses that I could comment
>>>> on, perhaps one way forward would be for you to explain how you
>>>> expect a trace to verify
>>>>
>>>>     "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>     parameter /would/ never halt /unless/ its execution is terminated"
>>>
>>> The sounds like an excellent way to proceed.
>>>
>>>> Note the "correctly" - that implies you must have a definition of
>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>> <cut>
>>> When this function:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>
>>> operates correctly then it
>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>
>>> It is utterly ridiculous that you have had such a very difficult time
>>> with that part.  Perhaps you have lots and lots of experience with
>>> naming your functions like this: ABNHBD() and it never occurred to you
>>> that the best function names precisely describe exactly what the
>>> function does.
>>
>> Never returning either true or false is consistent with this function's
>> name.
>>
>> Returning false for a non-halting computation what was not detected to be
>> non-halting is consistent with this function's name.
>>
>> Other instances where the name is vague are also arguable, but less
>> obviously so.
>>
>> Maybe you meant to call it
>>
>>    True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>
>> Probably not, because you must be trying to sneak some incorrect
>> decisions past your readers by using your bad name.

I see you are not prepared to acknowledge you have not specified your
key function in enough detail to be useful.  That is to be expected.
Vagueness rules in threads like this.

> If your suggestion would work... (and it might) then we could go all
> the way back to simply: Not_Halts(P, I) which is understood to mean:
>
> Stops executing and Accepts any and all non-halting inputs and Rejects
> any and all halting inputs as soon as they halt.

What is your obsession with Redundant Caps?  And why change the
description from that of a bool-valued function to something that
Accepts or Rejects things?  Is this just careless writing, or are you up
to something?

-- 
Ben.

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


#24810 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 19:28 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<YoednfOAg900_QLCnZ2dnUU7-TmdnZ2d@giganews.com>
In reply to#24809
On 11/1/2020 7:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>> Although there's lots in you recent responses that I could comment
>>>>> on, perhaps one way forward would be for you to explain how you
>>>>> expect a trace to verify
>>>>>
>>>>>      "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>      parameter /would/ never halt /unless/ its execution is terminated"
>>>>
>>>> The sounds like an excellent way to proceed.
>>>>
>>>>> Note the "correctly" - that implies you must have a definition of
>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>> <cut>
>>>> When this function:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>
>>>> operates correctly then it
>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>
>>>> It is utterly ridiculous that you have had such a very difficult time
>>>> with that part.  Perhaps you have lots and lots of experience with
>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>> that the best function names precisely describe exactly what the
>>>> function does.
>>>
>>> Never returning either true or false is consistent with this function's
>>> name.
>>>
>>> Returning false for a non-halting computation what was not detected to be
>>> non-halting is consistent with this function's name.
>>>
>>> Other instances where the name is vague are also arguable, but less
>>> obviously so.
>>>
>>> Maybe you meant to call it
>>>
>>>     True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>
>>> Probably not, because you must be trying to sneak some incorrect
>>> decisions past your readers by using your bad name.
> 
> I see you are not prepared to acknowledge you have not specified your
> key function in enough detail to be useful.  That is to be expected.
> Vagueness rules in threads like this.

I have specified it in enough detail to prove that the halting problem 
trick is defeated and the halting problem is no longer proved to be 
undecidable.

YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!
YOU ACTUALLY HAVE TO PAY ATTENTION TO SEE THIS !!!

>> If your suggestion would work... (and it might) then we could go all
>> the way back to simply: Not_Halts(P, I) which is understood to mean:
>>
>> Stops executing and Accepts any and all non-halting inputs and Rejects
>> any and all halting inputs as soon as they halt.
> 
> What is your obsession with Redundant Caps?  And why change the
> description from that of a bool-valued function to something that
> Accepts or Rejects things?  Is this just careless writing, or are you up
> to something?
> 


-- 
Copyright 2020 Pete Olcott

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

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


#24818 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-02 03:15 +0000
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<87mu00tpoh.fsf@bsb.me.uk>
In reply to#24810
olcott <NoOne@NoWhere.com> writes:

> On 11/1/2020 7:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>>> Although there's lots in you recent responses that I could comment
>>>>>> on, perhaps one way forward would be for you to explain how you
>>>>>> expect a trace to verify
>>>>>>
>>>>>>      "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>>      parameter /would/ never halt /unless/ its execution is terminated"
>>>>>
>>>>> The sounds like an excellent way to proceed.
>>>>>
>>>>>> Note the "correctly" - that implies you must have a definition of
>>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>>> <cut>
>>>>> When this function:
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>
>>>>> operates correctly then it
>>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>>
>>>>> It is utterly ridiculous that you have had such a very difficult time
>>>>> with that part.  Perhaps you have lots and lots of experience with
>>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>>> that the best function names precisely describe exactly what the
>>>>> function does.
>>>>
>>>> Never returning either true or false is consistent with this function's
>>>> name.
>>>>
>>>> Returning false for a non-halting computation what was not detected to be
>>>> non-halting is consistent with this function's name.
>>>>
>>>> Other instances where the name is vague are also arguable, but less
>>>> obviously so.
>>>>
>>>> Maybe you meant to call it
>>>>
>>>>     True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>>
>>>> Probably not, because you must be trying to sneak some incorrect
>>>> decisions past your readers by using your bad name.
>>
>> I see you are not prepared to acknowledge you have not specified your
>> key function in enough detail to be useful.  That is to be expected.
>> Vagueness rules in threads like this.
>
> I have specified it in enough detail to prove that the halting problem
> trick is defeated and the halting problem is no longer proved to be
> undecidable.

I accept that you believe that to be true.  I won't try to change your
mind, but I will continue to point out problems when the mood takes me.

-- 
Ben.

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


#24821 — Re: Architectural design of a halting problem solution [ Adaptation of Ben's code simplifications ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 22:20 -0600
SubjectRe: Architectural design of a halting problem solution [ Adaptation of Ben's code simplifications ]
Message-ID<vNadneno1-e0FALCnZ2dnUU7-L_NnZ2d@giganews.com>
In reply to#24818
On 11/1/2020 9:15 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/1/2020 7:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>>>> Although there's lots in you recent responses that I could comment
>>>>>>> on, perhaps one way forward would be for you to explain how you
>>>>>>> expect a trace to verify
>>>>>>>
>>>>>>>       "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>>>       parameter /would/ never halt /unless/ its execution is terminated"
>>>>>>
>>>>>> The sounds like an excellent way to proceed.
>>>>>>
>>>>>>> Note the "correctly" - that implies you must have a definition of
>>>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>>>> <cut>
>>>>>> When this function:
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>>
>>>>>> operates correctly then it
>>>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>>>
>>>>>> It is utterly ridiculous that you have had such a very difficult time
>>>>>> with that part.  Perhaps you have lots and lots of experience with
>>>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>>>> that the best function names precisely describe exactly what the
>>>>>> function does.
>>>>>
>>>>> Never returning either true or false is consistent with this function's
>>>>> name.
>>>>>
>>>>> Returning false for a non-halting computation what was not detected to be
>>>>> non-halting is consistent with this function's name.
>>>>>
>>>>> Other instances where the name is vague are also arguable, but less
>>>>> obviously so.
>>>>>
>>>>> Maybe you meant to call it
>>>>>
>>>>>      True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>>>
>>>>> Probably not, because you must be trying to sneak some incorrect
>>>>> decisions past your readers by using your bad name.
>>>
>>> I see you are not prepared to acknowledge you have not specified your
>>> key function in enough detail to be useful.  That is to be expected.
>>> Vagueness rules in threads like this.
>>
>> I have specified it in enough detail to prove that the halting problem
>> trick is defeated and the halting problem is no longer proved to be
>> undecidable.
> 
> I accept that you believe that to be true.  I won't try to change your
> mind, but I will continue to point out problems when the mood takes me.
> 

I went ahead and used a variation of your simplifications of my code and 
made these simplifications a little simpler still.

Your simplifications were focused on eliminating redundant code. Mine 
were focused on making code that is easiest to understand. I am going to 
use these versions from now on.


void Halts_Fooler(u32 P)
{
   if (Halts(P, P))
     HERE: goto HERE;
   else
     HALT
}


bool Halts(u32 P, u32 I)
{
   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
     return false // Non halting behavior detected
   else
     return true; // Input has already halted
}

When the halt decider does not makes its halting decision until after 
the input program has stopped running then the conventional halting 
problem trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.


-- 
Copyright 2020 Pete Olcott

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

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


#24816 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-02 03:02 +0000
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<Ld-dnQtGlf1U6wLCnZ2dnUU78f3NnZ2d@brightview.co.uk>
In reply to#24807
On 02/11/2020 01:05, olcott wrote:
> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>> Although there's lots in you recent responses that I could comment
>>>> on, perhaps one way forward would be for you to explain how you
>>>> expect a trace to verify
>>>>
>>>>     "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>     parameter /would/ never halt /unless/ its execution is terminated"
>>>
>>> The sounds like an excellent way to proceed.
>>>
>>>> Note the "correctly" - that implies you must have a definition of
>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>> <cut>
>>> When this function:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>
>>> operates correctly then it
>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>
>>> It is utterly ridiculous that you have had such a very difficult time
>>> with that part.  Perhaps you have lots and lots of experience with
>>> naming your functions like this: ABNHBD() and it never occurred to you
>>> that the best function names precisely describe exactly what the
>>> function does.
>>
>> Never returning either true or false is consistent with this function's
>> name.
>>
>> Returning false for a non-halting computation what was not detected to be
>> non-halting is consistent with this function's name.
>>
>> Other instances where the name is vague are also arguable, but less
>> obviously so.
>>
>> Maybe you meant to call it
>>
>>
>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>
>> Probably not, because you must be trying to sneak some incorrect
>> decisions past your readers by using your bad name.
>>
>
> If your suggestion would work (and it might) then we could go all the
> way back to simply: Not_Halts(P, I) which is understood to mean:
>
> Stops executing and Accepts any and all non-halting inputs and Rejects
> any and all halting inputs as soon as they halt.

That would be nice, because that is well-defined and clear, and what 
everybody expects it to mean.  No incoherent mysterious edits of source 
code and input data to create a totally new input pair (P_2, I_2) from 
the given pair (P,I).

Of course, by making things well-defined again, all your word game 
shenanigens are prevented, because you have gone back to the HP/Linz 
definitions, and now it is relevant to the Linz proof again.  [..that 
is, if you could actually deliver a decider H, correctly deciding its 
(H_Hat,H_Hat) input as you claimed 2 years ago...]

Mike.

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


#24819 — Re: Architectural design of a halting problem solution [ one paragraph says it all ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 21:55 -0600
SubjectRe: Architectural design of a halting problem solution [ one paragraph says it all ]
Message-ID<0-edne1sCIu6HgLCnZ2dnUU7-RnNnZ2d@giganews.com>
In reply to#24816
On 11/1/2020 9:02 PM, Mike Terry wrote:
> On 02/11/2020 01:05, olcott wrote:
>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>> Although there's lots in you recent responses that I could comment
>>>>> on, perhaps one way forward would be for you to explain how you
>>>>> expect a trace to verify
>>>>>
>>>>>     "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>     parameter /would/ never halt /unless/ its execution is terminated"
>>>>
>>>> The sounds like an excellent way to proceed.
>>>>
>>>>> Note the "correctly" - that implies you must have a definition of
>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>> <cut>
>>>> When this function:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>
>>>> operates correctly then it
>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>
>>>> It is utterly ridiculous that you have had such a very difficult time
>>>> with that part.  Perhaps you have lots and lots of experience with
>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>> that the best function names precisely describe exactly what the
>>>> function does.
>>>
>>> Never returning either true or false is consistent with this function's
>>> name.
>>>
>>> Returning false for a non-halting computation what was not detected 
>>> to be
>>> non-halting is consistent with this function's name.
>>>
>>> Other instances where the name is vague are also arguable, but less
>>> obviously so.
>>>
>>> Maybe you meant to call it
>>>
>>>
>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise 
>>>
>>>
>>> Probably not, because you must be trying to sneak some incorrect
>>> decisions past your readers by using your bad name.
>>>
>>
>> If your suggestion would work (and it might) then we could go all the
>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>
>> Stops executing and Accepts any and all non-halting inputs and Rejects
>> any and all halting inputs as soon as they halt.
> 
> That would be nice, because that is well-defined and clear, and what 
> everybody expects it to mean.  No incoherent mysterious edits of source 
> code and input data to create a totally new input pair (P_2, I_2) from 
> the given pair (P,I).

You only have to pay attention to one very simple point to see that this 
changes everything:

When the halt decider does not makes its halting decision until after 
the input program has stopped running then the conventional halting 
problem trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.

> Of course, by making things well-defined again, all your word game 
> shenanigens are prevented, because you have gone back to the HP/Linz 
> definitions, and now it is relevant to the Linz proof again.  [..that 
> is, if you could actually deliver a decider H, correctly deciding its 
> (H_Hat,H_Hat) input as you claimed 2 years ago...]
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#24823 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 22:25 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<vNadnevo1-fWFwLCnZ2dnUU7-L-dnZ2d@giganews.com>
In reply to#24816
On 11/1/2020 9:02 PM, Mike Terry wrote:
> On 02/11/2020 01:05, olcott wrote:
>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>> Although there's lots in you recent responses that I could comment
>>>>> on, perhaps one way forward would be for you to explain how you
>>>>> expect a trace to verify
>>>>>
>>>>>     "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>     parameter /would/ never halt /unless/ its execution is terminated"
>>>>
>>>> The sounds like an excellent way to proceed.
>>>>
>>>>> Note the "correctly" - that implies you must have a definition of
>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>> <cut>
>>>> When this function:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>
>>>> operates correctly then it
>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>
>>>> It is utterly ridiculous that you have had such a very difficult time
>>>> with that part.  Perhaps you have lots and lots of experience with
>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>> that the best function names precisely describe exactly what the
>>>> function does.
>>>
>>> Never returning either true or false is consistent with this function's
>>> name.
>>>
>>> Returning false for a non-halting computation what was not detected 
>>> to be
>>> non-halting is consistent with this function's name.
>>>
>>> Other instances where the name is vague are also arguable, but less
>>> obviously so.
>>>
>>> Maybe you meant to call it
>>>
>>>
>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise 
>>>
>>>
>>> Probably not, because you must be trying to sneak some incorrect
>>> decisions past your readers by using your bad name.
>>>
>>
>> If your suggestion would work (and it might) then we could go all the
>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>
>> Stops executing and Accepts any and all non-halting inputs and Rejects
>> any and all halting inputs as soon as they halt.
> 
> That would be nice, because that is well-defined and clear, and what 
> everybody expects it to mean.  No incoherent mysterious edits of source 
> code and input data to create a totally new input pair (P_2, I_2) from 
> the given pair (P,I).
> 
> Of course, by making things well-defined again, all your word game 
> shenanigens are prevented, because you have gone back to the HP/Linz 
> definitions, and now it is relevant to the Linz proof again.  [..that 
> is, if you could actually deliver a decider H, correctly deciding its 
> (H_Hat,H_Hat) input as you claimed 2 years ago...]
> 
> Mike.
> 

void Halts_Fooler(u32 P)
{
   if (Halts(P, P))
     HERE: goto HERE;
   else
     HALT
}


bool Halts(u32 P, u32 I)
{
   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
     return false // Non halting behavior detected
   else
     return true; // Input has already halted
}


int main()
{
   Halts((u32)Halts_Fooler, (u32)Halts_Fooler);
}

When the halt decider does not makes its halting decision until after 
the input program has stopped running then the conventional halting 
problem trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.


-- 
Copyright 2020 Pete Olcott

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

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


#24813 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-02 02:45 +0000
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<M_qdnRAkJPd97wLCnZ2dnUU78fvNnZ2d@brightview.co.uk>
In reply to#24799
On 01/11/2020 21:54, olcott wrote:
> On 11/1/2020 3:32 PM, Mike Terry wrote:
>> On 01/11/2020 20:38, olcott wrote:
>>> On 11/1/2020 1:50 PM, Mike Terry wrote:
>>>> On 01/11/2020 18:18, olcott wrote:
>>>>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>>>>> On 01/11/2020 14:40, olcott wrote:
>>>>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>> It is apparently over your head that the above code specifies
>>>>>>>>> three
>>>>>>>>> different instances of H_Hat and that
>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>>>>>> decide one of these three different instances.
>>>>>>>>
>>>>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>>>>> there
>>>>>>>> is but one definition of it.
>>>>>>>
>>>>>>> It can have one Turing Machine description that is executed multiple
>>>>>>> times by a master Turing machine. Each of these instances can have
>>>>>>> different amounts of data on their local tape.
>>>>>>>
>>>>>>> So it is exactly the same thing as three different instances of
>>>>>>> H_Hat
>>>>>>> each in their own local process context.
>>>>>>>
>>>>>>>> There is one embodiment of it as an actual machine in the
>>>>>>>> probem, and
>>>>>>>> multiple copies of a representation of it, suitable for H to
>>>>>>>> process.
>>>>>>>
>>>>>>> If we think of all of the machines involved as Turing Machine
>>>>>>> descriptions of UTMs that are executed by a single master UTM
>>>>>>> then we
>>>>>>> can get rid of the tedious dichotomy of a machine and its
>>>>>>> description
>>>>>>> and simply talk about machines that can execute other machines.
>>>>>>>
>>>>>>> In m y x86utm operting system the machine description language is
>>>>>>> x86
>>>>>>> and it is always directly executable.
>>>>>>>
>>>>>>>> For a given input, H_Hat will always produce the same result, that
>>>>>>>> is a
>>>>>>>> fundamental property of Turing Machines.
>>>>>>>
>>>>>>> Yet with three different instances of the same machine each one
>>>>>>> having a
>>>>>>>  longer execution trace the outermost invocation has the data
>>>>>>> required
>>>>>>> to make its halting decision first. As soon as it terminates its
>>>>>>> subordinate the entire process chain stops running.
>>>>>>
>>>>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>>>>>> (in some finite number of steps it reaches a halt state - you haven't
>>>>>> denied this, bearing in mind we're talking of the HP/Linz defined
>>>>>> term
>>>>>> "halts").
>>>>>
>>>>> int main()
>>>>> {
>>>>>   H_Hat(H_Hat)
>>>>>
>>>>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>> which correctly decides that its first parameter would never halt
>>>>> unless
>>>>> its execution is terminated.
>>>>>
>>>>> Everything else that you say is moot until you first understand the
>>>>> details related to what I just said prove that what I just said is
>>>>> true.
>>>>
>>>> LOL, but they don't.
>>>>
>>>> You say that everything else I'm saying is moot, but that's just your
>>>> way of avoiding having to take on board any reasoning that leads
>>>> towards the conclusion that you're wrong.  Similarly with your
>>>> "unresponsive" answers to others' questions - you know, when you just
>>>> change the subject and cut-and-paste stock phrases which you've
>>>> repeated over and over, which in no way address the questions asked.
>>>>
>>>> It doesn't matter to me that you don't want to listen to people
>>>> explaining your mistakes - cranks never do.  My prediction when I made
>>>> the previous post was that you would read half a dozen lines, then
>>>> make some dismissive remark excusing you from thinking any further.
>>>> This is your ages old pattern of behaviour, and as ever you are true
>>>> to form. :)
>>>>
>>>> By all means ignore all feedback - just continue with your plan to
>>>> publish your result and claim the recognition and credibility you feel
>>>> you deserve.  You've been trying for some years for this, and you feel
>>>> it's coming, yet somehow it's never quite arrived!  I'm happy for you
>>>> that you feel the culmination of you life's work is nearly at hand,
>>>> and you will finally get what's been coming to you for so long...
>>>>
>>>> Mike.
>>>>
>>>
>>> Unless and until you understand that this is a verifiable fact:
>>>
>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>> correctly decides that its first parameter would never halt unless
>>> its execution is terminated.
>>>
>>> You will continue to falsely presume that any confusion about this is
>>> mine and not yours.
>>>
>>> That you tend to dismiss the details that prove that above statement is
>>> true is a very strong indication of dishonestly on your part.
>>>
>>> In any case an execution trace would prove the truth of this.
>>>
>>
>> Although there's lots in you recent responses that I could comment on,
>> perhaps one way forward would be for you to explain how you expect a
>> trace to verify
>>
>>    "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>    parameter /would/ never halt /unless/ its execution is terminated"
>
> The sounds like an excellent way to proceed.
>
>> Note the "correctly" - that implies you must have a definition of what
>> ABNHBD(P,I) /should/ be, in terms of P and I.
>
> First of all the name: ABNHBD(H_Hat, H_Hat)
> is horribly terrible software engineering.
>
> High quality software engineering always has the function name describe
> exactly what the function does.
>
> If the function does too many things that cannot be described in a
> single concise name that proves** that the function needs to be
> decomposed into smaller functions. ** (for good software engineering).
>
> When this function:
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>
> operates correctly then it
> "Aborted its input Because Non-Halting Behavior was Detected".
>

ok, so when you say "non-halting behaviour was detected", what does 
"non-halting behaviour" mean?  Does it at least require that its input 
(P,I) must actually *be* non-halting?  Obviously I mean that P never 
halts when run with input I, in the HP/Linz sense?  Note, nothing in 
what I'm saying here is anything to do with emulating anything.

For reference, such a test which only matched in situations where its 
input (P,I) is /actually/ non-halting would normally be called a /SOUND/ 
non-halting test, i.e. no false matches!

> It is utterly ridiculous that you have had such a very difficult time
> with that part. Perhaps you have lots and lots of experience with naming
> your functions like this: ABNHBD() and it never occurred to you that the
> best function names precisely describe exactly what the function does.
>
>> Also note the conditional /would/ - what does that mean, for a general
>> input (P,I)?
>>
>> Mike.
>
> I am answering specifically rather than generally.
>
> When we comment out the part of
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> that aborts its input when it detects non-halting behavior and run:
> int main()
> {
>   H_Hat(H_Hat);
> the execution of H_Hat never terminates.
>

Yeah, but that doesn't actually make sense for a general input (P,I) - 
you see that, don't you?  And you /need/ to specify what you mean for a 
general input (P,I), because you are claiming they represent CLASSES of 
inputs which are being decided.  In fact, you suggest that these classes 
relates to the halting problem!

So have another go, but try to explain for a general input (P,I).

For the input (H_Hat, H_Hat) it seems you are saying that if you comment 
out bits of its source then you'd get a new program H_Hat_2, and that 
new program doesn't halt?  (I've covered this in previous posts but you 
just ignored it.)  In fact it looks like you're asking people to change 
both the program under test, /and/ the input data we're to run it with...

1. What do you expect to see in the trace of H_Hat that will
    verify that H_Hat_2(H_Hat_2) doesn't halt?

2. Any such definition along these lines, talking about some new
    program which is not even under discussion, is not related to
    anything in the HP/Linz proof, so wouldn't be able to refute
    anything!

You do understand that commenting out the lines from ABNHBD means you 
have changed the programs H_Hat, and H themselves, so they are no longer 
the "program under test"?  You will never succeed in making sense of 
this, because it's Just Daft.

But, I've had a better idea that could rescue you!  The idea is to 
provide an interpretation of the "/would/ only halt if..." that actually 
makes sense, by running with what is effectively a "modified" ABNHBD(), 
but /without/ the incoherent editing of program under test and its input 
data.  So it will have a coherent meaning when considered for a general 
input (P,I), as well as for the specific input (H_Hat,H_Hat)!  The 
"modified ABNHBD()" will be a NEW routine in a new program, while 
keeping H, H_Hat, ABNHBD etc. unchanged.

So, let's label the new program W [W for "would"], so now we have H, 
H_Hat and W.  We could say that W is a bit similar to H, but is not a 
decider.  It has its very own W_ABNHBD() with the changes you want 
[commenting out of the "detect non-halting behaviour" logic plus abort]. 
  But since it is distinct from H/H_Hat's ABNHBD(), the changes have 
effectively been made without having to alter the "program under test".

Here is new source code illustrating W being called to verify your claim 
for about (H_Hat,H_Hat):

====================================

void H_Hat(u32 M)
{
   if (ABNHBD(M, M))
     // Execution of M(N) has been aborted
     ;
   else
   {
     // M(N) has halted
     HERE: goto HERE;   //loop
   }
   HALT
}

void H(u32 M, u32 N)
{
   if (ABNHBD(M, N))
     MOV_EAX_0  // Execution of M(N) has been aborted
   else
     MOV_EAX_1  // M(N) has halted
   HALT
}

// ### new "program" (function) here
bool W(u32 M, u32 N)
{
   // this logic should mimic ABNHBD(), but without
   // the "detect non-terminating behaviour" test
   // I've guessed at exactly what this looks like, but
   // logically it will be like this...

    EmulationEngine e;  // this represents the inner
                        // emulation of M(N)
    e = CreateNewProcess (M, N);  // at start of emulation

    while (SingleStep(e))
    {
      // in ABNHBD, this is where "detect non-halting behaviour"
      // plus abort and return true logic would be.
      // I've commented those lines out.  Something like:
      // if (detected non halting behaviour)
      //    return true;   // M(N) aborted
    }
    // loop exits here when SingleStep(e) returns false due
    // to e reaching a halt state
    OUTPUT("W emulated M(N) and it halted");
    return false;     // M(N) halted
}


int main()
{
   u32 M = (u32)H_Hat;

   // just one of the following 3 lines, according to calculation
   // being built

   H(M, M);	// H running with input (H_Hat,H_Hat)
   H_Hat(M);	// H_Hat with input (H_Hat)
   W(M,M)        // <===###  New calculation: W with input (H_Hat,H_Hat)
                 //
   HALT;
}
===================================

Now, finally, you can give a well-defined meaning to your troublesome 
phrase "...would not halt if we commented out xxxxx, and adjusted the 
input string, um, somehow..."  :

When you say
    H_Hat(H_Hat) /wouldn't/ halt /if/ we edited its source to remove
    the abort logic and recompiled it to get some new program
    H_Hat_2, and then ran the new H_Hat_2 with the new H_Hat_2 as
    its input.

you can now simply say instead the properly-defined alternative:
    W(H_Hat,H_Hat)  DOES NOT halt.

or more generally, when talking of a general input (P,I) to ABNHBD, you 
can just say the plain and simple "W(P,I)" does not halt.  (Remember W 
is ABNHBD with any aborts commented out.)


Mike.

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


#24826 — Re: Architectural design of a halting problem solution [ non halting behavior detected ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 23:14 -0600
SubjectRe: Architectural design of a halting problem solution [ non halting behavior detected ]
Message-ID<PcadnStJJ8RRCALCnZ2dnUU7-enNnZ2d@giganews.com>
In reply to#24813
On 11/1/2020 8:45 PM, Mike Terry wrote:
> On 01/11/2020 21:54, olcott wrote:
>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>> On 01/11/2020 20:38, olcott wrote:
>>>> On 11/1/2020 1:50 PM, Mike Terry wrote:
>>>>> On 01/11/2020 18:18, olcott wrote:
>>>>>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>>>>>> On 01/11/2020 14:40, olcott wrote:
>>>>>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> It is apparently over your head that the above code specifies
>>>>>>>>>> three
>>>>>>>>>> different instances of H_Hat and that
>>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does 
>>>>>>>>>> correctly
>>>>>>>>>> decide one of these three different instances.
>>>>>>>>>
>>>>>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>>>>>> there
>>>>>>>>> is but one definition of it.
>>>>>>>>
>>>>>>>> It can have one Turing Machine description that is executed 
>>>>>>>> multiple
>>>>>>>> times by a master Turing machine. Each of these instances can have
>>>>>>>> different amounts of data on their local tape.
>>>>>>>>
>>>>>>>> So it is exactly the same thing as three different instances of
>>>>>>>> H_Hat
>>>>>>>> each in their own local process context.
>>>>>>>>
>>>>>>>>> There is one embodiment of it as an actual machine in the
>>>>>>>>> probem, and
>>>>>>>>> multiple copies of a representation of it, suitable for H to
>>>>>>>>> process.
>>>>>>>>
>>>>>>>> If we think of all of the machines involved as Turing Machine
>>>>>>>> descriptions of UTMs that are executed by a single master UTM
>>>>>>>> then we
>>>>>>>> can get rid of the tedious dichotomy of a machine and its
>>>>>>>> description
>>>>>>>> and simply talk about machines that can execute other machines.
>>>>>>>>
>>>>>>>> In m y x86utm operting system the machine description language is
>>>>>>>> x86
>>>>>>>> and it is always directly executable.
>>>>>>>>
>>>>>>>>> For a given input, H_Hat will always produce the same result, that
>>>>>>>>> is a
>>>>>>>>> fundamental property of Turing Machines.
>>>>>>>>
>>>>>>>> Yet with three different instances of the same machine each one
>>>>>>>> having a
>>>>>>>>  longer execution trace the outermost invocation has the data
>>>>>>>> required
>>>>>>>> to make its halting decision first. As soon as it terminates its
>>>>>>>> subordinate the entire process chain stops running.
>>>>>>>
>>>>>>> The calculation H-Hat(H_Hat) as you have described it elsewhere 
>>>>>>> halts
>>>>>>> (in some finite number of steps it reaches a halt state - you 
>>>>>>> haven't
>>>>>>> denied this, bearing in mind we're talking of the HP/Linz defined
>>>>>>> term
>>>>>>> "halts").
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>   H_Hat(H_Hat)
>>>>>>
>>>>>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>> which correctly decides that its first parameter would never halt
>>>>>> unless
>>>>>> its execution is terminated.
>>>>>>
>>>>>> Everything else that you say is moot until you first understand the
>>>>>> details related to what I just said prove that what I just said is
>>>>>> true.
>>>>>
>>>>> LOL, but they don't.
>>>>>
>>>>> You say that everything else I'm saying is moot, but that's just your
>>>>> way of avoiding having to take on board any reasoning that leads
>>>>> towards the conclusion that you're wrong.  Similarly with your
>>>>> "unresponsive" answers to others' questions - you know, when you just
>>>>> change the subject and cut-and-paste stock phrases which you've
>>>>> repeated over and over, which in no way address the questions asked.
>>>>>
>>>>> It doesn't matter to me that you don't want to listen to people
>>>>> explaining your mistakes - cranks never do.  My prediction when I made
>>>>> the previous post was that you would read half a dozen lines, then
>>>>> make some dismissive remark excusing you from thinking any further.
>>>>> This is your ages old pattern of behaviour, and as ever you are true
>>>>> to form. :)
>>>>>
>>>>> By all means ignore all feedback - just continue with your plan to
>>>>> publish your result and claim the recognition and credibility you feel
>>>>> you deserve.  You've been trying for some years for this, and you feel
>>>>> it's coming, yet somehow it's never quite arrived!  I'm happy for you
>>>>> that you feel the culmination of you life's work is nearly at hand,
>>>>> and you will finally get what's been coming to you for so long...
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> Unless and until you understand that this is a verifiable fact:
>>>>
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> correctly decides that its first parameter would never halt unless
>>>> its execution is terminated.
>>>>
>>>> You will continue to falsely presume that any confusion about this is
>>>> mine and not yours.
>>>>
>>>> That you tend to dismiss the details that prove that above statement is
>>>> true is a very strong indication of dishonestly on your part.
>>>>
>>>> In any case an execution trace would prove the truth of this.
>>>>
>>>
>>> Although there's lots in you recent responses that I could comment on,
>>> perhaps one way forward would be for you to explain how you expect a
>>> trace to verify
>>>
>>>    "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>    parameter /would/ never halt /unless/ its execution is terminated"
>>
>> The sounds like an excellent way to proceed.
>>
>>> Note the "correctly" - that implies you must have a definition of what
>>> ABNHBD(P,I) /should/ be, in terms of P and I.
>>
>> First of all the name: ABNHBD(H_Hat, H_Hat)
>> is horribly terrible software engineering.
>>
>> High quality software engineering always has the function name describe
>> exactly what the function does.
>>
>> If the function does too many things that cannot be described in a
>> single concise name that proves** that the function needs to be
>> decomposed into smaller functions. ** (for good software engineering).
>>
>> When this function:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>
>> operates correctly then it
>> "Aborted its input Because Non-Halting Behavior was Detected".
>>
> 
> ok, so when you say "non-halting behaviour was detected", what does 
> "non-halting behaviour" mean?  Does it at least require that its input 
> (P,I) must actually *be* non-halting?  

It means that unless the halt decider stops running the input program 
that the input program would never stop running.

The alternative is that the halt decider runs its input until it has 
stopped running.

In either case the

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

void Halts_Fooler(u32 P)
{
   if (Halts(P, P))
     HERE: goto HERE;
   else
     HALT
}

Does cannot possibly make halting undecidable because the input program 
has already stopped running.

> Obviously I mean that P never 
> halts when run with input I, in the HP/Linz sense?  Note, nothing in 
> what I'm saying here is anything to do with emulating anything.
> 
> For reference, such a test which only matched in situations where its 
> input (P,I) is /actually/ non-halting would normally be called a /SOUND/ 
> non-halting test, i.e. no false matches!
> 
>> It is utterly ridiculous that you have had such a very difficult time
>> with that part. Perhaps you have lots and lots of experience with naming
>> your functions like this: ABNHBD() and it never occurred to you that the
>> best function names precisely describe exactly what the function does.
>>
>>> Also note the conditional /would/ - what does that mean, for a general
>>> input (P,I)?
>>>
>>> Mike.
>>
>> I am answering specifically rather than generally.
>>
>> When we comment out the part of
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>> that aborts its input when it detects non-halting behavior and run:
>> int main()
>> {
>>   H_Hat(H_Hat);
>> the execution of H_Hat never terminates.
>>
> 
> Yeah, but that doesn't actually make sense for a general input (P,I) - 
> you see that, don't you?  And you /need/ to specify what you mean for a 
> general input (P,I), because you are claiming they represent CLASSES of 
> inputs which are being decided.  In fact, you suggest that these classes 
> relates to the halting problem!
> 
> So have another go, but try to explain for a general input (P,I).
> 
> For the input (H_Hat, H_Hat) it seems you are saying that if you comment 
> out bits of its source then you'd get a new program H_Hat_2, and that 
> new program doesn't halt?  (I've covered this in previous posts but you 
> just ignored it.)  In fact it looks like you're asking people to change 
> both the program under test, /and/ the input data we're to run it with...
> 
> 1. What do you expect to see in the trace of H_Hat that will
>     verify that H_Hat_2(H_Hat_2) doesn't halt?
> 
> 2. Any such definition along these lines, talking about some new
>     program which is not even under discussion, is not related to
>     anything in the HP/Linz proof, so wouldn't be able to refute
>     anything!
> 
> You do understand that commenting out the lines from ABNHBD means you 
> have changed the programs H_Hat, and H themselves, so they are no longer 
> the "program under test"?  You will never succeed in making sense of 
> this, because it's Just Daft.
> 
> But, I've had a better idea that could rescue you!  The idea is to 
> provide an interpretation of the "/would/ only halt if..." that actually 
> makes sense, by running with what is effectively a "modified" ABNHBD(), 
> but /without/ the incoherent editing of program under test and its input 
> data.  So it will have a coherent meaning when considered for a general 
> input (P,I), as well as for the specific input (H_Hat,H_Hat)!  The 
> "modified ABNHBD()" will be a NEW routine in a new program, while 
> keeping H, H_Hat, ABNHBD etc. unchanged.
> 
> So, let's label the new program W [W for "would"], so now we have H, 
> H_Hat and W.  We could say that W is a bit similar to H, but is not a 
> decider.  It has its very own W_ABNHBD() with the changes you want 
> [commenting out of the "detect non-halting behaviour" logic plus abort]. 
>   But since it is distinct from H/H_Hat's ABNHBD(), the changes have 
> effectively been made without having to alter the "program under test".
> 
> Here is new source code illustrating W being called to verify your claim 
> for about (H_Hat,H_Hat):
> 
> ====================================
> 
> void H_Hat(u32 M)
> {
>    if (ABNHBD(M, M))
>      // Execution of M(N) has been aborted
>      ;
>    else
>    {
>      // M(N) has halted
>      HERE: goto HERE;   //loop
>    }
>    HALT
> }
> 
> void H(u32 M, u32 N)
> {
>    if (ABNHBD(M, N))
>      MOV_EAX_0  // Execution of M(N) has been aborted
>    else
>      MOV_EAX_1  // M(N) has halted
>    HALT
> }
> 
> // ### new "program" (function) here
> bool W(u32 M, u32 N)
> {
>    // this logic should mimic ABNHBD(), but without
>    // the "detect non-terminating behaviour" test
>    // I've guessed at exactly what this looks like, but
>    // logically it will be like this...
> 
>     EmulationEngine e;  // this represents the inner
>                         // emulation of M(N)
>     e = CreateNewProcess (M, N);  // at start of emulation
> 
>     while (SingleStep(e))
>     {
>       // in ABNHBD, this is where "detect non-halting behaviour"
>       // plus abort and return true logic would be.
>       // I've commented those lines out.  Something like:
>       // if (detected non halting behaviour)
>       //    return true;   // M(N) aborted
>     }
>     // loop exits here when SingleStep(e) returns false due
>     // to e reaching a halt state
>     OUTPUT("W emulated M(N) and it halted");
>     return false;     // M(N) halted
> }
> 
> 
> int main()
> {
>    u32 M = (u32)H_Hat;
> 
>    // just one of the following 3 lines, according to calculation
>    // being built
> 
>    H(M, M);    // H running with input (H_Hat,H_Hat)
>    H_Hat(M);    // H_Hat with input (H_Hat)
>    W(M,M)        // <===###  New calculation: W with input (H_Hat,H_Hat)
>                  //
>    HALT;
> }
> ===================================
> 
> Now, finally, you can give a well-defined meaning to your troublesome 
> phrase "...would not halt if we commented out xxxxx, and adjusted the 
> input string, um, somehow..."  :
> 
> When you say
>     H_Hat(H_Hat) /wouldn't/ halt /if/ we edited its source to remove
>     the abort logic and recompiled it to get some new program
>     H_Hat_2, and then ran the new H_Hat_2 with the new H_Hat_2 as
>     its input.
> 
> you can now simply say instead the properly-defined alternative:
>     W(H_Hat,H_Hat)  DOES NOT halt.
> 
> or more generally, when talking of a general input (P,I) to ABNHBD, you 
> can just say the plain and simple "W(P,I)" does not halt.  (Remember W 
> is ABNHBD with any aborts commented out.)
> 
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#24827 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-11-02 03:12 -0800
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<d8c75c72-de4e-4ea3-be3c-f3e9aa0da9b0n@googlegroups.com>
In reply to#24799
On Sunday, 1 November 2020 at 21:54:44 UTC, olcott wrote:
> On 11/1/2020 3:32 PM, Mike Terry wrote: 
> > On 01/11/2020 20:38, olcott wrote: 
> >> On 11/1/2020 1:50 PM, Mike Terry wrote: 
> >>> On 01/11/2020 18:18, olcott wrote: 
> >>>> On 11/1/2020 10:11 AM, Mike Terry wrote: 
> >>>>> On 01/11/2020 14:40, olcott wrote: 
> >>>>>> On 11/1/2020 7:19 AM, Richard Damon wrote: 
> >>>>>>> On 10/31/20 11:18 PM, olcott wrote: 
> >>>>>>>> 
> >>>>>>>> It is apparently over your head that the above code specifies three 
> >>>>>>>> different instances of H_Hat and that 
> >>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly 
> >>>>>>>> decide one of these three different instances. 
> >>>>>>> 
> >>>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such 
> >>>>>>> there 
> >>>>>>> is but one definition of it. 
> >>>>>> 
> >>>>>> It can have one Turing Machine description that is executed multiple 
> >>>>>> times by a master Turing machine. Each of these instances can have 
> >>>>>> different amounts of data on their local tape. 
> >>>>>> 
> >>>>>> So it is exactly the same thing as three different instances of H_Hat 
> >>>>>> each in their own local process context. 
> >>>>>> 
> >>>>>>> There is one embodiment of it as an actual machine in the probem, 
> >>>>>>> and 
> >>>>>>> multiple copies of a representation of it, suitable for H to 
> >>>>>>> process. 
> >>>>>> 
> >>>>>> If we think of all of the machines involved as Turing Machine 
> >>>>>> descriptions of UTMs that are executed by a single master UTM then we 
> >>>>>> can get rid of the tedious dichotomy of a machine and its description 
> >>>>>> and simply talk about machines that can execute other machines. 
> >>>>>> 
> >>>>>> In m y x86utm operting system the machine description language is x86 
> >>>>>> and it is always directly executable. 
> >>>>>> 
> >>>>>>> For a given input, H_Hat will always produce the same result, that 
> >>>>>>> is a 
> >>>>>>> fundamental property of Turing Machines. 
> >>>>>> 
> >>>>>> Yet with three different instances of the same machine each one 
> >>>>>> having a 
> >>>>>> longer execution trace the outermost invocation has the data 
> >>>>>> required 
> >>>>>> to make its halting decision first. As soon as it terminates its 
> >>>>>> subordinate the entire process chain stops running. 
> >>>>> 
> >>>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts 
> >>>>> (in some finite number of steps it reaches a halt state - you haven't 
> >>>>> denied this, bearing in mind we're talking of the HP/Linz defined term 
> >>>>> "halts"). 
> >>>> 
> >>>> int main() 
> >>>> { 
> >>>> H_Hat(H_Hat) 
> >>>> 
> >>>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>> which correctly decides that its first parameter would never halt 
> >>>> unless 
> >>>> its execution is terminated. 
> >>>> 
> >>>> Everything else that you say is moot until you first understand the 
> >>>> details related to what I just said prove that what I just said is 
> >>>> true. 
> >>> 
> >>> LOL, but they don't. 
> >>> 
> >>> You say that everything else I'm saying is moot, but that's just your 
> >>> way of avoiding having to take on board any reasoning that leads 
> >>> towards the conclusion that you're wrong. Similarly with your 
> >>> "unresponsive" answers to others' questions - you know, when you just 
> >>> change the subject and cut-and-paste stock phrases which you've 
> >>> repeated over and over, which in no way address the questions asked. 
> >>> 
> >>> It doesn't matter to me that you don't want to listen to people 
> >>> explaining your mistakes - cranks never do. My prediction when I made 
> >>> the previous post was that you would read half a dozen lines, then 
> >>> make some dismissive remark excusing you from thinking any further. 
> >>> This is your ages old pattern of behaviour, and as ever you are true 
> >>> to form. :) 
> >>> 
> >>> By all means ignore all feedback - just continue with your plan to 
> >>> publish your result and claim the recognition and credibility you feel 
> >>> you deserve. You've been trying for some years for this, and you feel 
> >>> it's coming, yet somehow it's never quite arrived! I'm happy for you 
> >>> that you feel the culmination of you life's work is nearly at hand, 
> >>> and you will finally get what's been coming to you for so long... 
> >>> 
> >>> Mike. 
> >>> 
> >> 
> >> Unless and until you understand that this is a verifiable fact: 
> >> 
> >> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >> correctly decides that its first parameter would never halt unless 
> >> its execution is terminated. 
> >> 
> >> You will continue to falsely presume that any confusion about this is 
> >> mine and not yours. 
> >> 
> >> That you tend to dismiss the details that prove that above statement is 
> >> true is a very strong indication of dishonestly on your part. 
> >> 
> >> In any case an execution trace would prove the truth of this. 
> >> 
> > 
> > Although there's lots in you recent responses that I could comment on, 
> > perhaps one way forward would be for you to explain how you expect a 
> > trace to verify 
> > 
> > "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first 
> > parameter /would/ never halt /unless/ its execution is terminated"
> The sounds like an excellent way to proceed.
> > Note the "correctly" - that implies you must have a definition of what 
> > ABNHBD(P,I) /should/ be, in terms of P and I.
> First of all the name: ABNHBD(H_Hat, H_Hat) 
> is horribly terrible software engineering. 
> 
> High quality software engineering always has the function name describe 
> exactly what the function does. 
>
I agree with you here. The initials mean nothing to anyone not familiar with
the thread. If Aborted_Because_Non_Halting_Behavior_Detected is different
 from "Halts", then the name should reflect that. However you haven't been
clear on where the difference lies.

> When we comment out the part of
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> that aborts its input when it detects non-halting behavior and run: 
> int main() 
> { 
> H_Hat(H_Hat); 
> the execution of H_Hat never terminates.
> 
RIght.  So you want to comment in the aborting behaviour when H() is
run directly from main, comment it out when H_Hat()  is run directly
from main. Then you will indeed achieve two consistent programs.

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


#24828 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-02 04:52 -0700
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<rnoru1$aad$1@dont-email.me>
In reply to#24827
On 2020-11-02 04:12, Malcolm McLean wrote:
> On Sunday, 1 November 2020 at 21:54:44 UTC, olcott wrote:
>> When we comment out the part of
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>> that aborts its input when it detects non-halting behavior and run:
>> int main()
>> {
>> H_Hat(H_Hat);
>> the execution of H_Hat never terminates.
>>
> RIght.  So you want to comment in the aborting behaviour when H() is
> run directly from main, comment it out when H_Hat()  is run directly
> from main. Then you will indeed achieve two consistent programs.

But of course this means his H_Hat doesn't stand in the correct relation 
to his H, so the result has nothing to do with the Linz proof he claims 
to be 'refuting'.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#24831 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-02 08:01 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<WcOdnfQ0jd2njD3CnZ2dnUU7-cXNnZ2d@giganews.com>
In reply to#24828
On 11/2/2020 5:52 AM, André G. Isaak wrote:
> On 2020-11-02 04:12, Malcolm McLean wrote:
>> On Sunday, 1 November 2020 at 21:54:44 UTC, olcott wrote:
>>> When we comment out the part of
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>> that aborts its input when it detects non-halting behavior and run:
>>> int main()
>>> {
>>> H_Hat(H_Hat);
>>> the execution of H_Hat never terminates.
>>>
>> RIght.  So you want to comment in the aborting behaviour when H() is
>> run directly from main, comment it out when H_Hat()  is run directly
>> from main. Then you will indeed achieve two consistent programs.
> 
> But of course this means his H_Hat doesn't stand in the correct relation 
> to his H, so the result has nothing to do with the Linz proof he claims 
> to be 'refuting'.
> 
> André
> 

New names that are more descriptive.

void Halts_Fooler(u32 P)
{
   if (Halts(P, P))
     HERE: goto HERE;
   else
     HALT
}


bool Halts(u32 P, u32 I)
{
   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
     return false // Non halting behavior detected
   else
     return true; // Input has already halted
}


New claim:
Halts always decides its input correctly and cannot be shown otherwise.

-- 
Copyright 2020 Pete Olcott

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

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


#24835 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-02 08:12 -0700
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<rnp7ko$uh1$1@dont-email.me>
In reply to#24831
On 2020-11-02 07:01, olcott wrote:
> On 11/2/2020 5:52 AM, André G. Isaak wrote:
>> On 2020-11-02 04:12, Malcolm McLean wrote:
>>> On Sunday, 1 November 2020 at 21:54:44 UTC, olcott wrote:
>>>> When we comment out the part of
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>> that aborts its input when it detects non-halting behavior and run:
>>>> int main()
>>>> {
>>>> H_Hat(H_Hat);
>>>> the execution of H_Hat never terminates.
>>>>
>>> RIght.  So you want to comment in the aborting behaviour when H() is
>>> run directly from main, comment it out when H_Hat()  is run directly
>>> from main. Then you will indeed achieve two consistent programs.
>>
>> But of course this means his H_Hat doesn't stand in the correct 
>> relation to his H, so the result has nothing to do with the Linz proof 
>> he claims to be 'refuting'.
>>
>> André
>>
> 
> New names that are more descriptive.
> 
> void Halts_Fooler(u32 P)
> {
>    if (Halts(P, P))
>      HERE: goto HERE;
>    else
>      HALT
> }
> 
> 
> bool Halts(u32 P, u32 I)
> {
>    if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))

For someone who goes on about the importance of descriptive names, your 
choice of return values here is odd. They appear to be backwards from 
what your descriptive name suggests they should be.

>      return false // Non halting behavior detected
>    else
>      return true; // Input has already halted
> }
> 
> 
> New claim:
> Halts always decides its input correctly and cannot be shown otherwise.

And again, your claim is simply false.

If your Halts program is indeed a Halt decider, then Halts(Halt_Fooler, 
Halts_Fooler) must answer correctly describe the behaviour of 
Halts_Fooler(Halts_Fooler) when run *independently*, and it must be 
guaranteed to return an answer. That's the definition of a halt decider.

So what happens when we execute Halts_Fooler(Halts_Fooler)?

According to you, Halts_Fooler calls Halts(Halts_Fooler, Halts_Fooler), 
which in turn calls 
Aborted_Because_Non_Halting_Behavior_Detected(Halts_Fooler, Halts_Fooler).

Aborted_Because_Non_Halting_Behavior_Detected(Halts_Fooler, 
Halts_Fooler) detects that Halts_Fooler applied to Halts_Fooler's 
description will not terminate and needs to be aborted.

Aborted_Because_Non_Halting_Behavior_Detected aborts it and then returns 
false, as does Halts(), at which point Halts_Fooler *H*A*L*T*S

That's the behaviour which a halt detector needs to accurately describe. 
The fact that Halt_Fooler(Halts_Fooler) *HALTS* when run *independently*.

Your Halts(Halts_Fooler, Halts_Fooler) claims that it must be aborted. 
That is simply incorrect. Aborted_Because_Non_Halting_Behavior_Detected 
invoked from within Halts() does *not* need abort execution because the 
call to Aborted_Because_Non_Halting_Behavior_Detected within the 
outermost Halt_Fooler will abort it, meaning that it *will* terminate 
without any intervention from Halts(). It should therefore return true.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#24837 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-02 10:23 -0500
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<0wVnH.290545$GQ4.226017@fx02.iad>
In reply to#24835
On 11/2/20 10:12 AM, André G. Isaak wrote:
>>
> 
> And again, your claim is simply false.
> 
> If your Halts program is indeed a Halt decider, then Halts(Halt_Fooler,
> Halts_Fooler) must answer correctly describe the behaviour of
> Halts_Fooler(Halts_Fooler) when run *independently*, and it must be
> guaranteed to return an answer. That's the definition of a halt decider.
> 
> So what happens when we execute Halts_Fooler(Halts_Fooler)?
> 
> According to you, Halts_Fooler calls Halts(Halts_Fooler, Halts_Fooler),
> which in turn calls
> Aborted_Because_Non_Halting_Behavior_Detected(Halts_Fooler, Halts_Fooler).
> 
> Aborted_Because_Non_Halting_Behavior_Detected(Halts_Fooler,
> Halts_Fooler) detects that Halts_Fooler applied to Halts_Fooler's
> description will not terminate and needs to be aborted.
> 
> Aborted_Because_Non_Halting_Behavior_Detected aborts it and then returns
> false, as does Halts(), at which point Halts_Fooler *H*A*L*T*S
> 
> That's the behaviour which a halt detector needs to accurately describe.
> The fact that Halt_Fooler(Halts_Fooler) *HALTS* when run *independently*.
> 
> Your Halts(Halts_Fooler, Halts_Fooler) claims that it must be aborted.
> That is simply incorrect. Aborted_Because_Non_Halting_Behavior_Detected
> invoked from within Halts() does *not* need abort execution because the
> call to Aborted_Because_Non_Halting_Behavior_Detected within the
> outermost Halt_Fooler will abort it, meaning that it *will* terminate
> without any intervention from Halts(). It should therefore return true.
> 
> André

I think I finally get it. Peter is in a state where he belives
implicitly what is halt detector says and ignores all aspects of reality.

Deciding whether a machine halts isn't about the machine, it is about
the detetor.

Peter also seems incapable of understanding the infinite and anything
that get close to it shuts down his thinking process.

There is of course a word for someone who belives themselves more than
what can be observed in the actual world.

Peter has basically added an axiom to his logic system that his halt
detector is correct, Which of course means that it is (in his system),
if just means that his logic system is inconsistent.

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


#24830 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-02 07:58 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<b4qdnbV8EtXljT3CnZ2dnUU7-d3NnZ2d@giganews.com>
In reply to#24827
On 11/2/2020 5:12 AM, Malcolm McLean wrote:
> On Sunday, 1 November 2020 at 21:54:44 UTC, olcott wrote:
>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>> On 01/11/2020 20:38, olcott wrote:
>>>> On 11/1/2020 1:50 PM, Mike Terry wrote:
>>>>> On 01/11/2020 18:18, olcott wrote:
>>>>>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>>>>>> On 01/11/2020 14:40, olcott wrote:
>>>>>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> It is apparently over your head that the above code specifies three
>>>>>>>>>> different instances of H_Hat and that
>>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>>>>>>> decide one of these three different instances.
>>>>>>>>>
>>>>>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>>>>>> there
>>>>>>>>> is but one definition of it.
>>>>>>>>
>>>>>>>> It can have one Turing Machine description that is executed multiple
>>>>>>>> times by a master Turing machine. Each of these instances can have
>>>>>>>> different amounts of data on their local tape.
>>>>>>>>
>>>>>>>> So it is exactly the same thing as three different instances of H_Hat
>>>>>>>> each in their own local process context.
>>>>>>>>
>>>>>>>>> There is one embodiment of it as an actual machine in the probem,
>>>>>>>>> and
>>>>>>>>> multiple copies of a representation of it, suitable for H to
>>>>>>>>> process.
>>>>>>>>
>>>>>>>> If we think of all of the machines involved as Turing Machine
>>>>>>>> descriptions of UTMs that are executed by a single master UTM then we
>>>>>>>> can get rid of the tedious dichotomy of a machine and its description
>>>>>>>> and simply talk about machines that can execute other machines.
>>>>>>>>
>>>>>>>> In m y x86utm operting system the machine description language is x86
>>>>>>>> and it is always directly executable.
>>>>>>>>
>>>>>>>>> For a given input, H_Hat will always produce the same result, that
>>>>>>>>> is a
>>>>>>>>> fundamental property of Turing Machines.
>>>>>>>>
>>>>>>>> Yet with three different instances of the same machine each one
>>>>>>>> having a
>>>>>>>> longer execution trace the outermost invocation has the data
>>>>>>>> required
>>>>>>>> to make its halting decision first. As soon as it terminates its
>>>>>>>> subordinate the entire process chain stops running.
>>>>>>>
>>>>>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>>>>>>> (in some finite number of steps it reaches a halt state - you haven't
>>>>>>> denied this, bearing in mind we're talking of the HP/Linz defined term
>>>>>>> "halts").
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H_Hat(H_Hat)
>>>>>>
>>>>>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>> which correctly decides that its first parameter would never halt
>>>>>> unless
>>>>>> its execution is terminated.
>>>>>>
>>>>>> Everything else that you say is moot until you first understand the
>>>>>> details related to what I just said prove that what I just said is
>>>>>> true.
>>>>>
>>>>> LOL, but they don't.
>>>>>
>>>>> You say that everything else I'm saying is moot, but that's just your
>>>>> way of avoiding having to take on board any reasoning that leads
>>>>> towards the conclusion that you're wrong. Similarly with your
>>>>> "unresponsive" answers to others' questions - you know, when you just
>>>>> change the subject and cut-and-paste stock phrases which you've
>>>>> repeated over and over, which in no way address the questions asked.
>>>>>
>>>>> It doesn't matter to me that you don't want to listen to people
>>>>> explaining your mistakes - cranks never do. My prediction when I made
>>>>> the previous post was that you would read half a dozen lines, then
>>>>> make some dismissive remark excusing you from thinking any further.
>>>>> This is your ages old pattern of behaviour, and as ever you are true
>>>>> to form. :)
>>>>>
>>>>> By all means ignore all feedback - just continue with your plan to
>>>>> publish your result and claim the recognition and credibility you feel
>>>>> you deserve. You've been trying for some years for this, and you feel
>>>>> it's coming, yet somehow it's never quite arrived! I'm happy for you
>>>>> that you feel the culmination of you life's work is nearly at hand,
>>>>> and you will finally get what's been coming to you for so long...
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> Unless and until you understand that this is a verifiable fact:
>>>>
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> correctly decides that its first parameter would never halt unless
>>>> its execution is terminated.
>>>>
>>>> You will continue to falsely presume that any confusion about this is
>>>> mine and not yours.
>>>>
>>>> That you tend to dismiss the details that prove that above statement is
>>>> true is a very strong indication of dishonestly on your part.
>>>>
>>>> In any case an execution trace would prove the truth of this.
>>>>
>>>
>>> Although there's lots in you recent responses that I could comment on,
>>> perhaps one way forward would be for you to explain how you expect a
>>> trace to verify
>>>
>>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>> parameter /would/ never halt /unless/ its execution is terminated"
>> The sounds like an excellent way to proceed.
>>> Note the "correctly" - that implies you must have a definition of what
>>> ABNHBD(P,I) /should/ be, in terms of P and I.
>> First of all the name: ABNHBD(H_Hat, H_Hat)
>> is horribly terrible software engineering.
>>
>> High quality software engineering always has the function name describe
>> exactly what the function does.
>>
> I agree with you here. The initials mean nothing to anyone not familiar with
> the thread. If Aborted_Because_Non_Halting_Behavior_Detected is different
>   from "Halts", then the name should reflect that. However you haven't been
> clear on where the difference lies.

void Halts_Fooler(u32 P)
{
   if (Halts(P, P))
     HERE: goto HERE;
   else
     HALT
}

bool Halts(u32 P, u32 I)
{
   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
     return false // Non halting behavior detected
   else
     return true; // Input has already halted
}

When the halt decider does not makes its halting decision until after 
the input program has stopped running then the conventional halting 
problem trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.

>> When we comment out the part of
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>> that aborts its input when it detects non-halting behavior and run:
>> int main()
>> {
>> H_Hat(H_Hat);
>> the execution of H_Hat never terminates.
>>
> RIght.  So you want to comment in the aborting behaviour when H() is
> run directly from main, comment it out when H_Hat()  is run directly
> from main. Then you will indeed achieve two consistent programs.
> 

int main
{
   H_Hat(H_Hat);
calls
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);

The only reason why
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
ever terminates is that the execution of its input is aborted by the 
above function the execution trace of this proves beyond all possible 
doubt that (H_Hat, H_Hat) was decided correctly.

-- 
Copyright 2020 Pete Olcott

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

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


#24795 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 14:02 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<P5CdnaL7I_fAiQLCnZ2dnUU7-WfNnZ2d@giganews.com>
In reply to#24784
On 11/1/2020 10:11 AM, Mike Terry wrote:
> On 01/11/2020 14:40, olcott wrote:
>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>
>>>> It is apparently over your head that the above code specifies three
>>>> different instances of H_Hat and that
>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>> decide one of these three different instances.
>>>
>>> You seem to be unaware that H_Hat is a Turing machine, and as such there
>>> is but one definition of it.
>>
>> It can have one Turing Machine description that is executed multiple
>> times by a master Turing machine. Each of these instances can have
>> different amounts of data on their local tape.
>>
>> So it is exactly the same thing as three different instances of H_Hat
>> each in their own local process context.
>>
>>> There is one embodiment of it as an actual machine in the probem, and
>>> multiple copies of a representation of it, suitable for H to process.
>>
>> If we think of all of the machines involved as Turing Machine
>> descriptions of UTMs that are executed by a single master UTM then we
>> can get rid of the tedious dichotomy of a machine and its description
>> and simply talk about machines that can execute other machines.
>>
>> In m y x86utm operting system the machine description language is x86
>> and it is always directly executable.
>>
>>> For a given input, H_Hat will always produce the same result, that is a
>>> fundamental property of Turing Machines.
>>
>> Yet with three different instances of the same machine each one having a
>>  longer execution trace the outermost invocation has the data required
>> to make its halting decision first. As soon as it terminates its
>> subordinate the entire process chain stops running.
> 
> The calculation H-Hat(H_Hat) as you have described it elsewhere halts 
> (in some finite number of steps it reaches a halt state - you haven't 
> denied this, bearing in mind we're talking of the HP/Linz defined term 
> "halts").
> 
> Let's imagine, just for illustrative purposes, that it halts in 10000 
> steps.  That's to say, 10000 /specific/ steps, each one consisting of 
> one specific program state (current instruction within the program) 
> together with its data state.  We could write all these down exactly, if 
> we could be bothered, and had a big enough notebook!  The final step 
> 10000 is of course the calculation's halt state.
> 
> EVERY ONE OF YOUR EMULATIONS OF H_HAT ARE SIMPLY IN THE PROCESS OF 
> ENUMERATING THE 10000 STATES OF THIS ONE SINGLE CALCULATION.
> 
> The only difference between them is that at a given point in the (outer) 
> H_Hat or H calculation, they will each have enumerated a different 
> number of these steps.  Maybe the outer one has enumerated the first 
> 7000 steps out of the total 10000, while an inner one has only 
> enumerated 2000 of the same 10000 states, or whatever.
> 
> At this point, let's say the outer emulation process decides to stop 
> emulating for whatever reason - its seen enough!  So the emulation only 
> ever enumerates 7000 of the 10000 steps.  (Inner emulations enumerate 
> less.)
> 
> If you want to say that all the emulations had "different results" then 
> all you're saying is that each proceeded for a different number of steps 
> along one and the same calculation (which contains 10000 steps and then 
> halts, however you try to confuse things).
> 
>>
>>> If your 'UTM' gets a different answer when simulating the machine, then
>>> that is positive evidence that your UTM has a bug. The answer H gives
>>
>> Three identical function with different amounts of data can and do
>> derive different results.
> 
> You mean, each emulation can be abandonned after enumerating a different 
> number of steps before its emulator gives up.  (The underlying 
> calculation they are enumerating in each case is the same.  In our 
> illustration it is a calculation with 10000 steps, the last being the 
> halt state for the calculation.)
> 
>> The first one with complete data to make a
>> decision terminates the whole process chain of all the rest.
>>
>>> must match that actual answer that running the REAL H_Hat gives. If
>>> other instances act different, all that shows is that somewhere there is
>>> a discrepancy that invalidates the example.
>>>
>>
>> H_Hat(H_Hat)
>> There are three different instances of H_Hat having different lengths of
>> the execution trace of its subordinate. The halt decider has no data
>> regarding the execution trace of the first H_Hat because it has not been
>> invoked yet. When it is invoked if begins to acquire data regarding the
>> execution trace of its first parameter. As soon as it has a sufficiently
>> long execution trace it makes it halting decision.
>>
> 
> You have said that its decision is not a "halting/non-halting" decision 
> in the sense of HP/Linz proof.  I.e. it is not a decision on whether its 
> input is in class HALTING or NON_HALTING.  (Those classes being the 
> calculation that eventually reach a halt state, or don't, respectively.)

In <is> a halting / not halting decision in terms of the classes that 
its input is divided into.

Because it only makes this decision after its input has stopped 
executing it is not subject to the conventional
"do the opposite of whatever the halt decider decides"
trick that shows that some inputs are undecidable.

> Continuing the earlier illustration, the outer emulation was abandoned 
> after enumerating only 7000 of the full 10000 steps in the calculation, 
> because the internal code decided it had found evidence of non-halting 
> behaviour.  Clearly that evidence was wrong in any meaningful sense, 
> because in 10000 steps the calculation reaches a halt step.

int main()
{
   H_Hat(H_Hat)

invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
which correctly decides that its first parameter would never halt unless 
its execution is terminated.

Everything else that you say is moot until you first understand the 
details related to what I just said prove that what I just said is true.

Your confusion is anchored in failing to understand a verifiable fact.

> There's no arguing with that - I've got each of those 10000 explicit 
> steps written down exactly, in my notebood! :)  And look, step 10000 is 
> indeed a halt state, so the calculation DOES halt.  Whatever you are 
> deciding, it's not whether the input is in the NON_HALTING class.

Speaking about it vaguely like this allows key details to slip though 
the cracks without being noticed. That is why it was so crucial that I 
made every singlle detail 100% explicitly specified by actual fully 
operational code.

> Somehow you have just become confused and are looking at this 
> incorrectly.  You say the calculation /only/ terminates in 10000 steps 
> /because/ of the way its program is written (something about the 
> internal ABNHBD choosing to abandon its emulation after 7000 steps). 
> That doesn't matter - the calculation /does/ halt in 10000 steps. 
> Internal emulations may be abandoned when only 7000 steps have been 
> enumerated, but nobody but you cares about that!

int main()
{
   H_Hat(H_Hat)

invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
which correctly decides that its first parameter would never halt unless 
its execution is terminated.

Everything else that you say is moot until you first understand the 
details related to what I just said prove that what I just said is true.

Your confusion is anchored in failing to understand a verifiable fact.
You now dismiss the proof that I am correct as an irrelevant detail.

As long as you dismiss the proof that I am correct as an irrelevant 
details you prove that you do not care about the truth and only want to 
win an argument by dishonest means.


> The fact that if we replace H_Hat with H_Hat_2 [a different program, 
> where its internal routine ABNHBD lacks the "non-terminating behaviour" 
> test] then calculation H_Hat_2(H_Hat_2) doesn't halt is also quite 
> irrelevant.
> If your argument is that ABNHBD in H or H_Hat returned the "correct" 
> result, because ABNHBD did indeed abort its emulation after looking at 
> only 7000 of the 10000 steps in the calculation, then you would only be 
> saying that H is a "did my internal routine think it had found 
> non-terminating behaviour" decider.  Nobody is interested in that.  (It 
> would be a totally crass argument, not refuting anything.)
> 
> Mike.
> 
> 
>> None of the instances of H_Hat directly have any data about the
>> execution trace of their input. All of this execution trace  data is
>> held in the halt decider that they invoke:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>
>> If we construe that an H_Hat instance has the data of the halt decider
>> that it invoked by proxy then no halt decider has any data about the
>> outermost H_Hat. The outermost H_Hat though its halt decider has the
>> execution trace data of its input. This is the longest execution trace
>> thus the most data. Each subsequent H_Hat halt decider has decreasingly
>> less data.
>>
>> The halt decider for out outermost H_Hat does not exist so it has no
>> data. The halt decider for the H_Hat parameter to the outermost H_Hat
>> has the most data. The subsequent invocations of halt deciders and H_Hat
>> has increasingly less data.
>>
>> So the reason why the different H_Hats have different behavior is they
>> have a different amount of data.  There is zero data about the execution
>> trace of the first H_Hat. There is the most data about the execution
>> trace of the next _H_Hat and there is less data about the execution
>> trace of the third H_Hat.
>>
>> The first halt decider has the most data about the execution trace of
>> any instance of H_Hat thus providing the legitimate reason why its
>> behavior differs.
>>


-- 
Copyright 2020 Pete Olcott

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

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


#24801 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-01 17:52 -0500
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<V_GnH.786167$AN2.317660@fx46.iad>
In reply to#24795
On 11/1/20 3:02 PM, olcott wrote:
> Because it only makes this decision after its input has stopped
> executing it is not subject to the conventional
> "do the opposite of whatever the halt decider decides"
> trick that shows that some inputs are undecidable.

Note a simple fact.

It may have decided that non-halting behavior was detected, but it can
get the answer wrong. (which it has). Note the term in the name 'Needed'.

This can be proven by looking at the execution trace of the exact same
code that was allowed to execute longer (like the outer level) and
seeing that it ultimately did halt.

THUS, the determination that the behavior was inherently non-halting is
incorrect.

Or, are you saying that the machine that ran the outer version of the
code was incorrect?

Note, you need to be able to PROVE (despite the evidence of the outer
machine) that the inner machine actually was going to run forever with
non-halting behavior, and at the same time that H and the code inside it
will always halt in finite time. THAT is a bigger contradiction than
Linz used in H_Hat.

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


#24803 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-01 17:59 -0600
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<w7idnfxzdeFl1gLCnZ2dnUU7-QvNnZ2d@giganews.com>
In reply to#24801
On 11/1/2020 4:52 PM, Richard Damon wrote:
> On 11/1/20 3:02 PM, olcott wrote:
>> Because it only makes this decision after its input has stopped
>> executing it is not subject to the conventional
>> "do the opposite of whatever the halt decider decides"
>> trick that shows that some inputs are undecidable.
> 
> Note a simple fact.
> 
> It may have decided that non-halting behavior was detected, but it can
> get the answer wrong. (which it has). Note the term in the name 'Needed'.

It can be very easily verified that it did not get the answer wrong by 
simply commenting out (removing) the code that aborts the process and 
let the process continue.

> This can be proven by looking at the execution trace of the exact same
> code that was allowed to execute longer (like the outer level) and
> seeing that it ultimately did halt.

I thought this same thing might be possible for about two 60 hour weeks. 
I finally determined that unless this function
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
aborts its input its input never ever halts.

I was thinking (for at least two 60 hour weeks) that we might possibly 
be able to wait through a deeper recursion depth until
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
eventually aborts its input. It turns out that this never happens.

> THUS, the determination that the behavior was inherently non-halting is
> incorrect.
> 
> Or, are you saying that the machine that ran the outer version of the
> code was incorrect?

We must either abort the execution of the input as soon as we detect 
non-halting behavior or we can wait for some fixed recursion depth and 
then abort the execution. If we simply wait for the exection to be 
aborted the execution remains infinite.

> Note, you need to be able to PROVE (despite the evidence of the outer
> machine) that the inner machine actually was going to run forever with
> non-halting behavior, and at the same time that H and the code inside it
> will always halt in finite time. THAT is a bigger contradiction than
> Linz used in H_Hat.

We merely comment out (remove) the code that stops the execution and the 
fact that the execution becomes infinite proves that it must be aborted.

We could even wait for any fixed recursion depth and then terminate the 
execution. All this does is make the execution trace much messier.


-- 
Copyright 2020 Pete Olcott

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

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


#24812 — Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-01 21:38 -0500
SubjectRe: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ]
Message-ID<LiKnH.251348$mK4.218620@fx03.iad>
In reply to#24803
On 11/1/20 6:59 PM, olcott wrote:
> 
> It can be very easily verified that it did not get the answer wrong by
> simply commenting out (removing) the code that aborts the process and
> let the process continue.

And if you do this, and H doesn't return an answer in finite time, you
have just shown that without this, H doesn't meet it specifications.

By aborting the simulation inside H, then programs that depend on H, may
be given the wrong answer if the non-halting behavior was actually due
to a 'bug' in H, and not non-halting behavior

As was shown in my H_Hat2, which CLEARLY runs to a halt as long as H
meets its requirements, but your H decides it is non-halting and thus
returns the wrong answer.

YOU make the mistake of confusing the aborting of the emulation of
H_Hat2 inside H with needing to actually abort the real machine H_Hat2.

Note, if your answer, which you claim to be correct, depends on details
inside H, when the actual behavior doesn't depend on H, then your answer
is wrong.

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


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

Back to top | Article view | comp.theory


csiph-web