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


Groups > comp.theory > #24043 > unrolled thread

The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ]

Started byolcott <NoOne@NoWhere.com>
First post2020-10-20 11:33 -0500
Last post2020-10-29 14:01 +0100
Articles 20 on this page of 499 — 17 participants

Back to article view | Back to comp.theory


Contents

  The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 11:33 -0500
    Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-20 19:11 +0100
      Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 13:40 -0500
        Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 14:19 -0500
        Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 02:57 +0100
          Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 22:07 -0500
            Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 16:28 +0100
              Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 16:52 +0100
              Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 11:48 -0500
                Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 20:30 +0100
                  Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 15:27 -0500
                    Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] André G. Isaak <agisaak@gm.invalid> - 2020-10-21 14:57 -0600
                      Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 16:12 -0500
                        Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] André G. Isaak <agisaak@gm.invalid> - 2020-10-21 15:54 -0600
                          Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 17:20 -0500
                            Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 00:16 +0100
                              Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 18:28 -0500
                                Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 00:55 +0100
                                Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:20 -0500
                    Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 23:10 +0100
                      Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 17:55 -0500
                        Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 03:38 +0100
                          Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 21:54 -0500
                            Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 04:38 +0100
                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-21 23:33 -0500
                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 11:05 +0100
                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:44 -0500
                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 16:14 +0100
                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 08:00 -0400
                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:36 -0500
                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 15:57 +0100
                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 10:44 -0500
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 00:34 +0100
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 18:55 -0500
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 03:09 +0100
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 21:31 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 04:44 +0100
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:13 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 16:03 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:40 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:40 +0100
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-23 17:18 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 17:28 +0100
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:40 -0500
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:38 -0500
                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 16:25 +0100
                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 16:45 +0100
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 17:57 +0100
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:26 -0500
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 21:15 +0100
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:36 -0500
                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:38 -0500
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 09:56 -0700
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:09 -0500
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 10:27 -0700
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:32 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:33 +0100
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 10:58 -0700
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:19 -0500
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:30 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:34 +0100
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 20:53 +0100
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:24 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 13:28 -0700
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:25 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 00:51 +0100
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:09 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 02:50 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-22 21:27 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 05:00 +0100
                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:31 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 17:19 +0100
                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:22 -0400
                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 20:36 -0500
                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:50 -0400
                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:18 -0500
                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 10:00 -0400
                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:04 -0500
                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 00:12 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 03:47 -0700
                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:57 -0500
                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 07:34 -0700
                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:12 -0500
                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 16:20 +0100
                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:55 -0500
                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:52 +0100
                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 09:59 -0700
                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:20 -0500
                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 21:02 +0100
                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 13:29 -0700
                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 15:56 -0500
                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 14:12 -0700
                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 16:58 -0500
                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:35 -0400
                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 20:45 -0500
                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-23 19:54 -0700
                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:22 -0500
                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 12:46 +0100
                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-24 16:43 +0100
                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:01 -0500
                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-24 23:14 +0100
                                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:35 -0500
                                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-25 16:33 +0000
                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 12:37 -0500
                                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-25 12:10 -0600
                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:27 -0500
                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:42 -0500
                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 23:11 +0000
                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 03:18 -0600
                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 03:21 -0600
                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:58 -0400
                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:28 -0500
                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-23 21:03 -0700
                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 23:13 -0500
                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 13:27 -0400
                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:08 -0500
                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-24 19:54 +0000
                                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 15:48 -0500
                                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-24 21:41 +0000
                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 14:47 -0700
                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:20 -0500
                                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 13:37 +0000
                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 11:30 -0500
                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 10:43 -0600
                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 12:44 -0500
                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 17:38 +0000
                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 13:13 -0500
                                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 19:28 +0000
                                                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:46 -0500
                                                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 15:43 -0500
                                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 21:07 +0000
                                                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:27 -0500
                                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-27 07:03 +0000
                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 09:53 -0500
                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mostowski Collapse <janburse@fastmail.fm> - 2020-10-27 21:07 +0100
                                                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:57 -0500
                                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-27 04:53 -0600
                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 14:30 +0000
                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 07:52 -0700
                                                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 10:28 -0500
                                                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 15:30 +0000
                                                                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 08:45 -0700
                                                                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 16:05 +0000
                                                                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 11:05 -0500
                                                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 09:53 -0700
                                                                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 13:36 -0500
                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 12:05 -0700
                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 14:44 -0500
                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-27 16:05 -0400
                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 03:41 +0000
                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-28 02:57 -0700
                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 15:54 +0000
                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] David Kleinecke <dkleinecke@gmail.com> - 2020-10-28 09:25 -0700
                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-28 18:31 -0500
                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-29 00:02 +0000
                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 07:55 -0500
                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Richard Damon <Richard@Damon-Family.org> - 2020-10-29 09:28 -0400
                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 10:49 -0500
                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Richard Damon <Richard@Damon-Family.org> - 2020-10-29 12:32 -0400
                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:41 -0500
                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Richard Damon <Richard@Damon-Family.org> - 2020-10-29 16:01 -0400
                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 15:58 -0500
                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 06:28 -0700
                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 10:59 -0500
                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 09:50 -0700
                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:48 -0500
                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 11:51 -0700
                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 14:09 -0500
                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 13:12 -0700
                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 16:08 -0500
                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-29 22:51 +0000
                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 18:15 -0500
                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 01:05 +0000
                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 20:32 -0500
                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 02:16 +0000
                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 21:36 -0500
                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 21:51 -0500
                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 03:44 -0700
                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 06:32 -0500
                                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 06:40 -0500
                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-30 22:08 +0000
                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 17:21 -0500
                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 00:46 +0000
                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 20:07 -0500
                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 02:30 +0000
                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 02:44 +0000
                                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 21:56 -0500
                                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 16:41 +0000
                                                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Jeff Barnett <jbb@notatt.com> - 2020-10-31 11:16 -0600
                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 23:40 -0500
                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 16:28 +0000
                                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 12:56 -0500
                                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 20:49 +0000
                                                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 16:07 -0500
                                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 14:55 -0700
                                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:09 -0500
                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 15:22 -0700
                                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:30 -0500
                                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 16:00 -0700
                                                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 18:13 -0500
                                                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-01 13:56 +0000
                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Alan Mackenzie <acm@muc.de> - 2020-10-31 22:23 +0000
                                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:37 -0500
                                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 19:18 -0400
                                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 18:40 -0500
                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 20:12 -0400
                                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 21:29 -0400
                                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 22:34 -0400
                                                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 21:38 -0500
                                                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 08:13 -0500
                                                                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 12:18 -0500
                                                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:05 -0600
                                                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-01 10:43 -0800
                                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:56 -0600
                                                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ x86 machine description language ] olcott <NoOne@NoWhere.com> - 2020-11-01 13:32 -0600
                                                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 17:37 -0500
                                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 17:41 -0600
                                                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 19:09 -0500
                                                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:43 -0600
                                                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ execution trace described ] olcott <NoOne@NoWhere.com> - 2020-10-31 23:36 -0500
                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 00:05 -0500
                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 16:40 +0000
                                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 05:36 -0700
                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 10:32 -0500
                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 08:54 -0700
                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 11:30 -0500
                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 16:22 -0700
                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 18:41 -0500
                                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 16:48 -0700
                                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 18:50 -0500
                                                                                                                                                                                Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 16:59 -0700
                                                                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 19:07 -0500
                                                                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 17:23 -0700
                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 19:34 -0500
                                                                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 02:26 +0000
                                                                                                                                                                                        Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 03:05 -0700
                                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 12:23 +0000
                                                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 09:22 -0500
                                                                                                                                                          Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 14:26 +0000
                                                                                                                                                            Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 10:49 -0500
                                                                                                                                                              Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 01:26 +0000
                                                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-28 08:31 -0700
                                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Jeff Barnett <jbb@notatt.com> - 2020-10-28 10:57 -0600
                                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-28 12:05 -0700
                                                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-27 13:09 -0400
                                                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-27 13:57 -0600
                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 11:00 -0500
                                                                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 16:53 +0000
                                                                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided olcott <NoOne@NoWhere.com> - 2020-10-27 10:20 -0500
                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 15:56 +0000
                                                                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided André G. Isaak <agisaak@gm.invalid> - 2020-10-27 12:53 -0600
                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 01:25 +0100
                                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-25 18:38 +0000
                                                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-25 20:49 +0000
                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 23:26 +0000
                                                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-25 23:57 +0000
                                                                      Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 22:43 +0100
                                                                        Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 17:10 -0500
                                                                          Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:27 +0100
                                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:34 -0500
                                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:15 +0100
                                                            Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 16:46 +0100
                                                              Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:36 -0500
                                                                Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:05 +0100
                                                                  Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:15 -0500
                                                                    Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:29 +0100
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 23:41 -0400
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:02 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Tim Woodall <news001@woodall.me.uk> - 2020-10-23 07:05 +0000
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:38 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 11:02 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:45 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 15:56 +0100
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:30 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:32 +0100
                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:36 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:52 -0400
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-23 13:03 -0700
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 15:24 -0500
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 02:29 -0700
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:43 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 15:51 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:19 -0500
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 23:14 +0100
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 18:05 -0500
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 16:55 -0700
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:29 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 18:06 -0700
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 20:26 -0500
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-23 23:51 +0100
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 16:03 -0700
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:14 -0500
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:10 +0100
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 00:17 +0100
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:31 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 16:39 -0700
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:54 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 16:58 -0700
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:13 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 17:24 -0700
                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:43 +0100
                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 02:37 -0700
                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 10:41 -0500
                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 09:04 -0700
                                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:46 -0500
                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 00:54 +0100
                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 22:03 +0100
                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 14:35 -0700
                                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 01:23 +0000
                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 00:45 -0700
                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 09:35 -0500
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 07:39 -0700
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 10:33 -0500
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-25 12:14 -0400
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] olcott <NoOne@NoWhere.com> - 2020-10-25 13:42 -0500
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] Richard Damon <Richard@Damon-Family.org> - 2020-10-25 16:55 -0400
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] olcott <NoOne@NoWhere.com> - 2020-10-25 16:07 -0500
                                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 23:51 +0000
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-25 17:26 +0000
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 14:16 -0500
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 13:55 -0700
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:56 -0500
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-25 17:35 -0400
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 14:43 -0700
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 16:55 -0500
                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 14:43 +0000
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 08:36 -0700
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 12:23 -0500
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 22:54 +0000
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 16:19 -0700
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 18:35 -0500
                                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 18:40 -0500
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 01:17 +0000
                                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 02:49 +0000
                                                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 03:56 +0000
                                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 02:37 -0700
                                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 12:10 +0000
                                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 06:45 -0700
                                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 17:24 +0000
                                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 10:38 -0700
                                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-27 00:51 +0000
                                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 11:16 -0500
                                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 15:41 +0000
                                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 17:28 +0000
                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:52 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 01:21 +0100
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 01:06 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:39 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 04:27 +0100
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:40 -0500
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 23:02 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 16:58 +0100
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:38 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 01:17 +0100
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:06 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 00:38 +0100
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:46 -0500
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 01:03 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-24 08:04 -0600
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:25 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 15:38 +0100
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 10:36 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 17:37 +0100
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 12:49 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 19:32 +0100
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 11:40 -0700
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:42 -0500
                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 20:00 +0100
                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:05 -0500
                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 20:44 +0100
                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 15:41 -0500
                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 21:57 +0100
                                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:05 -0500
                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 22:44 +0100
                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:01 -0500
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 16:11 +0000
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:12 -0500
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 19:38 +0000
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:53 -0500
                                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 13:50 -0700
                                                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:01 -0500
                                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 14:08 -0700
                                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-26 14:26 -0700
                                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:35 -0500
                                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-26 20:59 -0400
                                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 20:35 -0500
                                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 02:19 -0700
                                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:31 -0500
                                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:08 -0500
                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 15:16 -0700
                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 18:30 -0400
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 15:47 -0700
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 18:08 -0500
                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:45 -0500
                                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 16:29 +0000
                                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 13:03 -0500
                                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction olcott <NoOne@NoWhere.com> - 2020-10-26 13:14 -0500
                                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 00:06 +0000
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-26 17:16 -0700
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 00:46 +0000
                                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 20:11 -0500
                                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 02:48 +0000
                                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 22:38 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 13:36 -0400
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:13 -0500
                                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 16:55 -0400
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 14:06 -0700
                                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:31 -0500
                                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 18:17 -0400
                                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 18:00 -0500
                                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 19:48 -0400
                                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 19:29 -0500
                                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:24 -0500
                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:52 -0500
                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-22 10:45 -0700
                Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-21 22:42 +0100
                Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Richard Damon <Richard@Damon-Family.org> - 2020-10-21 21:22 -0400
                  Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-21 21:14 -0500
                    Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 08:12 -0400
                      Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:41 -0500
                        Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 13:43 -0600
                          Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-22 14:54 -0500
                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:13 -0500
                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 14:34 -0600
                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:28 -0500
                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 15:34 -0600
                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:47 -0500
                      Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] Andy Walker <anw@cuboid.co.uk> - 2020-10-22 16:20 +0100
          Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Richard Damon <Richard@Damon-Family.org> - 2020-10-21 09:09 -0400
            Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-21 14:36 +0100
        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:19 -0500
          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:21 +0100
            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:27 -0500
              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:30 +0100
                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:35 -0500
                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:43 +0100
                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:08 -0500
                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:12 +0100
                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 11:17 -0700
                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:21 -0500
                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 11:30 -0700
                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:35 -0500
                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Jeff Barnett <jbb@notatt.com> - 2020-10-22 11:59 -0600
                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 10:45 -0700
                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:13 -0500
                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:17 +0100
                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:24 -0500
          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:40 -0500
            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:44 -0700
              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:49 -0500
                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:59 -0700
                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 18:13 -0700
                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 20:15 -0500
                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 00:10 -0400
                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:28 -0500
                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:22 -0400
                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 21:51 -0500
                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 13:07 +0100
                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:40 -0500
                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 02:07 +0000
                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 06:29 -0600
                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 09:10 -0500
                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 08:30 -0600
                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 09:52 -0500
                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 09:04 -0600
                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:49 -0500
                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 10:06 -0600
                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:48 -0500
                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 11:04 -0600
                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:31 -0500
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 12:00 -0600
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:12 -0500
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 12:35 -0600
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 14:04 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 15:34 -0600
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 17:05 -0500
                                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:32 -0400
                                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 21:55 -0500
                                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 09:50 -0400
                                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:14 -0500
                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 11:15 -0700
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:49 -0500
                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 17:37 +0100
                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:43 -0500
                                Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 17:49 +0100
                                  Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:06 -0500
                                    Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:10 +0100
                                      Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:24 -0500
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:35 +0100
                                          Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:46 -0500
                                            Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:53 +0100
                                              Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:06 -0500
    Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 17:54 +0100
      Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:57 -0500
        Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:05 +0100
          Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2020-10-22 12:55 -0600
            Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:59 +0100
              Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2020-10-22 19:13 +0000
    Stop crossposting you imbecil spammer (Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ]) Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 14:01 +0100

Page 10 of 25 — ← Prev page 1 … 8 9 [10] 11 12 … 25  Next page →


#24690 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-10-30 22:08 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<JPednfAJF-BsEwHCnZ2dnUU78KfNnZ2d@brightview.co.uk>
In reply to#24672
On 30/10/2020 11:40, olcott wrote:
> On 10/30/2020 6:32 AM, olcott wrote:
>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>
>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>> <cut>
>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>> NON_HALTING
>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>
>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>> while
>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>
>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>> terms like
>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>> accepted and
>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>> "always".
>>>>>>>>>
>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>> need to
>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>> paper degree of professionalism.
>>>>>>>>>
>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>> non-halting
>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>
>>>>>>>> Excellent. Very clear (though there is always the worry that you
>>>>>>>> are
>>>>>>>> using your own meanings for some of the words).
>>>>>>>>
>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>> must
>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>> written -- just write it! It will make you famous.
>>>>>> <cut>
>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>> years
>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>
>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>> that
>>>>>>> I am correct
>>>>>>
>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>> right" is not working out. You should try the "writing the code you
>>>>>> said you could" plan instead.
>>>>>>
>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>> work"
>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>
>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>
>>>>>
>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>> following non-halting decider that accepts any and all non-halting
>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>
>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>
>>>>> When the first step that a halt decider does to indicate its
>>>>> non-halting
>>>>> decision is stop executing its input, its input can't do anything
>>>>> at all
>>>>> because it is already terminated.
>>>> Since it continues to watch the execution of its input looking for
>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>> eventually
>>>> its input halts. At this point it reports HALTING.
>>>>
>>>> In both of these two possible cases it has totally defeated the
>>>> "do the opposite of whatever the halting decider decides" halting
>>>> problem trick: Because in both of these cases the input has already
>>>> terminated.
>>>>
>>> I don't think you've thought this through.
>>>
>>> I've suggested stubbing the function. If you do this, and run two tests,
>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>> and H_Hat(H_Hat), you'll see the problem.
>>>
>>> You mustn't omit the second test. That's the whole point.
>>>
>>
>> I know these execution traces very well because I have done them over
>> and over again in my own mind many times over the last two years.
>>
>> The outermost invocation of this function
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>> always returns true no matter what function calls it.
>
> This is the key aspect of the execution trace that forms the basis for
> deciding H_Hat: (All two years of my work has this as its foundation)
>
> This is the exact same 2018-12-13 @ 7:00 PM solution
> Detect that the halt decider is invoked two times from the same machine
> address without any conditional branch instructions in the execution
> trace of H_Hat that would terminate this otherwise infinite recursion.
>

I previously pointed out that there is a problem with your "without any 
conditional branch instructions in the execution trace of H_Hat that 
would terminate this otherwise infinite recursion".  (I don't think you 
responded.)

H_Hat /DOES/ contain conditional code that avoids the "otherwise 
infinite recursion"!  (That's assuming your ABNHBD() behaves as you've 
previously described.)  So your ABNHBD() is detecting non-halting 
behaviour incorrectly, according to your own description of what it does.

I suspect you are making the Big Mistake of assuming such "conditional 
code" has to occur [in the trace of emulated code] BEFORE the emulated 
code /initiates/ its nested emulation using the same machine address?

[By "initiates its nested emulation" I mean "sets up the new virtual 
process with its own stack, initialising the process ready to start 
single stepping the requested calculation".]

In fact, the conditional code occurs AFTER this point in the trace... 
so if ABNHBD() is checking for that code, it needs to
a) *first* spot the OS call to initiate an emulation using the
    same machine address,
b) *then* continue monitoring to determine that there is no
    conditional code that terminates the calculation.

Mike.

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


#24691 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-30 17:21 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<AdSdnc8r0LZqDAHCnZ2dnUU7-S3NnZ2d@giganews.com>
In reply to#24690
On 10/30/2020 5:08 PM, Mike Terry wrote:
> On 30/10/2020 11:40, olcott wrote:
>> On 10/30/2020 6:32 AM, olcott wrote:
>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>> <cut>
>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>
>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>> while
>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>
>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>> terms like
>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>> accepted and
>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>> "always".
>>>>>>>>>>
>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>> need to
>>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>
>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>> non-halting
>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>
>>>>>>>>> Excellent. Very clear (though there is always the worry that you
>>>>>>>>> are
>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>
>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>> must
>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>> <cut>
>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>> years
>>>>>>>>> walking that claim back. You've made another clear claim now. 
>>>>>>>>> Don't
>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>
>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>> that
>>>>>>>> I am correct
>>>>>>>
>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>> said you could" plan instead.
>>>>>>>
>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>> work"
>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>
>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>
>>>>>>
>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>
>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>
>>>>>> When the first step that a halt decider does to indicate its
>>>>>> non-halting
>>>>>> decision is stop executing its input, its input can't do anything
>>>>>> at all
>>>>>> because it is already terminated.
>>>>> Since it continues to watch the execution of its input looking for
>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>> eventually
>>>>> its input halts. At this point it reports HALTING.
>>>>>
>>>>> In both of these two possible cases it has totally defeated the
>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>> problem trick: Because in both of these cases the input has already
>>>>> terminated.
>>>>>
>>>> I don't think you've thought this through.
>>>>
>>>> I've suggested stubbing the function. If you do this, and run two 
>>>> tests,
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>
>>>> You mustn't omit the second test. That's the whole point.
>>>>
>>>
>>> I know these execution traces very well because I have done them over
>>> and over again in my own mind many times over the last two years.
>>>
>>> The outermost invocation of this function
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>> always returns true no matter what function calls it.
>>
>> This is the key aspect of the execution trace that forms the basis for
>> deciding H_Hat: (All two years of my work has this as its foundation)
>>
>> This is the exact same 2018-12-13 @ 7:00 PM solution
>> Detect that the halt decider is invoked two times from the same machine
>> address without any conditional branch instructions in the execution
>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>
> 
> I previously pointed out that there is a problem with your "without any 
> conditional branch instructions in the execution trace of H_Hat that 
> would terminate this otherwise infinite recursion".  (I don't think you 
> responded.)
> 
> H_Hat /DOES/ contain conditional code that avoids the "otherwise 
> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've 
> previously described.)  So your ABNHBD() is detecting non-halting 
> behaviour incorrectly, according to your own description of what it does.

No. Not at all. Not in the least.

bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
Only terminates inputs that would not otherwise terminate on their own.

Two examples of such inputs that would not terminate on their own:
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);

Unless the above function terminates its inputs they would never 
otherwise terminate.

> I suspect you are making the Big Mistake of assuming such "conditional 
> code" has to occur [in the trace of emulated code] BEFORE the emulated 
> code /initiates/ its nested emulation using the same machine address?
> 
> [By "initiates its nested emulation" I mean "sets up the new virtual 
> process with its own stack, initialising the process ready to start 
> single stepping the requested calculation".]
> 
> In fact, the conditional code occurs AFTER this point in the trace... so 
> if ABNHBD() is checking for that code, it needs to
> a) *first* spot the OS call to initiate an emulation using the
>     same machine address,
> b) *then* continue monitoring to determine that there is no
>     conditional code that terminates the calculation.
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#24707 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-10-31 00:46 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<Xf2dnTuvWc52LgHCnZ2dnUU78a-dnZ2d@brightview.co.uk>
In reply to#24691
On 30/10/2020 22:21, olcott wrote:
> On 10/30/2020 5:08 PM, Mike Terry wrote:
>> On 30/10/2020 11:40, olcott wrote:
>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>> <cut>
>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>
>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>> while
>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>
>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>> terms like
>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>> accepted and
>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>> "always".
>>>>>>>>>>>
>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>> need to
>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>> academic
>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>
>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>> non-halting
>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>
>>>>>>>>>> Excellent. Very clear (though there is always the worry that you
>>>>>>>>>> are
>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>
>>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>>> must
>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>> <cut>
>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>>> years
>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>> Don't
>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>
>>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>>> that
>>>>>>>>> I am correct
>>>>>>>>
>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>>> said you could" plan instead.
>>>>>>>>
>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>>> work"
>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>
>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>
>>>>>>>
>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>> the
>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>
>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>
>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>> non-halting
>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>> at all
>>>>>>> because it is already terminated.
>>>>>> Since it continues to watch the execution of its input looking for
>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>> eventually
>>>>>> its input halts. At this point it reports HALTING.
>>>>>>
>>>>>> In both of these two possible cases it has totally defeated the
>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>> problem trick: Because in both of these cases the input has already
>>>>>> terminated.
>>>>>>
>>>>> I don't think you've thought this through.
>>>>>
>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>> tests,
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>
>>>>> You mustn't omit the second test. That's the whole point.
>>>>>
>>>>
>>>> I know these execution traces very well because I have done them over
>>>> and over again in my own mind many times over the last two years.
>>>>
>>>> The outermost invocation of this function
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>> always returns true no matter what function calls it.
>>>
>>> This is the key aspect of the execution trace that forms the basis for
>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>
>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>> Detect that the halt decider is invoked two times from the same machine
>>> address without any conditional branch instructions in the execution
>>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>>
>>
>> I previously pointed out that there is a problem with your "without
>> any conditional branch instructions in the execution trace of H_Hat
>> that would terminate this otherwise infinite recursion".  (I don't
>> think you responded.)
>>
>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>> previously described.)  So your ABNHBD() is detecting non-halting
>> behaviour incorrectly, according to your own description of what it does.
>
> No. Not at all. Not in the least.
Dorky
>
> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
> Only terminates inputs that would not otherwise terminate on their own.
>
> Two examples of such inputs that would not terminate on their own:
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>
> Unless the above function terminates its inputs they would never
> otherwise terminate.
>

You are totally confusing different versions of the program whose 
calculations are being decided!


H_Hat is ONE FIXED program.  *It's source code can't change!*  To help 
keep things clear, let's say what we have is version 1 of ABNHBD, and 
call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.

Now if we look at this source code for H_Hat_1, we will see a function 
ABNHBD_1(P,I), and this routine emulates the calculation P(I), up to a 
point at least.  The code of ABNHBD_1(P,I) *DOES* include steps that 
will abort certain of these emulated calculations P(I).  I'll call this 
the *test T*.

When we trace the calculation H_Hat_1(H_Hat_1) what do we see?  There is 
a call ABNHBD_1(H_Hat_1,H_Hat_1) which starts an internal emulation of 
calculation H_Hat_1(H_Hat_1).  We don't need to go into the details of 
what that emulated calculation is doing - suffice it to say that the T 
test in ABNHBD_1 /DOES/ detect what it /thinks/ is "non-halting 
behaviour", aborts its emulation, and the calculation H_Hat_1(H_Hat_1) 
DOES halt.

*Summary so far*: Calculation H_Hat_1(H_Hat_1) halts.  (I think you have 
come to agree with this, given the regular HP/Linz meaning for "halts").

But you want to go on and say "it /only/ halts because 
ABNHBD_1(H_Hat_1,H_Hat_1) aborted its emulation".  Or put another way, 
it /only/ halts because its code contains tests and associated logic 
that resulted in it halting.

When you say that H_Hat_1 /wouldn't/ have halted if ABNHBD_1() hadn't 
been written as it was, you're just say that H_Hat_1 wouldn't have 
halted if H_Hat_1 had been written differently!  Well, duh!  No surprise 
there :)

Anyway, let's suppose we clone all the version 1 code to get version 2. 
We edit ABNHBD_2() to remove test T, and recompile the source to get 
H_Hat(2), and sure enough H_Hat_2(H_Hat_2) never halts.

H_Hat_2 is *A COMPLETELY DIFFERENT PROGRAM*!  It remains the case that 
H_Hat_1(H_Hat_1) halts.  If calculation H_Hat_1(H_Hat_1) were executed 
by some emulator which just let its calculation run to completion, the 
emulation would likewise halt.  That's because the behaviour under a 
correctly written emulator tracks the states of the calculation it's 
emulating, and for H_Hat_1(H_Hat_1) that calculation halts.

Alternatively, if your x86utm included a debug facility, we might be 
able to set a breakpoint within ABNHBD_2() at the T test [within the 
"native"/outer level process only!  No breaking within inner level 
emulations!].  Each time the breakpoint hits we jump the IP over the T 
test, so it is effectively prevented from taking its abort branch, then 
we resume execution.  Continuing like this, we will eventually see that 
the calculation being emulated *does* terminate.

*Conclusion*:  Talking about two different source codes for two 
different test programs when we were only asked about one, is not even 
coherent in the case of general ABNHBD input (P,I)!  And for the 
specific case of H_Hat() these /other/ programs are completely 
irrelevent to anything in the HP proof, or the Linz proof in particular.

Hmm, I bet this is why you've steadfastly refused to give a proper 
specification for ABNHBD!  It's because your underlying idea at its most 
basic level is incoherent - you don't know how to meaningfully explain 
all about "Emulation of P_2(I_2) /wouldn't/ halt, where you got P2 by 
editing P's source code by, ummmm, by, ummm..., and don't forget you 
have to amend input data I somehow, umm..." !


Mike.


>> I suspect you are making the Big Mistake of assuming such "conditional
>> code" has to occur [in the trace of emulated code] BEFORE the emulated
>> code /initiates/ its nested emulation using the same machine address?
>>
>> [By "initiates its nested emulation" I mean "sets up the new virtual
>> process with its own stack, initialising the process ready to start
>> single stepping the requested calculation".]
>>
>> In fact, the conditional code occurs AFTER this point in the trace...
>> so if ABNHBD() is checking for that code, it needs to
>> a) *first* spot the OS call to initiate an emulation using the
>>     same machine address,
>> b) *then* continue monitoring to determine that there is no
>>     conditional code that terminates the calculation.
>>
>> Mike.
>>
>
>

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


#24708 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-30 20:07 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<4a-dnYAMC6kjJQHCnZ2dnUU7-KXNnZ2d@giganews.com>
In reply to#24707
On 10/30/2020 7:46 PM, Mike Terry wrote:
> On 30/10/2020 22:21, olcott wrote:
>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>> On 30/10/2020 11:40, olcott wrote:
>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>> <cut>
>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>
>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>> while
>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>
>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>> terms like
>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>> "always".
>>>>>>>>>>>>
>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>> need to
>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>> academic
>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>
>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>> non-halting
>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>
>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you
>>>>>>>>>>> are
>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>
>>>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>>>> must
>>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>> <cut>
>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent 
>>>>>>>>>>> two
>>>>>>>>>>> years
>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>> Don't
>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>
>>>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>>>> that
>>>>>>>>>> I am correct
>>>>>>>>>
>>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>>> right" is not working out. You should try the "writing the code 
>>>>>>>>> you
>>>>>>>>> said you could" plan instead.
>>>>>>>>>
>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>>>> work"
>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>
>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>> the
>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>
>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>
>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>> non-halting
>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>> at all
>>>>>>>> because it is already terminated.
>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>> eventually
>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>
>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>> terminated.
>>>>>>>
>>>>>> I don't think you've thought this through.
>>>>>>
>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>> tests,
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>
>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>
>>>>>
>>>>> I know these execution traces very well because I have done them over
>>>>> and over again in my own mind many times over the last two years.
>>>>>
>>>>> The outermost invocation of this function
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>> always returns true no matter what function calls it.
>>>>
>>>> This is the key aspect of the execution trace that forms the basis for
>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>
>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>> Detect that the halt decider is invoked two times from the same machine
>>>> address without any conditional branch instructions in the execution
>>>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>>>
>>>
>>> I previously pointed out that there is a problem with your "without
>>> any conditional branch instructions in the execution trace of H_Hat
>>> that would terminate this otherwise infinite recursion".  (I don't
>>> think you responded.)
>>>
>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>>> previously described.)  So your ABNHBD() is detecting non-halting
>>> behaviour incorrectly, according to your own description of what it 
>>> does.
>>
>> No. Not at all. Not in the least.
> Dorky
>>
>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>> Only terminates inputs that would not otherwise terminate on their own.
>>
>> Two examples of such inputs that would not terminate on their own:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>
>> Unless the above function terminates its inputs they would never
>> otherwise terminate.
>>
> 
> You are totally confusing different versions of the program whose 
> calculations are being decided!
> 

When I finish fixing the bug in process context local stacks I can write 
the actual halt deciding code. The actual code will merely show that the 
execution trace that I describe below is accurate. If we simply 
hypothesize that this execution trace is accurate we can conclude that 
my proof is correct.

Within the recursive invocation sequence subsequent invocations of the 
same virtual machine have less data than the prior invocations. Each of 
these invocations exists in its own process context. The address of its 
process data can be used as a unique process identifier.

This invocation has two instances of H_Hat and two instances of ABNHBD.
The outer ABNHB makes its decision on the basis of its first H_Hat 
parameter.

int main()
{
   u32 M = (u32)H_Hat;
   H(M, M);
   HALT;
}

This invocation has three instances of H_Hat and two instances of 
ABNHBD. The outer ABNHB makes its decision on the basis of its first 
H_Hat parameter.

int main()
{
   u32 M = (u32)H_Hat;
   H_Hat(M, M);
   HALT;
}

If you simply hypothesize that these details are reported accurately you 
can see that the outer ABNHB decides its input correctly according to 
this criteria:

The halt decider executes its input one step at a time until it detects 
non-halting behavior or its input has terminated normally. When the halt 
decider detects non-halting behavior it stops executing its input and 
transitions to its own final state of: 
NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never 
detected then as soon as the input terminates the halt decider 
transitions to its own final state of INPUT_HAS_TERMINATED.

2018-12-13 @ 7:00 PM solution.
The halt decider detects the non-halting behavior of the Linz H_Hat 
equivalent when it calls the halt decider from the same machine address 
a second time and there are no conditional branches in the H_Hat 
execution trace that would terminate this otherwise infinite recursion.

bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
Stops executing and Accepts any and all non-halting inputs and Rejects 
any and all halting inputs.


> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help 
> keep things clear, let's say what we have is version 1 of ABNHBD, and 
> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.
> 
> Now if we look at this source code for H_Hat_1, we will see a function 
> ABNHBD_1(P,I), and this routine emulates the calculation P(I), up to a 
> point at least.  The code of ABNHBD_1(P,I) *DOES* include steps that 
> will abort certain of these emulated calculations P(I).  I'll call this 
> the *test T*.
> 
> When we trace the calculation H_Hat_1(H_Hat_1) what do we see?  There is 
> a call ABNHBD_1(H_Hat_1,H_Hat_1) which starts an internal emulation of 
> calculation H_Hat_1(H_Hat_1).  We don't need to go into the details of 
> what that emulated calculation is doing - suffice it to say that the T 
> test in ABNHBD_1 /DOES/ detect what it /thinks/ is "non-halting 
> behaviour", aborts its emulation, and the calculation H_Hat_1(H_Hat_1) 
> DOES halt.
> 
> *Summary so far*: Calculation H_Hat_1(H_Hat_1) halts.  (I think you have 
> come to agree with this, given the regular HP/Linz meaning for "halts").
> 
> But you want to go on and say "it /only/ halts because 
> ABNHBD_1(H_Hat_1,H_Hat_1) aborted its emulation".  Or put another way, 
> it /only/ halts because its code contains tests and associated logic 
> that resulted in it halting.
> 
> When you say that H_Hat_1 /wouldn't/ have halted if ABNHBD_1() hadn't 
> been written as it was, you're just say that H_Hat_1 wouldn't have 
> halted if H_Hat_1 had been written differently!  Well, duh!  No surprise 
> there :)
> 
> Anyway, let's suppose we clone all the version 1 code to get version 2. 
> We edit ABNHBD_2() to remove test T, and recompile the source to get 
> H_Hat(2), and sure enough H_Hat_2(H_Hat_2) never halts.
> 
> H_Hat_2 is *A COMPLETELY DIFFERENT PROGRAM*!  It remains the case that 
> H_Hat_1(H_Hat_1) halts.  If calculation H_Hat_1(H_Hat_1) were executed 
> by some emulator which just let its calculation run to completion, the 
> emulation would likewise halt.  That's because the behaviour under a 
> correctly written emulator tracks the states of the calculation it's 
> emulating, and for H_Hat_1(H_Hat_1) that calculation halts.
> 
> Alternatively, if your x86utm included a debug facility, we might be 
> able to set a breakpoint within ABNHBD_2() at the T test [within the 
> "native"/outer level process only!  No breaking within inner level 
> emulations!].  Each time the breakpoint hits we jump the IP over the T 
> test, so it is effectively prevented from taking its abort branch, then 
> we resume execution.  Continuing like this, we will eventually see that 
> the calculation being emulated *does* terminate.
> 
> *Conclusion*:  Talking about two different source codes for two 
> different test programs when we were only asked about one, is not even 
> coherent in the case of general ABNHBD input (P,I)!  And for the 
> specific case of H_Hat() these /other/ programs are completely 
> irrelevent to anything in the HP proof, or the Linz proof in particular.
> 
> Hmm, I bet this is why you've steadfastly refused to give a proper 
> specification for ABNHBD!  It's because your underlying idea at its most 
> basic level is incoherent - you don't know how to meaningfully explain 
> all about "Emulation of P_2(I_2) /wouldn't/ halt, where you got P2 by 
> editing P's source code by, ummmm, by, ummm..., and don't forget you 
> have to amend input data I somehow, umm..." !
> 
> 
> Mike.
> 
> 
>>> I suspect you are making the Big Mistake of assuming such "conditional
>>> code" has to occur [in the trace of emulated code] BEFORE the emulated
>>> code /initiates/ its nested emulation using the same machine address?
>>>
>>> [By "initiates its nested emulation" I mean "sets up the new virtual
>>> process with its own stack, initialising the process ready to start
>>> single stepping the requested calculation".]
>>>
>>> In fact, the conditional code occurs AFTER this point in the trace...
>>> so if ABNHBD() is checking for that code, it needs to
>>> a) *first* spot the OS call to initiate an emulation using the
>>>     same machine address,
>>> b) *then* continue monitoring to determine that there is no
>>>     conditional code that terminates the calculation.
>>>
>>> Mike.
>>>
>>
>>


-- 
Copyright 2020 Pete Olcott

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

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


#24712 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-10-31 02:30 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<87d00zw2ip.fsf@bsb.me.uk>
In reply to#24708
olcott <NoOne@NoWhere.com> writes:

> 2018-12-13 @ 7:00 PM solution.

This was a pair of fully encoded actual Turing machines exactly and
precisely as in Linz but where H gives the correct answer about the
halting of ([H^], [H^]).

What a thing that would be!  Why won't you post it?

-- 
Ben.

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


#24713 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-10-31 02:44 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<v7WdncLGEdwGUgHCnZ2dnUU78R3NnZ2d@brightview.co.uk>
In reply to#24708
On 31/10/2020 01:07, olcott wrote:
> On 10/30/2020 7:46 PM, Mike Terry wrote:
>> On 30/10/2020 22:21, olcott wrote:
>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>> On 30/10/2020 11:40, olcott wrote:
>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>>> while
>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>>> "always".
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>>> need to
>>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>>> academic
>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that
>>>>>>>>>>>> you
>>>>>>>>>>>> are
>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>
>>>>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>>>>> must
>>>>>>>>>>>> do). There is no point in insisting over and over that it
>>>>>>>>>>>> can be
>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>> <cut>
>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've
>>>>>>>>>>>> spent two
>>>>>>>>>>>> years
>>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>>> Don't
>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>
>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>>>>> that
>>>>>>>>>>> I am correct
>>>>>>>>>>
>>>>>>>>>> Where is the program you claim you can write? The "proving you
>>>>>>>>>> are
>>>>>>>>>> right" is not working out. You should try the "writing the
>>>>>>>>>> code you
>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>
>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>>>>> work"
>>>>>>>>>> and "this show I could do it" because, as you can imagine, I
>>>>>>>>>> would
>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>
>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>>> the
>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>
>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>
>>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>>> non-halting
>>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>>> at all
>>>>>>>>> because it is already terminated.
>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>>> eventually
>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>
>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>> terminated.
>>>>>>>>
>>>>>>> I don't think you've thought this through.
>>>>>>>
>>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>>> tests,
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>
>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>
>>>>>>
>>>>>> I know these execution traces very well because I have done them over
>>>>>> and over again in my own mind many times over the last two years.
>>>>>>
>>>>>> The outermost invocation of this function
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> always returns true no matter what function calls it.
>>>>>
>>>>> This is the key aspect of the execution trace that forms the basis for
>>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>>
>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>> Detect that the halt decider is invoked two times from the same
>>>>> machine
>>>>> address without any conditional branch instructions in the execution
>>>>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>>>>
>>>>
>>>> I previously pointed out that there is a problem with your "without
>>>> any conditional branch instructions in the execution trace of H_Hat
>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>> think you responded.)
>>>>
>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>> behaviour incorrectly, according to your own description of what it
>>>> does.
>>>
>>> No. Not at all. Not in the least.
>> Dorky
>>>
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>> Only terminates inputs that would not otherwise terminate on their own.
>>>
>>> Two examples of such inputs that would not terminate on their own:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>
>>> Unless the above function terminates its inputs they would never
>>> otherwise terminate.
>>>
>>
>> You are totally confusing different versions of the program whose
>> calculations are being decided!
>>
>
> When I finish fixing the bug in process context local stacks I can write

..blah blah.
Dude!  You've got confused somewhere - your response was nothing to do 
with the point I was making!  I think you just cut and pasted stuff from 
another post into the wrong place or something.  Also you added in more 
OT newsgroups for some reason...

[... snip the usual non-responsive crap ...]
>> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help
>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.
>>
>> Now if we look at this source code for H_Hat_1, we will see a function
>> ABNHBD_1(P,I), and this routine emulates the calculation P(I), up to a
>> point at least.  The code of ABNHBD_1(P,I) *DOES* include steps that
>> will abort certain of these emulated calculations P(I).  I'll call
>> this the *test T*.
>>
>> When we trace the calculation H_Hat_1(H_Hat_1) what do we see?  There
>> is a call ABNHBD_1(H_Hat_1,H_Hat_1) which starts an internal emulation
>> of calculation H_Hat_1(H_Hat_1).  We don't need to go into the details
>> of what that emulated calculation is doing - suffice it to say that
>> the T test in ABNHBD_1 /DOES/ detect what it /thinks/ is "non-halting
>> behaviour", aborts its emulation, and the calculation H_Hat_1(H_Hat_1)
>> DOES halt.
>>
>> *Summary so far*: Calculation H_Hat_1(H_Hat_1) halts.  (I think you
>> have come to agree with this, given the regular HP/Linz meaning for
>> "halts").
>>
>> But you want to go on and say "it /only/ halts because
>> ABNHBD_1(H_Hat_1,H_Hat_1) aborted its emulation".  Or put another way,
>> it /only/ halts because its code contains tests and associated logic
>> that resulted in it halting.
>>
>> When you say that H_Hat_1 /wouldn't/ have halted if ABNHBD_1() hadn't
>> been written as it was, you're just say that H_Hat_1 wouldn't have
>> halted if H_Hat_1 had been written differently!  Well, duh!  No
>> surprise there :)
>>
>> Anyway, let's suppose we clone all the version 1 code to get version
>> 2. We edit ABNHBD_2() to remove test T, and recompile the source to
>> get H_Hat(2), and sure enough H_Hat_2(H_Hat_2) never halts.
>>
>> H_Hat_2 is *A COMPLETELY DIFFERENT PROGRAM*!  It remains the case that
>> H_Hat_1(H_Hat_1) halts.  If calculation H_Hat_1(H_Hat_1) were executed
>> by some emulator which just let its calculation run to completion, the
>> emulation would likewise halt.  That's because the behaviour under a
>> correctly written emulator tracks the states of the calculation it's
>> emulating, and for H_Hat_1(H_Hat_1) that calculation halts.
>>
>> Alternatively, if your x86utm included a debug facility, we might be
>> able to set a breakpoint within ABNHBD_2() at the T test [within the
>> "native"/outer level process only!  No breaking within inner level
>> emulations!].  Each time the breakpoint hits we jump the IP over the T
>> test, so it is effectively prevented from taking its abort branch,
>> then we resume execution.  Continuing like this, we will eventually
>> see that the calculation being emulated *does* terminate.
>>
>> *Conclusion*:  Talking about two different source codes for two
>> different test programs when we were only asked about one, is not even
>> coherent in the case of general ABNHBD input (P,I)!  And for the
>> specific case of H_Hat() these /other/ programs are completely
>> irrelevent to anything in the HP proof, or the Linz proof in particular.
>>
>> Hmm, I bet this is why you've steadfastly refused to give a proper
>> specification for ABNHBD!  It's because your underlying idea at its
>> most basic level is incoherent - you don't know how to meaningfully
>> explain all about "Emulation of P_2(I_2) /wouldn't/ halt, where you
>> got P2 by editing P's source code by, ummmm, by, ummm..., and don't
>> forget you have to amend input data I somehow, umm..." !
>>
>>
>> Mike.
>>
>>
>>>> I suspect you are making the Big Mistake of assuming such "conditional
>>>> code" has to occur [in the trace of emulated code] BEFORE the emulated
>>>> code /initiates/ its nested emulation using the same machine address?
>>>>
>>>> [By "initiates its nested emulation" I mean "sets up the new virtual
>>>> process with its own stack, initialising the process ready to start
>>>> single stepping the requested calculation".]
>>>>
>>>> In fact, the conditional code occurs AFTER this point in the trace...
>>>> so if ABNHBD() is checking for that code, it needs to
>>>> a) *first* spot the OS call to initiate an emulation using the
>>>>     same machine address,
>>>> b) *then* continue monitoring to determine that there is no
>>>>     conditional code that terminates the calculation.
>>>>
>>>> Mike.
>>>>
>>>
>>>
>
>

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


#24715 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-30 21:56 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<686dnQjkFJzrTwHCnZ2dnUU7-S3NnZ2d@giganews.com>
In reply to#24713
On 10/30/2020 9:44 PM, Mike Terry wrote:
> On 31/10/2020 01:07, olcott wrote:
>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>> On 30/10/2020 22:21, olcott wrote:
>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>>>> while
>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>>>> "always".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>>>> need to
>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>>>> academic
>>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that
>>>>>>>>>>>>> you
>>>>>>>>>>>>> are
>>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>>
>>>>>>>>>>>>> No such decider can be written (you can, of course, define 
>>>>>>>>>>>>> what
>>>>>>>>>>>>> must
>>>>>>>>>>>>> do). There is no point in insisting over and over that it
>>>>>>>>>>>>> can be
>>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>>> <cut>
>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've
>>>>>>>>>>>>> spent two
>>>>>>>>>>>>> years
>>>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>>>> Don't
>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>>
>>>>>>>>>>>> As usual you make completely sure to totally ignore how I 
>>>>>>>>>>>> proved
>>>>>>>>>>>> that
>>>>>>>>>>>> I am correct
>>>>>>>>>>>
>>>>>>>>>>> Where is the program you claim you can write? The "proving you
>>>>>>>>>>> are
>>>>>>>>>>> right" is not working out. You should try the "writing the
>>>>>>>>>>> code you
>>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>>
>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it 
>>>>>>>>>>> will
>>>>>>>>>>> work"
>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I
>>>>>>>>>>> would
>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>>
>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>>>> the
>>>>>>>>>> following non-halting decider that accepts any and all 
>>>>>>>>>> non-halting
>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>>
>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>>
>>>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>>>> non-halting
>>>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>>>> at all
>>>>>>>>>> because it is already terminated.
>>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>>>> eventually
>>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>>
>>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>> problem trick: Because in both of these cases the input has 
>>>>>>>>> already
>>>>>>>>> terminated.
>>>>>>>>>
>>>>>>>> I don't think you've thought this through.
>>>>>>>>
>>>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>>>> tests,
>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>>
>>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>>
>>>>>>>
>>>>>>> I know these execution traces very well because I have done them 
>>>>>>> over
>>>>>>> and over again in my own mind many times over the last two years.
>>>>>>>
>>>>>>> The outermost invocation of this function
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>> always returns true no matter what function calls it.
>>>>>>
>>>>>> This is the key aspect of the execution trace that forms the basis 
>>>>>> for
>>>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>>>
>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>> machine
>>>>>> address without any conditional branch instructions in the execution
>>>>>> trace of H_Hat that would terminate this otherwise infinite 
>>>>>> recursion.
>>>>>>
>>>>>
>>>>> I previously pointed out that there is a problem with your "without
>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>>> think you responded.)
>>>>>
>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>>> behaviour incorrectly, according to your own description of what it
>>>>> does.
>>>>
>>>> No. Not at all. Not in the least.
>>> Dorky
>>>>
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>> Only terminates inputs that would not otherwise terminate on their own.
>>>>
>>>> Two examples of such inputs that would not terminate on their own:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>
>>>> Unless the above function terminates its inputs they would never
>>>> otherwise terminate.
>>>>
>>>
>>> You are totally confusing different versions of the program whose
>>> calculations are being decided!
>>>
>>
>> When I finish fixing the bug in process context local stacks I can write
> 
> ..blah blah.
> Dude!  You've got confused somewhere - your response was nothing to do 
> with the point I was making!  I think you just cut and pasted stuff from 
> another post into the wrong place or something.  Also you added in more 
> OT newsgroups for some reason...


The gist of what I was saying in my prior post is that there are several 
different process contexts of the various functions each one having 
different amounts of data.

It turns out that the outermost
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
always decides the halting of its first parameter correctly.

If you go back to my prior post I elaborate this in complete detail.

-- 
Copyright 2020 Pete Olcott

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

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


#24735 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-10-31 16:41 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<Y-WdnYW0IKpVDgDCnZ2dnUU78KNQAAAA@brightview.co.uk>
In reply to#24715
On 31/10/2020 02:56, olcott wrote:
> On 10/30/2020 9:44 PM, Mike Terry wrote:
>> On 31/10/2020 01:07, olcott wrote:
>>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>>> On 30/10/2020 22:21, olcott wrote:
>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting
>>>>>>>>>>>>>>>> inputs,
>>>>>>>>>>>>>>>> while
>>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but
>>>>>>>>>>>>>>>> technical
>>>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>>>>> "always".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording
>>>>>>>>>>>>>>> that I
>>>>>>>>>>>>>>> need to
>>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>>>>> academic
>>>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that
>>>>>>>>>>>>>> you
>>>>>>>>>>>>>> are
>>>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No such decider can be written (you can, of course, define
>>>>>>>>>>>>>> what
>>>>>>>>>>>>>> must
>>>>>>>>>>>>>> do). There is no point in insisting over and over that it
>>>>>>>>>>>>>> can be
>>>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've
>>>>>>>>>>>>>> spent two
>>>>>>>>>>>>>> years
>>>>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>>>>> Don't
>>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As usual you make completely sure to totally ignore how I
>>>>>>>>>>>>> proved
>>>>>>>>>>>>> that
>>>>>>>>>>>>> I am correct
>>>>>>>>>>>>
>>>>>>>>>>>> Where is the program you claim you can write? The "proving you
>>>>>>>>>>>> are
>>>>>>>>>>>> right" is not working out. You should try the "writing the
>>>>>>>>>>>> code you
>>>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>>>
>>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it
>>>>>>>>>>>> will
>>>>>>>>>>>> work"
>>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I
>>>>>>>>>>>> would
>>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>>>
>>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand
>>>>>>>>>>> how
>>>>>>>>>>> the
>>>>>>>>>>> following non-halting decider that accepts any and all
>>>>>>>>>>> non-halting
>>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>>>
>>>>>>>>>>> "do the opposite of whatever the halting decider decides"
>>>>>>>>>>> halting
>>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>>>
>>>>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>>>>> non-halting
>>>>>>>>>>> decision is stop executing its input, its input can't do
>>>>>>>>>>> anything
>>>>>>>>>>> at all
>>>>>>>>>>> because it is already terminated.
>>>>>>>>>> Since it continues to watch the execution of its input looking
>>>>>>>>>> for
>>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>>>>> eventually
>>>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>>>
>>>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>> problem trick: Because in both of these cases the input has
>>>>>>>>>> already
>>>>>>>>>> terminated.
>>>>>>>>>>
>>>>>>>>> I don't think you've thought this through.
>>>>>>>>>
>>>>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>>>>> tests,
>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>>>
>>>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I know these execution traces very well because I have done them
>>>>>>>> over
>>>>>>>> and over again in my own mind many times over the last two years.
>>>>>>>>
>>>>>>>> The outermost invocation of this function
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>> always returns true no matter what function calls it.
>>>>>>>
>>>>>>> This is the key aspect of the execution trace that forms the
>>>>>>> basis for
>>>>>>> deciding H_Hat: (All two years of my work has this as its
>>>>>>> foundation)
>>>>>>>
>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>>> machine
>>>>>>> address without any conditional branch instructions in the execution
>>>>>>> trace of H_Hat that would terminate this otherwise infinite
>>>>>>> recursion.
>>>>>>>
>>>>>>
>>>>>> I previously pointed out that there is a problem with your "without
>>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>>>> think you responded.)
>>>>>>
>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as
>>>>>> you've
>>>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>>>> behaviour incorrectly, according to your own description of what it
>>>>>> does.
>>>>>
>>>>> No. Not at all. Not in the least.
>>>> Dorky
>>>>>
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>>> Only terminates inputs that would not otherwise terminate on their
>>>>> own.
>>>>>
>>>>> Two examples of such inputs that would not terminate on their own:
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>>
>>>>> Unless the above function terminates its inputs they would never
>>>>> otherwise terminate.
>>>>>
>>>>
>>>> You are totally confusing different versions of the program whose
>>>> calculations are being decided!
>>>>
>>>
>>> When I finish fixing the bug in process context local stacks I can write
>>
>> ..blah blah.
>> Dude!  You've got confused somewhere - your response was nothing to do
>> with the point I was making!  I think you just cut and pasted stuff
>> from another post into the wrong place or something.  Also you added
>> in more OT newsgroups for some reason...
>
>
> The gist of what I was saying in my prior post is that there are several
> different process contexts of the various functions each one having
> different amounts of data.
>
> It turns out that the outermost
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> always decides the halting of its first parameter correctly.
>
> If you go back to my prior post I elaborate this in complete detail.

No you don't.  In the prior post you say ABNHBD() decides based on it's 
first parameter H_Hat.  Elsewhere you say it decides based on detection 
of non-halting behaviour.  Nowhere have you ever specified what ABNHBD() 
actually must return (i.e. according to its non-existant spec) for 
anyone to judge whether an actual return code is in fact correct.  This 
is all quite hopeless, I'm afraid.

All I know for certain (from what you /have/ said that makes sense) is 
that when invoked within (outer) H(H_Hat,H_Hat) it returns true, which 
is the "accept" decision for your non-halting decider - i.e. it decides 
(H_Hat,H_Hat) is in NON_HALTING class, when IN FACT it is HALTING.  So 
that's not a good start.

Look, if you can't explain why you're not just your everyday crank in a 
broadly tolerant environment like UseNet, where readers have 1000x as 
much patience as your average quality journal peer reviewer [who has a 
job to do and will just do it efficiently and move on], and where there 
are readers who are willing to engage in long too-and-fro conversations 
littered with non-responsive answers, and where readers are reasonably 
tollerant of your lack of knowledge of the terminology in use in the 
field, and tolerant of incoherent arguments, YOU ARE NOT GOING TO GET 
*ANYWHERE* in any stricter environment (like a professional peer 
reviewing).

Just saying:  be prepared for a coming fall...  [I'm sure you'll recover 
and carry on much as you always have - and you won't even take it as 
reflecting in any way on your ideas!]   And BTW I don't see the point in 
finishing your non-halter code - it's not going to make any difference 
to anything.  (But I know you will.)

Regards,
Mike.

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


#24736 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromJeff Barnett <jbb@notatt.com>
Date2020-10-31 11:16 -0600
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<rnk666$rbo$1@dont-email.me>
In reply to#24735
On 10/31/2020 10:41 AM, Mike Terry wrote:
> On 31/10/2020 02:56, olcott wrote:
>  <snip>
> Just saying:  be prepared for a coming fall...  [I'm sure you'll recover 
> and carry on much as you always have - and you won't even take it as 
> reflecting in any way on your ideas!]   And BTW I don't see the point in 
> finishing your non-halter code - it's not going to make any difference 
> to anything.  (But I know you will.)

No point in finishing? Of course that's correct but I don't think he 
ever intended to. Our correspondent's trolling instincts and troubled 
psychology made him do it. Over decades he's never finished anything. 
The none trolling part of his psyche believes that if he thinks it, then 
it must be true. He covers actual truth of his incompetence from himself 
as much as he withholds other "truths" from others. PO believes that he 
is trolling others for sport (which he is) but is sure that the truth is 
apparent to himself. He dismisses his evasions, not as proof that his 
head is up his backside, but that he is sporting with his inferiors, his 
captive audience of admirers.
-- 
Jeff Barnett

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


#24719 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-30 23:40 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<59ednTNak_YtdwHCnZ2dnUU7-c3NnZ2d@giganews.com>
In reply to#24707
On 10/30/2020 7:46 PM, Mike Terry wrote:
> On 30/10/2020 22:21, olcott wrote:
>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>> On 30/10/2020 11:40, olcott wrote:
>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>> <cut>
>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>
>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>> while
>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>
>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>> terms like
>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>> "always".
>>>>>>>>>>>>
>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>> need to
>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>> academic
>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>
>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>> non-halting
>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>
>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you
>>>>>>>>>>> are
>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>
>>>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>>>> must
>>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>> <cut>
>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent 
>>>>>>>>>>> two
>>>>>>>>>>> years
>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>> Don't
>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>
>>>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>>>> that
>>>>>>>>>> I am correct
>>>>>>>>>
>>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>>> right" is not working out. You should try the "writing the code 
>>>>>>>>> you
>>>>>>>>> said you could" plan instead.
>>>>>>>>>
>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>>>> work"
>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>
>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>> the
>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>
>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>
>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>> non-halting
>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>> at all
>>>>>>>> because it is already terminated.
>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>> eventually
>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>
>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>> terminated.
>>>>>>>
>>>>>> I don't think you've thought this through.
>>>>>>
>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>> tests,
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>
>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>
>>>>>
>>>>> I know these execution traces very well because I have done them over
>>>>> and over again in my own mind many times over the last two years.
>>>>>
>>>>> The outermost invocation of this function
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>> always returns true no matter what function calls it.
>>>>
>>>> This is the key aspect of the execution trace that forms the basis for
>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>
>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>> Detect that the halt decider is invoked two times from the same machine
>>>> address without any conditional branch instructions in the execution
>>>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>>>
>>>
>>> I previously pointed out that there is a problem with your "without
>>> any conditional branch instructions in the execution trace of H_Hat
>>> that would terminate this otherwise infinite recursion".  (I don't
>>> think you responded.)
>>>
>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>>> previously described.)  So your ABNHBD() is detecting non-halting
>>> behaviour incorrectly, according to your own description of what it 
>>> does.
>>
>> No. Not at all. Not in the least.
> Dorky
>>
>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>> Only terminates inputs that would not otherwise terminate on their own.
>>
>> Two examples of such inputs that would not terminate on their own:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>
>> Unless the above function terminates its inputs they would never
>> otherwise terminate.
>>
> 
> You are totally confusing different versions of the program whose 
> calculations are being decided!
> 
> 
> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help 
> keep things clear, let's say what we have is version 1 of ABNHBD, and 
> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.


void H_Hat(u32 P)
{
   if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
     MOV_EAX_1  // Execution of P(P) has been aborted
   else
   {
     MOV_EAX_0  // P(P) has halted
     HERE: goto HERE;
   }
   HALT
}


void H(u32 P, u32 I)
{
   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
     MOV_EAX_1  // Execution of P(I) has been aborted
   else
     MOV_EAX_0  // P(I) has halted
   HALT
}


01 int main()
02 {
03   u32 P = (u32)H_Hat;
04   H(P, P);   // MOV_EAX_0
05   H_Hat(P);  // MOV_EAX_0
06   HALT
06 }


The invocation on line 04 specifies two different process contexts of 
H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).

The invocation on line 05 specifies three different process contexts of 
H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).

bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
The above function really does Stop executing and Accepts any and all 
non-halting inputs and Rejects any and all halting inputs.

This can be empirically proven for lines 04 and 05 above. I just have to 
get rid of the bug in the local process stacks and then write the code 
that I already 100% completely described in these threads.


> Now if we look at this source code for H_Hat_1, we will see a function 
> ABNHBD_1(P,I), and this routine emulates the calculation P(I), up to a 
> point at least.  The code of ABNHBD_1(P,I) *DOES* include steps that 
> will abort certain of these emulated calculations P(I).  I'll call this 
> the *test T*.
> 
> When we trace the calculation H_Hat_1(H_Hat_1) what do we see?  There is 
> a call ABNHBD_1(H_Hat_1,H_Hat_1) which starts an internal emulation of 
> calculation H_Hat_1(H_Hat_1).  We don't need to go into the details of 
> what that emulated calculation is doing - suffice it to say that the T 
> test in ABNHBD_1 /DOES/ detect what it /thinks/ is "non-halting 
> behaviour", aborts its emulation, and the calculation H_Hat_1(H_Hat_1) 
> DOES halt.
> 
> *Summary so far*: Calculation H_Hat_1(H_Hat_1) halts.  (I think you have 
> come to agree with this, given the regular HP/Linz meaning for "halts").
> 
> But you want to go on and say "it /only/ halts because 
> ABNHBD_1(H_Hat_1,H_Hat_1) aborted its emulation".  Or put another way, 
> it /only/ halts because its code contains tests and associated logic 
> that resulted in it halting.
> 
> When you say that H_Hat_1 /wouldn't/ have halted if ABNHBD_1() hadn't 
> been written as it was, you're just say that H_Hat_1 wouldn't have 
> halted if H_Hat_1 had been written differently!  Well, duh!  No surprise 
> there :)
> 
> Anyway, let's suppose we clone all the version 1 code to get version 2. 
> We edit ABNHBD_2() to remove test T, and recompile the source to get 
> H_Hat(2), and sure enough H_Hat_2(H_Hat_2) never halts.
> 
> H_Hat_2 is *A COMPLETELY DIFFERENT PROGRAM*!  It remains the case that 
> H_Hat_1(H_Hat_1) halts.  If calculation H_Hat_1(H_Hat_1) were executed 
> by some emulator which just let its calculation run to completion, the 
> emulation would likewise halt.  That's because the behaviour under a 
> correctly written emulator tracks the states of the calculation it's 
> emulating, and for H_Hat_1(H_Hat_1) that calculation halts.
> 
> Alternatively, if your x86utm included a debug facility, we might be 
> able to set a breakpoint within ABNHBD_2() at the T test [within the 
> "native"/outer level process only!  No breaking within inner level 
> emulations!].  Each time the breakpoint hits we jump the IP over the T 
> test, so it is effectively prevented from taking its abort branch, then 
> we resume execution.  Continuing like this, we will eventually see that 
> the calculation being emulated *does* terminate.
> 
> *Conclusion*:  Talking about two different source codes for two 
> different test programs when we were only asked about one, is not even 
> coherent in the case of general ABNHBD input (P,I)!  And for the 
> specific case of H_Hat() these /other/ programs are completely 
> irrelevent to anything in the HP proof, or the Linz proof in particular.
> 
> Hmm, I bet this is why you've steadfastly refused to give a proper 
> specification for ABNHBD!  It's because your underlying idea at its most 
> basic level is incoherent - you don't know how to meaningfully explain 
> all about "Emulation of P_2(I_2) /wouldn't/ halt, where you got P2 by 
> editing P's source code by, ummmm, by, ummm..., and don't forget you 
> have to amend input data I somehow, umm..." !
> 
> 
> Mike.
> 
> 
>>> I suspect you are making the Big Mistake of assuming such "conditional
>>> code" has to occur [in the trace of emulated code] BEFORE the emulated
>>> code /initiates/ its nested emulation using the same machine address?
>>>
>>> [By "initiates its nested emulation" I mean "sets up the new virtual
>>> process with its own stack, initialising the process ready to start
>>> single stepping the requested calculation".]
>>>
>>> In fact, the conditional code occurs AFTER this point in the trace...
>>> so if ABNHBD() is checking for that code, it needs to
>>> a) *first* spot the OS call to initiate an emulation using the
>>>     same machine address,
>>> b) *then* continue monitoring to determine that there is no
>>>     conditional code that terminates the calculation.
>>>
>>> Mike.
>>>
>>
>>


-- 
Copyright 2020 Pete Olcott

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

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


#24733 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-10-31 16:28 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<Vd2dndrG3LcNDQDCnZ2dnUU78dPNnZ2d@brightview.co.uk>
In reply to#24719
On 31/10/2020 04:40, olcott wrote:
> On 10/30/2020 7:46 PM, Mike Terry wrote:
>> On 30/10/2020 22:21, olcott wrote:
>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>> On 30/10/2020 11:40, olcott wrote:
>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>>> while
>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>>> "always".
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>>> need to
>>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>>> academic
>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that
>>>>>>>>>>>> you
>>>>>>>>>>>> are
>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>
>>>>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>>>>> must
>>>>>>>>>>>> do). There is no point in insisting over and over that it
>>>>>>>>>>>> can be
>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>> <cut>
>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've
>>>>>>>>>>>> spent two
>>>>>>>>>>>> years
>>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>>> Don't
>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>
>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>>>>> that
>>>>>>>>>>> I am correct
>>>>>>>>>>
>>>>>>>>>> Where is the program you claim you can write? The "proving you
>>>>>>>>>> are
>>>>>>>>>> right" is not working out. You should try the "writing the
>>>>>>>>>> code you
>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>
>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>>>>> work"
>>>>>>>>>> and "this show I could do it" because, as you can imagine, I
>>>>>>>>>> would
>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>
>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>>> the
>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>
>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>
>>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>>> non-halting
>>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>>> at all
>>>>>>>>> because it is already terminated.
>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>>> eventually
>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>
>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>> terminated.
>>>>>>>>
>>>>>>> I don't think you've thought this through.
>>>>>>>
>>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>>> tests,
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>
>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>
>>>>>>
>>>>>> I know these execution traces very well because I have done them over
>>>>>> and over again in my own mind many times over the last two years.
>>>>>>
>>>>>> The outermost invocation of this function
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> always returns true no matter what function calls it.
>>>>>
>>>>> This is the key aspect of the execution trace that forms the basis for
>>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>>
>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>> Detect that the halt decider is invoked two times from the same
>>>>> machine
>>>>> address without any conditional branch instructions in the execution
>>>>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>>>>
>>>>
>>>> I previously pointed out that there is a problem with your "without
>>>> any conditional branch instructions in the execution trace of H_Hat
>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>> think you responded.)
>>>>
>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>> behaviour incorrectly, according to your own description of what it
>>>> does.
>>>
>>> No. Not at all. Not in the least.
>> Dorky
>>>
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>> Only terminates inputs that would not otherwise terminate on their own.
>>>
>>> Two examples of such inputs that would not terminate on their own:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>
>>> Unless the above function terminates its inputs they would never
>>> otherwise terminate.
>>>
>>
>> You are totally confusing different versions of the program whose
>> calculations are being decided!
>>
>>
>> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help
>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.
>
>
> void H_Hat(u32 P)
> {
>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>     MOV_EAX_1  // Execution of P(P) has been aborted
>   else
>   {
>     MOV_EAX_0  // P(P) has halted
>     HERE: goto HERE;
>   }
>   HALT
> }
>
>
> void H(u32 P, u32 I)
> {
>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>     MOV_EAX_1  // Execution of P(I) has been aborted
>   else
>     MOV_EAX_0  // P(I) has halted
>   HALT
> }
>
>
> 01 int main()
> 02 {
> 03   u32 P = (u32)H_Hat;
> 04   H(P, P);   // MOV_EAX_0
> 05   H_Hat(P);  // MOV_EAX_0
> 06   HALT
> 06 }
>
>
> The invocation on line 04 specifies two different process contexts of
> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>
> The invocation on line 05 specifies three different process contexts of
> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
> The above function really does Stop executing and Accepts any and all
> non-halting inputs and Rejects any and all halting inputs.

No it doesn't.

You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input.  So 
your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is 
non-halting.  In HP and Linz world, non-halting means the corresponding 
calculation H_Hat(H_Hat) doesn't halt.

And yet the calculation H_Hat(H_Hat) halts, and proper traces of 04 and 
05 above will confirm that.

[Above assumes you have not changed the definitions of the classes 
HALTING and NONHALTING (which are being decided):

HALTING = class of pairs (P,I) such that P(I) halts
NONHALTING = class of pairs (P,I) such that P(I) never halts
]

So which of the following statements do you disagree with?

a)  ABNHBD(H_Hat,H_Hat) returns true  [accept: input is non-halting]
b)  (H_Hat,H_Hat) is in class HALTING [calculation H_Hat(H_Hat) halts]

Mike.

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


#24737 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-31 12:56 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<muOdnfd_sOP3OADCnZ2dnUU7-KHNnZ2d@giganews.com>
In reply to#24733
On 10/31/2020 11:28 AM, Mike Terry wrote:
> On 31/10/2020 04:40, olcott wrote:
>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>> On 30/10/2020 22:21, olcott wrote:
>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>>>> while
>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>>>> "always".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>>>> need to
>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>>>> academic
>>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that
>>>>>>>>>>>>> you
>>>>>>>>>>>>> are
>>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>>
>>>>>>>>>>>>> No such decider can be written (you can, of course, define 
>>>>>>>>>>>>> what
>>>>>>>>>>>>> must
>>>>>>>>>>>>> do). There is no point in insisting over and over that it
>>>>>>>>>>>>> can be
>>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>>> <cut>
>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've
>>>>>>>>>>>>> spent two
>>>>>>>>>>>>> years
>>>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>>>> Don't
>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>>
>>>>>>>>>>>> As usual you make completely sure to totally ignore how I 
>>>>>>>>>>>> proved
>>>>>>>>>>>> that
>>>>>>>>>>>> I am correct
>>>>>>>>>>>
>>>>>>>>>>> Where is the program you claim you can write? The "proving you
>>>>>>>>>>> are
>>>>>>>>>>> right" is not working out. You should try the "writing the
>>>>>>>>>>> code you
>>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>>
>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it 
>>>>>>>>>>> will
>>>>>>>>>>> work"
>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I
>>>>>>>>>>> would
>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>>
>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>>>> the
>>>>>>>>>> following non-halting decider that accepts any and all 
>>>>>>>>>> non-halting
>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>>
>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>>
>>>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>>>> non-halting
>>>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>>>> at all
>>>>>>>>>> because it is already terminated.
>>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>>>> eventually
>>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>>
>>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>> problem trick: Because in both of these cases the input has 
>>>>>>>>> already
>>>>>>>>> terminated.
>>>>>>>>>
>>>>>>>> I don't think you've thought this through.
>>>>>>>>
>>>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>>>> tests,
>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>>
>>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>>
>>>>>>>
>>>>>>> I know these execution traces very well because I have done them 
>>>>>>> over
>>>>>>> and over again in my own mind many times over the last two years.
>>>>>>>
>>>>>>> The outermost invocation of this function
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>> always returns true no matter what function calls it.
>>>>>>
>>>>>> This is the key aspect of the execution trace that forms the basis 
>>>>>> for
>>>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>>>
>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>> machine
>>>>>> address without any conditional branch instructions in the execution
>>>>>> trace of H_Hat that would terminate this otherwise infinite 
>>>>>> recursion.
>>>>>>
>>>>>
>>>>> I previously pointed out that there is a problem with your "without
>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>>> think you responded.)
>>>>>
>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as you've
>>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>>> behaviour incorrectly, according to your own description of what it
>>>>> does.
>>>>
>>>> No. Not at all. Not in the least.
>>> Dorky
>>>>
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>> Only terminates inputs that would not otherwise terminate on their own.
>>>>
>>>> Two examples of such inputs that would not terminate on their own:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>
>>>> Unless the above function terminates its inputs they would never
>>>> otherwise terminate.
>>>>
>>>
>>> You are totally confusing different versions of the program whose
>>> calculations are being decided!
>>>
>>>
>>> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help
>>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>>> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.
>>
>>
>> void H_Hat(u32 P)
>> {
>>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>     MOV_EAX_1  // Execution of P(P) has been aborted
>>   else
>>   {
>>     MOV_EAX_0  // P(P) has halted
>>     HERE: goto HERE;
>>   }
>>   HALT
>> }
>>
>>
>> void H(u32 P, u32 I)
>> {
>>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>     MOV_EAX_1  // Execution of P(I) has been aborted
>>   else
>>     MOV_EAX_0  // P(I) has halted
>>   HALT
>> }
>>
>>
>> 01 int main()
>> 02 {
>> 03   u32 P = (u32)H_Hat;
>> 04   H(P, P);   // MOV_EAX_0
>> 05   H_Hat(P);  // MOV_EAX_0
>> 06   HALT
>> 06 }
>>
>>
>> The invocation on line 04 specifies two different process contexts of
>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>
>> The invocation on line 05 specifies three different process contexts of
>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>> The above function really does Stop executing and Accepts any and all
>> non-halting inputs and Rejects any and all halting inputs.
> 
> No it doesn't.
> 
> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input.  So 
> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is 
> non-halting.  In HP and Linz world, non-halting means the corresponding 
> calculation H_Hat(H_Hat) doesn't halt.

H_Hat(H_Hat) would never ever halt unless and until
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
stops executing its input which is the same input to H_Hat above.

bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
Stops executing and Accepts any and all non-halting inputs and Rejects 
any and all halting inputs as soon as they halt.

When you say that the H_Hat on line 05 halts, this is not contradicting 
the above claim. It is just like I say that every citizen of the USA 
pays taxes to the USA and you provide a counter example of a guy in 
Russia that is not a citizen of the USA.

> And yet the calculation H_Hat(H_Hat) halts, and proper traces of 04 and 
> 05 above will confirm that.
> 
> [Above assumes you have not changed the definitions of the classes 
> HALTING and NONHALTING (which are being decided):
> 
> HALTING = class of pairs (P,I) such that P(I) halts
> NONHALTING = class of pairs (P,I) such that P(I) never halts
> ]
> 
> So which of the following statements do you disagree with?
> 
> a)  ABNHBD(H_Hat,H_Hat) returns true  [accept: input is non-halting]
> b)  (H_Hat,H_Hat) is in class HALTING [calculation H_Hat(H_Hat) halts]
> 
> Mike.
> 

I defined a non-halting decider
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
That stops executing and Accepts any and all non-halting inputs and 
Rejects any and all halting inputs as soon as they halt.

You can point to a guy in Russia that does not pay his taxes because he 
is not a citizen of the USA but what you cannot do is provide a 
counter-example that shows that non-halting is undecidable.

-- 
Copyright 2020 Pete Olcott

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

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


#24745 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-10-31 20:49 +0000
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<WJOdncyBDMh3UADCnZ2dnUU78Y_NnZ2d@brightview.co.uk>
In reply to#24737
On 31/10/2020 17:56, olcott wrote:
> On 10/31/2020 11:28 AM, Mike Terry wrote:
>> On 31/10/2020 04:40, olcott wrote:
>>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>>> On 30/10/2020 22:21, olcott wrote:
>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>>> On 10/30/2020 6:32 AM, olcott wrote:

[... snip ...]
>>>>>>> This is the key aspect of the execution trace that forms the
>>>>>>> basis for
>>>>>>> deciding H_Hat: (All two years of my work has this as its
>>>>>>> foundation)
>>>>>>>
>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>>> machine
>>>>>>> address without any conditional branch instructions in the execution
>>>>>>> trace of H_Hat that would terminate this otherwise infinite
>>>>>>> recursion.
>>>>>>>
>>>>>>
>>>>>> I previously pointed out that there is a problem with your "without
>>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>>>> think you responded.)
>>>>>>
>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as
>>>>>> you've
>>>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>>>> behaviour incorrectly, according to your own description of what it
>>>>>> does.
>>>>>
>>>>> No. Not at all. Not in the least.
>>>> Dorky
>>>>>
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>>> Only terminates inputs that would not otherwise terminate on their
>>>>> own.
>>>>>
>>>>> Two examples of such inputs that would not terminate on their own:
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>>
>>>>> Unless the above function terminates its inputs they would never
>>>>> otherwise terminate.
>>>>>
>>>>
>>>> You are totally confusing different versions of the program whose
>>>> calculations are being decided!
>>>>
>>>>
>>>> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help
>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>>>> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.
>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>     MOV_EAX_1  // Execution of P(P) has been aborted
>>>   else
>>>   {
>>>     MOV_EAX_0  // P(P) has halted
>>>     HERE: goto HERE;
>>>   }
>>>   HALT
>>> }
>>>
>>>
>>> void H(u32 P, u32 I)
>>> {
>>>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>>     MOV_EAX_1  // Execution of P(I) has been aborted
>>>   else
>>>     MOV_EAX_0  // P(I) has halted
>>>   HALT
>>> }
>>>
>>>
>>> 01 int main()
>>> 02 {
>>> 03   u32 P = (u32)H_Hat;
>>> 04   H(P, P);   // MOV_EAX_0
>>> 05   H_Hat(P);  // MOV_EAX_0
>>> 06   HALT
>>> 06 }
>>>
>>>
>>> The invocation on line 04 specifies two different process contexts of
>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>
>>> The invocation on line 05 specifies three different process contexts of
>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>> The above function really does Stop executing and Accepts any and all
>>> non-halting inputs and Rejects any and all halting inputs.
>>
>> No it doesn't.
>>
>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input.  So
>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is
>> non-halting.  In HP and Linz world, non-halting means the
>> corresponding calculation H_Hat(H_Hat) doesn't halt.
>
> H_Hat(H_Hat) would never ever halt unless and until
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
> stops executing its input which is the same input to H_Hat above.
>

Your claim that was under discussion is

PO:
    "The above function really does Stop executing and Accepts
    any and all non-halting inputs and Rejects any and all
    halting inputs."

The meaning of "halting inputs" and "non-halting inputs" are fixed by 
the statement of HP, and by the Linz proof, so the meaning of what you 
said was similarly clear.  I commented that you were wrong and gave the 
reason.

Now, YOU are trying to pretend you said something else, concerning 
calculations which "/would/ never ever halt /unless/ blah blah".  That 
is ultimately incoherent as I explained upthread, but more obviously it 
WAS NOT WHAT YOU WERE TALKING ABOUT ABOVE.  Above and elsewhere you have 
given a definition of what a non-halt decider should be, in terms of 
accepting precisely inputs in NON-HALTING class [calulations which 
halt].  Um, here is one place you do this:

PO:
    "A non-halting decider can be defined that always Accepts
     NON_HALTING input and Rejects HALTING input as follows:..."

Note that HALTING and NON_HALTING input are also precisely defined in HP 
terminology, and you have not claimed to be redefining those terms.  You 
say that a "halt decider" is defined in terms of those classes and so is 
your "non-halting decider", and you cannot reasonably be switching 
definitions half way through here!

Summary:  There is nothing anywhere in definitions for "non-halting" or 
"NON_HALTING" about "calculations which /would/ not halt /if/ some code 
change is made to those programs".  Also there is nothing about 
"calculations which /would/ be be aborted if run in some function you've 
written that internally emulates the calculation".

So your previous comment is just out of place...

> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> Stops executing and Accepts any and all non-halting inputs and Rejects
> any and all halting inputs as soon as they halt.
>
> When you say that the H_Hat on line 05 halts, this is not contradicting
> the above claim.

What "above claim"?  You've now introduced multiple different claims 
over a chain of responses...

It *IS* contradicting the above claim

PO:
    "The above function really does Stop executing and Accepts
    any and all non-halting inputs and Rejects any and all
    halting inputs."

because the above function in fact accepts input (H_Hat,H_Hat) which is 
a halting input.  THAT claim is Just Wrong, and it's the one I was 
talking about.

[At this point, I should say that if you have used the term 
"non-halting" with your own secret meaning, different from what HP, Linz 
and everybody here but you, would take it to mean, then you need to 
define your meaning for the term.]

Whether or not it would contradict your amended claim, also above:

PO:
 > H_Hat(H_Hat) would never ever halt unless and until
 > bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
 > stops executing its input which is the same input to H_Hat above.

is irrelevent, because:
a)  that's not what you said before, and is not what I was
     talking about
b)  it's of no relevance to HP, or Linz proof.

[... snip stuff about paying taxes ...]

>> And yet the calculation H_Hat(H_Hat) halts, and proper traces of 04
>> and 05 above will confirm that.
>>
>> [Above assumes you have not changed the definitions of the classes
>> HALTING and NONHALTING (which are being decided):
>>
>> HALTING = class of pairs (P,I) such that P(I) halts
>> NONHALTING = class of pairs (P,I) such that P(I) never halts
>> ]
>>
>> So which of the following statements do you disagree with?
>>
>> a)  ABNHBD(H_Hat,H_Hat) returns true  [accept: input is non-halting]
>> b)  (H_Hat,H_Hat) is in class HALTING [calculation H_Hat(H_Hat) halts]
>>
>> Mike.

[... snipped repetitive non-responsive answer ...]

Mike.

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


#24747 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-31 16:07 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<KqWdnc2QEfWVTwDCnZ2dnUU7-fPNnZ2d@giganews.com>
In reply to#24745
On 10/31/2020 3:49 PM, Mike Terry wrote:
> On 31/10/2020 17:56, olcott wrote:
>> On 10/31/2020 11:28 AM, Mike Terry wrote:
>>> On 31/10/2020 04:40, olcott wrote:
>>>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>>>> On 30/10/2020 22:21, olcott wrote:
>>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
> 
> [... snip ...]
>>>>>>>> This is the key aspect of the execution trace that forms the
>>>>>>>> basis for
>>>>>>>> deciding H_Hat: (All two years of my work has this as its
>>>>>>>> foundation)
>>>>>>>>
>>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>>>> machine
>>>>>>>> address without any conditional branch instructions in the 
>>>>>>>> execution
>>>>>>>> trace of H_Hat that would terminate this otherwise infinite
>>>>>>>> recursion.
>>>>>>>>
>>>>>>>
>>>>>>> I previously pointed out that there is a problem with your "without
>>>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>>>> that would terminate this otherwise infinite recursion".  (I don't
>>>>>>> think you responded.)
>>>>>>>
>>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>>>> infinite recursion"!  (That's assuming your ABNHBD() behaves as
>>>>>>> you've
>>>>>>> previously described.)  So your ABNHBD() is detecting non-halting
>>>>>>> behaviour incorrectly, according to your own description of what it
>>>>>>> does.
>>>>>>
>>>>>> No. Not at all. Not in the least.
>>>>> Dorky
>>>>>>
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>>>> Only terminates inputs that would not otherwise terminate on their
>>>>>> own.
>>>>>>
>>>>>> Two examples of such inputs that would not terminate on their own:
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>>>
>>>>>> Unless the above function terminates its inputs they would never
>>>>>> otherwise terminate.
>>>>>>
>>>>>
>>>>> You are totally confusing different versions of the program whose
>>>>> calculations are being decided!
>>>>>
>>>>>
>>>>> H_Hat is ONE FIXED program.  *It's source code can't change!*  To help
>>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>>>>> call it ABNHBD_1.  Similarly, we have associated H_1 and H_Hat_1.
>>>>
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>>     MOV_EAX_1  // Execution of P(P) has been aborted
>>>>   else
>>>>   {
>>>>     MOV_EAX_0  // P(P) has halted
>>>>     HERE: goto HERE;
>>>>   }
>>>>   HALT
>>>> }
>>>>
>>>>
>>>> void H(u32 P, u32 I)
>>>> {
>>>>   if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>>>     MOV_EAX_1  // Execution of P(I) has been aborted
>>>>   else
>>>>     MOV_EAX_0  // P(I) has halted
>>>>   HALT
>>>> }
>>>>
>>>>
>>>> 01 int main()
>>>> 02 {
>>>> 03   u32 P = (u32)H_Hat;
>>>> 04   H(P, P);   // MOV_EAX_0
>>>> 05   H_Hat(P);  // MOV_EAX_0
>>>> 06   HALT
>>>> 06 }
>>>>
>>>>
>>>> The invocation on line 04 specifies two different process contexts of
>>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>
>>>> The invocation on line 05 specifies three different process contexts of
>>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>> The above function really does Stop executing and Accepts any and all
>>>> non-halting inputs and Rejects any and all halting inputs.
>>>
>>> No it doesn't.
>>>
>>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input.  So
>>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is
>>> non-halting.  In HP and Linz world, non-halting means the
>>> corresponding calculation H_Hat(H_Hat) doesn't halt.
>>
>> H_Hat(H_Hat) would never ever halt unless and until
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> stops executing its input which is the same input to H_Hat above.
>>
> 
> Your claim that was under discussion is
> 
> PO:
>     "The above function really does Stop executing and Accepts
>     any and all non-halting inputs and Rejects any and all
>     halting inputs."
> 
> The meaning of "halting inputs" and "non-halting inputs" are fixed by 
> the statement of HP, and by the Linz proof, so the meaning of what you 
> said was similarly clear.  I commented that you were wrong and gave the 
> reason.

Yes and you broke the rules.
When I claim that every citizen of the USA pays taxes a guy in Russia 
that is not a citizen of the USA is not a valid counter-example.

The H_Hat() on line 05 of main() is not an input to
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
thus tossed out on its ass as an invalid counter-example to this claim:

bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
Stops executing and Accepts any and all non-halting inputs and Rejects 
any and all halting inputs as soon as they halt.

If no inputs exist that it fails to decides incorrectly or fails to 
decide then this is complete proof that I am correct and all rebuttals 
are incorrect.

Anyone paying 100% complete attention will realize that your argument is 
an example of the straw-man fallacy.

https://en.wikipedia.org/wiki/Straw_man

Another analogy:
(1) I have a very excellent mechanic named Bill that can fix anything 
that is wrong with any car.

(2) You claim that Bill cannot fix anything wrong with any car because 
he did not fix your car.

(3) I ask you: Did you take your car to Bill to have it fixed?

(4) You say no, I didn't do that.

> Now, YOU are trying to pretend you said something else, concerning 
> calculations which "/would/ never ever halt /unless/ blah blah".  That 
> is ultimately incoherent as I explained upthread, but more obviously it 
> WAS NOT WHAT YOU WERE TALKING ABOUT ABOVE.  Above and elsewhere you have 
> given a definition of what a non-halt decider should be, in terms of 
> accepting precisely inputs in NON-HALTING class [calulations which 
> halt].  Um, here is one place you do this:
> 
> PO:
>     "A non-halting decider can be defined that always Accepts
>      NON_HALTING input and Rejects HALTING input as follows:..."
> 
> Note that HALTING and NON_HALTING input are also precisely defined in HP 
> terminology, and you have not claimed to be redefining those terms.  You 
> say that a "halt decider" is defined in terms of those classes and so is 
> your "non-halting decider", and you cannot reasonably be switching 
> definitions half way through here!
> 
> Summary:  There is nothing anywhere in definitions for "non-halting" or 
> "NON_HALTING" about "calculations which /would/ not halt /if/ some code 
> change is made to those programs".  Also there is nothing about 
> "calculations which /would/ be be aborted if run in some function you've 
> written that internally emulates the calculation".
> 
> So your previous comment is just out of place...
> 
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>> Stops executing and Accepts any and all non-halting inputs and Rejects
>> any and all halting inputs as soon as they halt.
>>
>> When you say that the H_Hat on line 05 halts, this is not contradicting
>> the above claim.
> 
> What "above claim"?  You've now introduced multiple different claims 
> over a chain of responses...
> 
> It *IS* contradicting the above claim
> 
> PO:
>     "The above function really does Stop executing and Accepts
>     any and all non-halting inputs and Rejects any and all
>     halting inputs."
> 
> because the above function in fact accepts input (H_Hat,H_Hat) which is 
> a halting input.  THAT claim is Just Wrong, and it's the one I was 
> talking about.
> 
> [At this point, I should say that if you have used the term 
> "non-halting" with your own secret meaning, different from what HP, Linz 
> and everybody here but you, would take it to mean, then you need to 
> define your meaning for the term.]
> 
> Whether or not it would contradict your amended claim, also above:
> 
> PO:
>  > H_Hat(H_Hat) would never ever halt unless and until
>  > bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>  > stops executing its input which is the same input to H_Hat above.
> 
> is irrelevent, because:
> a)  that's not what you said before, and is not what I was
>      talking about
> b)  it's of no relevance to HP, or Linz proof.
> 
> [... snip stuff about paying taxes ...]
> 
>>> And yet the calculation H_Hat(H_Hat) halts, and proper traces of 04
>>> and 05 above will confirm that.
>>>
>>> [Above assumes you have not changed the definitions of the classes
>>> HALTING and NONHALTING (which are being decided):
>>>
>>> HALTING = class of pairs (P,I) such that P(I) halts
>>> NONHALTING = class of pairs (P,I) such that P(I) never halts
>>> ]
>>>
>>> So which of the following statements do you disagree with?
>>>
>>> a)  ABNHBD(H_Hat,H_Hat) returns true  [accept: input is non-halting]
>>> b)  (H_Hat,H_Hat) is in class HALTING [calculation H_Hat(H_Hat) halts]
>>>
>>> Mike.
> 
> [... snipped repetitive non-responsive answer ...]
> 
> Mike.


-- 
Copyright 2020 Pete Olcott

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

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


#24752 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-10-31 14:55 -0700
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<e271a53b-6d13-4b9e-b3e9-a401770a4834n@googlegroups.com>
In reply to#24747
On Saturday, 31 October 2020 at 21:07:28 UTC, olcott wrote:
> On 10/31/2020 3:49 PM, Mike Terry wrote: 
> > On 31/10/2020 17:56, olcott wrote: 
> >> On 10/31/2020 11:28 AM, Mike Terry wrote: 
> >>> On 31/10/2020 04:40, olcott wrote: 
> >>>> On 10/30/2020 7:46 PM, Mike Terry wrote: 
> >>>>> On 30/10/2020 22:21, olcott wrote: 
> >>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote: 
> >>>>>>> On 30/10/2020 11:40, olcott wrote: 
> >>>>>>>> On 10/30/2020 6:32 AM, olcott wrote: 
> > 
> > [... snip ...] 
> >>>>>>>> This is the key aspect of the execution trace that forms the 
> >>>>>>>> basis for 
> >>>>>>>> deciding H_Hat: (All two years of my work has this as its 
> >>>>>>>> foundation) 
> >>>>>>>> 
> >>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution 
> >>>>>>>> Detect that the halt decider is invoked two times from the same 
> >>>>>>>> machine 
> >>>>>>>> address without any conditional branch instructions in the 
> >>>>>>>> execution 
> >>>>>>>> trace of H_Hat that would terminate this otherwise infinite 
> >>>>>>>> recursion. 
> >>>>>>>> 
> >>>>>>> 
> >>>>>>> I previously pointed out that there is a problem with your "without 
> >>>>>>> any conditional branch instructions in the execution trace of H_Hat 
> >>>>>>> that would terminate this otherwise infinite recursion". (I don't 
> >>>>>>> think you responded.) 
> >>>>>>> 
> >>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise 
> >>>>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as 
> >>>>>>> you've 
> >>>>>>> previously described.) So your ABNHBD() is detecting non-halting 
> >>>>>>> behaviour incorrectly, according to your own description of what it 
> >>>>>>> does. 
> >>>>>> 
> >>>>>> No. Not at all. Not in the least. 
> >>>>> Dorky 
> >>>>>> 
> >>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I); 
> >>>>>> Only terminates inputs that would not otherwise terminate on their 
> >>>>>> own. 
> >>>>>> 
> >>>>>> Two examples of such inputs that would not terminate on their own: 
> >>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H); 
> >>>>>> 
> >>>>>> Unless the above function terminates its inputs they would never 
> >>>>>> otherwise terminate. 
> >>>>>> 
> >>>>> 
> >>>>> You are totally confusing different versions of the program whose 
> >>>>> calculations are being decided! 
> >>>>> 
> >>>>> 
> >>>>> H_Hat is ONE FIXED program. *It's source code can't change!* To help 
> >>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and 
> >>>>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1. 
> >>>> 
> >>>> 
> >>>> void H_Hat(u32 P) 
> >>>> { 
> >>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P)) 
> >>>> MOV_EAX_1 // Execution of P(P) has been aborted 
> >>>> else 
> >>>> { 
> >>>> MOV_EAX_0 // P(P) has halted 
> >>>> HERE: goto HERE; 
> >>>> } 
> >>>> HALT 
> >>>> } 
> >>>> 
> >>>> 
> >>>> void H(u32 P, u32 I) 
> >>>> { 
> >>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I)) 
> >>>> MOV_EAX_1 // Execution of P(I) has been aborted 
> >>>> else 
> >>>> MOV_EAX_0 // P(I) has halted 
> >>>> HALT 
> >>>> } 
> >>>> 
> >>>> 
> >>>> 01 int main() 
> >>>> 02 { 
> >>>> 03 u32 P = (u32)H_Hat; 
> >>>> 04 H(P, P); // MOV_EAX_0 
> >>>> 05 H_Hat(P); // MOV_EAX_0 
> >>>> 06 HALT 
> >>>> 06 } 
> >>>> 
> >>>> 
> >>>> The invocation on line 04 specifies two different process contexts of 
> >>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I). 
> >>>> 
> >>>> The invocation on line 05 specifies three different process contexts of 
> >>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I). 
> >>>> 
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) 
> >>>> The above function really does Stop executing and Accepts any and all 
> >>>> non-halting inputs and Rejects any and all halting inputs. 
> >>> 
> >>> No it doesn't. 
> >>> 
> >>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input. So 
> >>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is 
> >>> non-halting. In HP and Linz world, non-halting means the 
> >>> corresponding calculation H_Hat(H_Hat) doesn't halt. 
> >> 
> >> H_Hat(H_Hat) would never ever halt unless and until 
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >> stops executing its input which is the same input to H_Hat above. 
> >> 
> > 
> > Your claim that was under discussion is 
> > 
> > PO: 
> > "The above function really does Stop executing and Accepts 
> > any and all non-halting inputs and Rejects any and all 
> > halting inputs." 
> > 
> > The meaning of "halting inputs" and "non-halting inputs" are fixed by 
> > the statement of HP, and by the Linz proof, so the meaning of what you 
> > said was similarly clear. I commented that you were wrong and gave the 
> > reason.
> Yes and you broke the rules. 
> When I claim that every citizen of the USA pays taxes a guy in Russia 
> that is not a citizen of the USA is not a valid counter-example. 
> 
> The H_Hat() on line 05 of main() is not an input to 
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> thus tossed out on its ass as an invalid counter-example to this claim:
> 
You really don't get it.

In Linz's proof, H(H_Hat, H_Hat) and H_Hat(H_Hat) have to be consistent.
So if H(H_Hat, H_Hat) returns "halts" H_Hat(H_Hat) must halt, if it 
returns "Non_Halting" H_Hat(H_Hat) must run forever.

So you have to produce two programs or functions, showing this consistency.

 

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


#24753 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-31 17:09 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<gK-dnUIEZa47fQDCnZ2dnUU7-LfNnZ2d@giganews.com>
In reply to#24752
On 10/31/2020 4:55 PM, Malcolm McLean wrote:
> On Saturday, 31 October 2020 at 21:07:28 UTC, olcott wrote:
>> On 10/31/2020 3:49 PM, Mike Terry wrote:
>>> On 31/10/2020 17:56, olcott wrote:
>>>> On 10/31/2020 11:28 AM, Mike Terry wrote:
>>>>> On 31/10/2020 04:40, olcott wrote:
>>>>>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>>>>>> On 30/10/2020 22:21, olcott wrote:
>>>>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>
>>> [... snip ...]
>>>>>>>>>> This is the key aspect of the execution trace that forms the
>>>>>>>>>> basis for
>>>>>>>>>> deciding H_Hat: (All two years of my work has this as its
>>>>>>>>>> foundation)
>>>>>>>>>>
>>>>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>>>>>> machine
>>>>>>>>>> address without any conditional branch instructions in the
>>>>>>>>>> execution
>>>>>>>>>> trace of H_Hat that would terminate this otherwise infinite
>>>>>>>>>> recursion.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I previously pointed out that there is a problem with your "without
>>>>>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>>>>>> that would terminate this otherwise infinite recursion". (I don't
>>>>>>>>> think you responded.)
>>>>>>>>>
>>>>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>>>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as
>>>>>>>>> you've
>>>>>>>>> previously described.) So your ABNHBD() is detecting non-halting
>>>>>>>>> behaviour incorrectly, according to your own description of what it
>>>>>>>>> does.
>>>>>>>>
>>>>>>>> No. Not at all. Not in the least.
>>>>>>> Dorky
>>>>>>>>
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>>>>>> Only terminates inputs that would not otherwise terminate on their
>>>>>>>> own.
>>>>>>>>
>>>>>>>> Two examples of such inputs that would not terminate on their own:
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>>>>>
>>>>>>>> Unless the above function terminates its inputs they would never
>>>>>>>> otherwise terminate.
>>>>>>>>
>>>>>>>
>>>>>>> You are totally confusing different versions of the program whose
>>>>>>> calculations are being decided!
>>>>>>>
>>>>>>>
>>>>>>> H_Hat is ONE FIXED program. *It's source code can't change!* To help
>>>>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>>>>>>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1.
>>>>>>
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>>>> MOV_EAX_1 // Execution of P(P) has been aborted
>>>>>> else
>>>>>> {
>>>>>> MOV_EAX_0 // P(P) has halted
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>>
>>>>>> void H(u32 P, u32 I)
>>>>>> {
>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>>>>> MOV_EAX_1 // Execution of P(I) has been aborted
>>>>>> else
>>>>>> MOV_EAX_0 // P(I) has halted
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>>
>>>>>> 01 int main()
>>>>>> 02 {
>>>>>> 03 u32 P = (u32)H_Hat;
>>>>>> 04 H(P, P); // MOV_EAX_0
>>>>>> 05 H_Hat(P); // MOV_EAX_0
>>>>>> 06 HALT
>>>>>> 06 }
>>>>>>
>>>>>>
>>>>>> The invocation on line 04 specifies two different process contexts of
>>>>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>>>
>>>>>> The invocation on line 05 specifies three different process contexts of
>>>>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>>>
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>> The above function really does Stop executing and Accepts any and all
>>>>>> non-halting inputs and Rejects any and all halting inputs.
>>>>>
>>>>> No it doesn't.
>>>>>
>>>>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input. So
>>>>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is
>>>>> non-halting. In HP and Linz world, non-halting means the
>>>>> corresponding calculation H_Hat(H_Hat) doesn't halt.
>>>>
>>>> H_Hat(H_Hat) would never ever halt unless and until
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> stops executing its input which is the same input to H_Hat above.
>>>>
>>>
>>> Your claim that was under discussion is
>>>
>>> PO:
>>> "The above function really does Stop executing and Accepts
>>> any and all non-halting inputs and Rejects any and all
>>> halting inputs."
>>>
>>> The meaning of "halting inputs" and "non-halting inputs" are fixed by
>>> the statement of HP, and by the Linz proof, so the meaning of what you
>>> said was similarly clear. I commented that you were wrong and gave the
>>> reason.
>> Yes and you broke the rules.
>> When I claim that every citizen of the USA pays taxes a guy in Russia
>> that is not a citizen of the USA is not a valid counter-example.
>>
>> The H_Hat() on line 05 of main() is not an input to
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> thus tossed out on its ass as an invalid counter-example to this claim:
>>
> You really don't get it.
> 
> In Linz's proof, H(H_Hat, H_Hat) and H_Hat(H_Hat) have to be consistent.
> So if H(H_Hat, H_Hat) returns "halts" H_Hat(H_Hat) must halt, if it
> returns "Non_Halting" H_Hat(H_Hat) must run forever.
> 
> So you have to produce two programs or functions, showing this consistency.

All of the conventional halting problem proofs framed the problem in 
such a way that it cannot be solved the way that they framed it.

When we reframe this problem this way the halting problem ceases to be 
undecidable:

bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
Stops executing and Accepts any and all non-halting inputs and Rejects 
any and all halting inputs as soon as they halt.

If no inputs exist that it fails to decide correctly then this is 
complete proof that the above definition is an actual halt decider.



-- 
Copyright 2020 Pete Olcott

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

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


#24754 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-10-31 15:22 -0700
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<dc7510a6-4b04-40ab-bbc7-4de2f1eaead0n@googlegroups.com>
In reply to#24753
On Saturday, 31 October 2020 at 22:09:50 UTC, olcott wrote:
> On 10/31/2020 4:55 PM, Malcolm McLean wrote: 
> > On Saturday, 31 October 2020 at 21:07:28 UTC, olcott wrote: 
> >> On 10/31/2020 3:49 PM, Mike Terry wrote: 
> >>> On 31/10/2020 17:56, olcott wrote: 
> >>>> On 10/31/2020 11:28 AM, Mike Terry wrote: 
> >>>>> On 31/10/2020 04:40, olcott wrote: 
> >>>>>> On 10/30/2020 7:46 PM, Mike Terry wrote: 
> >>>>>>> On 30/10/2020 22:21, olcott wrote: 
> >>>>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote: 
> >>>>>>>>> On 30/10/2020 11:40, olcott wrote: 
> >>>>>>>>>> On 10/30/2020 6:32 AM, olcott wrote: 
> >>> 
> >>> [... snip ...] 
> >>>>>>>>>> This is the key aspect of the execution trace that forms the 
> >>>>>>>>>> basis for 
> >>>>>>>>>> deciding H_Hat: (All two years of my work has this as its 
> >>>>>>>>>> foundation) 
> >>>>>>>>>> 
> >>>>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution 
> >>>>>>>>>> Detect that the halt decider is invoked two times from the same 
> >>>>>>>>>> machine 
> >>>>>>>>>> address without any conditional branch instructions in the 
> >>>>>>>>>> execution 
> >>>>>>>>>> trace of H_Hat that would terminate this otherwise infinite 
> >>>>>>>>>> recursion. 
> >>>>>>>>>> 
> >>>>>>>>> 
> >>>>>>>>> I previously pointed out that there is a problem with your "without 
> >>>>>>>>> any conditional branch instructions in the execution trace of H_Hat 
> >>>>>>>>> that would terminate this otherwise infinite recursion". (I don't 
> >>>>>>>>> think you responded.) 
> >>>>>>>>> 
> >>>>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise 
> >>>>>>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as 
> >>>>>>>>> you've 
> >>>>>>>>> previously described.) So your ABNHBD() is detecting non-halting 
> >>>>>>>>> behaviour incorrectly, according to your own description of what it 
> >>>>>>>>> does. 
> >>>>>>>> 
> >>>>>>>> No. Not at all. Not in the least. 
> >>>>>>> Dorky 
> >>>>>>>> 
> >>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I); 
> >>>>>>>> Only terminates inputs that would not otherwise terminate on their 
> >>>>>>>> own. 
> >>>>>>>> 
> >>>>>>>> Two examples of such inputs that would not terminate on their own: 
> >>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H); 
> >>>>>>>> 
> >>>>>>>> Unless the above function terminates its inputs they would never 
> >>>>>>>> otherwise terminate. 
> >>>>>>>> 
> >>>>>>> 
> >>>>>>> You are totally confusing different versions of the program whose 
> >>>>>>> calculations are being decided! 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> H_Hat is ONE FIXED program. *It's source code can't change!* To help 
> >>>>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and 
> >>>>>>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1. 
> >>>>>> 
> >>>>>> 
> >>>>>> void H_Hat(u32 P) 
> >>>>>> { 
> >>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P)) 
> >>>>>> MOV_EAX_1 // Execution of P(P) has been aborted 
> >>>>>> else 
> >>>>>> { 
> >>>>>> MOV_EAX_0 // P(P) has halted 
> >>>>>> HERE: goto HERE; 
> >>>>>> } 
> >>>>>> HALT 
> >>>>>> } 
> >>>>>> 
> >>>>>> 
> >>>>>> void H(u32 P, u32 I) 
> >>>>>> { 
> >>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I)) 
> >>>>>> MOV_EAX_1 // Execution of P(I) has been aborted 
> >>>>>> else 
> >>>>>> MOV_EAX_0 // P(I) has halted 
> >>>>>> HALT 
> >>>>>> } 
> >>>>>> 
> >>>>>> 
> >>>>>> 01 int main() 
> >>>>>> 02 { 
> >>>>>> 03 u32 P = (u32)H_Hat; 
> >>>>>> 04 H(P, P); // MOV_EAX_0 
> >>>>>> 05 H_Hat(P); // MOV_EAX_0 
> >>>>>> 06 HALT 
> >>>>>> 06 } 
> >>>>>> 
> >>>>>> 
> >>>>>> The invocation on line 04 specifies two different process contexts of 
> >>>>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I). 
> >>>>>> 
> >>>>>> The invocation on line 05 specifies three different process contexts of 
> >>>>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I). 
> >>>>>> 
> >>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) 
> >>>>>> The above function really does Stop executing and Accepts any and all 
> >>>>>> non-halting inputs and Rejects any and all halting inputs. 
> >>>>> 
> >>>>> No it doesn't. 
> >>>>> 
> >>>>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input. So 
> >>>>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is 
> >>>>> non-halting. In HP and Linz world, non-halting means the 
> >>>>> corresponding calculation H_Hat(H_Hat) doesn't halt. 
> >>>> 
> >>>> H_Hat(H_Hat) would never ever halt unless and until 
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>> stops executing its input which is the same input to H_Hat above. 
> >>>> 
> >>> 
> >>> Your claim that was under discussion is 
> >>> 
> >>> PO: 
> >>> "The above function really does Stop executing and Accepts 
> >>> any and all non-halting inputs and Rejects any and all 
> >>> halting inputs." 
> >>> 
> >>> The meaning of "halting inputs" and "non-halting inputs" are fixed by 
> >>> the statement of HP, and by the Linz proof, so the meaning of what you 
> >>> said was similarly clear. I commented that you were wrong and gave the 
> >>> reason. 
> >> Yes and you broke the rules. 
> >> When I claim that every citizen of the USA pays taxes a guy in Russia 
> >> that is not a citizen of the USA is not a valid counter-example. 
> >> 
> >> The H_Hat() on line 05 of main() is not an input to 
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >> thus tossed out on its ass as an invalid counter-example to this claim: 
> >> 
> > You really don't get it. 
> > 
> > In Linz's proof, H(H_Hat, H_Hat) and H_Hat(H_Hat) have to be consistent. 
> > So if H(H_Hat, H_Hat) returns "halts" H_Hat(H_Hat) must halt, if it 
> > returns "Non_Halting" H_Hat(H_Hat) must run forever. 
> > 
> > So you have to produce two programs or functions, showing this consistency.
> All of the conventional halting problem proofs framed the problem in 
> such a way that it cannot be solved the way that they framed it. 
> 
> When we reframe this problem this way the halting problem ceases to be 
> undecidable:
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I); 
> Stops executing and Accepts any and all non-halting inputs and Rejects 
> any and all halting inputs as soon as they halt.
> If no inputs exist that it fails to decide correctly then this is 
> complete proof that the above definition is an actual halt decider.
> 
So how do you know if it has decided an input correctly?

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


#24757 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-31 17:30 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<oKadnT3q3c3reADCnZ2dnUU7-KfNnZ2d@giganews.com>
In reply to#24754
On 10/31/2020 5:22 PM, Malcolm McLean wrote:
> On Saturday, 31 October 2020 at 22:09:50 UTC, olcott wrote:
>> On 10/31/2020 4:55 PM, Malcolm McLean wrote:
>>> On Saturday, 31 October 2020 at 21:07:28 UTC, olcott wrote:
>>>> On 10/31/2020 3:49 PM, Mike Terry wrote:
>>>>> On 31/10/2020 17:56, olcott wrote:
>>>>>> On 10/31/2020 11:28 AM, Mike Terry wrote:
>>>>>>> On 31/10/2020 04:40, olcott wrote:
>>>>>>>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>>>>>>>> On 30/10/2020 22:21, olcott wrote:
>>>>>>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>>>>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>>>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>
>>>>> [... snip ...]
>>>>>>>>>>>> This is the key aspect of the execution trace that forms the
>>>>>>>>>>>> basis for
>>>>>>>>>>>> deciding H_Hat: (All two years of my work has this as its
>>>>>>>>>>>> foundation)
>>>>>>>>>>>>
>>>>>>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>>>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>>>>>>>> machine
>>>>>>>>>>>> address without any conditional branch instructions in the
>>>>>>>>>>>> execution
>>>>>>>>>>>> trace of H_Hat that would terminate this otherwise infinite
>>>>>>>>>>>> recursion.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I previously pointed out that there is a problem with your "without
>>>>>>>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>>>>>>>> that would terminate this otherwise infinite recursion". (I don't
>>>>>>>>>>> think you responded.)
>>>>>>>>>>>
>>>>>>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>>>>>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as
>>>>>>>>>>> you've
>>>>>>>>>>> previously described.) So your ABNHBD() is detecting non-halting
>>>>>>>>>>> behaviour incorrectly, according to your own description of what it
>>>>>>>>>>> does.
>>>>>>>>>>
>>>>>>>>>> No. Not at all. Not in the least.
>>>>>>>>> Dorky
>>>>>>>>>>
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>>>>>>>> Only terminates inputs that would not otherwise terminate on their
>>>>>>>>>> own.
>>>>>>>>>>
>>>>>>>>>> Two examples of such inputs that would not terminate on their own:
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>>>>>>>
>>>>>>>>>> Unless the above function terminates its inputs they would never
>>>>>>>>>> otherwise terminate.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are totally confusing different versions of the program whose
>>>>>>>>> calculations are being decided!
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H_Hat is ONE FIXED program. *It's source code can't change!* To help
>>>>>>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>>>>>>>>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1.
>>>>>>>>
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>>>>>> MOV_EAX_1 // Execution of P(P) has been aborted
>>>>>>>> else
>>>>>>>> {
>>>>>>>> MOV_EAX_0 // P(P) has halted
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>> HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> void H(u32 P, u32 I)
>>>>>>>> {
>>>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>>>>>>> MOV_EAX_1 // Execution of P(I) has been aborted
>>>>>>>> else
>>>>>>>> MOV_EAX_0 // P(I) has halted
>>>>>>>> HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> 01 int main()
>>>>>>>> 02 {
>>>>>>>> 03 u32 P = (u32)H_Hat;
>>>>>>>> 04 H(P, P); // MOV_EAX_0
>>>>>>>> 05 H_Hat(P); // MOV_EAX_0
>>>>>>>> 06 HALT
>>>>>>>> 06 }
>>>>>>>>
>>>>>>>>
>>>>>>>> The invocation on line 04 specifies two different process contexts of
>>>>>>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>>>>>
>>>>>>>> The invocation on line 05 specifies three different process contexts of
>>>>>>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>>>>>
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>> The above function really does Stop executing and Accepts any and all
>>>>>>>> non-halting inputs and Rejects any and all halting inputs.
>>>>>>>
>>>>>>> No it doesn't.
>>>>>>>
>>>>>>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input. So
>>>>>>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is
>>>>>>> non-halting. In HP and Linz world, non-halting means the
>>>>>>> corresponding calculation H_Hat(H_Hat) doesn't halt.
>>>>>>
>>>>>> H_Hat(H_Hat) would never ever halt unless and until
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>> stops executing its input which is the same input to H_Hat above.
>>>>>>
>>>>>
>>>>> Your claim that was under discussion is
>>>>>
>>>>> PO:
>>>>> "The above function really does Stop executing and Accepts
>>>>> any and all non-halting inputs and Rejects any and all
>>>>> halting inputs."
>>>>>
>>>>> The meaning of "halting inputs" and "non-halting inputs" are fixed by
>>>>> the statement of HP, and by the Linz proof, so the meaning of what you
>>>>> said was similarly clear. I commented that you were wrong and gave the
>>>>> reason.
>>>> Yes and you broke the rules.
>>>> When I claim that every citizen of the USA pays taxes a guy in Russia
>>>> that is not a citizen of the USA is not a valid counter-example.
>>>>
>>>> The H_Hat() on line 05 of main() is not an input to
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> thus tossed out on its ass as an invalid counter-example to this claim:
>>>>
>>> You really don't get it.
>>>
>>> In Linz's proof, H(H_Hat, H_Hat) and H_Hat(H_Hat) have to be consistent.
>>> So if H(H_Hat, H_Hat) returns "halts" H_Hat(H_Hat) must halt, if it
>>> returns "Non_Halting" H_Hat(H_Hat) must run forever.
>>>
>>> So you have to produce two programs or functions, showing this consistency.
>> All of the conventional halting problem proofs framed the problem in
>> such a way that it cannot be solved the way that they framed it.
>>
>> When we reframe this problem this way the halting problem ceases to be
>> undecidable:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>> Stops executing and Accepts any and all non-halting inputs and Rejects
>> any and all halting inputs as soon as they halt.
>> If no inputs exist that it fails to decide correctly then this is
>> complete proof that the above definition is an actual halt decider.
>>
> So how do you know if it has decided an input correctly?
> 

In the case of the Peter Linz H/Ĥ I worked out that the execution trace 
had to be "Aborted Because Non-Halting Behavior Detected" was true
on 2018-12-13 @ 7:00 PM .

It was true for the reason that I first pointed out in this group three 
years ago:

[Infinitely Recursive input on HP Proofs]
https://groups.google.com/forum/#!msg/comp.theory/NcFS02hKs1U/PlBF-1LRBAAJ


-- 
Copyright 2020 Pete Olcott

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

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


#24762 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-10-31 16:00 -0700
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<96267629-cdc2-45ee-bfd7-77a378a1bb70n@googlegroups.com>
In reply to#24757
On Saturday, 31 October 2020 at 22:30:22 UTC, olcott wrote:
> On 10/31/2020 5:22 PM, Malcolm McLean wrote: 
> > On Saturday, 31 October 2020 at 22:09:50 UTC, olcott wrote: 
> >> On 10/31/2020 4:55 PM, Malcolm McLean wrote: 
> >>> On Saturday, 31 October 2020 at 21:07:28 UTC, olcott wrote: 
> >>>> On 10/31/2020 3:49 PM, Mike Terry wrote: 
> >>>>> On 31/10/2020 17:56, olcott wrote: 
> >>>>>> On 10/31/2020 11:28 AM, Mike Terry wrote: 
> >>>>>>> On 31/10/2020 04:40, olcott wrote: 
> >>>>>>>> On 10/30/2020 7:46 PM, Mike Terry wrote: 
> >>>>>>>>> On 30/10/2020 22:21, olcott wrote: 
> >>>>>>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote: 
> >>>>>>>>>>> On 30/10/2020 11:40, olcott wrote: 
> >>>>>>>>>>>> On 10/30/2020 6:32 AM, olcott wrote: 
> >>>>> 
> >>>>> [... snip ...] 
> >>>>>>>>>>>> This is the key aspect of the execution trace that forms the 
> >>>>>>>>>>>> basis for 
> >>>>>>>>>>>> deciding H_Hat: (All two years of my work has this as its 
> >>>>>>>>>>>> foundation) 
> >>>>>>>>>>>> 
> >>>>>>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution 
> >>>>>>>>>>>> Detect that the halt decider is invoked two times from the same 
> >>>>>>>>>>>> machine 
> >>>>>>>>>>>> address without any conditional branch instructions in the 
> >>>>>>>>>>>> execution 
> >>>>>>>>>>>> trace of H_Hat that would terminate this otherwise infinite 
> >>>>>>>>>>>> recursion. 
> >>>>>>>>>>>> 
> >>>>>>>>>>> 
> >>>>>>>>>>> I previously pointed out that there is a problem with your "without 
> >>>>>>>>>>> any conditional branch instructions in the execution trace of H_Hat 
> >>>>>>>>>>> that would terminate this otherwise infinite recursion". (I don't 
> >>>>>>>>>>> think you responded.) 
> >>>>>>>>>>> 
> >>>>>>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise 
> >>>>>>>>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as 
> >>>>>>>>>>> you've 
> >>>>>>>>>>> previously described.) So your ABNHBD() is detecting non-halting 
> >>>>>>>>>>> behaviour incorrectly, according to your own description of what it 
> >>>>>>>>>>> does. 
> >>>>>>>>>> 
> >>>>>>>>>> No. Not at all. Not in the least. 
> >>>>>>>>> Dorky 
> >>>>>>>>>> 
> >>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I); 
> >>>>>>>>>> Only terminates inputs that would not otherwise terminate on their 
> >>>>>>>>>> own. 
> >>>>>>>>>> 
> >>>>>>>>>> Two examples of such inputs that would not terminate on their own: 
> >>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H); 
> >>>>>>>>>> 
> >>>>>>>>>> Unless the above function terminates its inputs they would never 
> >>>>>>>>>> otherwise terminate. 
> >>>>>>>>>> 
> >>>>>>>>> 
> >>>>>>>>> You are totally confusing different versions of the program whose 
> >>>>>>>>> calculations are being decided! 
> >>>>>>>>> 
> >>>>>>>>> 
> >>>>>>>>> H_Hat is ONE FIXED program. *It's source code can't change!* To help 
> >>>>>>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and 
> >>>>>>>>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1. 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> void H_Hat(u32 P) 
> >>>>>>>> { 
> >>>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P)) 
> >>>>>>>> MOV_EAX_1 // Execution of P(P) has been aborted 
> >>>>>>>> else 
> >>>>>>>> { 
> >>>>>>>> MOV_EAX_0 // P(P) has halted 
> >>>>>>>> HERE: goto HERE; 
> >>>>>>>> } 
> >>>>>>>> HALT 
> >>>>>>>> } 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> void H(u32 P, u32 I) 
> >>>>>>>> { 
> >>>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I)) 
> >>>>>>>> MOV_EAX_1 // Execution of P(I) has been aborted 
> >>>>>>>> else 
> >>>>>>>> MOV_EAX_0 // P(I) has halted 
> >>>>>>>> HALT 
> >>>>>>>> } 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> 01 int main() 
> >>>>>>>> 02 { 
> >>>>>>>> 03 u32 P = (u32)H_Hat; 
> >>>>>>>> 04 H(P, P); // MOV_EAX_0 
> >>>>>>>> 05 H_Hat(P); // MOV_EAX_0 
> >>>>>>>> 06 HALT 
> >>>>>>>> 06 } 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> The invocation on line 04 specifies two different process contexts of 
> >>>>>>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I). 
> >>>>>>>> 
> >>>>>>>> The invocation on line 05 specifies three different process contexts of 
> >>>>>>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I). 
> >>>>>>>> 
> >>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) 
> >>>>>>>> The above function really does Stop executing and Accepts any and all 
> >>>>>>>> non-halting inputs and Rejects any and all halting inputs. 
> >>>>>>> 
> >>>>>>> No it doesn't. 
> >>>>>>> 
> >>>>>>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input. So 
> >>>>>>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is 
> >>>>>>> non-halting. In HP and Linz world, non-halting means the 
> >>>>>>> corresponding calculation H_Hat(H_Hat) doesn't halt. 
> >>>>>> 
> >>>>>> H_Hat(H_Hat) would never ever halt unless and until 
> >>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>>>> stops executing its input which is the same input to H_Hat above. 
> >>>>>> 
> >>>>> 
> >>>>> Your claim that was under discussion is 
> >>>>> 
> >>>>> PO: 
> >>>>> "The above function really does Stop executing and Accepts 
> >>>>> any and all non-halting inputs and Rejects any and all 
> >>>>> halting inputs." 
> >>>>> 
> >>>>> The meaning of "halting inputs" and "non-halting inputs" are fixed by 
> >>>>> the statement of HP, and by the Linz proof, so the meaning of what you 
> >>>>> said was similarly clear. I commented that you were wrong and gave the 
> >>>>> reason. 
> >>>> Yes and you broke the rules. 
> >>>> When I claim that every citizen of the USA pays taxes a guy in Russia 
> >>>> that is not a citizen of the USA is not a valid counter-example. 
> >>>> 
> >>>> The H_Hat() on line 05 of main() is not an input to 
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); 
> >>>> thus tossed out on its ass as an invalid counter-example to this claim: 
> >>>> 
> >>> You really don't get it. 
> >>> 
> >>> In Linz's proof, H(H_Hat, H_Hat) and H_Hat(H_Hat) have to be consistent. 
> >>> So if H(H_Hat, H_Hat) returns "halts" H_Hat(H_Hat) must halt, if it 
> >>> returns "Non_Halting" H_Hat(H_Hat) must run forever. 
> >>> 
> >>> So you have to produce two programs or functions, showing this consistency. 
> >> All of the conventional halting problem proofs framed the problem in 
> >> such a way that it cannot be solved the way that they framed it. 
> >> 
> >> When we reframe this problem this way the halting problem ceases to be 
> >> undecidable: 
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I); 
> >> Stops executing and Accepts any and all non-halting inputs and Rejects 
> >> any and all halting inputs as soon as they halt. 
> >> If no inputs exist that it fails to decide correctly then this is 
> >> complete proof that the above definition is an actual halt decider. 
> >> 
> > So how do you know if it has decided an input correctly? 
> >
> In the case of the Peter Linz H/Ĥ I worked out that the execution trace 
> had to be "Aborted Because Non-Halting Behavior Detected" was true 
> on 2018-12-13 @ 7:00 PM . 
> 
> It was true for the reason that I first pointed out in this group three 
> years ago: 
> 
> [Infinitely Recursive input on HP Proofs] 
> https://groups.google.com/forum/#!msg/comp.theory/NcFS02hKs1U/PlBF-1LRBAAJ
> 
Ah, so you require test programs to be run with the execution
trace apparatus, as provided by you?

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


#24763 — Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-31 18:13 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ]
Message-ID<NqCdncVpw6kycgDCnZ2dnUU7-QnNnZ2d@giganews.com>
In reply to#24762
On 10/31/2020 6:00 PM, Malcolm McLean wrote:
> On Saturday, 31 October 2020 at 22:30:22 UTC, olcott wrote:
>> On 10/31/2020 5:22 PM, Malcolm McLean wrote:
>>> On Saturday, 31 October 2020 at 22:09:50 UTC, olcott wrote:
>>>> On 10/31/2020 4:55 PM, Malcolm McLean wrote:
>>>>> On Saturday, 31 October 2020 at 21:07:28 UTC, olcott wrote:
>>>>>> On 10/31/2020 3:49 PM, Mike Terry wrote:
>>>>>>> On 31/10/2020 17:56, olcott wrote:
>>>>>>>> On 10/31/2020 11:28 AM, Mike Terry wrote:
>>>>>>>>> On 31/10/2020 04:40, olcott wrote:
>>>>>>>>>> On 10/30/2020 7:46 PM, Mike Terry wrote:
>>>>>>>>>>> On 30/10/2020 22:21, olcott wrote:
>>>>>>>>>>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>>>>>>>>>>> On 30/10/2020 11:40, olcott wrote:
>>>>>>>>>>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>>>
>>>>>>> [... snip ...]
>>>>>>>>>>>>>> This is the key aspect of the execution trace that forms the
>>>>>>>>>>>>>> basis for
>>>>>>>>>>>>>> deciding H_Hat: (All two years of my work has this as its
>>>>>>>>>>>>>> foundation)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>>>>>>>>>>> Detect that the halt decider is invoked two times from the same
>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>> address without any conditional branch instructions in the
>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>> trace of H_Hat that would terminate this otherwise infinite
>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I previously pointed out that there is a problem with your "without
>>>>>>>>>>>>> any conditional branch instructions in the execution trace of H_Hat
>>>>>>>>>>>>> that would terminate this otherwise infinite recursion". (I don't
>>>>>>>>>>>>> think you responded.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>>>>>>>>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as
>>>>>>>>>>>>> you've
>>>>>>>>>>>>> previously described.) So your ABNHBD() is detecting non-halting
>>>>>>>>>>>>> behaviour incorrectly, according to your own description of what it
>>>>>>>>>>>>> does.
>>>>>>>>>>>>
>>>>>>>>>>>> No. Not at all. Not in the least.
>>>>>>>>>>> Dorky
>>>>>>>>>>>>
>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>>>>>>>>>>> Only terminates inputs that would not otherwise terminate on their
>>>>>>>>>>>> own.
>>>>>>>>>>>>
>>>>>>>>>>>> Two examples of such inputs that would not terminate on their own:
>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>>>>>>>>>>
>>>>>>>>>>>> Unless the above function terminates its inputs they would never
>>>>>>>>>>>> otherwise terminate.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You are totally confusing different versions of the program whose
>>>>>>>>>>> calculations are being decided!
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H_Hat is ONE FIXED program. *It's source code can't change!* To help
>>>>>>>>>>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>>>>>>>>>>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>> {
>>>>>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>>>>>>>> MOV_EAX_1 // Execution of P(P) has been aborted
>>>>>>>>>> else
>>>>>>>>>> {
>>>>>>>>>> MOV_EAX_0 // P(P) has halted
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>> HALT
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void H(u32 P, u32 I)
>>>>>>>>>> {
>>>>>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>>>>>>>>> MOV_EAX_1 // Execution of P(I) has been aborted
>>>>>>>>>> else
>>>>>>>>>> MOV_EAX_0 // P(I) has halted
>>>>>>>>>> HALT
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 01 int main()
>>>>>>>>>> 02 {
>>>>>>>>>> 03 u32 P = (u32)H_Hat;
>>>>>>>>>> 04 H(P, P); // MOV_EAX_0
>>>>>>>>>> 05 H_Hat(P); // MOV_EAX_0
>>>>>>>>>> 06 HALT
>>>>>>>>>> 06 }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The invocation on line 04 specifies two different process contexts of
>>>>>>>>>> H_Hat() and Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>>>>>>>
>>>>>>>>>> The invocation on line 05 specifies three different process contexts of
>>>>>>>>>> H_Hat() and two of Aborted_Because_Non_Halting_Behavior_Detected(P, I).
>>>>>>>>>>
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>> The above function really does Stop executing and Accepts any and all
>>>>>>>>>> non-halting inputs and Rejects any and all halting inputs.
>>>>>>>>>
>>>>>>>>> No it doesn't.
>>>>>>>>>
>>>>>>>>> You have said elsewhere that ABNHBD accepts (H_Hat,H_Hat) input. So
>>>>>>>>> your previous paragraph would imply ABNHBD decides (H_Hat,H_Hat) is
>>>>>>>>> non-halting. In HP and Linz world, non-halting means the
>>>>>>>>> corresponding calculation H_Hat(H_Hat) doesn't halt.
>>>>>>>>
>>>>>>>> H_Hat(H_Hat) would never ever halt unless and until
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>>>> stops executing its input which is the same input to H_Hat above.
>>>>>>>>
>>>>>>>
>>>>>>> Your claim that was under discussion is
>>>>>>>
>>>>>>> PO:
>>>>>>> "The above function really does Stop executing and Accepts
>>>>>>> any and all non-halting inputs and Rejects any and all
>>>>>>> halting inputs."
>>>>>>>
>>>>>>> The meaning of "halting inputs" and "non-halting inputs" are fixed by
>>>>>>> the statement of HP, and by the Linz proof, so the meaning of what you
>>>>>>> said was similarly clear. I commented that you were wrong and gave the
>>>>>>> reason.
>>>>>> Yes and you broke the rules.
>>>>>> When I claim that every citizen of the USA pays taxes a guy in Russia
>>>>>> that is not a citizen of the USA is not a valid counter-example.
>>>>>>
>>>>>> The H_Hat() on line 05 of main() is not an input to
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>>>> thus tossed out on its ass as an invalid counter-example to this claim:
>>>>>>
>>>>> You really don't get it.
>>>>>
>>>>> In Linz's proof, H(H_Hat, H_Hat) and H_Hat(H_Hat) have to be consistent.
>>>>> So if H(H_Hat, H_Hat) returns "halts" H_Hat(H_Hat) must halt, if it
>>>>> returns "Non_Halting" H_Hat(H_Hat) must run forever.
>>>>>
>>>>> So you have to produce two programs or functions, showing this consistency.
>>>> All of the conventional halting problem proofs framed the problem in
>>>> such a way that it cannot be solved the way that they framed it.
>>>>
>>>> When we reframe this problem this way the halting problem ceases to be
>>>> undecidable:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>> Stops executing and Accepts any and all non-halting inputs and Rejects
>>>> any and all halting inputs as soon as they halt.
>>>> If no inputs exist that it fails to decide correctly then this is
>>>> complete proof that the above definition is an actual halt decider.
>>>>
>>> So how do you know if it has decided an input correctly?
>>>
>> In the case of the Peter Linz H/Ĥ I worked out that the execution trace
>> had to be "Aborted Because Non-Halting Behavior Detected" was true
>> on 2018-12-13 @ 7:00 PM .
>>
>> It was true for the reason that I first pointed out in this group three
>> years ago:
>>
>> [Infinitely Recursive input on HP Proofs]
>> https://groups.google.com/forum/#!msg/comp.theory/NcFS02hKs1U/PlBF-1LRBAAJ
>>
> Ah, so you require test programs to be run with the execution
> trace apparatus, as provided by you?
> 

A halt decider must make its decision on the basis of actual input.

One way that a halt decider can be defined that cannot be circumvented 
by tricks is to have the halt decider UTM execute its subordinate TM/UTM 
input one state transition at a time until it detects any kind of non 
terminating behavior. Then the first thing that it does to indicate its 
decision is it stops executing its input TM/UTM.

ALL the halting problem proofs use the trick of having the input program
DO THE OPPOSITE OF WHATEVER THE HALT DECIDER DECIDES

It is obvious that the above defined halt decider is not effected by 
this trick. No input program can possibly
DO THE OPPOSITE OF WHATEVER THE HALT DECIDER DECIDES
If its execution has already been terminated.


-- 
Copyright 2020 Pete Olcott

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

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


Page 10 of 25 — ← Prev page 1 … 8 9 [10] 11 12 … 25  Next page →

Back to top | Article view | comp.theory


csiph-web