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


Groups > comp.lang.c > #155812 > 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-11-06 20:34 -0800
Articles 20 on this page of 256 — 15 participants

Back to article view | Back to comp.lang.c


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 ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-20 14:26 -0700
          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:41 +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 ] 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 ] 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 ] 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 ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:21 -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: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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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) [ 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 ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 03:28 -0700
                                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 ] 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 ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 08:07 -0700
                                      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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:09 -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-22 21: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-22 23:31 -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 20:36 -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 22:18 -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-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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 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 ] 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 ] 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 ] 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 ] 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 ] olcott <NoOne@NoWhere.com> - 2020-10-27 14:44 -0500
                                                                                  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 ] 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 ] 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 ] 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 ] 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 ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:48 -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 13:57 -0600
                                            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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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-23 18:14 -0500
                                          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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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 ] olcott <NoOne@NoWhere.com> - 2020-10-25 10:33 -0500
                                                  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] olcott <NoOne@NoWhere.com> - 2020-10-25 16:07 -0500
                                                  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 ] 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 ] 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 ] 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 ] 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 ] 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-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 ] 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 ] 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 ] 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 ] 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 ] 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 ] 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-26 16:35 -0500
                                                                              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 ] 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 ] 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 ] 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 ] 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 ] 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 ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 03:18 -0700
                                              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 ] 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-24 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 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 ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 01:07 -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:07 -0500
                                      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 ] 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 ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 09:09 -0700
                                        Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11: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-22 20:41 +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 ] 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 ] 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 ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:40 -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-21 22:42 +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 16:56 -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:25 +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 23:26 +0100
                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 [ 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) [ 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
    Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] audating801@gmail.com - 2020-11-06 20:34 -0800

Page 12 of 13 — ← Prev page 1 … 10 11 [12] 13  Next page →


#156143 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-10-27 03:18 -0700
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<ecffb2b8-7ba9-44ac-aa6a-860325abed7an@googlegroups.com>
In reply to#156138
On Tuesday, 27 October 2020 at 03:38:31 UTC, olcott wrote:
> On 10/26/2020 9:48 PM, Mike Terry wrote:
> 
> > The REAL key thing is whether your H, H^ are correctly related (as in 
> > the Linz proof), and whether H correctly decides the halting for H^ 
> > running with input H^. THAT is what you've always said you were going 
> > to deliver. 
> 
> I have done that a bunch of times now. It is OK if what I said is too 
> complex to understand. I will write the actual code and then make its 
> execution trace only show the key decision points. 
> 
You don't need to. H or whatever we are calling it today is a function (nothing
to do with the C standard's misuse of the term). So we can replace it by
any equivalent code. In this case, we're only interested in what it does when
fed H_Hat, H_Hat. So we can stub it. We know that H_Hat, H_Hat will lead
to an infinite accumulation of DebugTraces if we DebugTrace it, so we 
detect that situation and abort.
  
the code is just
int eax =1; // set to 0 to indicate abort
H(M, N)
{
   if(M == H_Hat && N == H_Hat)
   {
        // would lead to infinite overflow if we didn't take action, so take it here.
        eax = 0;  // the calculation was aborted 
        return 0;
   }
}

H_Hat(M)
{
    if(H(M,M))
       while(1);
}

We then run H(H_Hat, H_Hat) and eax is 0, meaing non-halting behaviour was detected
and the operation was aborted because otherwise it would have looped forever.

We then run H_Hat(H_Hat) and eax is 0, meaning non-halting behaviour was detected
and the operation was aborted because otherwise it would have looped forever.

Anyone ought to be able to see that this is the case, and this will be the result.
I really don't see the problem some posters seem to have.

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


#156028 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-24 14:13 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<hN-dnaGefsIg4QnCnZ2dnUU7-N_NnZ2d@giganews.com>
In reply to#155997
On 10/24/2020 12:36 PM, Richard Damon wrote:
> On 10/24/20 11:36 AM, olcott wrote:
>>
>> I am refuting that the Linz proof proves that the halting problem is
>> undecidable by finding another way to define the halt decider that
>> cannot be contradicted.
> 
> That is like refute the fact that there is no highest prime number by
> redefining prime numbers (or maybe redefining the Natural Numbers that
> primes are part of).

Not at all.

Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
means that the input has infinite execution.

Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
means that the input DOES NOT HAVE infinite execution.

and there are no programs left over that can be shown to be undecidable.

-- 
Copyright 2020 Pete Olcott

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


#156037 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-24 16:24 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<-cmdnWoATZ3iBgnCnZ2dnUU7-RfNnZ2d@giganews.com>
In reply to#156028
On 10/24/2020 3:55 PM, Richard Damon wrote:
> On 10/24/20 3:13 PM, olcott wrote:
>> On 10/24/2020 12:36 PM, Richard Damon wrote:
>>> On 10/24/20 11:36 AM, olcott wrote:
>>>>
>>>> I am refuting that the Linz proof proves that the halting problem is
>>>> undecidable by finding another way to define the halt decider that
>>>> cannot be contradicted.
>>>
>>> That is like refute the fact that there is no highest prime number by
>>> redefining prime numbers (or maybe redefining the Natural Numbers that
>>> primes are part of).
>>
>> Not at all.
>>
>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>> means that the input has infinite execution.
>>
>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>> means that the input DOES NOT HAVE infinite execution.
>>
>> and there are no programs left over that can be shown to be undecidable.
>>
> 
> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite
> execution.
> 
> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and thus
> H_Hat does NOT have infinite execution, contrary to what H said.

You must be able to follow the key nuances that an outer instance of
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) that was 
invoked by the outer instance of H_Hat() has a longer execution trace 
thus more data than the inner instance of
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) that was 
invoked by the inner instance of H_Hat().

If you cannot follow this analysis because it is too complex or you 
simply don't believe in different instances then you can wait until I 
finish encoding it as fully executable code.

When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any 
level of outer or inner invocations then H_Hat(H_Hat) never terminates.

> THUS, H does not met the requirements of the Halting Problem.
> 
> The Halting Problem, the one which mathematics wants, and how it defines
> it, is to have a determiner, that will tell you in finite time,
> accurately, whether a specified machine with specified input will
> ultimately halt or never halt.
> 
> All you have shown, is that your particular method of trying to
> implement the machine H, is incapable of doing the job. Linz did you one
> better, he showed that NO machine can do the job.
> 
> The question asked was, will the program stop.

When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any 
level of outer or inner invocations then H_Hat(H_Hat) never terminates.

> Your answer was, I don't know, I got overloaded thinking about it.
> 
> Note, that your method is actually doomed to fail on most interesting
> machines, because it is fundamentally finite, and from everything I have
> heard, you seem to be anticipating that you will detect looping by
> getting into repeated state. While it is true, that the loop in H_Hat is
> detectable by this, many of the interesting machines don't hit this sort
> of state, but the machine data just keeps growing infinitely large until
> it either finds the answer it is looking for, or never stops if there is
> no possible answer.
> 


-- 
Copyright 2020 Pete Olcott

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


#156038 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-24 16:31 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<haadnWzXes27AAnCnZ2dnUU7-SvNnZ2d@giganews.com>
In reply to#156028
On 10/24/2020 4:06 PM, Malcolm McLean wrote:
> On Saturday, 24 October 2020 at 21:55:39 UTC+1, Richard Damon wrote:
>> On 10/24/20 3:13 PM, olcott wrote:
>>> On 10/24/2020 12:36 PM, Richard Damon wrote:
>>>> On 10/24/20 11:36 AM, olcott wrote:
>>>>>
>>>>> I am refuting that the Linz proof proves that the halting problem is
>>>>> undecidable by finding another way to define the halt decider that
>>>>> cannot be contradicted.
>>>>
>>>> That is like refute the fact that there is no highest prime number by
>>>> redefining prime numbers (or maybe redefining the Natural Numbers that
>>>> primes are part of).
>>>
>>> Not at all.
>>>
>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>> means that the input has infinite execution.
>>>
>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>> means that the input DOES NOT HAVE infinite execution.
>>>
>>> and there are no programs left over that can be shown to be undecidable.
>>>
>> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite
>> execution.
>>
>> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and thus
>> H_Hat does NOT have infinite execution, contrary to what H said.
>>
>> THUS, H does not met the requirements of the Halting Problem.
>>
>> The Halting Problem, the one which mathematics wants, and how it defines
>> it, is to have a determiner, that will tell you in finite time,
>> accurately, whether a specified machine with specified input will
>> ultimately halt or never halt.
>>
>> All you have shown, is that your particular method of trying to
>> implement the machine H, is incapable of doing the job. Linz did you one
>> better, he showed that NO machine can do the job.
>>
>> The question asked was, will the program stop.
>>
>> Your answer was, I don't know, I got overloaded thinking about it.
>>
>> Note, that your method is actually doomed to fail on most interesting
>> machines, because it is fundamentally finite, and from everything I have
>> heard, you seem to be anticipating that you will detect looping by
>> getting into repeated state. While it is true, that the loop in H_Hat is
>> detectable by this, many of the interesting machines don't hit this sort
>> of state, but the machine data just keeps growing infinitely large until
>> it either finds the answer it is looking for, or never stops if there is
>> no possible answer.
>>
> The scope of this was to show that the Linz proof is unsound, not to
> construct an actual halt decider. It's logically possible for one proof
> that halt deciders can't be written to be unsound, whilst another one
> is sound.
> However in fact the proof is sound. The weakness is that it requires that
> H be a Turing machine. It's not a proof that no halt decider is possible,
> just that the halt decider is not a Turing machine.
> 

Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
means that the input has infinite execution.

Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
means that the input DOES NOT HAVE infinite execution.

All Input is divided into exactly one of these two sets:
(a) The input Program/TM has infinite execution.
(b) The input Program/TM DOES NOT HAVE infinite execution.

There is no reason why a UTM halt decider could not be implemented so 
that it examines every state transition of its input UTM in the exact 
same way as described above.


-- 
Copyright 2020 Pete Olcott

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


#156049 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-24 18:00 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<vJidnTyM9IxiLAnCnZ2dnUU7-YXNnZ2d@giganews.com>
In reply to#156038
On 10/24/2020 5:17 PM, Richard Damon wrote:
> On 10/24/20 5:31 PM, olcott wrote:
>> On 10/24/2020 4:06 PM, Malcolm McLean wrote:
>>> On Saturday, 24 October 2020 at 21:55:39 UTC+1, Richard Damon wrote:
>>>> On 10/24/20 3:13 PM, olcott wrote:
>>>>> On 10/24/2020 12:36 PM, Richard Damon wrote:
>>>>>> On 10/24/20 11:36 AM, olcott wrote:
>>>>>>>
>>>>>>> I am refuting that the Linz proof proves that the halting problem is
>>>>>>> undecidable by finding another way to define the halt decider that
>>>>>>> cannot be contradicted.
>>>>>>
>>>>>> That is like refute the fact that there is no highest prime number by
>>>>>> redefining prime numbers (or maybe redefining the Natural Numbers that
>>>>>> primes are part of).
>>>>>
>>>>> Not at all.
>>>>>
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>>>> means that the input has infinite execution.
>>>>>
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>>>> means that the input DOES NOT HAVE infinite execution.
>>>>>
>>>>> and there are no programs left over that can be shown to be
>>>>> undecidable.
>>>>>
>>>> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite
>>>> execution.
>>>>
>>>> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and thus
>>>> H_Hat does NOT have infinite execution, contrary to what H said.
>>>>
>>>> THUS, H does not met the requirements of the Halting Problem.
>>>>
>>>> The Halting Problem, the one which mathematics wants, and how it defines
>>>> it, is to have a determiner, that will tell you in finite time,
>>>> accurately, whether a specified machine with specified input will
>>>> ultimately halt or never halt.
>>>>
>>>> All you have shown, is that your particular method of trying to
>>>> implement the machine H, is incapable of doing the job. Linz did you one
>>>> better, he showed that NO machine can do the job.
>>>>
>>>> The question asked was, will the program stop.
>>>>
>>>> Your answer was, I don't know, I got overloaded thinking about it.
>>>>
>>>> Note, that your method is actually doomed to fail on most interesting
>>>> machines, because it is fundamentally finite, and from everything I have
>>>> heard, you seem to be anticipating that you will detect looping by
>>>> getting into repeated state. While it is true, that the loop in H_Hat is
>>>> detectable by this, many of the interesting machines don't hit this sort
>>>> of state, but the machine data just keeps growing infinitely large until
>>>> it either finds the answer it is looking for, or never stops if there is
>>>> no possible answer.
>>>>
>>> The scope of this was to show that the Linz proof is unsound, not to
>>> construct an actual halt decider. It's logically possible for one proof
>>> that halt deciders can't be written to be unsound, whilst another one
>>> is sound.
>>> However in fact the proof is sound. The weakness is that it requires that
>>> H be a Turing machine. It's not a proof that no halt decider is possible,
>>> just that the halt decider is not a Turing machine.
>>>
>>
>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>> means that the input has infinite execution.
>>
>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>> means that the input DOES NOT HAVE infinite execution.
>>
>> All Input is divided into exactly one of these two sets:
>> (a) The input Program/TM has infinite execution.
>> (b) The input Program/TM DOES NOT HAVE infinite execution.
>>
>> There is no reason why a UTM halt decider could not be implemented so
>> that it examines every state transition of its input UTM in the exact
>> same way as described above.
>>
>>
> 
> Lets look at this statement.
> 
> We have two programs in view, H(H_Hat, H_Hat) which calls
> Aborted_Because_Non_Halting_Behavior_Detected and H_Hat(H_Hat) which
> will also call Aborted_Because_Non_Halting_Behavior_Detected, and in
> both case the call is given exactly the same input, so it will, by
> necessity, generate exactly the same output.
> 
> The first possibility, which is how it seems you are saying it will go,
> the function will detect infinite recursion in the input program, and
> thus return true. When we run H this way, H being the required halt
> detector, based on the value it got, will declare H_Hat(H_Hat) to be a
> non-Halting program.
> 
> Now, we run H_Hat(H_Hat), and it will also get the same true answer, and
> it will then immediately Halt. Thus it is clear that H gave the wrong
> answer, 

No the outer H_Hat() is an entirely different process and has much more 
data than the inner H_Hat(). Because the same code has entirely 
different data one instance can have a completely different execution 
trace than the other.

> as when we ran H, it said that it wouldn't. The fact that H_Hat
> stopped on its own, its irrefutable. Note, H by its definition and your
> construction does NOT have infinite execution, and H_Hat, at least if H
> returned non-Halting, adds a very small finite amount of execution to
> it, so it is also finite in execution.

Different instances of H_Hat() having entirely different data must be 
against your religion, none-the-less fully operational code will totally 
prove my point.

> If there IS a problem of infinite execution, then that problem is in H,
> which is what YOU provided, so if there is a problem, it is yours.

No H() and H_Hat() are merely the conventional functions used in every 
standard halting problem proof.

> The alternative case, would be if
> Aborted_Because_Non_Halting_Behavior_Detected returns false, then H will
> say that H_Hat does terminate, but when you run H_Hat is will never
> halt, so again you get the wrong answer.

Yes you can break my solution to make it not work. That is not any sort 
of actual rebuttal what-so-ever.

> Also, based on what I think you are describing, I suspect that if you
> run H(H) it will also declare it as having infinite execution, even
> though H will always (by its definition) halt in finite time.



-- 
Copyright 2020 Pete Olcott

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


#156051 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

FromRichard Damon <Richard@Damon-Family.org>
Date2020-10-24 19:48 -0400
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<W23lH.28770$ri1.12583@fx26.iad>
In reply to#156049
On 10/24/20 7:00 PM, olcott wrote:
> On 10/24/2020 5:17 PM, Richard Damon wrote:
>> On 10/24/20 5:31 PM, olcott wrote:
>>> On 10/24/2020 4:06 PM, Malcolm McLean wrote:
>>>> On Saturday, 24 October 2020 at 21:55:39 UTC+1, Richard Damon wrote:
>>>>> On 10/24/20 3:13 PM, olcott wrote:
>>>>>> On 10/24/2020 12:36 PM, Richard Damon wrote:
>>>>>>> On 10/24/20 11:36 AM, olcott wrote:
>>>>>>>>
>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>> problem is
>>>>>>>> undecidable by finding another way to define the halt decider that
>>>>>>>> cannot be contradicted.
>>>>>>>
>>>>>>> That is like refute the fact that there is no highest prime
>>>>>>> number by
>>>>>>> redefining prime numbers (or maybe redefining the Natural Numbers
>>>>>>> that
>>>>>>> primes are part of).
>>>>>>
>>>>>> Not at all.
>>>>>>
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>>>>> means that the input has infinite execution.
>>>>>>
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>>>>> means that the input DOES NOT HAVE infinite execution.
>>>>>>
>>>>>> and there are no programs left over that can be shown to be
>>>>>> undecidable.
>>>>>>
>>>>> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite
>>>>> execution.
>>>>>
>>>>> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and
>>>>> thus
>>>>> H_Hat does NOT have infinite execution, contrary to what H said.
>>>>>
>>>>> THUS, H does not met the requirements of the Halting Problem.
>>>>>
>>>>> The Halting Problem, the one which mathematics wants, and how it
>>>>> defines
>>>>> it, is to have a determiner, that will tell you in finite time,
>>>>> accurately, whether a specified machine with specified input will
>>>>> ultimately halt or never halt.
>>>>>
>>>>> All you have shown, is that your particular method of trying to
>>>>> implement the machine H, is incapable of doing the job. Linz did
>>>>> you one
>>>>> better, he showed that NO machine can do the job.
>>>>>
>>>>> The question asked was, will the program stop.
>>>>>
>>>>> Your answer was, I don't know, I got overloaded thinking about it.
>>>>>
>>>>> Note, that your method is actually doomed to fail on most interesting
>>>>> machines, because it is fundamentally finite, and from everything I
>>>>> have
>>>>> heard, you seem to be anticipating that you will detect looping by
>>>>> getting into repeated state. While it is true, that the loop in
>>>>> H_Hat is
>>>>> detectable by this, many of the interesting machines don't hit this
>>>>> sort
>>>>> of state, but the machine data just keeps growing infinitely large
>>>>> until
>>>>> it either finds the answer it is looking for, or never stops if
>>>>> there is
>>>>> no possible answer.
>>>>>
>>>> The scope of this was to show that the Linz proof is unsound, not to
>>>> construct an actual halt decider. It's logically possible for one proof
>>>> that halt deciders can't be written to be unsound, whilst another one
>>>> is sound.
>>>> However in fact the proof is sound. The weakness is that it requires
>>>> that
>>>> H be a Turing machine. It's not a proof that no halt decider is
>>>> possible,
>>>> just that the halt decider is not a Turing machine.
>>>>
>>>
>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>> means that the input has infinite execution.
>>>
>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>> means that the input DOES NOT HAVE infinite execution.
>>>
>>> All Input is divided into exactly one of these two sets:
>>> (a) The input Program/TM has infinite execution.
>>> (b) The input Program/TM DOES NOT HAVE infinite execution.
>>>
>>> There is no reason why a UTM halt decider could not be implemented so
>>> that it examines every state transition of its input UTM in the exact
>>> same way as described above.
>>>
>>>
>>
>> Lets look at this statement.
>>
>> We have two programs in view, H(H_Hat, H_Hat) which calls
>> Aborted_Because_Non_Halting_Behavior_Detected and H_Hat(H_Hat) which
>> will also call Aborted_Because_Non_Halting_Behavior_Detected, and in
>> both case the call is given exactly the same input, so it will, by
>> necessity, generate exactly the same output.
>>
>> The first possibility, which is how it seems you are saying it will go,
>> the function will detect infinite recursion in the input program, and
>> thus return true. When we run H this way, H being the required halt
>> detector, based on the value it got, will declare H_Hat(H_Hat) to be a
>> non-Halting program.
>>
>> Now, we run H_Hat(H_Hat), and it will also get the same true answer, and
>> it will then immediately Halt. Thus it is clear that H gave the wrong
>> answer, 
> 
> No the outer H_Hat() is an entirely different process and has much more
> data than the inner H_Hat(). Because the same code has entirely
> different data one instance can have a completely different execution
> trace than the other.

Both the outer H and outer H_Hat invoke the function in identical
manners, if they don't you have translated them right. Thus they invoke
the detection function the same way.

The inner H_Hat is supposed to be a faithful representation of the outer
H_Hat, if not, you haven't encoded it properly.

Both are calculating the value of H_Hat(H_Hat), one as the actual
program and one as your emulated program. Yes, because you are emulating
the inner H_Hat, your emulator can do what it wants to that inner one,
but the whole purpose of this to let H decide what the running of H_Hat
is going to do. Making the emulated one act differently just isn't going
to help you figure out what the real machine is going to do.


> 
>> as when we ran H, it said that it wouldn't. The fact that H_Hat
>> stopped on its own, its irrefutable. Note, H by its definition and your
>> construction does NOT have infinite execution, and H_Hat, at least if H
>> returned non-Halting, adds a very small finite amount of execution to
>> it, so it is also finite in execution.
> 
> Different instances of H_Hat() having entirely different data must be
> against your religion, none-the-less fully operational code will totally
> prove my point.

There is nothing wrong with running H_Hat with some other data, but it
is meaningless to the Linz proof. Linz everywhere is using H_Hat(H_Hat)
and H(H_Hat, H_Hat).

> 
>> If there IS a problem of infinite execution, then that problem is in H,
>> which is what YOU provided, so if there is a problem, it is yours.
> 
> No H() and H_Hat() are merely the conventional functions used in every
> standard halting problem proof.
> 
>> The alternative case, would be if
>> Aborted_Because_Non_Halting_Behavior_Detected returns false, then H will
>> say that H_Hat does terminate, but when you run H_Hat is will never
>> halt, so again you get the wrong answer.
> 
> Yes you can break my solution to make it not work. That is not any sort
> of actual rebuttal what-so-ever.
> 
>> Also, based on what I think you are describing, I suspect that if you
>> run H(H) it will also declare it as having infinite execution, even
>> though H will always (by its definition) halt in finite time.
> 
> 
> 

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


#156052 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-24 19:29 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<ldSdncS-ho1xWwnCnZ2dnUU7-fvNnZ2d@giganews.com>
In reply to#156051
On 10/24/2020 6:48 PM, Richard Damon wrote:
> On 10/24/20 7:00 PM, olcott wrote:
>> On 10/24/2020 5:17 PM, Richard Damon wrote:
>>> On 10/24/20 5:31 PM, olcott wrote:
>>>> On 10/24/2020 4:06 PM, Malcolm McLean wrote:
>>>>> On Saturday, 24 October 2020 at 21:55:39 UTC+1, Richard Damon wrote:
>>>>>> On 10/24/20 3:13 PM, olcott wrote:
>>>>>>> On 10/24/2020 12:36 PM, Richard Damon wrote:
>>>>>>>> On 10/24/20 11:36 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>> problem is
>>>>>>>>> undecidable by finding another way to define the halt decider that
>>>>>>>>> cannot be contradicted.
>>>>>>>>
>>>>>>>> That is like refute the fact that there is no highest prime
>>>>>>>> number by
>>>>>>>> redefining prime numbers (or maybe redefining the Natural Numbers
>>>>>>>> that
>>>>>>>> primes are part of).
>>>>>>>
>>>>>>> Not at all.
>>>>>>>
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>>>>>> means that the input has infinite execution.
>>>>>>>
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>>>>>> means that the input DOES NOT HAVE infinite execution.
>>>>>>>
>>>>>>> and there are no programs left over that can be shown to be
>>>>>>> undecidable.
>>>>>>>
>>>>>> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite
>>>>>> execution.
>>>>>>
>>>>>> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and
>>>>>> thus
>>>>>> H_Hat does NOT have infinite execution, contrary to what H said.
>>>>>>
>>>>>> THUS, H does not met the requirements of the Halting Problem.
>>>>>>
>>>>>> The Halting Problem, the one which mathematics wants, and how it
>>>>>> defines
>>>>>> it, is to have a determiner, that will tell you in finite time,
>>>>>> accurately, whether a specified machine with specified input will
>>>>>> ultimately halt or never halt.
>>>>>>
>>>>>> All you have shown, is that your particular method of trying to
>>>>>> implement the machine H, is incapable of doing the job. Linz did
>>>>>> you one
>>>>>> better, he showed that NO machine can do the job.
>>>>>>
>>>>>> The question asked was, will the program stop.
>>>>>>
>>>>>> Your answer was, I don't know, I got overloaded thinking about it.
>>>>>>
>>>>>> Note, that your method is actually doomed to fail on most interesting
>>>>>> machines, because it is fundamentally finite, and from everything I
>>>>>> have
>>>>>> heard, you seem to be anticipating that you will detect looping by
>>>>>> getting into repeated state. While it is true, that the loop in
>>>>>> H_Hat is
>>>>>> detectable by this, many of the interesting machines don't hit this
>>>>>> sort
>>>>>> of state, but the machine data just keeps growing infinitely large
>>>>>> until
>>>>>> it either finds the answer it is looking for, or never stops if
>>>>>> there is
>>>>>> no possible answer.
>>>>>>
>>>>> The scope of this was to show that the Linz proof is unsound, not to
>>>>> construct an actual halt decider. It's logically possible for one proof
>>>>> that halt deciders can't be written to be unsound, whilst another one
>>>>> is sound.
>>>>> However in fact the proof is sound. The weakness is that it requires
>>>>> that
>>>>> H be a Turing machine. It's not a proof that no halt decider is
>>>>> possible,
>>>>> just that the halt decider is not a Turing machine.
>>>>>
>>>>
>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>>> means that the input has infinite execution.
>>>>
>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>>> means that the input DOES NOT HAVE infinite execution.
>>>>
>>>> All Input is divided into exactly one of these two sets:
>>>> (a) The input Program/TM has infinite execution.
>>>> (b) The input Program/TM DOES NOT HAVE infinite execution.
>>>>
>>>> There is no reason why a UTM halt decider could not be implemented so
>>>> that it examines every state transition of its input UTM in the exact
>>>> same way as described above.
>>>>
>>>>
>>>
>>> Lets look at this statement.
>>>
>>> We have two programs in view, H(H_Hat, H_Hat) which calls
>>> Aborted_Because_Non_Halting_Behavior_Detected and H_Hat(H_Hat) which
>>> will also call Aborted_Because_Non_Halting_Behavior_Detected, and in
>>> both case the call is given exactly the same input, so it will, by
>>> necessity, generate exactly the same output.
>>>
>>> The first possibility, which is how it seems you are saying it will go,
>>> the function will detect infinite recursion in the input program, and
>>> thus return true. When we run H this way, H being the required halt
>>> detector, based on the value it got, will declare H_Hat(H_Hat) to be a
>>> non-Halting program.
>>>
>>> Now, we run H_Hat(H_Hat), and it will also get the same true answer, and
>>> it will then immediately Halt. Thus it is clear that H gave the wrong
>>> answer,
>>
>> No the outer H_Hat() is an entirely different process and has much more
>> data than the inner H_Hat(). Because the same code has entirely
>> different data one instance can have a completely different execution
>> trace than the other.
> 
> Both the outer H and outer H_Hat invoke the function in identical
> manners, if they don't you have translated them right. Thus they invoke
> the detection function the same way.
> 
> The inner H_Hat is supposed to be a faithful representation of the outer
> H_Hat, if not, you haven't encoded it properly.

The inner H_Hat has the exact same machine code as the outer H_Hat yet 
the outer DebugTrace() has seen many more steps of the inner H_Hat() 
than this inner H_Hat()'s DebugTrace() have seen of its own inner inner 
H_Hat().

> Both are calculating the value of H_Hat(H_Hat), one as the actual
> program and one as your emulated program. Yes, because you are emulating
> the inner H_Hat, your emulator can do what it wants to that inner one,
> but the whole purpose of this to let H decide what the running of H_Hat
> is going to do. Making the emulated one act differently just isn't going
> to help you figure out what the real machine is going to do.

Actually you are missing a key detail. The only function in the whole 
system that decides halting is
Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)

>>> as when we ran H, it said that it wouldn't. The fact that H_Hat
>>> stopped on its own, its irrefutable. Note, H by its definition and your
>>> construction does NOT have infinite execution, and H_Hat, at least if H
>>> returned non-Halting, adds a very small finite amount of execution to
>>> it, so it is also finite in execution.
>>
>> Different instances of H_Hat() having entirely different data must be
>> against your religion, none-the-less fully operational code will totally
>> prove my point.
> 
> There is nothing wrong with running H_Hat with some other data, but it
> is meaningless to the Linz proof. Linz everywhere is using H_Hat(H_Hat)
> and H(H_Hat, H_Hat).

No one seems to be getting the idea that there are three different 
H_Hats() specified by the execution of this code:

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


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

The H_Hat() called by main() is the outermost H_Hat().

Aborted_Because_Non_Halting_Behavior_Detected(M, M) creates a whole 
brand new process context to execute its own H_Hat() instance

which in turn executes a whole other instance of 
Aborted_Because_Non_Halting_Behavior_Detected(M, M) in the process 
instance of the inner H_Hat()

which which in turn creates yet another whole process instance to 
execute an inner inner H_Hat().

The two instances of the actual halt deciders:
Aborted_Because_Non_Halting_Behavior_Detected(M, M)
have different amounts of data.

The outer instance decides to abort the whole process tree. This aborts 
both inner and inner H_Hats() and it also aborts the inner instance of 
Aborted_Because_Non_Halting_Behavior_Detected(M, M) before it ever 
returns a value.

Apparently this stuff is simply too difficult to understand without 
seeing working code that proves that the execution trace has been 
described accurately.

>>> If there IS a problem of infinite execution, then that problem is in H,
>>> which is what YOU provided, so if there is a problem, it is yours.
>>
>> No H() and H_Hat() are merely the conventional functions used in every
>> standard halting problem proof.
>>
>>> The alternative case, would be if
>>> Aborted_Because_Non_Halting_Behavior_Detected returns false, then H will
>>> say that H_Hat does terminate, but when you run H_Hat is will never
>>> halt, so again you get the wrong answer.
>>
>> Yes you can break my solution to make it not work. That is not any sort
>> of actual rebuttal what-so-ever.
>>
>>> Also, based on what I think you are describing, I suspect that if you
>>> run H(H) it will also declare it as having infinite execution, even
>>> though H will always (by its definition) halt in finite time.
>>
>>
>>
> 


-- 
Copyright 2020 Pete Olcott

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


#156057 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-10-25 01:07 -0700
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<0a11c11d-3d51-4fad-b322-703e21918d62n@googlegroups.com>
In reply to#156052
On Sunday, 25 October 2020 at 01:29:54 UTC+1, olcott wrote:
> On 10/24/2020 6:48 PM, Richard Damon wrote: 
> > On 10/24/20 7:00 PM, olcott wrote: 
> >> On 10/24/2020 5:17 PM, Richard Damon wrote: 
> >>> On 10/24/20 5:31 PM, olcott wrote: 
> >>>> On 10/24/2020 4:06 PM, Malcolm McLean wrote: 
> >>>>> On Saturday, 24 October 2020 at 21:55:39 UTC+1, Richard Damon wrote: 
> >>>>>> On 10/24/20 3:13 PM, olcott wrote: 
> >>>>>>> On 10/24/2020 12:36 PM, Richard Damon wrote: 
> >>>>>>>> On 10/24/20 11:36 AM, olcott wrote: 
> >>>>>>>>> 
> >>>>>>>>> I am refuting that the Linz proof proves that the halting 
> >>>>>>>>> problem is 
> >>>>>>>>> undecidable by finding another way to define the halt decider that 
> >>>>>>>>> cannot be contradicted. 
> >>>>>>>> 
> >>>>>>>> That is like refute the fact that there is no highest prime 
> >>>>>>>> number by 
> >>>>>>>> redefining prime numbers (or maybe redefining the Natural Numbers 
> >>>>>>>> that 
> >>>>>>>> primes are part of). 
> >>>>>>> 
> >>>>>>> Not at all. 
> >>>>>>> 
> >>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true 
> >>>>>>> means that the input has infinite execution. 
> >>>>>>> 
> >>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false 
> >>>>>>> means that the input DOES NOT HAVE infinite execution. 
> >>>>>>> 
> >>>>>>> and there are no programs left over that can be shown to be 
> >>>>>>> undecidable. 
> >>>>>>> 
> >>>>>> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite 
> >>>>>> execution. 
> >>>>>> 
> >>>>>> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and 
> >>>>>> thus 
> >>>>>> H_Hat does NOT have infinite execution, contrary to what H said. 
> >>>>>> 
> >>>>>> THUS, H does not met the requirements of the Halting Problem. 
> >>>>>> 
> >>>>>> The Halting Problem, the one which mathematics wants, and how it 
> >>>>>> defines 
> >>>>>> it, is to have a determiner, that will tell you in finite time, 
> >>>>>> accurately, whether a specified machine with specified input will 
> >>>>>> ultimately halt or never halt. 
> >>>>>> 
> >>>>>> All you have shown, is that your particular method of trying to 
> >>>>>> implement the machine H, is incapable of doing the job. Linz did 
> >>>>>> you one 
> >>>>>> better, he showed that NO machine can do the job. 
> >>>>>> 
> >>>>>> The question asked was, will the program stop. 
> >>>>>> 
> >>>>>> Your answer was, I don't know, I got overloaded thinking about it. 
> >>>>>> 
> >>>>>> Note, that your method is actually doomed to fail on most interesting 
> >>>>>> machines, because it is fundamentally finite, and from everything I 
> >>>>>> have 
> >>>>>> heard, you seem to be anticipating that you will detect looping by 
> >>>>>> getting into repeated state. While it is true, that the loop in 
> >>>>>> H_Hat is 
> >>>>>> detectable by this, many of the interesting machines don't hit this 
> >>>>>> sort 
> >>>>>> of state, but the machine data just keeps growing infinitely large 
> >>>>>> until 
> >>>>>> it either finds the answer it is looking for, or never stops if 
> >>>>>> there is 
> >>>>>> no possible answer. 
> >>>>>> 
> >>>>> The scope of this was to show that the Linz proof is unsound, not to 
> >>>>> construct an actual halt decider. It's logically possible for one proof 
> >>>>> that halt deciders can't be written to be unsound, whilst another one 
> >>>>> is sound. 
> >>>>> However in fact the proof is sound. The weakness is that it requires 
> >>>>> that 
> >>>>> H be a Turing machine. It's not a proof that no halt decider is 
> >>>>> possible, 
> >>>>> just that the halt decider is not a Turing machine. 
> >>>>> 
> >>>> 
> >>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true 
> >>>> means that the input has infinite execution. 
> >>>> 
> >>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false 
> >>>> means that the input DOES NOT HAVE infinite execution. 
> >>>> 
> >>>> All Input is divided into exactly one of these two sets: 
> >>>> (a) The input Program/TM has infinite execution. 
> >>>> (b) The input Program/TM DOES NOT HAVE infinite execution. 
> >>>> 
> >>>> There is no reason why a UTM halt decider could not be implemented so 
> >>>> that it examines every state transition of its input UTM in the exact 
> >>>> same way as described above. 
> >>>> 
> >>>> 
> >>> 
> >>> Lets look at this statement. 
> >>> 
> >>> We have two programs in view, H(H_Hat, H_Hat) which calls 
> >>> Aborted_Because_Non_Halting_Behavior_Detected and H_Hat(H_Hat) which 
> >>> will also call Aborted_Because_Non_Halting_Behavior_Detected, and in 
> >>> both case the call is given exactly the same input, so it will, by 
> >>> necessity, generate exactly the same output. 
> >>> 
> >>> The first possibility, which is how it seems you are saying it will go, 
> >>> the function will detect infinite recursion in the input program, and 
> >>> thus return true. When we run H this way, H being the required halt 
> >>> detector, based on the value it got, will declare H_Hat(H_Hat) to be a 
> >>> non-Halting program. 
> >>> 
> >>> Now, we run H_Hat(H_Hat), and it will also get the same true answer, and 
> >>> it will then immediately Halt. Thus it is clear that H gave the wrong 
> >>> answer, 
> >> 
> >> No the outer H_Hat() is an entirely different process and has much more 
> >> data than the inner H_Hat(). Because the same code has entirely 
> >> different data one instance can have a completely different execution 
> >> trace than the other. 
> > 
> > Both the outer H and outer H_Hat invoke the function in identical 
> > manners, if they don't you have translated them right. Thus they invoke 
> > the detection function the same way. 
> > 
> > The inner H_Hat is supposed to be a faithful representation of the outer 
> > H_Hat, if not, you haven't encoded it properly.
> The inner H_Hat has the exact same machine code as the outer H_Hat yet 
> the outer DebugTrace() has seen many more steps of the inner H_Hat() 
> than this inner H_Hat()'s DebugTrace() have seen of its own inner inner 
> H_Hat().
> > Both are calculating the value of H_Hat(H_Hat), one as the actual 
> > program and one as your emulated program. Yes, because you are emulating 
> > the inner H_Hat, your emulator can do what it wants to that inner one, 
> > but the whole purpose of this to let H decide what the running of H_Hat 
> > is going to do. Making the emulated one act differently just isn't going 
> > to help you figure out what the real machine is going to do.
> Actually you are missing a key detail. The only function in the whole 
> system that decides halting is 
> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
> >>> as when we ran H, it said that it wouldn't. The fact that H_Hat 
> >>> stopped on its own, its irrefutable. Note, H by its definition and your 
> >>> construction does NOT have infinite execution, and H_Hat, at least if H 
> >>> returned non-Halting, adds a very small finite amount of execution to 
> >>> it, so it is also finite in execution. 
> >> 
> >> Different instances of H_Hat() having entirely different data must be 
> >> against your religion, none-the-less fully operational code will totally 
> >> prove my point. 
> > 
> > There is nothing wrong with running H_Hat with some other data, but it 
> > is meaningless to the Linz proof. Linz everywhere is using H_Hat(H_Hat) 
> > and H(H_Hat, H_Hat).
> No one seems to be getting the idea that there are three different 
> H_Hats() specified by the execution of this code: 
> 
> void H_Hat(u32 M) 
> { 
> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
> MOV_EAX_0 // Execution of M(N) has been aborted 
> else 
> { 
> MOV_EAX_1 // M(N) has halted 
> HERE: goto HERE; 
> } 
> HALT 
> }
> int main() 
> { 
> u32 M = (u32)H_Hat;
> H_Hat(M); // MOV_EAX_0 
> HALT; 
> } 
> 
> The H_Hat() called by main() is the outermost H_Hat(). 
> 
> Aborted_Because_Non_Halting_Behavior_Detected(M, M) creates a whole 
> brand new process context to execute its own H_Hat() instance 
> 
> which in turn executes a whole other instance of 
> Aborted_Because_Non_Halting_Behavior_Detected(M, M) in the process 
> instance of the inner H_Hat() 
> 
> which which in turn creates yet another whole process instance to 
> execute an inner inner H_Hat(). 
> 
> The two instances of the actual halt deciders: 
> Aborted_Because_Non_Halting_Behavior_Detected(M, M) 
> have different amounts of data. 
>
That's another way of solving the problem. Pass hidden data to
Aborted_Because_Non_Halting_Behavior_Detected(M, M). It's the
route I thought you would take.
> 
> The outer instance decides to abort the whole process tree. This aborts 
> both inner and inner H_Hats() and it also aborts the inner instance of 
> Aborted_Because_Non_Halting_Behavior_Detected(M, M) before it ever 
> returns a value. 
>
You mean "both outer and inner H_Hats?". This is crucial. If you abort
H_Hat, it can't halt, and so Linz is side-stepped. (Linz only applies to halt
detectors that are Turing machines, and by giving the machine an "abort"
state you've stopped it from being a strict Turing machine. Linz wasn't
wrong, but you've shown that his proof was limited to strict Turing machines). 
>
> Apparently this stuff is simply too difficult to understand without 
> seeing working code that proves that the execution trace has been 
> described accurately.

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


#156064 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-25 10:07 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<utmdneqQB6FQCQjCnZ2dnUU7-avNnZ2d@giganews.com>
In reply to#156057
On 10/25/2020 3:07 AM, Malcolm McLean wrote:
> On Sunday, 25 October 2020 at 01:29:54 UTC+1, olcott wrote:
>> On 10/24/2020 6:48 PM, Richard Damon wrote:
>>> On 10/24/20 7:00 PM, olcott wrote:
>>>> On 10/24/2020 5:17 PM, Richard Damon wrote:
>>>>> On 10/24/20 5:31 PM, olcott wrote:
>>>>>> On 10/24/2020 4:06 PM, Malcolm McLean wrote:
>>>>>>> On Saturday, 24 October 2020 at 21:55:39 UTC+1, Richard Damon wrote:
>>>>>>>> On 10/24/20 3:13 PM, olcott wrote:
>>>>>>>>> On 10/24/2020 12:36 PM, Richard Damon wrote:
>>>>>>>>>> On 10/24/20 11:36 AM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>> problem is
>>>>>>>>>>> undecidable by finding another way to define the halt decider that
>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>
>>>>>>>>>> That is like refute the fact that there is no highest prime
>>>>>>>>>> number by
>>>>>>>>>> redefining prime numbers (or maybe redefining the Natural Numbers
>>>>>>>>>> that
>>>>>>>>>> primes are part of).
>>>>>>>>>
>>>>>>>>> Not at all.
>>>>>>>>>
>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>>>>>>>> means that the input has infinite execution.
>>>>>>>>>
>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>>>>>>>> means that the input DOES NOT HAVE infinite execution.
>>>>>>>>>
>>>>>>>>> and there are no programs left over that can be shown to be
>>>>>>>>> undecidable.
>>>>>>>>>
>>>>>>>> I run H(H_Hat, H_Hat), I get the answer that H_Hat(H_Hat) has infinite
>>>>>>>> execution.
>>>>>>>>
>>>>>>>> I run H_Hat(H_Hat), the function returns true, so H_Hat halts, and
>>>>>>>> thus
>>>>>>>> H_Hat does NOT have infinite execution, contrary to what H said.
>>>>>>>>
>>>>>>>> THUS, H does not met the requirements of the Halting Problem.
>>>>>>>>
>>>>>>>> The Halting Problem, the one which mathematics wants, and how it
>>>>>>>> defines
>>>>>>>> it, is to have a determiner, that will tell you in finite time,
>>>>>>>> accurately, whether a specified machine with specified input will
>>>>>>>> ultimately halt or never halt.
>>>>>>>>
>>>>>>>> All you have shown, is that your particular method of trying to
>>>>>>>> implement the machine H, is incapable of doing the job. Linz did
>>>>>>>> you one
>>>>>>>> better, he showed that NO machine can do the job.
>>>>>>>>
>>>>>>>> The question asked was, will the program stop.
>>>>>>>>
>>>>>>>> Your answer was, I don't know, I got overloaded thinking about it.
>>>>>>>>
>>>>>>>> Note, that your method is actually doomed to fail on most interesting
>>>>>>>> machines, because it is fundamentally finite, and from everything I
>>>>>>>> have
>>>>>>>> heard, you seem to be anticipating that you will detect looping by
>>>>>>>> getting into repeated state. While it is true, that the loop in
>>>>>>>> H_Hat is
>>>>>>>> detectable by this, many of the interesting machines don't hit this
>>>>>>>> sort
>>>>>>>> of state, but the machine data just keeps growing infinitely large
>>>>>>>> until
>>>>>>>> it either finds the answer it is looking for, or never stops if
>>>>>>>> there is
>>>>>>>> no possible answer.
>>>>>>>>
>>>>>>> The scope of this was to show that the Linz proof is unsound, not to
>>>>>>> construct an actual halt decider. It's logically possible for one proof
>>>>>>> that halt deciders can't be written to be unsound, whilst another one
>>>>>>> is sound.
>>>>>>> However in fact the proof is sound. The weakness is that it requires
>>>>>>> that
>>>>>>> H be a Turing machine. It's not a proof that no halt decider is
>>>>>>> possible,
>>>>>>> just that the halt decider is not a Turing machine.
>>>>>>>
>>>>>>
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == true
>>>>>> means that the input has infinite execution.
>>>>>>
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I) == false
>>>>>> means that the input DOES NOT HAVE infinite execution.
>>>>>>
>>>>>> All Input is divided into exactly one of these two sets:
>>>>>> (a) The input Program/TM has infinite execution.
>>>>>> (b) The input Program/TM DOES NOT HAVE infinite execution.
>>>>>>
>>>>>> There is no reason why a UTM halt decider could not be implemented so
>>>>>> that it examines every state transition of its input UTM in the exact
>>>>>> same way as described above.
>>>>>>
>>>>>>
>>>>>
>>>>> Lets look at this statement.
>>>>>
>>>>> We have two programs in view, H(H_Hat, H_Hat) which calls
>>>>> Aborted_Because_Non_Halting_Behavior_Detected and H_Hat(H_Hat) which
>>>>> will also call Aborted_Because_Non_Halting_Behavior_Detected, and in
>>>>> both case the call is given exactly the same input, so it will, by
>>>>> necessity, generate exactly the same output.
>>>>>
>>>>> The first possibility, which is how it seems you are saying it will go,
>>>>> the function will detect infinite recursion in the input program, and
>>>>> thus return true. When we run H this way, H being the required halt
>>>>> detector, based on the value it got, will declare H_Hat(H_Hat) to be a
>>>>> non-Halting program.
>>>>>
>>>>> Now, we run H_Hat(H_Hat), and it will also get the same true answer, and
>>>>> it will then immediately Halt. Thus it is clear that H gave the wrong
>>>>> answer,
>>>>
>>>> No the outer H_Hat() is an entirely different process and has much more
>>>> data than the inner H_Hat(). Because the same code has entirely
>>>> different data one instance can have a completely different execution
>>>> trace than the other.
>>>
>>> Both the outer H and outer H_Hat invoke the function in identical
>>> manners, if they don't you have translated them right. Thus they invoke
>>> the detection function the same way.
>>>
>>> The inner H_Hat is supposed to be a faithful representation of the outer
>>> H_Hat, if not, you haven't encoded it properly.
>> The inner H_Hat has the exact same machine code as the outer H_Hat yet
>> the outer DebugTrace() has seen many more steps of the inner H_Hat()
>> than this inner H_Hat()'s DebugTrace() have seen of its own inner inner
>> H_Hat().
>>> Both are calculating the value of H_Hat(H_Hat), one as the actual
>>> program and one as your emulated program. Yes, because you are emulating
>>> the inner H_Hat, your emulator can do what it wants to that inner one,
>>> but the whole purpose of this to let H decide what the running of H_Hat
>>> is going to do. Making the emulated one act differently just isn't going
>>> to help you figure out what the real machine is going to do.
>> Actually you are missing a key detail. The only function in the whole
>> system that decides halting is
>> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>> as when we ran H, it said that it wouldn't. The fact that H_Hat
>>>>> stopped on its own, its irrefutable. Note, H by its definition and your
>>>>> construction does NOT have infinite execution, and H_Hat, at least if H
>>>>> returned non-Halting, adds a very small finite amount of execution to
>>>>> it, so it is also finite in execution.
>>>>
>>>> Different instances of H_Hat() having entirely different data must be
>>>> against your religion, none-the-less fully operational code will totally
>>>> prove my point.
>>>
>>> There is nothing wrong with running H_Hat with some other data, but it
>>> is meaningless to the Linz proof. Linz everywhere is using H_Hat(H_Hat)
>>> and H(H_Hat, H_Hat).
>> No one seems to be getting the idea that there are three different
>> H_Hats() specified by the execution of this code:
>>
>> void H_Hat(u32 M)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>> MOV_EAX_0 // Execution of M(N) has been aborted
>> else
>> {
>> MOV_EAX_1 // M(N) has halted
>> HERE: goto HERE;
>> }
>> HALT
>> }
>> int main()
>> {
>> u32 M = (u32)H_Hat;
>> H_Hat(M); // MOV_EAX_0
>> HALT;
>> }
>>
>> The H_Hat() called by main() is the outermost H_Hat().
>>
>> Aborted_Because_Non_Halting_Behavior_Detected(M, M) creates a whole
>> brand new process context to execute its own H_Hat() instance
>>
>> which in turn executes a whole other instance of
>> Aborted_Because_Non_Halting_Behavior_Detected(M, M) in the process
>> instance of the inner H_Hat()
>>
>> which which in turn creates yet another whole process instance to
>> execute an inner inner H_Hat().
>>
>> The two instances of the actual halt deciders:
>> Aborted_Because_Non_Halting_Behavior_Detected(M, M)
>> have different amounts of data.
>>
> That's another way of solving the problem. Pass hidden data to
> Aborted_Because_Non_Halting_Behavior_Detected(M, M). It's the
> route I thought you would take.

There is nothing hidden. The x86utm operating system is a master UTM.
As is common knowledge a UTM can see everything that its subordinate TM 
does. The x86utm master UTM provides an operating system function that 
allows a subordinate TM to execute its own subordinate TMs in 
DebugStep() mode.

>> The outer instance decides to abort the whole process tree. This aborts
>> both inner and inner H_Hats() and it also aborts the inner instance of
>> Aborted_Because_Non_Halting_Behavior_Detected(M, M) before it ever
>> returns a value.
>>
> You mean "both outer and inner H_Hats?". This is crucial. If you abort

H_Hat(H_Hat) has one outer H_Hat() and two inner H_Hat()s.

When the outer H_Hat()'s
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
traces the execution of its first param it detects infinite recursion.

The first inner H_Hat invokes its own
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
in its own process context.

The outer Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
aborts the first inner H_Hat() before the inner H_Hat()s
The outer Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) 
has returned its value. It can do this because it has already seen more 
DebugStep() processing steps than the inner process has seen.

> H_Hat, it can't halt, and so Linz is side-stepped. (Linz only applies to halt
> detectors that are Turing machines, and by giving the machine an "abort"
> state you've stopped it from being a strict Turing machine. Linz wasn't

So you are saying that it is impossible for a UTM to decide to stop 
executing its TM. Why do you believe this?

> wrong, but you've shown that his proof was limited to strict Turing machines).
>>
>> Apparently this stuff is simply too difficult to understand without
>> seeing working code that proves that the execution trace has been
>> described accurately.
> 


-- 
Copyright 2020 Pete Olcott

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


#155876 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-22 12:26 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<2u6dna1sWuonXQzCnZ2dnUU7-V_NnZ2d@giganews.com>
In reply to#155862
On 10/22/2020 11:57 AM, Mike Terry wrote:
> On 22/10/2020 16:45, Ben Bacarisse wrote:
>> Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
>>
>>> On 22/10/2020 15:36, olcott wrote:
>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>
>>>>>> The difference is that it is no longer possible for H_Hat() to do the
>>>>>> opposite of what H() decides. This transforms an undecidable problem
>>>>>> into a decidable problem.
>>>>>
>>>>> If H_Hat no longer does what the proof defined, then your 
>>>>> demonstration
>>>>> is no longer applicable to the proof.
>>>>>
>>>>
>>>> If the halt decider is to report whether or not its input halts another
>>>> program can be constructed on the the basis of this halt decider that
>>>> does the opposite of whatever the halt decider decides.
>>>>
>>>> This is how H() and H_Hat() are defined in the Linz proof.
>>>>
>>>> If the halt decider is to report whether or not it aborted its input
>>>> program because its input program would otherwise cause the halt 
>>>> decider
>>>> to get stuck in infinite execution then this other program can no 
>>>> longer
>>>> fool its halt decider and do the opposite of whatever it decides.
>>>>
>>>> If H() aborts the execution of H_Hat() then H_Hat() cannot continue to
>>>> execute because H() has complete control over H_Hat.
>>>>
>>>> The end result of this slight change is that the halting problem can no
>>>> longer be shown to be undecidable.
>>>
>>> It is suspicious that in none of this have you ever stated what is
>>> actually wrong in the Linz proof.
>>
>> He has!  He's wrong, of course, but he /has/ said.  The part PO disputes
>> is asserting that H can not give the correct halting answer for the
>> input pair <[H^], [H^]>.  And to show that that assertion is wrong he
>> was going to produce two actual Turing machines, fully encoded, exactly
>> as in Linz, but where H correctly decides the <[H^], [H^]> case.  We
>> will never see that.
>>
> 
> That doesn't count as stating what is wrong with the Linz proof, because 
> "H can not give the correct halting answer for the input pair <[H^], 
> [H^]>" is a /conclusion/ within the proof, based on a contradiction 
> generated in turn by the previous state transition diagrams.
> 

Within Linz's faulty assumption that the only possible way to create a 
universal halt decider is to directly ask the question:
Does the input program halt on its input?
The Linz proof is correct.

When we realize that this assumption is faulty and instead ask the 
question: Was the execution of the input program on its input aborted 
because non halting behavior was detected?

Then creating a universal halt decider is no longer "proved" to be 
impossible on the basis of the conventional self-referential halting 
problem counter-examples.

The halt decider either detects non-halting behavior and reports it or 
allows the input program to terminate on its own.

> PO would need to do one of the following:  identify one of the state 
> transition claims which is wrong; agree that the state transition 
> diagrams are correct, but there is no contradiction in them; or say that 
> there is a contradiction, but this doesn't mean that one of the 
> assumptions leading to the contradiction is wrong; or say that one of 
> the assumptions leading to the contradiction is wrong, but it is some 
> other assumption than "H is a halt decider"; etc..
> 
> Just saying "It's wrong that H can not give the correct halting answer 
> for the input pair <[H^], [H^]>" is just disagreeing with a conclusion.
> 
> Perhaps I should have said that he has never identified the specific 
> /reasoning/ step in the proof which is wrong.  (If he had, we could have 
> expanded any missing/unclear reasoning steps to the point where he would 
> have to agree that particular step was in fact ok.  Hmm, ok maybe we 
> couldn't do that as for some people there's really no convincing them, 
> but I don't believe he's ever been this specific about the problem.  I 
> could be wrong on that I guess.)
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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


#155864 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-22 10:44 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<vu2dnQ0pFuZYNQzCnZ2dnUU7-LnNnZ2d@giganews.com>
In reply to#155857
On 10/22/2020 9:57 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>
>>>> The difference is that it is no longer possible for H_Hat() to do the
>>>> opposite of what H() decides. This transforms an undecidable problem
>>>> into a decidable problem.
>>>
>>> If H_Hat no longer does what the proof defined, then your demonstration
>>> is no longer applicable to the proof.
>>
>> If the halt decider is to report whether or not its input halts
>> another program can be constructed on the the basis of this halt
>> decider that does the opposite of whatever the halt decider decides.
>>
>> This is how H() and H_Hat() are defined in the Linz proof.
> 
> Yes, and this is what you have been claiming to have had for nearly two
> years and everyone else has been saying is impossible.  Do you now
> accept that it is impossible and that you were wrong to say you had such
> a pair?
> 
>> If the halt decider is to report whether or not it aborted its input
>> program because its input program would otherwise cause the halt
>> decider to get stuck in infinite execution then this other program can
>> no longer fool its halt decider and do the opposite of whatever it
>> decides.
>>
>> If H() aborts the execution of H_Hat() then H_Hat() cannot continue to
>> execute because H() has complete control over H_Hat.
>>
>> The end result of this slight change is that the halting problem can
>> no longer be shown to be undecidable.
> 
> Unfortunately, pairs like this -- where H and H^ are not related exactly
> as in Linz, or where they are but H gets the answer wrong -- are
> ten-a-penny.  What you wasted everyone's time with was a clear claim to
> have a pair, H and H^, related exactly as in Linz, where H gives the
> correct halting answer for H(H^, H^).  Do you now see that such a pair
> is impossible?
> 

I think that the problem is that you are not even glancing at what I say 
before you form your baseless rebuttal.

I have already proven that the H() to H_Hat() relationship is the same 
as the conventional self-referential halting problem counter-example 
relationship by providing its exact source code.

I adapted Mike's version of H_Hat(),
His comments regarding the halting decision were incorrect.

On 10/20/2020 8:57 PM, Mike Terry wrote:
 > OK.  I've added a valid implementation for H_Hat below.
 >      int H_Hat(u32 M)
 >      {
 >        int Abort = DebugTrace(M, M);
 >        if (Abort)
 >        {
 >          // DebugTrace says M(M) does not halt
 >          HALT       // ..so we halt
 >        }
 >        else
 >        {
 >          // DebugTrace says M(M) halts
 >          for (;;);  // ..so we loop
 >        }
 >      }


// M has address of H_Hat()
int H_Hat(u32 M)
{
   int Abort = DebugTrace(M, M);
   if (Abort)
   {
     MOV_EAX_0  // DebugTrace says that M(M)
     HALT       // has been aborted
   }
   else
   {
     MOV_EAX_1  // M(M) has halted
     HERE: goto HERE;
     HALT
   }
}


The much more subtle nuance that cannot be understood by anyone that is 
not an expert in this field and only then with very intense focused 
concentration is that my simple change to the halting question converts 
the halting problem from an undecidable problem into a decidable problem.

Did the input program have to be aborted to prevent the halt decider 
from getting stuck in infinite execution?

Cannot be thwarted by pathological self-reference.

It is no longer impossible for a halt decider to divide all of its 
inputs into (a) halting and (b) would not otherwise halt.

-- 
Copyright 2020 Pete Olcott

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


#155865 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-10-22 09:09 -0700
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<77a1e314-2c9e-42ae-abdc-c5f648ad6d6an@googlegroups.com>
In reply to#155864
On Thursday, 22 October 2020 at 16:44:27 UTC+1, olcott wrote:
> 
> The much more subtle nuance that cannot be understood by anyone that is 
> not an expert in this field and only then with very intense focused 
> concentration is that my simple change to the halting question converts 
> the halting problem from an undecidable problem into a decidable problem. 
> 
> Did the input program have to be aborted to prevent the halt decider
> from getting stuck in infinite execution?
> Cannot be thwarted by pathological self-reference. 
> 
> It is no longer impossible for a halt decider to divide all of its 
> inputs into (a) halting and (b) would not otherwise halt.
> 
Yes. If you ask not "did the program halt?" but "was there an abortion
anywhere on the call stack?" then the problem becomes soluble. 

It's now defined by your "DebugTrace" function and it's behaviour
rather then the halting problem as such. 

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


#155870 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-22 11:55 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<UeSdnSQn4METJAzCnZ2dnUU7-S3NnZ2d@giganews.com>
In reply to#155865
On 10/22/2020 11:09 AM, Malcolm McLean wrote:
> On Thursday, 22 October 2020 at 16:44:27 UTC+1, olcott wrote:
>>
>> The much more subtle nuance that cannot be understood by anyone that is
>> not an expert in this field and only then with very intense focused
>> concentration is that my simple change to the halting question converts
>> the halting problem from an undecidable problem into a decidable problem.
>>
>> Did the input program have to be aborted to prevent the halt decider
>> from getting stuck in infinite execution?
>> Cannot be thwarted by pathological self-reference.
>>
>> It is no longer impossible for a halt decider to divide all of its
>> inputs into (a) halting and (b) would not otherwise halt.
>>
> Yes. If you ask not "did the program halt?" but "was there an abortion
> anywhere on the call stack?" then the problem becomes soluble.
> 

DebugTrace() is the halt decider that decides to abort the execution of 
its input program as soon as it detects that its input program would not 
otherwise halt.

> It's now defined by your "DebugTrace" function and it's behaviour
> rather then the halting problem as such.
> 


-- 
Copyright 2020 Pete Olcott

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


#155897 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-10-22 20:41 +0100
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<87imb29hfs.fsf@bsb.me.uk>
In reply to#155865
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

Not picking on you in particular, but can I ask everyone to check the
newsgroups before posting.  PO's nonsense can overwhelm a group.  I know
I reply, buy do so in comp.theory which is (a) the right group for the
content and (b) already dead.  PO will add in comp.lang.c no matter how
many times he's asked not to, but we can all try to limit the damage.

-- 
Ben.

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


#155905 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-22 18:55 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<tIadnb_W1fxuhg_CnZ2dnUU7-XXNnZ2d@giganews.com>
In reply to#155864
On 10/22/2020 6:34 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 10/22/2020 9:57 AM, Ben Bacarisse wrote:
> <cut>
>>> Unfortunately, pairs like this -- where H and H^ are not related exactly
>>> as in Linz, or where they are but H gets the answer wrong -- are
>>> ten-a-penny.  What you wasted everyone's time with was a clear claim to
>>> have a pair, H and H^, related exactly as in Linz, where H gives the
>>> correct halting answer for H(H^, H^).  Do you now see that such a pair
>>> is impossible?
>>
>> I think that the problem is that you are not even glancing at what I
>> say before you form your baseless rebuttal.
> 
> I didn't rebut anything.  Mike Terry is doing the rebutting (and doing
> it very well I might add).
> 
> If you want someone else picking your claim apart, I am happy to join
> in, but as you know I'm a nit-picking details guy.  You won't get the
> big-picture view of your mistakes that Mike Terry will give you.
> 
>> // M has address of H_Hat()
>> int H_Hat(u32 M)
>> {
>>    int Abort = DebugTrace(M, M);
>>    if (Abort)
>>    {
>>      MOV_EAX_0  // DebugTrace says that M(M)
>>      HALT       // has been aborted
>>    }
>>    else
>>    {
>>      MOV_EAX_1  // M(M) has halted
>>      HERE: goto HERE;
>>      HALT
>>    }
>> }
> 
> I'd start by saying that H_Hat neither includes nor makes reference to H
> as Linz's H^ does.  Yes, I know that H is just a thin shim over
> DebugTrace but I am sure you want to get the details right.
> 

Linz's H^ is defined as a sequence of two sets of modifications to his 
H. DebugTrace() contains all of the ⊢* state transtions.

> Further questions: is DebugTrace vapourware or do you have it written
> and running? 

The reason for the great delay is that I waited until I got DebugTrace() 
fully operational before I presented H() and H_Hat().

>  It you have it running, can you run DebugTrace(H_Hat,
> H_Hat) to get a return value?  If not why not?  If you can, what is the
> return value?
> 

It took me a man-year to write my x86utm operating system. Now I finally 
have the full basis to write the most robust halt deciding code.



-- 
Copyright 2020 Pete Olcott

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


#155933 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-23 10:40 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<ad-dnWVSSbz9ZA_CnZ2dnUU7-QXNnZ2d@giganews.com>
In reply to#155905
On 10/23/2020 10:03 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> Your answer does not have a correct yes or no answer.
> s/answer/question/
>> I have run DebugTrace() and it did correctly return a value is a
>> correct but misleading answer.
>>
>>> So what is the returned result from DebugTrace(H_Hat, H_Hat)?
>>
>> It is the fixed value of 1 that I used to test if it could correctly
>> return a value.
> 
> I don't think you are taking this seriously.  It's up to if you want to
> come across as a clown.  If not, you can take the questions people ask
> seriously.
> 

DebugTrace() is totally complete as a function that creates new process 
contexts and executes virtual machines within this new process context.
The most difficult part was to get DebugTrace() to DebugTrace() itself 
to an arbitrary recursive depth.

I had to do this because H() invokes DebugTrace() to invoke H_Hat() to 
invoke DebugTrace() to invoke another H_Hat() process.

As I have said dozens of times now the halt decider code has not been 
written. The x86utm operating system is complete. This took one 
man-year. The halt deciding criteria for the Linz proof has been 
complete since 2016. We spoke about this at very great length and you 
made sure not to pay any attention at all.

-- 
Copyright 2020 Pete Olcott

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


#155937 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-23 11:38 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<pZidnbSdJISHmg7CnZ2dnUU7-N3NnZ2d@giganews.com>
In reply to#155905
On 10/23/2020 11:18 AM, Mike Terry wrote:
> On 23/10/2020 05:13, olcott wrote:
>> On 10/22/2020 10:44 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 10/22/2020 9:09 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 10/22/2020 6:34 PM, Ben Bacarisse wrote:
>>> <cut>
>>>>>>> Further questions: is DebugTrace vapourware or do you have it 
>>>>>>> written
>>>>>>> and running?
>>>>>>
>>>>>> The reason for the great delay is that I waited until I got
>>>>>> DebugTrace() fully operational before I presented H() and H_Hat().
>>>>>>
>>>>>>>    It you have it running, can you run DebugTrace(H_Hat,
>>>>>>> H_Hat) to get a return value?  If not why not?  If you can, what
>>>>>>> is the
>>>>>>> return value?
>>>>>>
>>>>>> It took me a man-year to write my x86utm operating system. Now I
>>>>>> finally have the full basis to write the most robust halt deciding
>>>>>> code.
>>>>>
>>>>> Can you run DebugTrace(H_Hat, H_Hat) to get a return value?
>>>>
>>>> I have already answered this question completely.
>>>
>>> That's pure crank 101.  People who want to be understood are happy to
>>> repeat an answer: "sorry, did you miss it?  I said yes".  You see?
>>> Clear and unambiguous.  Cranks don't do that because they want as many
>>> get-out clauses left open as they can.
>>>
>>
>> It is bad for me to have patience with people to to pay so little
>> attention to what I am saying that after I have answered their question
>> five times they did not bother to notice the answer even a single time.
>>
>> Your answer does not have a correct yes or no answer.
>> I have run DebugTrace() and it did correctly return a value is a correct
>> but misleading answer.
>>
> 
> LOL, I think I can see what's happened now!  :)
> 
> Two years ago you genuinely thought you had a /design/ for a TM that 
> would actually contradict the Linz logic, and so you announced that you 
> had two fully coded TMs that worked, when in fact you just had an idea. 
> [You clearly thought at the time it would only be a couple of weeks of 
> coding to implement your idea, so what harm in lying about actually 
> having the TMs?  That's not a lie, because you would have them soon and 
> nobody would know otherwise.  And the lie sounds "more convincing" than 
> the truth that it was just an idea you had, so you went for it...]
> 
> Since then you've been playing catchup, realising you couldn't code a 
> TM, and then even coding in a C environment would be months/years of work.
> 
> Now (in the last week or so) for the first time, you've actually been 
> able to try out your idea, and I provided you with an H_Hat skeleton 
> which forced you to follow the Linz proof restrictions - 


> and you FINALLY 
> realised your idea didn't work, and WHY it didn't!  

Not at all. Not in the least little bit.
You aren't paying very close attention are you?

> The decision of 
> H_copy [the copy of H embedded in H_Hat] on running H_Hat with input 
> <H_Hat> is made BEFORE H_Hat actually finishes running, so H_Hat's 
> actual behaviour can be different, showing H's decision to be incorrect.
> 

As in all of the conventional proofs the input program is based on 
modifications made to the halt decider.

Next, we modify H to produce a Turing machine H' with the structure
shown in Figure 12.2.

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

// Simpifications of H() and H_Hat() provided by
// Ben Bacarisse wrote On 10/22/2020 11:00 PM


// M has address of H_Hat()
void H_Hat(u32 M)
{
   if (!DebugTrace(M, M)) // M(M) Aborted?
     HERE: goto HERE;
   HALT
}


// M and N have the address of H_Hat()
void H(u32 M, u32 N)
{
   if (DebugTrace(M, N)) // M(N) Aborted?
     MOV_EAX_0  // Execution of M(N) has been aborted
   else
     MOV_EAX_1  // M(N) has halted
   HALT
}


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

> FINALLY I think you (at least partially) understand the proof, which 
> everybody else understood all along, and you are stuffed.  Rather than 
> admit you'd just been a dumbo for 15 years, you did what you always do: 
> just carry on regardless, changing whatever needs to be changed about 
> your original claim and the meaning of the terms in the proof you're 
> "refuting" to try to make your revised claim still true!  [I'd have to 
> say that you are one of the most inflexible thinkers I've come across on 
> UseNet when it comes to recognising mistakes/dead ends and switching to 
> better approaches - totally the opposite behaviour exhibited by "true 
> geniuses"...]
> 
> Hence all the rubbish in the last week or so about "changing the 
> question" to try to make your problem go away.  I think that what you're 
> thinking is that you can make the problem of H_Hat finishing AFTER 
> H_Copy has returned its decision JUST GO AWAY by 

Forcing H_Hat() to terminate before the decision is returned.

This makes it impossible for H_Hat() to do anything at all, thus H_Hat() 
cannot possibly do the opposite of whatever DebugTrace() decides.

> saying the decision of 
> H_Copy is not "whether H_Hat halts", but in fact should be read as 
> "whether or not I decided H_Hat would halt and aborted it".  And since 

The unique discovery that I made in 2016 indicates that H_Hat() would 
never terminate unless it was aborted.

> your H_Copy aborts it's emulation of H_Hat before the emulation actually 
> finishes, we're for some reason not allowed to talk about what H_Hat 
> /actually/ does.  (Duh!)
> 

No. The DebugTrace() of H_Hat() that is invoked by H() aborts its 
execution of H_Hat() because unless H_Hat() is aborted it would never 
terminate.

> You can't make the basic problem you've suddenly encountered go away 
> like that - Linz's proof worked all along, and you've only just 
> understood (at least partially) how it works in the last couple of 
> weeks.  And now you can't bring yourself to just admit it, because you 
> are an unacknowledged genius who CAN'T be wrong, so you MUST have be 
> right all along for some other reason... [now if only you could come up 
> with a plausible reason, but you can't!  :) ]
> 
> Regards,
> Mike.
> 

The reason that I can't admit that I am wrong this that I am correct and 
you can't show otherwise.

-- 
Copyright 2020 Pete Olcott

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


#155949 — Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-23 12:40 -0500
SubjectRe: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ]
Message-ID<A_WdnTO2jN80iA7CnZ2dnUU7-f3NnZ2d@giganews.com>
In reply to#155905
On 10/23/2020 11:28 AM, Ben Bacarisse wrote:
> Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
> 
>> Two years ago you genuinely thought you had a /design/ for a TM that
>> would actually contradict the Linz logic, and so you announced that
>> you had two fully coded TMs that worked, when in fact you just had an
>> idea. [You clearly thought at the time it would only be a couple of
>> weeks of coding to implement your idea, so what harm in lying about
>> actually having the TMs?  That's not a lie, because you would have
>> them soon and nobody would know otherwise.  And the lie sounds "more
>> convincing" than the truth that it was just an idea you had, so you
>> went for it...]
>>
>> Since then you've been playing catchup, realising you couldn't code a
>> TM, and then even coding in a C environment would be months/years of
>> work.
> 
> For the record, that's exactly what I've thought all along.  As usual,
> you are being a bit kinder than I would be, but that's your way.
> 

Instead of the C function DebugTrace() we could simply have a UTM that 
executes an (already on the tape) input UTM. This halt decider UTM would 
execute its (already on the tape) input UTM one state transition at a 
time. As soon as the halt decider UTM detects that its (already on the 
tape) input UTM would not halt, the halt decider UTM stops executing its 
(already on the tape) input UTM and transitions to its own final state 
indicating Aborted_Because_Non_Halting_Behavior_Detected.

Thus DebugTrace() <is> equivalent to a UTM doing the same thing.

>> Now (in the last week or so) for the first time, you've actually been
>> able to try out your idea, and I provided you with an H_Hat skeleton
>> which forced you to follow the Linz proof restrictions - and you
>> FINALLY realised your idea didn't work, and WHY it didn't!
> 
> I find this much more of a stretch!
> 


-- 
Copyright 2020 Pete Olcott

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


#155826

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-10-21 22:42 +0100
Message-ID<87zh4fcl2q.fsf@bsb.me.uk>
In reply to#155821
There's actually something topical in comp.lang.c...

olcott <NoOne@NoWhere.com> writes:

> As Ben has very carefully elaborated twice the invocation of a
> function with the same input must result in the same output. The
> return value from H_Hat() and the return value from H() are the same
> return value.

That first sentence, attributed to me, is not true, and I hope I never
said it!  (If I did, post a message ID so I can post a correction,
please.)

You appear to writing C (or maybe C++), and in C, the invocation of a
function with the same "input" does not necessarily result in the same
"output", not unless the terms "input" and "output" are being stretched
beyond all reason.

-- 
Ben.

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


#155828

Fromolcott <NoOne@NoWhere.com>
Date2020-10-21 16:56 -0500
Message-ID<V9idndJMa4_uMw3CnZ2dnUU7-d3NnZ2d@giganews.com>
In reply to#155826
On 10/21/2020 4:42 PM, Ben Bacarisse wrote:
> There's actually something topical in comp.lang.c...
> 
> olcott <NoOne@NoWhere.com> writes:
> 
>> As Ben has very carefully elaborated twice the invocation of a
>> function with the same input must result in the same output. The
>> return value from H_Hat() and the return value from H() are the same
>> return value.
> 
> That first sentence, attributed to me, is not true, and I hope I never
> said it!  (If I did, post a message ID so I can post a correction,
> please.)
> 

On 10/21/2020 8:36 AM, Ben Bacarisse wrote:
 > Yup.  But I want to nitpick...  It would be better to say that the
 > result of a Turing machine is determined solely by it's input.

> You appear to writing C (or maybe C++), and in C, the invocation of a
> function with the same "input" does not necessarily result in the same
> "output", not unless the terms "input" and "output" are being stretched
> beyond all reason.


-- 
Copyright 2020 Pete Olcott

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


Page 12 of 13 — ← Prev page 1 … 10 11 [12] 13  Next page →

Back to top | Article view | comp.lang.c


csiph-web