Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #24043 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-10-20 11:33 -0500 |
| Last post | 2020-10-29 14:01 +0100 |
| Articles | 20 on this page of 499 — 17 participants |
Back to article view | Back to comp.theory
The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 11:33 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-20 19:11 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 13:40 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 14:19 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 02:57 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 22:07 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 16:28 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 16:52 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 11:48 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 20:30 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 15:27 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] André G. Isaak <agisaak@gm.invalid> - 2020-10-21 14:57 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 16:12 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] André G. Isaak <agisaak@gm.invalid> - 2020-10-21 15:54 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 17:20 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 00:16 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 18:28 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 00:55 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:20 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 23:10 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 17:55 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 03:38 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 21:54 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 04:38 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-21 23:33 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 11:05 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:44 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 16:14 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 08:00 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:36 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 15:57 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 10:44 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 00:34 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 18:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 03:09 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 21:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 04:44 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 16:03 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:40 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-23 17:18 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 17:28 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 16:25 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 16:45 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 17:57 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:26 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 21:15 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:36 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 09:56 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:09 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 10:27 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:32 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:33 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 10:58 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:19 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:30 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:34 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 20:53 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 13:28 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:25 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 00:51 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:09 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 02:50 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-22 21:27 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 05:00 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:31 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 17:19 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:22 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 20:36 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:50 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:18 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 10:00 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:04 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 00:12 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 03:47 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:57 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 07:34 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:12 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 16:20 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:55 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:52 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 09:59 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:20 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 21:02 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 13:29 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 15:56 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 14:12 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 16:58 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:35 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 20:45 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-23 19:54 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:22 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 12:46 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-24 16:43 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:01 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-24 23:14 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:35 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-25 16:33 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 12:37 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-25 12:10 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:27 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:42 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 23:11 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 03:18 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 03:21 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:58 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:28 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-23 21:03 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 23:13 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 13:27 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:08 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-24 19:54 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 15:48 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-24 21:41 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 14:47 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:20 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 13:37 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 11:30 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 10:43 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 12:44 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 17:38 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 13:13 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 19:28 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:46 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 15:43 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-26 21:07 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:27 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-27 07:03 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 09:53 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mostowski Collapse <janburse@fastmail.fm> - 2020-10-27 21:07 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:57 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-27 04:53 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 14:30 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 07:52 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 10:28 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 15:30 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 08:45 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 16:05 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 11:05 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 09:53 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 13:36 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 12:05 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 14:44 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-27 16:05 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 03:41 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-28 02:57 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 15:54 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] David Kleinecke <dkleinecke@gmail.com> - 2020-10-28 09:25 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-28 18:31 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-29 00:02 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 07:55 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Richard Damon <Richard@Damon-Family.org> - 2020-10-29 09:28 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 10:49 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Richard Damon <Richard@Damon-Family.org> - 2020-10-29 12:32 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:41 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Richard Damon <Richard@Damon-Family.org> - 2020-10-29 16:01 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 15:58 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 06:28 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 10:59 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 09:50 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:48 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 11:51 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 14:09 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-29 13:12 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 16:08 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-29 22:51 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 18:15 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 01:05 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 20:32 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 02:16 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 21:36 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-29 21:51 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 03:44 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 06:32 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 06:40 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-30 22:08 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 17:21 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 00:46 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 20:07 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 02:30 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 02:44 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 21:56 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 16:41 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Jeff Barnett <jbb@notatt.com> - 2020-10-31 11:16 -0600
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 23:40 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 16:28 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 12:56 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 20:49 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 16:07 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 14:55 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:09 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 15:22 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:30 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 16:00 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 18:13 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-01 13:56 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Alan Mackenzie <acm@muc.de> - 2020-10-31 22:23 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:37 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 19:18 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 18:40 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 20:12 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 21:29 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 22:34 -0400
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 21:38 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 08:13 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 12:18 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:05 -0600
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-01 10:43 -0800
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:56 -0600
Re: The key aspects of x86utm are now finally complete [ x86 machine description language ] olcott <NoOne@NoWhere.com> - 2020-11-01 13:32 -0600
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 17:37 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 17:41 -0600
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 19:09 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:43 -0600
Re: The key aspects of x86utm are now finally complete [ execution trace described ] olcott <NoOne@NoWhere.com> - 2020-10-31 23:36 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 00:05 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-31 16:40 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 05:36 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 10:32 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 08:54 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 11:30 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 16:22 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 18:41 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 16:48 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 18:50 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 16:59 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 19:07 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-30 17:23 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 19:34 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 02:26 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-31 03:05 -0700
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 12:23 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-31 09:22 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 14:26 +0000
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] olcott <NoOne@NoWhere.com> - 2020-10-30 10:49 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 01:26 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-28 08:31 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Jeff Barnett <jbb@notatt.com> - 2020-10-28 10:57 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-28 12:05 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-27 13:09 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-27 13:57 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 11:00 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 16:53 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided olcott <NoOne@NoWhere.com> - 2020-10-27 10:20 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 15:56 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided André G. Isaak <agisaak@gm.invalid> - 2020-10-27 12:53 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 01:25 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-25 18:38 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Alan Mackenzie <acm@muc.de> - 2020-10-25 20:49 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 23:26 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Andy Walker <anw@cuboid.co.uk> - 2020-10-25 23:57 +0000
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 22:43 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 17:10 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:27 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:34 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:15 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 16:46 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:36 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:05 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:15 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:29 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 23:41 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:02 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Tim Woodall <news001@woodall.me.uk> - 2020-10-23 07:05 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 11:02 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:45 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 15:56 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:30 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 00:32 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:36 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:52 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-23 13:03 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 15:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 02:29 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:43 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-23 15:51 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:19 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 23:14 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 18:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 16:55 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:29 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 18:06 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 20:26 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-23 23:51 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 16:03 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:10 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 00:17 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 16:39 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:54 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 16:58 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 17:24 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 01:43 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 02:37 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 10:41 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 09:04 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:46 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 00:54 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 22:03 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 14:35 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 01:23 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 00:45 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 09:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 07:39 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 10:33 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-25 12:14 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] olcott <NoOne@NoWhere.com> - 2020-10-25 13:42 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] Richard Damon <Richard@Damon-Family.org> - 2020-10-25 16:55 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] olcott <NoOne@NoWhere.com> - 2020-10-25 16:07 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 23:51 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-25 17:26 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 14:16 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 13:55 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:56 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-25 17:35 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 14:43 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 16:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 14:43 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 08:36 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 12:23 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 22:54 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 16:19 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 18:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 18:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 01:17 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 02:49 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 03:56 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 02:37 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 12:10 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 06:45 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 17:24 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 10:38 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-27 00:51 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 11:16 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 15:41 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-26 17:28 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:52 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 01:21 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 01:06 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:39 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 04:27 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 23:02 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 16:58 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 01:17 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:06 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 00:38 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:46 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 01:03 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-24 08:04 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:25 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 15:38 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 10:36 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 17:37 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 12:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 19:32 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 11:40 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:42 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 20:00 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 20:44 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 15:41 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 21:57 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 22:44 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:01 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 16:11 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:12 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 19:38 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:53 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 13:50 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:01 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-26 14:08 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-26 14:26 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-26 20:59 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 20:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 02:19 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:08 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 15:16 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 18:30 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 15:47 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 18:08 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:45 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 16:29 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 13:03 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction olcott <NoOne@NoWhere.com> - 2020-10-26 13:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 00:06 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-26 17:16 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 00:46 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 20:11 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 02:48 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 22:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 13:36 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 16:55 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-24 14:06 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 18:17 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 18:00 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 19:48 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 19:29 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:52 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-22 10:45 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-21 22:42 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Richard Damon <Richard@Damon-Family.org> - 2020-10-21 21:22 -0400
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-21 21:14 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 08:12 -0400
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:41 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 13:43 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-22 14:54 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 14:34 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:28 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 15:34 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:47 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] Andy Walker <anw@cuboid.co.uk> - 2020-10-22 16:20 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Richard Damon <Richard@Damon-Family.org> - 2020-10-21 09:09 -0400
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-21 14:36 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:19 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:21 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:27 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:30 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:43 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:08 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:12 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 11:17 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:21 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 11:30 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Jeff Barnett <jbb@notatt.com> - 2020-10-22 11:59 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 10:45 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:17 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:44 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:59 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 18:13 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 20:15 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 00:10 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:28 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:22 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 21:51 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-24 13:07 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-25 02:07 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 06:29 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 09:10 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 08:30 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 09:52 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 09:04 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 10:06 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:48 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 11:04 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 12:00 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:12 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 12:35 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 14:04 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 15:34 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 17:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:32 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 21:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 09:50 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-23 11:15 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 17:37 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:43 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 17:49 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:06 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:10 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:35 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:46 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:53 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:06 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 17:54 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:57 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:05 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2020-10-22 12:55 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:59 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2020-10-22 19:13 +0000
Stop crossposting you imbecil spammer (Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ]) Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 14:01 +0100
Page 12 of 25 — ← Prev page 1 … 10 11 [12] 13 14 … 25 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-31 00:05 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <H_2dnZHGPs8ubQHCnZ2dnUU7-fXNnZ2d@giganews.com> |
| In reply to | #24707 |
On 10/30/2020 7:46 PM, Mike Terry wrote: > On 30/10/2020 22:21, olcott wrote: >> On 10/30/2020 5:08 PM, Mike Terry wrote: >>> On 30/10/2020 11:40, olcott wrote: >>>> On 10/30/2020 6:32 AM, olcott wrote: >>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote: >>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote: >>>>>>> On 10/29/2020 9:36 PM, olcott wrote: >>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote: >>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>> >>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote: >>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>> >>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote: >>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>> <cut> >>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts >>>>>>>>>>>>>> NON_HALTING >>>>>>>>>>>>>> input and Rejects HALTING input as follows: >>>>>>>>>>>>> >>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, >>>>>>>>>>>>> while >>>>>>>>>>>>> rejecting all, and only all, halting ones. >>>>>>>>>>>>> >>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical >>>>>>>>>>>>> terms like >>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are >>>>>>>>>>>>> accepted and >>>>>>>>>>>>> which rejected by saying "all, and only all" rather than >>>>>>>>>>>>> "always". >>>>>>>>>>>> >>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I >>>>>>>>>>>> need to >>>>>>>>>>>> make my presentation conform somewhat more closely to an >>>>>>>>>>>> academic >>>>>>>>>>>> paper degree of professionalism. >>>>>>>>>>>> >>>>>>>>>>>> The non-halting decider that I defined accepts any and all >>>>>>>>>>>> non-halting >>>>>>>>>>>> inputs and rejects any and all halting inputs. >>>>>>>>>>> >>>>>>>>>>> Excellent. Very clear (though there is always the worry that you >>>>>>>>>>> are >>>>>>>>>>> using your own meanings for some of the words). >>>>>>>>>>> >>>>>>>>>>> No such decider can be written (you can, of course, define what >>>>>>>>>>> must >>>>>>>>>>> do). There is no point in insisting over and over that it can be >>>>>>>>>>> written -- just write it! It will make you famous. >>>>>>>>> <cut> >>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent >>>>>>>>>>> two >>>>>>>>>>> years >>>>>>>>>>> walking that claim back. You've made another clear claim now. >>>>>>>>>>> Don't >>>>>>>>>>> spend another two years reneging on it -- write the program. >>>>>>>>>> >>>>>>>>>> As usual you make completely sure to totally ignore how I proved >>>>>>>>>> that >>>>>>>>>> I am correct >>>>>>>>> >>>>>>>>> Where is the program you claim you can write? The "proving you are >>>>>>>>> right" is not working out. You should try the "writing the code >>>>>>>>> you >>>>>>>>> said you could" plan instead. >>>>>>>>> >>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will >>>>>>>>> work" >>>>>>>>> and "this show I could do it" because, as you can imagine, I would >>>>>>>>> prefer you /not/ to write the code I'm saying can't be written! >>>>>>>>> >>>>>>>>> But so far, it's going well for me. How's it going for you? >>>>>>>>> >>>>>>>> >>>>>>>> If you are not a learned-by-rote dogmatist you can understand how >>>>>>>> the >>>>>>>> following non-halting decider that accepts any and all non-halting >>>>>>>> inputs and rejects any and all halting inputs defeats the: >>>>>>>> >>>>>>>> "do the opposite of whatever the halting decider decides" halting >>>>>>>> problem trick. (perhaps you were not aware of this trick?) >>>>>>>> >>>>>>>> When the first step that a halt decider does to indicate its >>>>>>>> non-halting >>>>>>>> decision is stop executing its input, its input can't do anything >>>>>>>> at all >>>>>>>> because it is already terminated. >>>>>>> Since it continues to watch the execution of its input looking for >>>>>>> non-halting behavior (infinite loops, and infinite recursion) >>>>>>> eventually >>>>>>> its input halts. At this point it reports HALTING. >>>>>>> >>>>>>> In both of these two possible cases it has totally defeated the >>>>>>> "do the opposite of whatever the halting decider decides" halting >>>>>>> problem trick: Because in both of these cases the input has already >>>>>>> terminated. >>>>>>> >>>>>> I don't think you've thought this through. >>>>>> >>>>>> I've suggested stubbing the function. If you do this, and run two >>>>>> tests, >>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) >>>>>> and H_Hat(H_Hat), you'll see the problem. >>>>>> >>>>>> You mustn't omit the second test. That's the whole point. >>>>>> >>>>> >>>>> I know these execution traces very well because I have done them over >>>>> and over again in my own mind many times over the last two years. >>>>> >>>>> The outermost invocation of this function >>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) >>>>> always returns true no matter what function calls it. >>>> >>>> This is the key aspect of the execution trace that forms the basis for >>>> deciding H_Hat: (All two years of my work has this as its foundation) >>>> >>>> This is the exact same 2018-12-13 @ 7:00 PM solution >>>> Detect that the halt decider is invoked two times from the same machine >>>> address without any conditional branch instructions in the execution >>>> trace of H_Hat that would terminate this otherwise infinite recursion. >>>> >>> >>> I previously pointed out that there is a problem with your "without >>> any conditional branch instructions in the execution trace of H_Hat >>> that would terminate this otherwise infinite recursion". (I don't >>> think you responded.) >>> >>> H_Hat /DOES/ contain conditional code that avoids the "otherwise >>> infinite recursion"! (That's assuming your ABNHBD() behaves as you've >>> previously described.) So your ABNHBD() is detecting non-halting >>> behaviour incorrectly, according to your own description of what it >>> does. >> >> No. Not at all. Not in the least. > Dorky >> >> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I); >> Only terminates inputs that would not otherwise terminate on their own. >> >> Two examples of such inputs that would not terminate on their own: >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); >> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H); >> >> Unless the above function terminates its inputs they would never >> otherwise terminate. >> > > You are totally confusing different versions of the program whose > calculations are being decided! > > > H_Hat is ONE FIXED program. *It's source code can't change!* To help > keep things clear, let's say what we have is version 1 of ABNHBD, and > call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1. > > Now if we look at this source code for H_Hat_1, we will see a function > ABNHBD_1(P,I), and this routine emulates the calculation P(I), up to a > point at least. The code of ABNHBD_1(P,I) *DOES* include steps that > will abort certain of these emulated calculations P(I). I'll call this > the *test T*. > > When we trace the calculation H_Hat_1(H_Hat_1) what do we see? There is > a call ABNHBD_1(H_Hat_1,H_Hat_1) which starts an internal emulation of > calculation H_Hat_1(H_Hat_1). We don't need to go into the details of > what that emulated calculation is doing - suffice it to say that the T > test in ABNHBD_1 /DOES/ detect what it /thinks/ is "non-halting > behaviour", aborts its emulation, and the calculation H_Hat_1(H_Hat_1) > DOES halt. As I have said many times now and you simply keep ignoring (Which is no actual rebuttal at all) the first (outer most instance of ABNHBD) does detect that its first parameter would never ever halt unless it stops executing it in DebugStep() mode. Maybe you are simply overwhelmed by the details involved in verifying that its decision it correct. > *Summary so far*: Calculation H_Hat_1(H_Hat_1) halts. (I think you have > come to agree with this, given the regular HP/Linz meaning for "halts"). > > But you want to go on and say "it /only/ halts because > ABNHBD_1(H_Hat_1,H_Hat_1) aborted its emulation". Or put another way, > it /only/ halts because its code contains tests and associated logic > that resulted in it halting. > > When you say that H_Hat_1 /wouldn't/ have halted if ABNHBD_1() hadn't > been written as it was, you're just say that H_Hat_1 wouldn't have > halted if H_Hat_1 had been written differently! Well, duh! No surprise > there :) > > Anyway, let's suppose we clone all the version 1 code to get version 2. > We edit ABNHBD_2() to remove test T, and recompile the source to get > H_Hat(2), and sure enough H_Hat_2(H_Hat_2) never halts. > > H_Hat_2 is *A COMPLETELY DIFFERENT PROGRAM*! It remains the case that > H_Hat_1(H_Hat_1) halts. If calculation H_Hat_1(H_Hat_1) were executed > by some emulator which just let its calculation run to completion, the > emulation would likewise halt. That's because the behaviour under a > correctly written emulator tracks the states of the calculation it's > emulating, and for H_Hat_1(H_Hat_1) that calculation halts. > > Alternatively, if your x86utm included a debug facility, we might be > able to set a breakpoint within ABNHBD_2() at the T test [within the > "native"/outer level process only! No breaking within inner level > emulations!]. Each time the breakpoint hits we jump the IP over the T > test, so it is effectively prevented from taking its abort branch, then > we resume execution. Continuing like this, we will eventually see that > the calculation being emulated *does* terminate. > > *Conclusion*: Talking about two different source codes for two > different test programs when we were only asked about one, is not even > coherent in the case of general ABNHBD input (P,I)! And for the > specific case of H_Hat() these /other/ programs are completely > irrelevent to anything in the HP proof, or the Linz proof in particular. > > Hmm, I bet this is why you've steadfastly refused to give a proper > specification for ABNHBD! It's because your underlying idea at its most > basic level is incoherent - you don't know how to meaningfully explain > all about "Emulation of P_2(I_2) /wouldn't/ halt, where you got P2 by > editing P's source code by, ummmm, by, ummm..., and don't forget you > have to amend input data I somehow, umm..." ! > > > Mike. > > >>> I suspect you are making the Big Mistake of assuming such "conditional >>> code" has to occur [in the trace of emulated code] BEFORE the emulated >>> code /initiates/ its nested emulation using the same machine address? >>> >>> [By "initiates its nested emulation" I mean "sets up the new virtual >>> process with its own stack, initialising the process ready to start >>> single stepping the requested calculation".] >>> >>> In fact, the conditional code occurs AFTER this point in the trace... >>> so if ABNHBD() is checking for that code, it needs to >>> a) *first* spot the OS call to initiate an emulation using the >>> same machine address, >>> b) *then* continue monitoring to determine that there is no >>> conditional code that terminates the calculation. >>> >>> Mike. >>> >> >> -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-31 16:40 +0000 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <Y-WdnYq0IKoTDgDCnZ2dnUU78KPNnZ2d@brightview.co.uk> |
| In reply to | #24720 |
On 31/10/2020 05:05, olcott wrote:
> On 10/30/2020 7:46 PM, Mike Terry wrote:
>> On 30/10/2020 22:21, olcott wrote:
>>> On 10/30/2020 5:08 PM, Mike Terry wrote:
>>>> On 30/10/2020 11:40, olcott wrote:
>>>>> On 10/30/2020 6:32 AM, olcott wrote:
>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts
>>>>>>>>>>>>>>> NON_HALTING
>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs,
>>>>>>>>>>>>>> while
>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than
>>>>>>>>>>>>>> "always".
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I
>>>>>>>>>>>>> need to
>>>>>>>>>>>>> make my presentation conform somewhat more closely to an
>>>>>>>>>>>>> academic
>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all
>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that
>>>>>>>>>>>> you
>>>>>>>>>>>> are
>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>
>>>>>>>>>>>> No such decider can be written (you can, of course, define what
>>>>>>>>>>>> must
>>>>>>>>>>>> do). There is no point in insisting over and over that it
>>>>>>>>>>>> can be
>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>> <cut>
>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've
>>>>>>>>>>>> spent two
>>>>>>>>>>>> years
>>>>>>>>>>>> walking that claim back. You've made another clear claim now.
>>>>>>>>>>>> Don't
>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>
>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved
>>>>>>>>>>> that
>>>>>>>>>>> I am correct
>>>>>>>>>>
>>>>>>>>>> Where is the program you claim you can write? The "proving you
>>>>>>>>>> are
>>>>>>>>>> right" is not working out. You should try the "writing the
>>>>>>>>>> code you
>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>
>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will
>>>>>>>>>> work"
>>>>>>>>>> and "this show I could do it" because, as you can imagine, I
>>>>>>>>>> would
>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>
>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how
>>>>>>>>> the
>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>
>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>
>>>>>>>>> When the first step that a halt decider does to indicate its
>>>>>>>>> non-halting
>>>>>>>>> decision is stop executing its input, its input can't do anything
>>>>>>>>> at all
>>>>>>>>> because it is already terminated.
>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>> non-halting behavior (infinite loops, and infinite recursion)
>>>>>>>> eventually
>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>
>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>> terminated.
>>>>>>>>
>>>>>>> I don't think you've thought this through.
>>>>>>>
>>>>>>> I've suggested stubbing the function. If you do this, and run two
>>>>>>> tests,
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>
>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>
>>>>>>
>>>>>> I know these execution traces very well because I have done them over
>>>>>> and over again in my own mind many times over the last two years.
>>>>>>
>>>>>> The outermost invocation of this function
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> always returns true no matter what function calls it.
>>>>>
>>>>> This is the key aspect of the execution trace that forms the basis for
>>>>> deciding H_Hat: (All two years of my work has this as its foundation)
>>>>>
>>>>> This is the exact same 2018-12-13 @ 7:00 PM solution
>>>>> Detect that the halt decider is invoked two times from the same
>>>>> machine
>>>>> address without any conditional branch instructions in the execution
>>>>> trace of H_Hat that would terminate this otherwise infinite recursion.
>>>>>
>>>>
>>>> I previously pointed out that there is a problem with your "without
>>>> any conditional branch instructions in the execution trace of H_Hat
>>>> that would terminate this otherwise infinite recursion". (I don't
>>>> think you responded.)
>>>>
>>>> H_Hat /DOES/ contain conditional code that avoids the "otherwise
>>>> infinite recursion"! (That's assuming your ABNHBD() behaves as you've
>>>> previously described.) So your ABNHBD() is detecting non-halting
>>>> behaviour incorrectly, according to your own description of what it
>>>> does.
>>>
>>> No. Not at all. Not in the least.
>> Dorky
>>>
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(P, I);
>>> Only terminates inputs that would not otherwise terminate on their own.
>>>
>>> Two examples of such inputs that would not terminate on their own:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H, H);
>>>
>>> Unless the above function terminates its inputs they would never
>>> otherwise terminate.
>>>
>>
>> You are totally confusing different versions of the program whose
>> calculations are being decided!
>>
>>
>> H_Hat is ONE FIXED program. *It's source code can't change!* To help
>> keep things clear, let's say what we have is version 1 of ABNHBD, and
>> call it ABNHBD_1. Similarly, we have associated H_1 and H_Hat_1.
>>
>> Now if we look at this source code for H_Hat_1, we will see a function
>> ABNHBD_1(P,I), and this routine emulates the calculation P(I), up to a
>> point at least. The code of ABNHBD_1(P,I) *DOES* include steps that
>> will abort certain of these emulated calculations P(I). I'll call
>> this the *test T*.
>>
>> When we trace the calculation H_Hat_1(H_Hat_1) what do we see? There
>> is a call ABNHBD_1(H_Hat_1,H_Hat_1) which starts an internal emulation
>> of calculation H_Hat_1(H_Hat_1). We don't need to go into the details
>> of what that emulated calculation is doing - suffice it to say that
>> the T test in ABNHBD_1 /DOES/ detect what it /thinks/ is "non-halting
>> behaviour", aborts its emulation, and the calculation H_Hat_1(H_Hat_1)
>> DOES halt.
>
>
> As I have said many times now and you simply keep ignoring
> (Which is no actual rebuttal at all) the first
> (outer most instance of ABNHBD) does detect that its first parameter
> would never ever halt unless it stops executing it in DebugStep() mode.
>
I am not confused. You are presumably objecting to my preceding text,
which (breaking it into clauses) said:
a) the T test in ABNHBD_1 /DOES/ detect what it
/thinks/ is "non-halting behaviour"
b) ..and aborts its emulation
c) ..and the calculation H_Hat_1(H_Hat_1) DOES halt.
Your response is that ABNHBD does detect that its first parameterwould
never ever halt unless it stops executing it in DebugStep() mode.
Presumably you're still talking about what I was talking about, namely
a trace of calculation H_Hat(H_Hat). And we have got to the point in
the trace where ABNHBD() is called (at outer level) with paramters
(H_Hat,H_Hat).
So are you saying that in that context, (a) above is wrong?
Are you saying that in that context, (b) above is wrong?
Are you saying that in that context, (c) above is wrong?
Or do you agree with all of those, but just thought you'd accuse me of
being confused when you agree with what I said?
Mike.
> Maybe you are simply overwhelmed by the details involved in verifying
> that its decision it correct.
>
>> *Summary so far*: Calculation H_Hat_1(H_Hat_1) halts. (I think you
>> have come to agree with this, given the regular HP/Linz meaning for
>> "halts").
>>
>> But you want to go on and say "it /only/ halts because
>> ABNHBD_1(H_Hat_1,H_Hat_1) aborted its emulation". Or put another way,
>> it /only/ halts because its code contains tests and associated logic
>> that resulted in it halting.
>>
>> When you say that H_Hat_1 /wouldn't/ have halted if ABNHBD_1() hadn't
>> been written as it was, you're just say that H_Hat_1 wouldn't have
>> halted if H_Hat_1 had been written differently! Well, duh! No
>> surprise there :)
>>
>> Anyway, let's suppose we clone all the version 1 code to get version
>> 2. We edit ABNHBD_2() to remove test T, and recompile the source to
>> get H_Hat(2), and sure enough H_Hat_2(H_Hat_2) never halts.
>>
>> H_Hat_2 is *A COMPLETELY DIFFERENT PROGRAM*! It remains the case that
>> H_Hat_1(H_Hat_1) halts. If calculation H_Hat_1(H_Hat_1) were executed
>> by some emulator which just let its calculation run to completion, the
>> emulation would likewise halt. That's because the behaviour under a
>> correctly written emulator tracks the states of the calculation it's
>> emulating, and for H_Hat_1(H_Hat_1) that calculation halts.
>>
>> Alternatively, if your x86utm included a debug facility, we might be
>> able to set a breakpoint within ABNHBD_2() at the T test [within the
>> "native"/outer level process only! No breaking within inner level
>> emulations!]. Each time the breakpoint hits we jump the IP over the T
>> test, so it is effectively prevented from taking its abort branch,
>> then we resume execution. Continuing like this, we will eventually
>> see that the calculation being emulated *does* terminate.
>>
>> *Conclusion*: Talking about two different source codes for two
>> different test programs when we were only asked about one, is not even
>> coherent in the case of general ABNHBD input (P,I)! And for the
>> specific case of H_Hat() these /other/ programs are completely
>> irrelevent to anything in the HP proof, or the Linz proof in particular.
>>
>> Hmm, I bet this is why you've steadfastly refused to give a proper
>> specification for ABNHBD! It's because your underlying idea at its
>> most basic level is incoherent - you don't know how to meaningfully
>> explain all about "Emulation of P_2(I_2) /wouldn't/ halt, where you
>> got P2 by editing P's source code by, ummmm, by, ummm..., and don't
>> forget you have to amend input data I somehow, umm..." !
>>
>>
>> Mike.
>>
>>
>>>> I suspect you are making the Big Mistake of assuming such "conditional
>>>> code" has to occur [in the trace of emulated code] BEFORE the emulated
>>>> code /initiates/ its nested emulation using the same machine address?
>>>>
>>>> [By "initiates its nested emulation" I mean "sets up the new virtual
>>>> process with its own stack, initialising the process ready to start
>>>> single stepping the requested calculation".]
>>>>
>>>> In fact, the conditional code occurs AFTER this point in the trace...
>>>> so if ABNHBD() is checking for that code, it needs to
>>>> a) *first* spot the OS call to initiate an emulation using the
>>>> same machine address,
>>>> b) *then* continue monitoring to determine that there is no
>>>> conditional code that terminates the calculation.
>>>>
>>>> Mike.
>>>>
>>>
>>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-30 05:36 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <35d97d30-49d4-48a1-a0c2-a03f00ffbad0n@googlegroups.com> |
| In reply to | #24671 |
On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
> > On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
> >> On 10/29/2020 9:36 PM, olcott wrote:
> >>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
> >>>> olcott <No...@NoWhere.com> writes:
> >>>>
> >>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
> >>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>
> >>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
> >>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>> <cut>
> >>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
> >>>>>>>>> input and Rejects HALTING input as follows:
> >>>>>>>>
> >>>>>>>> No decider can accept all, and only all, non-halting inputs, while
> >>>>>>>> rejecting all, and only all, halting ones.
> >>>>>>>>
> >>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
> >>>>>>>> terms like
> >>>>>>>> halting and non-halting. (b) I say exactly what inputs are
> >>>>>>>> accepted and
> >>>>>>>> which rejected by saying "all, and only all" rather than "always".
> >>>>>>>
> >>>>>>> Yes that is the exactly kind of improvement in wording that I need to
> >>>>>>> make my presentation conform somewhat more closely to an academic
> >>>>>>> paper degree of professionalism.
> >>>>>>>
> >>>>>>> The non-halting decider that I defined accepts any and all non-halting
> >>>>>>> inputs and rejects any and all halting inputs.
> >>>>>>
> >>>>>> Excellent. Very clear (though there is always the worry that you are
> >>>>>> using your own meanings for some of the words).
> >>>>>>
> >>>>>> No such decider can be written (you can, of course, define what must
> >>>>>> do). There is no point in insisting over and over that it can be
> >>>>>> written -- just write it! It will make you famous.
> >>>> <cut>
> >>>>>> You once made a clear claim. That was wrong, and you've spent two
> >>>>>> years
> >>>>>> walking that claim back. You've made another clear claim now. Don't
> >>>>>> spend another two years reneging on it -- write the program.
> >>>>>
> >>>>> As usual you make completely sure to totally ignore how I proved that
> >>>>> I am correct
> >>>>
> >>>> Where is the program you claim you can write? The "proving you are
> >>>> right" is not working out. You should try the "writing the code you
> >>>> said you could" plan instead.
> >>>>
> >>>> Of course I'm fine with you endlessly saying "this is how it will work"
> >>>> and "this show I could do it" because, as you can imagine, I would
> >>>> prefer you /not/ to write the code I'm saying can't be written!
> >>>>
> >>>> But so far, it's going well for me. How's it going for you?
> >>>>
> >>>
> >>> If you are not a learned-by-rote dogmatist you can understand how the
> >>> following non-halting decider that accepts any and all non-halting
> >>> inputs and rejects any and all halting inputs defeats the:
> >>>
> >>> "do the opposite of whatever the halting decider decides" halting
> >>> problem trick. (perhaps you were not aware of this trick?)
> >>>
> >>> When the first step that a halt decider does to indicate its non-halting
> >>> decision is stop executing its input, its input can't do anything at all
> >>> because it is already terminated.
> >> Since it continues to watch the execution of its input looking for
> >> non-halting behavior (infinite loops, and infinite recursion) eventually
> >> its input halts. At this point it reports HALTING.
> >>
> >> In both of these two possible cases it has totally defeated the
> >> "do the opposite of whatever the halting decider decides" halting
> >> problem trick: Because in both of these cases the input has already
> >> terminated.
> >>
> > I don't think you've thought this through.
> >
> > I've suggested stubbing the function. If you do this, and run two tests,
> > Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> > and H_Hat(H_Hat), you'll see the problem.
> >
> > You mustn't omit the second test. That's the whole point.
> >
> I know these execution traces very well because I have done them over
> and over again in my own mind many times over the last two years.
>
> The outermost invocation of this function
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> always returns true no matter what function call it.
>
OK. So let's stub it
bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
{
if (M == H_Hat && N == H_Hat)
return true;
else
assert(0); // we're a stub.
}
Now drop that in to your system, and you should see the problem.
You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
will terminate or not, so you need to run H first to get the answer. Then you
need to run H_Hat(H_Hat) to show that the answer was correct.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 10:32 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <TpednfDAEfphrAHCnZ2dnUU7-WnNnZ2d@giganews.com> |
| In reply to | #24674 |
On 10/30/2020 7:36 AM, Malcolm McLean wrote:
> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>
>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>> <cut>
>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>
>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>
>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>> terms like
>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>> accepted and
>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
>>>>>>>>>
>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>> paper degree of professionalism.
>>>>>>>>>
>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>
>>>>>>>> Excellent. Very clear (though there is always the worry that you are
>>>>>>>> using your own meanings for some of the words).
>>>>>>>>
>>>>>>>> No such decider can be written (you can, of course, define what must
>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>> written -- just write it! It will make you famous.
>>>>>> <cut>
>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>> years
>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>
>>>>>>> As usual you make completely sure to totally ignore how I proved that
>>>>>>> I am correct
>>>>>>
>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>> right" is not working out. You should try the "writing the code you
>>>>>> said you could" plan instead.
>>>>>>
>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>
>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>
>>>>>
>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>> following non-halting decider that accepts any and all non-halting
>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>
>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>
>>>>> When the first step that a halt decider does to indicate its non-halting
>>>>> decision is stop executing its input, its input can't do anything at all
>>>>> because it is already terminated.
>>>> Since it continues to watch the execution of its input looking for
>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
>>>> its input halts. At this point it reports HALTING.
>>>>
>>>> In both of these two possible cases it has totally defeated the
>>>> "do the opposite of whatever the halting decider decides" halting
>>>> problem trick: Because in both of these cases the input has already
>>>> terminated.
>>>>
>>> I don't think you've thought this through.
>>>
>>> I've suggested stubbing the function. If you do this, and run two tests,
>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>> and H_Hat(H_Hat), you'll see the problem.
>>>
>>> You mustn't omit the second test. That's the whole point.
>>>
>> I know these execution traces very well because I have done them over
>> and over again in my own mind many times over the last two years.
>>
>> The outermost invocation of this function
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>> always returns true no matter what function call it.
>>
> OK. So let's stub it
>
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
> {
> if (M == H_Hat && N == H_Hat)
> return true;
> else
> assert(0); // we're a stub.
> }
>
> Now drop that in to your system, and you should see the problem.
I is fake code, I am basing my answer on real code.
> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
> will terminate or not, so you need to run H first to get the answer. Then you
> need to run H_Hat(H_Hat) to show that the answer was correct.
>
What you are suggesing is like this:
Lets pretend that all cats are dogs.
Do cats bark?
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-30 08:54 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <8e45a613-7607-4078-bf94-bc8bfdf56789n@googlegroups.com> |
| In reply to | #24678 |
On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
> > On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
> >> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
> >>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
> >>>> On 10/29/2020 9:36 PM, olcott wrote:
> >>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
> >>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>
> >>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
> >>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>
> >>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
> >>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>> <cut>
> >>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
> >>>>>>>>>>> input and Rejects HALTING input as follows:
> >>>>>>>>>>
> >>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
> >>>>>>>>>> rejecting all, and only all, halting ones.
> >>>>>>>>>>
> >>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
> >>>>>>>>>> terms like
> >>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
> >>>>>>>>>> accepted and
> >>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
> >>>>>>>>>
> >>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
> >>>>>>>>> make my presentation conform somewhat more closely to an academic
> >>>>>>>>> paper degree of professionalism.
> >>>>>>>>>
> >>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
> >>>>>>>>> inputs and rejects any and all halting inputs.
> >>>>>>>>
> >>>>>>>> Excellent. Very clear (though there is always the worry that you are
> >>>>>>>> using your own meanings for some of the words).
> >>>>>>>>
> >>>>>>>> No such decider can be written (you can, of course, define what must
> >>>>>>>> do). There is no point in insisting over and over that it can be
> >>>>>>>> written -- just write it! It will make you famous.
> >>>>>> <cut>
> >>>>>>>> You once made a clear claim. That was wrong, and you've spent two
> >>>>>>>> years
> >>>>>>>> walking that claim back. You've made another clear claim now. Don't
> >>>>>>>> spend another two years reneging on it -- write the program.
> >>>>>>>
> >>>>>>> As usual you make completely sure to totally ignore how I proved that
> >>>>>>> I am correct
> >>>>>>
> >>>>>> Where is the program you claim you can write? The "proving you are
> >>>>>> right" is not working out. You should try the "writing the code you
> >>>>>> said you could" plan instead.
> >>>>>>
> >>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
> >>>>>> and "this show I could do it" because, as you can imagine, I would
> >>>>>> prefer you /not/ to write the code I'm saying can't be written!
> >>>>>>
> >>>>>> But so far, it's going well for me. How's it going for you?
> >>>>>>
> >>>>>
> >>>>> If you are not a learned-by-rote dogmatist you can understand how the
> >>>>> following non-halting decider that accepts any and all non-halting
> >>>>> inputs and rejects any and all halting inputs defeats the:
> >>>>>
> >>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>> problem trick. (perhaps you were not aware of this trick?)
> >>>>>
> >>>>> When the first step that a halt decider does to indicate its non-halting
> >>>>> decision is stop executing its input, its input can't do anything at all
> >>>>> because it is already terminated.
> >>>> Since it continues to watch the execution of its input looking for
> >>>> non-halting behavior (infinite loops, and infinite recursion) eventually
> >>>> its input halts. At this point it reports HALTING.
> >>>>
> >>>> In both of these two possible cases it has totally defeated the
> >>>> "do the opposite of whatever the halting decider decides" halting
> >>>> problem trick: Because in both of these cases the input has already
> >>>> terminated.
> >>>>
> >>> I don't think you've thought this through.
> >>>
> >>> I've suggested stubbing the function. If you do this, and run two tests,
> >>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>> and H_Hat(H_Hat), you'll see the problem.
> >>>
> >>> You mustn't omit the second test. That's the whole point.
> >>>
> >> I know these execution traces very well because I have done them over
> >> and over again in my own mind many times over the last two years.
> >>
> >> The outermost invocation of this function
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >> always returns true no matter what function call it.
> >>
> > OK. So let's stub it
> >
> > bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
> > {
> > if (M == H_Hat && N == H_Hat)
> > return true;
> > else
> > assert(0); // we're a stub.
> > }
> >
> > Now drop that in to your system, and you should see the problem.
> I is fake code, I am basing my answer on real code.
> > You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
> > will terminate or not, so you need to run H first to get the answer. Then you
> > need to run H_Hat(H_Hat) to show that the answer was correct.
> >
> What you are suggesing is like this:
> Lets pretend that all cats are dogs.
> Do cats bark?
>
No, I'm suggesting stubbing the function. That means, write it so that it
return correct results for one or two cases, and ignores the other cases.
The stubbed function has to behave like the real function, from the point
of view of a caller calling with one of the special cases.
Stubbed functions are used quite a bit in software prototyping or proof
of concept.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 11:30 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <ds-dne07ed48ogHCnZ2dnUU7-KHNnZ2d@giganews.com> |
| In reply to | #24680 |
On 10/30/2020 10:54 AM, Malcolm McLean wrote:
> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>> <cut>
>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>
>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>
>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>> terms like
>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>> accepted and
>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
>>>>>>>>>>>
>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>
>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>
>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>
>>>>>>>>>> No such decider can be written (you can, of course, define what must
>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>> <cut>
>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>>> years
>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>
>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
>>>>>>>>> I am correct
>>>>>>>>
>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>>> said you could" plan instead.
>>>>>>>>
>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>
>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>
>>>>>>>
>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>
>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>
>>>>>>> When the first step that a halt decider does to indicate its non-halting
>>>>>>> decision is stop executing its input, its input can't do anything at all
>>>>>>> because it is already terminated.
>>>>>> Since it continues to watch the execution of its input looking for
>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
>>>>>> its input halts. At this point it reports HALTING.
>>>>>>
>>>>>> In both of these two possible cases it has totally defeated the
>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>> problem trick: Because in both of these cases the input has already
>>>>>> terminated.
>>>>>>
>>>>> I don't think you've thought this through.
>>>>>
>>>>> I've suggested stubbing the function. If you do this, and run two tests,
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>
>>>>> You mustn't omit the second test. That's the whole point.
>>>>>
>>>> I know these execution traces very well because I have done them over
>>>> and over again in my own mind many times over the last two years.
>>>>
>>>> The outermost invocation of this function
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>> always returns true no matter what function call it.
>>>>
>>> OK. So let's stub it
>>>
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
>>> {
>>> if (M == H_Hat && N == H_Hat)
>>> return true;
>>> else
>>> assert(0); // we're a stub.
>>> }
>>>
>>> Now drop that in to your system, and you should see the problem.
>> I is fake code, I am basing my answer on real code.
>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
>>> will terminate or not, so you need to run H first to get the answer. Then you
>>> need to run H_Hat(H_Hat) to show that the answer was correct.
>>>
>> What you are suggesing is like this:
>> Lets pretend that all cats are dogs.
>> Do cats bark?
>>
> No, I'm suggesting stubbing the function. That means, write it so that it
> return correct results for one or two cases, and ignores the other cases.
> The stubbed function has to behave like the real function, from the point
> of view of a caller calling with one of the special cases.
>
> Stubbed functions are used quite a bit in software prototyping or proof
> of concept.
It leaves out all the key details that proves it is the correct answer.
The halt decider executes its input one step at a time until it detects
non-halting behavior or its input has terminated normally. When the halt
decider detects non-halting behavior it stops executing its input and
transitions to its own final state of:
NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
detected then as soon as the input terminates the halt decider
transitions to its own final state of INPUT_HAS_TERMINATED.
2018-12-13 @ 7:00 PM solution.
The halt decider detects the non-halting behavior of the Linz H_Hat
equivalent when it calls the halt decider from the same machine address
a second time and there are no conditional branches in the H_Hat
execution trace that would terminate this otherwise infinite recursion.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-30 16:22 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <4029e7b1-e798-4f42-9c53-50fb1fb34a2dn@googlegroups.com> |
| In reply to | #24684 |
On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
> > On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
> >> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
> >>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
> >>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
> >>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
> >>>>>> On 10/29/2020 9:36 PM, olcott wrote:
> >>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
> >>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>
> >>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
> >>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>
> >>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>> <cut>
> >>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
> >>>>>>>>>>>>> input and Rejects HALTING input as follows:
> >>>>>>>>>>>>
> >>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
> >>>>>>>>>>>> rejecting all, and only all, halting ones.
> >>>>>>>>>>>>
> >>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
> >>>>>>>>>>>> terms like
> >>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
> >>>>>>>>>>>> accepted and
> >>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
> >>>>>>>>>>>
> >>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
> >>>>>>>>>>> make my presentation conform somewhat more closely to an academic
> >>>>>>>>>>> paper degree of professionalism.
> >>>>>>>>>>>
> >>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
> >>>>>>>>>>> inputs and rejects any and all halting inputs.
> >>>>>>>>>>
> >>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
> >>>>>>>>>> using your own meanings for some of the words).
> >>>>>>>>>>
> >>>>>>>>>> No such decider can be written (you can, of course, define what must
> >>>>>>>>>> do). There is no point in insisting over and over that it can be
> >>>>>>>>>> written -- just write it! It will make you famous.
> >>>>>>>> <cut>
> >>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
> >>>>>>>>>> years
> >>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
> >>>>>>>>>> spend another two years reneging on it -- write the program.
> >>>>>>>>>
> >>>>>>>>> As usual you make completely sure to totally ignore how I proved that
> >>>>>>>>> I am correct
> >>>>>>>>
> >>>>>>>> Where is the program you claim you can write? The "proving you are
> >>>>>>>> right" is not working out. You should try the "writing the code you
> >>>>>>>> said you could" plan instead.
> >>>>>>>>
> >>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
> >>>>>>>> and "this show I could do it" because, as you can imagine, I would
> >>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
> >>>>>>>>
> >>>>>>>> But so far, it's going well for me. How's it going for you?
> >>>>>>>>
> >>>>>>>
> >>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
> >>>>>>> following non-halting decider that accepts any and all non-halting
> >>>>>>> inputs and rejects any and all halting inputs defeats the:
> >>>>>>>
> >>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>> problem trick. (perhaps you were not aware of this trick?)
> >>>>>>>
> >>>>>>> When the first step that a halt decider does to indicate its non-halting
> >>>>>>> decision is stop executing its input, its input can't do anything at all
> >>>>>>> because it is already terminated.
> >>>>>> Since it continues to watch the execution of its input looking for
> >>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
> >>>>>> its input halts. At this point it reports HALTING.
> >>>>>>
> >>>>>> In both of these two possible cases it has totally defeated the
> >>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>> problem trick: Because in both of these cases the input has already
> >>>>>> terminated.
> >>>>>>
> >>>>> I don't think you've thought this through.
> >>>>>
> >>>>> I've suggested stubbing the function. If you do this, and run two tests,
> >>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>> and H_Hat(H_Hat), you'll see the problem.
> >>>>>
> >>>>> You mustn't omit the second test. That's the whole point.
> >>>>>
> >>>> I know these execution traces very well because I have done them over
> >>>> and over again in my own mind many times over the last two years.
> >>>>
> >>>> The outermost invocation of this function
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>> always returns true no matter what function call it.
> >>>>
> >>> OK. So let's stub it
> >>>
> >>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
> >>> {
> >>> if (M == H_Hat && N == H_Hat)
> >>> return true;
> >>> else
> >>> assert(0); // we're a stub.
> >>> }
> >>>
> >>> Now drop that in to your system, and you should see the problem.
> >> I is fake code, I am basing my answer on real code.
> >>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
> >>> will terminate or not, so you need to run H first to get the answer. Then you
> >>> need to run H_Hat(H_Hat) to show that the answer was correct.
> >>>
> >> What you are suggesing is like this:
> >> Lets pretend that all cats are dogs.
> >> Do cats bark?
> >>
> > No, I'm suggesting stubbing the function. That means, write it so that it
> > return correct results for one or two cases, and ignores the other cases.
> > The stubbed function has to behave like the real function, from the point
> > of view of a caller calling with one of the special cases.
> >
> > Stubbed functions are used quite a bit in software prototyping or proof
> > of concept.
> It leaves out all the key details that proves it is the correct answer.
>
It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
or false, and it always returns the same value for the same inputs. So if you only
have one input to handle, it can be stubbed by a simple return true / return false.
Unless it does something else as well. Then trying to stub it will expose
that something else.
>
> The halt decider executes its input one step at a time until it detects
> non-halting behavior or its input has terminated normally. When the halt
> decider detects non-halting behavior it stops executing its input and
> transitions to its own final state of:
> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
> detected then as soon as the input terminates the halt decider
> transitions to its own final state of INPUT_HAS_TERMINATED.
>
> 2018-12-13 @ 7:00 PM solution.
> The halt decider detects the non-halting behavior of the Linz H_Hat
> equivalent when it calls the halt decider from the same machine address
> a second time and there are no conditional branches in the H_Hat
> execution trace that would terminate this otherwise infinite recursion.
>
Once you've stubbed the complex function (for a real decider) we can see
these parts. As I've said, I think that will make clear to you the problem
with your system.
The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
The results need to be consistent.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 18:41 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <_cOdnY34PYhaOQHCnZ2dnUU7-WnNnZ2d@giganews.com> |
| In reply to | #24695 |
On 10/30/2020 6:22 PM, Malcolm McLean wrote:
> On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
>> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
>>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
>>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
>>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>
>>>>>>>>>>>> No such decider can be written (you can, of course, define what must
>>>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>> <cut>
>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>>>>> years
>>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>
>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
>>>>>>>>>>> I am correct
>>>>>>>>>>
>>>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>
>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
>>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>
>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>
>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>
>>>>>>>>> When the first step that a halt decider does to indicate its non-halting
>>>>>>>>> decision is stop executing its input, its input can't do anything at all
>>>>>>>>> because it is already terminated.
>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>
>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>> terminated.
>>>>>>>>
>>>>>>> I don't think you've thought this through.
>>>>>>>
>>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>
>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>
>>>>>> I know these execution traces very well because I have done them over
>>>>>> and over again in my own mind many times over the last two years.
>>>>>>
>>>>>> The outermost invocation of this function
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> always returns true no matter what function call it.
>>>>>>
>>>>> OK. So let's stub it
>>>>>
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
>>>>> {
>>>>> if (M == H_Hat && N == H_Hat)
>>>>> return true;
>>>>> else
>>>>> assert(0); // we're a stub.
>>>>> }
>>>>>
>>>>> Now drop that in to your system, and you should see the problem.
>>>> I is fake code, I am basing my answer on real code.
>>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
>>>>> will terminate or not, so you need to run H first to get the answer. Then you
>>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
>>>>>
>>>> What you are suggesing is like this:
>>>> Lets pretend that all cats are dogs.
>>>> Do cats bark?
>>>>
>>> No, I'm suggesting stubbing the function. That means, write it so that it
>>> return correct results for one or two cases, and ignores the other cases.
>>> The stubbed function has to behave like the real function, from the point
>>> of view of a caller calling with one of the special cases.
>>>
>>> Stubbed functions are used quite a bit in software prototyping or proof
>>> of concept.
>> It leaves out all the key details that proves it is the correct answer.
>>
> It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
> or false, and it always returns the same value for the same inputs. So if you only
> have one input to handle, it can be stubbed by a simple return true / return false.
>
> Unless it does something else as well. Then trying to stub it will expose
> that something else.
>>
>> The halt decider executes its input one step at a time until it detects
>> non-halting behavior or its input has terminated normally. When the halt
>> decider detects non-halting behavior it stops executing its input and
>> transitions to its own final state of:
>> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
>> detected then as soon as the input terminates the halt decider
>> transitions to its own final state of INPUT_HAS_TERMINATED.
>>
>> 2018-12-13 @ 7:00 PM solution.
>> The halt decider detects the non-halting behavior of the Linz H_Hat
>> equivalent when it calls the halt decider from the same machine address
>> a second time and there are no conditional branches in the H_Hat
>> execution trace that would terminate this otherwise infinite recursion.
>>
> Once you've stubbed the complex function (for a real decider) we can see
> these parts. As I've said, I think that will make clear to you the problem
> with your system.
> The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
> The results need to be consistent.
>
As soon as I fix the bug with the local process context stacks I can
code the actual halt decider that does exactly what I claimed that it does.
If it does exactly what I claimed that it does in the detailed
description of the execution trace then we can know that it does decide
H_Hat() correctly.
In the mean time people could simply hypothesize that my detailed
execution trace is accurate and see that this does correctly decide
H_Hat (see below).
The halt decider executes its input one step at a time until it detects
non-halting behavior or its input has terminated normally. When the halt
decider detects non-halting behavior it stops executing its input and
transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
If non-halting behavior is never detected then as soon as the input
terminates the halt decider transitions to its own final state of
INPUT_HAS_TERMINATED.
2018-12-13 @ 7:00 PM solution.
The halt decider detects the non-halting behavior of the Linz H_Hat
equivalent when H_Hat calls the halt decider from the same machine
address a second time and there are no conditional branches in the H_Hat
execution trace that would terminate this otherwise infinite recursion.
x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
Stops executing and accepts any and all non-halting inputs and rejects
any and all halting inputs.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-30 16:48 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <59a2c865-cd4d-4609-bc66-fef0f2983b97n@googlegroups.com> |
| In reply to | #24696 |
On Friday, 30 October 2020 at 23:42:07 UTC, olcott wrote:
> On 10/30/2020 6:22 PM, Malcolm McLean wrote:
> > On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
> >> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
> >>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
> >>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
> >>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
> >>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
> >>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
> >>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
> >>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
> >>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>
> >>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>> <cut>
> >>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
> >>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
> >>>>>>>>>>>>>> rejecting all, and only all, halting ones.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
> >>>>>>>>>>>>>> terms like
> >>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
> >>>>>>>>>>>>>> accepted and
> >>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
> >>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
> >>>>>>>>>>>>> paper degree of professionalism.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
> >>>>>>>>>>>>> inputs and rejects any and all halting inputs.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
> >>>>>>>>>>>> using your own meanings for some of the words).
> >>>>>>>>>>>>
> >>>>>>>>>>>> No such decider can be written (you can, of course, define what must
> >>>>>>>>>>>> do). There is no point in insisting over and over that it can be
> >>>>>>>>>>>> written -- just write it! It will make you famous.
> >>>>>>>>>> <cut>
> >>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
> >>>>>>>>>>>> years
> >>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
> >>>>>>>>>>>> spend another two years reneging on it -- write the program.
> >>>>>>>>>>>
> >>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
> >>>>>>>>>>> I am correct
> >>>>>>>>>>
> >>>>>>>>>> Where is the program you claim you can write? The "proving you are
> >>>>>>>>>> right" is not working out. You should try the "writing the code you
> >>>>>>>>>> said you could" plan instead.
> >>>>>>>>>>
> >>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
> >>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
> >>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
> >>>>>>>>>>
> >>>>>>>>>> But so far, it's going well for me. How's it going for you?
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
> >>>>>>>>> following non-halting decider that accepts any and all non-halting
> >>>>>>>>> inputs and rejects any and all halting inputs defeats the:
> >>>>>>>>>
> >>>>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
> >>>>>>>>>
> >>>>>>>>> When the first step that a halt decider does to indicate its non-halting
> >>>>>>>>> decision is stop executing its input, its input can't do anything at all
> >>>>>>>>> because it is already terminated.
> >>>>>>>> Since it continues to watch the execution of its input looking for
> >>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
> >>>>>>>> its input halts. At this point it reports HALTING.
> >>>>>>>>
> >>>>>>>> In both of these two possible cases it has totally defeated the
> >>>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>>> problem trick: Because in both of these cases the input has already
> >>>>>>>> terminated.
> >>>>>>>>
> >>>>>>> I don't think you've thought this through.
> >>>>>>>
> >>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
> >>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>>>> and H_Hat(H_Hat), you'll see the problem.
> >>>>>>>
> >>>>>>> You mustn't omit the second test. That's the whole point.
> >>>>>>>
> >>>>>> I know these execution traces very well because I have done them over
> >>>>>> and over again in my own mind many times over the last two years.
> >>>>>>
> >>>>>> The outermost invocation of this function
> >>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>>> always returns true no matter what function call it.
> >>>>>>
> >>>>> OK. So let's stub it
> >>>>>
> >>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
> >>>>> {
> >>>>> if (M == H_Hat && N == H_Hat)
> >>>>> return true;
> >>>>> else
> >>>>> assert(0); // we're a stub.
> >>>>> }
> >>>>>
> >>>>> Now drop that in to your system, and you should see the problem.
> >>>> I is fake code, I am basing my answer on real code.
> >>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
> >>>>> will terminate or not, so you need to run H first to get the answer. Then you
> >>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
> >>>>>
> >>>> What you are suggesing is like this:
> >>>> Lets pretend that all cats are dogs.
> >>>> Do cats bark?
> >>>>
> >>> No, I'm suggesting stubbing the function. That means, write it so that it
> >>> return correct results for one or two cases, and ignores the other cases.
> >>> The stubbed function has to behave like the real function, from the point
> >>> of view of a caller calling with one of the special cases.
> >>>
> >>> Stubbed functions are used quite a bit in software prototyping or proof
> >>> of concept.
> >> It leaves out all the key details that proves it is the correct answer.
> >>
> > It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
> > or false, and it always returns the same value for the same inputs. So if you only
> > have one input to handle, it can be stubbed by a simple return true / return false.
> >
> > Unless it does something else as well. Then trying to stub it will expose
> > that something else.
> >>
> >> The halt decider executes its input one step at a time until it detects
> >> non-halting behavior or its input has terminated normally. When the halt
> >> decider detects non-halting behavior it stops executing its input and
> >> transitions to its own final state of:
> >> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
> >> detected then as soon as the input terminates the halt decider
> >> transitions to its own final state of INPUT_HAS_TERMINATED.
> >>
> >> 2018-12-13 @ 7:00 PM solution.
> >> The halt decider detects the non-halting behavior of the Linz H_Hat
> >> equivalent when it calls the halt decider from the same machine address
> >> a second time and there are no conditional branches in the H_Hat
> >> execution trace that would terminate this otherwise infinite recursion.
> >>
> > Once you've stubbed the complex function (for a real decider) we can see
> > these parts. As I've said, I think that will make clear to you the problem
> > with your system.
> > The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
> > The results need to be consistent.
> >
> As soon as I fix the bug with the local process context stacks I can
> code the actual halt decider that does exactly what I claimed that it does.
>
> If it does exactly what I claimed that it does in the detailed
> description of the execution trace then we can know that it does decide
> H_Hat() correctly.
>
> In the mean time people could simply hypothesize that my detailed
> execution trace is accurate and see that this does correctly decide
> H_Hat (see below).
> The halt decider executes its input one step at a time until it detects
> non-halting behavior or its input has terminated normally. When the halt
> decider detects non-halting behavior it stops executing its input and
> transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
>
> If non-halting behavior is never detected then as soon as the input
> terminates the halt decider transitions to its own final state of
> INPUT_HAS_TERMINATED.
>
> 2018-12-13 @ 7:00 PM solution.
> The halt decider detects the non-halting behavior of the Linz H_Hat
> equivalent when H_Hat calls the halt decider from the same machine
> address a second time and there are no conditional branches in the H_Hat
> execution trace that would terminate this otherwise infinite recursion.
> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>
> Stops executing and accepts any and all non-halting inputs and rejects
> any and all halting inputs.
>
So how are you using the term "rejects?"
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 18:50 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <huSdnSoAx9kyOwHCnZ2dnUU7-YWdnZ2d@giganews.com> |
| In reply to | #24697 |
On 10/30/2020 6:48 PM, Malcolm McLean wrote:
> On Friday, 30 October 2020 at 23:42:07 UTC, olcott wrote:
>> On 10/30/2020 6:22 PM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
>>>> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
>>>>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
>>>>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
>>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
>>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
>>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
>>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
>>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
>>>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No such decider can be written (you can, of course, define what must
>>>>>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>>>>>>> years
>>>>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
>>>>>>>>>>>>> I am correct
>>>>>>>>>>>>
>>>>>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>>>
>>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
>>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>>>
>>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>>>
>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>>>
>>>>>>>>>>> When the first step that a halt decider does to indicate its non-halting
>>>>>>>>>>> decision is stop executing its input, its input can't do anything at all
>>>>>>>>>>> because it is already terminated.
>>>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
>>>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>>>
>>>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>>>> terminated.
>>>>>>>>>>
>>>>>>>>> I don't think you've thought this through.
>>>>>>>>>
>>>>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>>>
>>>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>>>
>>>>>>>> I know these execution traces very well because I have done them over
>>>>>>>> and over again in my own mind many times over the last two years.
>>>>>>>>
>>>>>>>> The outermost invocation of this function
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>> always returns true no matter what function call it.
>>>>>>>>
>>>>>>> OK. So let's stub it
>>>>>>>
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
>>>>>>> {
>>>>>>> if (M == H_Hat && N == H_Hat)
>>>>>>> return true;
>>>>>>> else
>>>>>>> assert(0); // we're a stub.
>>>>>>> }
>>>>>>>
>>>>>>> Now drop that in to your system, and you should see the problem.
>>>>>> I is fake code, I am basing my answer on real code.
>>>>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
>>>>>>> will terminate or not, so you need to run H first to get the answer. Then you
>>>>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
>>>>>>>
>>>>>> What you are suggesing is like this:
>>>>>> Lets pretend that all cats are dogs.
>>>>>> Do cats bark?
>>>>>>
>>>>> No, I'm suggesting stubbing the function. That means, write it so that it
>>>>> return correct results for one or two cases, and ignores the other cases.
>>>>> The stubbed function has to behave like the real function, from the point
>>>>> of view of a caller calling with one of the special cases.
>>>>>
>>>>> Stubbed functions are used quite a bit in software prototyping or proof
>>>>> of concept.
>>>> It leaves out all the key details that proves it is the correct answer.
>>>>
>>> It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
>>> or false, and it always returns the same value for the same inputs. So if you only
>>> have one input to handle, it can be stubbed by a simple return true / return false.
>>>
>>> Unless it does something else as well. Then trying to stub it will expose
>>> that something else.
>>>>
>>>> The halt decider executes its input one step at a time until it detects
>>>> non-halting behavior or its input has terminated normally. When the halt
>>>> decider detects non-halting behavior it stops executing its input and
>>>> transitions to its own final state of:
>>>> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
>>>> detected then as soon as the input terminates the halt decider
>>>> transitions to its own final state of INPUT_HAS_TERMINATED.
>>>>
>>>> 2018-12-13 @ 7:00 PM solution.
>>>> The halt decider detects the non-halting behavior of the Linz H_Hat
>>>> equivalent when it calls the halt decider from the same machine address
>>>> a second time and there are no conditional branches in the H_Hat
>>>> execution trace that would terminate this otherwise infinite recursion.
>>>>
>>> Once you've stubbed the complex function (for a real decider) we can see
>>> these parts. As I've said, I think that will make clear to you the problem
>>> with your system.
>>> The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
>>> The results need to be consistent.
>>>
>> As soon as I fix the bug with the local process context stacks I can
>> code the actual halt decider that does exactly what I claimed that it does.
>>
>> If it does exactly what I claimed that it does in the detailed
>> description of the execution trace then we can know that it does decide
>> H_Hat() correctly.
>>
>> In the mean time people could simply hypothesize that my detailed
>> execution trace is accurate and see that this does correctly decide
>> H_Hat (see below).
>> The halt decider executes its input one step at a time until it detects
>> non-halting behavior or its input has terminated normally. When the halt
>> decider detects non-halting behavior it stops executing its input and
>> transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
>>
>> If non-halting behavior is never detected then as soon as the input
>> terminates the halt decider transitions to its own final state of
>> INPUT_HAS_TERMINATED.
>>
>> 2018-12-13 @ 7:00 PM solution.
>> The halt decider detects the non-halting behavior of the Linz H_Hat
>> equivalent when H_Hat calls the halt decider from the same machine
>> address a second time and there are no conditional branches in the H_Hat
>> execution trace that would terminate this otherwise infinite recursion.
>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>
>> Stops executing and accepts any and all non-halting inputs and rejects
>> any and all halting inputs.
>>
> So how are you using the term "rejects?"
>
Intuitively, a decider should be a Turing machine that given an input,
halts and either accepts or rejects, relaying its answer in one of many
equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape.Yuval Filmus
https://cs.stackexchange.com/questions/84433/what-is-decider
Yuval Filmus top 0.04% overall Assistant Professor in the Department of
Computer Science at the Technion.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-30 16:59 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <487c1c0a-2c32-402f-b62b-c9f0f8d18848n@googlegroups.com> |
| In reply to | #24698 |
On Friday, 30 October 2020 at 23:50:14 UTC, olcott wrote:
> On 10/30/2020 6:48 PM, Malcolm McLean wrote:
> > On Friday, 30 October 2020 at 23:42:07 UTC, olcott wrote:
> >> On 10/30/2020 6:22 PM, Malcolm McLean wrote:
> >>> On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
> >>>> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
> >>>>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
> >>>>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
> >>>>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
> >>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
> >>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
> >>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
> >>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>> <cut>
> >>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
> >>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
> >>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
> >>>>>>>>>>>>>>>> terms like
> >>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
> >>>>>>>>>>>>>>>> accepted and
> >>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
> >>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
> >>>>>>>>>>>>>>> paper degree of professionalism.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
> >>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
> >>>>>>>>>>>>>> using your own meanings for some of the words).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> No such decider can be written (you can, of course, define what must
> >>>>>>>>>>>>>> do). There is no point in insisting over and over that it can be
> >>>>>>>>>>>>>> written -- just write it! It will make you famous.
> >>>>>>>>>>>> <cut>
> >>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
> >>>>>>>>>>>>>> years
> >>>>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
> >>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
> >>>>>>>>>>>>> I am correct
> >>>>>>>>>>>>
> >>>>>>>>>>>> Where is the program you claim you can write? The "proving you are
> >>>>>>>>>>>> right" is not working out. You should try the "writing the code you
> >>>>>>>>>>>> said you could" plan instead.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
> >>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
> >>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
> >>>>>>>>>>>>
> >>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
> >>>>>>>>>>> following non-halting decider that accepts any and all non-halting
> >>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
> >>>>>>>>>>>
> >>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
> >>>>>>>>>>>
> >>>>>>>>>>> When the first step that a halt decider does to indicate its non-halting
> >>>>>>>>>>> decision is stop executing its input, its input can't do anything at all
> >>>>>>>>>>> because it is already terminated.
> >>>>>>>>>> Since it continues to watch the execution of its input looking for
> >>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
> >>>>>>>>>> its input halts. At this point it reports HALTING.
> >>>>>>>>>>
> >>>>>>>>>> In both of these two possible cases it has totally defeated the
> >>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>>>>> problem trick: Because in both of these cases the input has already
> >>>>>>>>>> terminated.
> >>>>>>>>>>
> >>>>>>>>> I don't think you've thought this through.
> >>>>>>>>>
> >>>>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
> >>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
> >>>>>>>>>
> >>>>>>>>> You mustn't omit the second test. That's the whole point.
> >>>>>>>>>
> >>>>>>>> I know these execution traces very well because I have done them over
> >>>>>>>> and over again in my own mind many times over the last two years.
> >>>>>>>>
> >>>>>>>> The outermost invocation of this function
> >>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>>>>> always returns true no matter what function call it.
> >>>>>>>>
> >>>>>>> OK. So let's stub it
> >>>>>>>
> >>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
> >>>>>>> {
> >>>>>>> if (M == H_Hat && N == H_Hat)
> >>>>>>> return true;
> >>>>>>> else
> >>>>>>> assert(0); // we're a stub.
> >>>>>>> }
> >>>>>>>
> >>>>>>> Now drop that in to your system, and you should see the problem.
> >>>>>> I is fake code, I am basing my answer on real code.
> >>>>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
> >>>>>>> will terminate or not, so you need to run H first to get the answer. Then you
> >>>>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
> >>>>>>>
> >>>>>> What you are suggesing is like this:
> >>>>>> Lets pretend that all cats are dogs.
> >>>>>> Do cats bark?
> >>>>>>
> >>>>> No, I'm suggesting stubbing the function. That means, write it so that it
> >>>>> return correct results for one or two cases, and ignores the other cases.
> >>>>> The stubbed function has to behave like the real function, from the point
> >>>>> of view of a caller calling with one of the special cases.
> >>>>>
> >>>>> Stubbed functions are used quite a bit in software prototyping or proof
> >>>>> of concept.
> >>>> It leaves out all the key details that proves it is the correct answer.
> >>>>
> >>> It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
> >>> or false, and it always returns the same value for the same inputs. So if you only
> >>> have one input to handle, it can be stubbed by a simple return true / return false.
> >>>
> >>> Unless it does something else as well. Then trying to stub it will expose
> >>> that something else.
> >>>>
> >>>> The halt decider executes its input one step at a time until it detects
> >>>> non-halting behavior or its input has terminated normally. When the halt
> >>>> decider detects non-halting behavior it stops executing its input and
> >>>> transitions to its own final state of:
> >>>> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
> >>>> detected then as soon as the input terminates the halt decider
> >>>> transitions to its own final state of INPUT_HAS_TERMINATED.
> >>>>
> >>>> 2018-12-13 @ 7:00 PM solution.
> >>>> The halt decider detects the non-halting behavior of the Linz H_Hat
> >>>> equivalent when it calls the halt decider from the same machine address
> >>>> a second time and there are no conditional branches in the H_Hat
> >>>> execution trace that would terminate this otherwise infinite recursion.
> >>>>
> >>> Once you've stubbed the complex function (for a real decider) we can see
> >>> these parts. As I've said, I think that will make clear to you the problem
> >>> with your system.
> >>> The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
> >>> The results need to be consistent.
> >>>
> >> As soon as I fix the bug with the local process context stacks I can
> >> code the actual halt decider that does exactly what I claimed that it does.
> >>
> >> If it does exactly what I claimed that it does in the detailed
> >> description of the execution trace then we can know that it does decide
> >> H_Hat() correctly.
> >>
> >> In the mean time people could simply hypothesize that my detailed
> >> execution trace is accurate and see that this does correctly decide
> >> H_Hat (see below).
> >> The halt decider executes its input one step at a time until it detects
> >> non-halting behavior or its input has terminated normally. When the halt
> >> decider detects non-halting behavior it stops executing its input and
> >> transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
> >>
> >> If non-halting behavior is never detected then as soon as the input
> >> terminates the halt decider transitions to its own final state of
> >> INPUT_HAS_TERMINATED.
> >>
> >> 2018-12-13 @ 7:00 PM solution.
> >> The halt decider detects the non-halting behavior of the Linz H_Hat
> >> equivalent when H_Hat calls the halt decider from the same machine
> >> address a second time and there are no conditional branches in the H_Hat
> >> execution trace that would terminate this otherwise infinite recursion.
> >> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> >>
> >> Stops executing and accepts any and all non-halting inputs and rejects
> >> any and all halting inputs.
> >>
> > So how are you using the term "rejects?"
> >
> Intuitively, a decider should be a Turing machine that given an input,
> halts and either accepts or rejects, relaying its answer in one of many
> equivalent ways, such as halting at an ACCEPT or REJECT state, or
> leaving its answer on the output tape.Yuval Filmus
> https://cs.stackexchange.com/questions/84433/what-is-decider
>
> Yuval Filmus top 0.04% overall Assistant Professor in the Department of
> Computer Science at the Technion.
>
So "rejects" just means "returns true", as far as
"Aborted_Because_Non_Halting_Behavior_Detected" is concerned.
No obstacle there to stubbing the function. So what is the obstacle?
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 19:07 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <CZydna3_WtQqNwHCnZ2dnUU7-UnNnZ2d@giganews.com> |
| In reply to | #24699 |
On 10/30/2020 6:59 PM, Malcolm McLean wrote:
> On Friday, 30 October 2020 at 23:50:14 UTC, olcott wrote:
>> On 10/30/2020 6:48 PM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 23:42:07 UTC, olcott wrote:
>>>> On 10/30/2020 6:22 PM, Malcolm McLean wrote:
>>>>> On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
>>>>>> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
>>>>>>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
>>>>>>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
>>>>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
>>>>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
>>>>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
>>>>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
>>>>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
>>>>>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No such decider can be written (you can, of course, define what must
>>>>>>>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>>>>>>>>> years
>>>>>>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
>>>>>>>>>>>>>>> I am correct
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
>>>>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>>>>>
>>>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>>>>>
>>>>>>>>>>>>> When the first step that a halt decider does to indicate its non-halting
>>>>>>>>>>>>> decision is stop executing its input, its input can't do anything at all
>>>>>>>>>>>>> because it is already terminated.
>>>>>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
>>>>>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>>>>>
>>>>>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>>>>>> terminated.
>>>>>>>>>>>>
>>>>>>>>>>> I don't think you've thought this through.
>>>>>>>>>>>
>>>>>>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
>>>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>>>>>
>>>>>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>>>>>
>>>>>>>>>> I know these execution traces very well because I have done them over
>>>>>>>>>> and over again in my own mind many times over the last two years.
>>>>>>>>>>
>>>>>>>>>> The outermost invocation of this function
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>>>> always returns true no matter what function call it.
>>>>>>>>>>
>>>>>>>>> OK. So let's stub it
>>>>>>>>>
>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
>>>>>>>>> {
>>>>>>>>> if (M == H_Hat && N == H_Hat)
>>>>>>>>> return true;
>>>>>>>>> else
>>>>>>>>> assert(0); // we're a stub.
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Now drop that in to your system, and you should see the problem.
>>>>>>>> I is fake code, I am basing my answer on real code.
>>>>>>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
>>>>>>>>> will terminate or not, so you need to run H first to get the answer. Then you
>>>>>>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
>>>>>>>>>
>>>>>>>> What you are suggesing is like this:
>>>>>>>> Lets pretend that all cats are dogs.
>>>>>>>> Do cats bark?
>>>>>>>>
>>>>>>> No, I'm suggesting stubbing the function. That means, write it so that it
>>>>>>> return correct results for one or two cases, and ignores the other cases.
>>>>>>> The stubbed function has to behave like the real function, from the point
>>>>>>> of view of a caller calling with one of the special cases.
>>>>>>>
>>>>>>> Stubbed functions are used quite a bit in software prototyping or proof
>>>>>>> of concept.
>>>>>> It leaves out all the key details that proves it is the correct answer.
>>>>>>
>>>>> It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
>>>>> or false, and it always returns the same value for the same inputs. So if you only
>>>>> have one input to handle, it can be stubbed by a simple return true / return false.
>>>>>
>>>>> Unless it does something else as well. Then trying to stub it will expose
>>>>> that something else.
>>>>>>
>>>>>> The halt decider executes its input one step at a time until it detects
>>>>>> non-halting behavior or its input has terminated normally. When the halt
>>>>>> decider detects non-halting behavior it stops executing its input and
>>>>>> transitions to its own final state of:
>>>>>> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
>>>>>> detected then as soon as the input terminates the halt decider
>>>>>> transitions to its own final state of INPUT_HAS_TERMINATED.
>>>>>>
>>>>>> 2018-12-13 @ 7:00 PM solution.
>>>>>> The halt decider detects the non-halting behavior of the Linz H_Hat
>>>>>> equivalent when it calls the halt decider from the same machine address
>>>>>> a second time and there are no conditional branches in the H_Hat
>>>>>> execution trace that would terminate this otherwise infinite recursion.
>>>>>>
>>>>> Once you've stubbed the complex function (for a real decider) we can see
>>>>> these parts. As I've said, I think that will make clear to you the problem
>>>>> with your system.
>>>>> The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
>>>>> The results need to be consistent.
>>>>>
>>>> As soon as I fix the bug with the local process context stacks I can
>>>> code the actual halt decider that does exactly what I claimed that it does.
>>>>
>>>> If it does exactly what I claimed that it does in the detailed
>>>> description of the execution trace then we can know that it does decide
>>>> H_Hat() correctly.
>>>>
>>>> In the mean time people could simply hypothesize that my detailed
>>>> execution trace is accurate and see that this does correctly decide
>>>> H_Hat (see below).
>>>> The halt decider executes its input one step at a time until it detects
>>>> non-halting behavior or its input has terminated normally. When the halt
>>>> decider detects non-halting behavior it stops executing its input and
>>>> transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
>>>>
>>>> If non-halting behavior is never detected then as soon as the input
>>>> terminates the halt decider transitions to its own final state of
>>>> INPUT_HAS_TERMINATED.
>>>>
>>>> 2018-12-13 @ 7:00 PM solution.
>>>> The halt decider detects the non-halting behavior of the Linz H_Hat
>>>> equivalent when H_Hat calls the halt decider from the same machine
>>>> address a second time and there are no conditional branches in the H_Hat
>>>> execution trace that would terminate this otherwise infinite recursion.
>>>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>
>>>> Stops executing and accepts any and all non-halting inputs and rejects
>>>> any and all halting inputs.
>>>>
>>> So how are you using the term "rejects?"
>>>
>> Intuitively, a decider should be a Turing machine that given an input,
>> halts and either accepts or rejects, relaying its answer in one of many
>> equivalent ways, such as halting at an ACCEPT or REJECT state, or
>> leaving its answer on the output tape.Yuval Filmus
>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>
>> Yuval Filmus top 0.04% overall Assistant Professor in the Department of
>> Computer Science at the Technion.
>>
> So "rejects" just means "returns true", as far as
> "Aborted_Because_Non_Halting_Behavior_Detected" is concerned.
True means that the input is accepted as not halting.
> No obstacle there to stubbing the function. So what is the obstacle?
>
A stub function seems to provide nothing more that a dogmatic assertion
that I (or it) is right.
Here is the gist of the whole idea:
The conventional idea of a halt decider can be fooled by simply making
the input program do the opposite of whatever the halt decider decides.
When the halt decider only makes its decision after the input program
has stopped running it cannot possibly do the opposite of whatever the
halt decider decides.
This simple little change makes the halting problem decidable.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-30 17:23 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <04770910-25a1-43d8-a0e5-030ff132f2e8n@googlegroups.com> |
| In reply to | #24701 |
On Saturday, 31 October 2020 at 00:07:27 UTC, olcott wrote:
> On 10/30/2020 6:59 PM, Malcolm McLean wrote:
> > On Friday, 30 October 2020 at 23:50:14 UTC, olcott wrote:
> >> On 10/30/2020 6:48 PM, Malcolm McLean wrote:
> >>> On Friday, 30 October 2020 at 23:42:07 UTC, olcott wrote:
> >>>> On 10/30/2020 6:22 PM, Malcolm McLean wrote:
> >>>>> On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
> >>>>>> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
> >>>>>>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
> >>>>>>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
> >>>>>>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
> >>>>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
> >>>>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
> >>>>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
> >>>>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>> <cut>
> >>>>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
> >>>>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
> >>>>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
> >>>>>>>>>>>>>>>>>> terms like
> >>>>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
> >>>>>>>>>>>>>>>>>> accepted and
> >>>>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
> >>>>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
> >>>>>>>>>>>>>>>>> paper degree of professionalism.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
> >>>>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
> >>>>>>>>>>>>>>>> using your own meanings for some of the words).
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> No such decider can be written (you can, of course, define what must
> >>>>>>>>>>>>>>>> do). There is no point in insisting over and over that it can be
> >>>>>>>>>>>>>>>> written -- just write it! It will make you famous.
> >>>>>>>>>>>>>> <cut>
> >>>>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
> >>>>>>>>>>>>>>>> years
> >>>>>>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
> >>>>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
> >>>>>>>>>>>>>>> I am correct
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Where is the program you claim you can write? The "proving you are
> >>>>>>>>>>>>>> right" is not working out. You should try the "writing the code you
> >>>>>>>>>>>>>> said you could" plan instead.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
> >>>>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
> >>>>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
> >>>>>>>>>>>>> following non-halting decider that accepts any and all non-halting
> >>>>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> When the first step that a halt decider does to indicate its non-halting
> >>>>>>>>>>>>> decision is stop executing its input, its input can't do anything at all
> >>>>>>>>>>>>> because it is already terminated.
> >>>>>>>>>>>> Since it continues to watch the execution of its input looking for
> >>>>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
> >>>>>>>>>>>> its input halts. At this point it reports HALTING.
> >>>>>>>>>>>>
> >>>>>>>>>>>> In both of these two possible cases it has totally defeated the
> >>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
> >>>>>>>>>>>> problem trick: Because in both of these cases the input has already
> >>>>>>>>>>>> terminated.
> >>>>>>>>>>>>
> >>>>>>>>>>> I don't think you've thought this through.
> >>>>>>>>>>>
> >>>>>>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
> >>>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
> >>>>>>>>>>>
> >>>>>>>>>>> You mustn't omit the second test. That's the whole point.
> >>>>>>>>>>>
> >>>>>>>>>> I know these execution traces very well because I have done them over
> >>>>>>>>>> and over again in my own mind many times over the last two years.
> >>>>>>>>>>
> >>>>>>>>>> The outermost invocation of this function
> >>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> >>>>>>>>>> always returns true no matter what function call it.
> >>>>>>>>>>
> >>>>>>>>> OK. So let's stub it
> >>>>>>>>>
> >>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
> >>>>>>>>> {
> >>>>>>>>> if (M == H_Hat && N == H_Hat)
> >>>>>>>>> return true;
> >>>>>>>>> else
> >>>>>>>>> assert(0); // we're a stub.
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> Now drop that in to your system, and you should see the problem.
> >>>>>>>> I is fake code, I am basing my answer on real code.
> >>>>>>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
> >>>>>>>>> will terminate or not, so you need to run H first to get the answer. Then you
> >>>>>>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
> >>>>>>>>>
> >>>>>>>> What you are suggesing is like this:
> >>>>>>>> Lets pretend that all cats are dogs.
> >>>>>>>> Do cats bark?
> >>>>>>>>
> >>>>>>> No, I'm suggesting stubbing the function. That means, write it so that it
> >>>>>>> return correct results for one or two cases, and ignores the other cases.
> >>>>>>> The stubbed function has to behave like the real function, from the point
> >>>>>>> of view of a caller calling with one of the special cases.
> >>>>>>>
> >>>>>>> Stubbed functions are used quite a bit in software prototyping or proof
> >>>>>>> of concept.
> >>>>>> It leaves out all the key details that proves it is the correct answer.
> >>>>>>
> >>>>> It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
> >>>>> or false, and it always returns the same value for the same inputs. So if you only
> >>>>> have one input to handle, it can be stubbed by a simple return true / return false.
> >>>>>
> >>>>> Unless it does something else as well. Then trying to stub it will expose
> >>>>> that something else.
> >>>>>>
> >>>>>> The halt decider executes its input one step at a time until it detects
> >>>>>> non-halting behavior or its input has terminated normally. When the halt
> >>>>>> decider detects non-halting behavior it stops executing its input and
> >>>>>> transitions to its own final state of:
> >>>>>> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
> >>>>>> detected then as soon as the input terminates the halt decider
> >>>>>> transitions to its own final state of INPUT_HAS_TERMINATED.
> >>>>>>
> >>>>>> 2018-12-13 @ 7:00 PM solution.
> >>>>>> The halt decider detects the non-halting behavior of the Linz H_Hat
> >>>>>> equivalent when it calls the halt decider from the same machine address
> >>>>>> a second time and there are no conditional branches in the H_Hat
> >>>>>> execution trace that would terminate this otherwise infinite recursion.
> >>>>>>
> >>>>> Once you've stubbed the complex function (for a real decider) we can see
> >>>>> these parts. As I've said, I think that will make clear to you the problem
> >>>>> with your system.
> >>>>> The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
> >>>>> The results need to be consistent.
> >>>>>
> >>>> As soon as I fix the bug with the local process context stacks I can
> >>>> code the actual halt decider that does exactly what I claimed that it does.
> >>>>
> >>>> If it does exactly what I claimed that it does in the detailed
> >>>> description of the execution trace then we can know that it does decide
> >>>> H_Hat() correctly.
> >>>>
> >>>> In the mean time people could simply hypothesize that my detailed
> >>>> execution trace is accurate and see that this does correctly decide
> >>>> H_Hat (see below).
> >>>> The halt decider executes its input one step at a time until it detects
> >>>> non-halting behavior or its input has terminated normally. When the halt
> >>>> decider detects non-halting behavior it stops executing its input and
> >>>> transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
> >>>>
> >>>> If non-halting behavior is never detected then as soon as the input
> >>>> terminates the halt decider transitions to its own final state of
> >>>> INPUT_HAS_TERMINATED.
> >>>>
> >>>> 2018-12-13 @ 7:00 PM solution.
> >>>> The halt decider detects the non-halting behavior of the Linz H_Hat
> >>>> equivalent when H_Hat calls the halt decider from the same machine
> >>>> address a second time and there are no conditional branches in the H_Hat
> >>>> execution trace that would terminate this otherwise infinite recursion.
> >>>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> >>>>
> >>>> Stops executing and accepts any and all non-halting inputs and rejects
> >>>> any and all halting inputs.
> >>>>
> >>> So how are you using the term "rejects?"
> >>>
> >> Intuitively, a decider should be a Turing machine that given an input,
> >> halts and either accepts or rejects, relaying its answer in one of many
> >> equivalent ways, such as halting at an ACCEPT or REJECT state, or
> >> leaving its answer on the output tape.Yuval Filmus
> >> https://cs.stackexchange.com/questions/84433/what-is-decider
> >>
> >> Yuval Filmus top 0.04% overall Assistant Professor in the Department of
> >> Computer Science at the Technion.
> >>
> > So "rejects" just means "returns true", as far as
> > "Aborted_Because_Non_Halting_Behavior_Detected" is concerned.
> True means that the input is accepted as not halting.
> > No obstacle there to stubbing the function. So what is the obstacle?
> >
> A stub function seems to provide nothing more that a dogmatic assertion
> that I (or it) is right.
>
> Here is the gist of the whole idea:
> The conventional idea of a halt decider can be fooled by simply making
> the input program do the opposite of whatever the halt decider decides.
>
As I thought. You need a new architecture if you are goign to get round
Linz's stratagem.
>
> When the halt decider only makes its decision after the input program
> has stopped running it cannot possibly do the opposite of whatever the
> halt decider decides.
>
> This simple little change makes the halting problem decidable.
>
You haven't quite thought this through, however. If the halt decider
take an input program, and emulates it, then stops that input program
from running, then it can be stubbed by "return true". That's no good,
we are agreed.
The halt decider needs to stop all instances of the input program,
globally.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 19:34 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <h4ednSl8SpivLAHCnZ2dnUU7-c3NnZ2d@giganews.com> |
| In reply to | #24704 |
On 10/30/2020 7:23 PM, Malcolm McLean wrote:
> On Saturday, 31 October 2020 at 00:07:27 UTC, olcott wrote:
>> On 10/30/2020 6:59 PM, Malcolm McLean wrote:
>>> On Friday, 30 October 2020 at 23:50:14 UTC, olcott wrote:
>>>> On 10/30/2020 6:48 PM, Malcolm McLean wrote:
>>>>> On Friday, 30 October 2020 at 23:42:07 UTC, olcott wrote:
>>>>>> On 10/30/2020 6:22 PM, Malcolm McLean wrote:
>>>>>>> On Friday, 30 October 2020 at 16:30:33 UTC, olcott wrote:
>>>>>>>> On 10/30/2020 10:54 AM, Malcolm McLean wrote:
>>>>>>>>> On Friday, 30 October 2020 at 15:32:20 UTC, olcott wrote:
>>>>>>>>>> On 10/30/2020 7:36 AM, Malcolm McLean wrote:
>>>>>>>>>>> On Friday, 30 October 2020 at 11:33:02 UTC, olcott wrote:
>>>>>>>>>>>> On 10/30/2020 5:44 AM, Malcolm McLean wrote:
>>>>>>>>>>>>> On Friday, 30 October 2020 at 02:51:31 UTC, olcott wrote:
>>>>>>>>>>>>>> On 10/29/2020 9:36 PM, olcott wrote:
>>>>>>>>>>>>>>> On 10/29/2020 9:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 10/29/2020 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 10/29/2020 5:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>>>>>>> A non-halting decider can be defined that always Accepts NON_HALTING
>>>>>>>>>>>>>>>>>>>>> input and Rejects HALTING input as follows:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No decider can accept all, and only all, non-halting inputs, while
>>>>>>>>>>>>>>>>>>>> rejecting all, and only all, halting ones.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> See the difference? (a) I don't use MAGIC_CAPS but technical
>>>>>>>>>>>>>>>>>>>> terms like
>>>>>>>>>>>>>>>>>>>> halting and non-halting. (b) I say exactly what inputs are
>>>>>>>>>>>>>>>>>>>> accepted and
>>>>>>>>>>>>>>>>>>>> which rejected by saying "all, and only all" rather than "always".
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes that is the exactly kind of improvement in wording that I need to
>>>>>>>>>>>>>>>>>>> make my presentation conform somewhat more closely to an academic
>>>>>>>>>>>>>>>>>>> paper degree of professionalism.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The non-halting decider that I defined accepts any and all non-halting
>>>>>>>>>>>>>>>>>>> inputs and rejects any and all halting inputs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Excellent. Very clear (though there is always the worry that you are
>>>>>>>>>>>>>>>>>> using your own meanings for some of the words).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No such decider can be written (you can, of course, define what must
>>>>>>>>>>>>>>>>>> do). There is no point in insisting over and over that it can be
>>>>>>>>>>>>>>>>>> written -- just write it! It will make you famous.
>>>>>>>>>>>>>>>> <cut>
>>>>>>>>>>>>>>>>>> You once made a clear claim. That was wrong, and you've spent two
>>>>>>>>>>>>>>>>>> years
>>>>>>>>>>>>>>>>>> walking that claim back. You've made another clear claim now. Don't
>>>>>>>>>>>>>>>>>> spend another two years reneging on it -- write the program.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> As usual you make completely sure to totally ignore how I proved that
>>>>>>>>>>>>>>>>> I am correct
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Where is the program you claim you can write? The "proving you are
>>>>>>>>>>>>>>>> right" is not working out. You should try the "writing the code you
>>>>>>>>>>>>>>>> said you could" plan instead.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Of course I'm fine with you endlessly saying "this is how it will work"
>>>>>>>>>>>>>>>> and "this show I could do it" because, as you can imagine, I would
>>>>>>>>>>>>>>>> prefer you /not/ to write the code I'm saying can't be written!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But so far, it's going well for me. How's it going for you?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you are not a learned-by-rote dogmatist you can understand how the
>>>>>>>>>>>>>>> following non-halting decider that accepts any and all non-halting
>>>>>>>>>>>>>>> inputs and rejects any and all halting inputs defeats the:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>>>>>>> problem trick. (perhaps you were not aware of this trick?)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the first step that a halt decider does to indicate its non-halting
>>>>>>>>>>>>>>> decision is stop executing its input, its input can't do anything at all
>>>>>>>>>>>>>>> because it is already terminated.
>>>>>>>>>>>>>> Since it continues to watch the execution of its input looking for
>>>>>>>>>>>>>> non-halting behavior (infinite loops, and infinite recursion) eventually
>>>>>>>>>>>>>> its input halts. At this point it reports HALTING.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In both of these two possible cases it has totally defeated the
>>>>>>>>>>>>>> "do the opposite of whatever the halting decider decides" halting
>>>>>>>>>>>>>> problem trick: Because in both of these cases the input has already
>>>>>>>>>>>>>> terminated.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't think you've thought this through.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I've suggested stubbing the function. If you do this, and run two tests,
>>>>>>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>>>>>>> and H_Hat(H_Hat), you'll see the problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You mustn't omit the second test. That's the whole point.
>>>>>>>>>>>>>
>>>>>>>>>>>> I know these execution traces very well because I have done them over
>>>>>>>>>>>> and over again in my own mind many times over the last two years.
>>>>>>>>>>>>
>>>>>>>>>>>> The outermost invocation of this function
>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>>>>>>>> always returns true no matter what function call it.
>>>>>>>>>>>>
>>>>>>>>>>> OK. So let's stub it
>>>>>>>>>>>
>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32*M, u32 *N)
>>>>>>>>>>> {
>>>>>>>>>>> if (M == H_Hat && N == H_Hat)
>>>>>>>>>>> return true;
>>>>>>>>>>> else
>>>>>>>>>>> assert(0); // we're a stub.
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Now drop that in to your system, and you should see the problem.
>>>>>>>>>> I is fake code, I am basing my answer on real code.
>>>>>>>>>>> You need to run two tests. H() need sto determine whether H_Hat(H_Hat)
>>>>>>>>>>> will terminate or not, so you need to run H first to get the answer. Then you
>>>>>>>>>>> need to run H_Hat(H_Hat) to show that the answer was correct.
>>>>>>>>>>>
>>>>>>>>>> What you are suggesing is like this:
>>>>>>>>>> Lets pretend that all cats are dogs.
>>>>>>>>>> Do cats bark?
>>>>>>>>>>
>>>>>>>>> No, I'm suggesting stubbing the function. That means, write it so that it
>>>>>>>>> return correct results for one or two cases, and ignores the other cases.
>>>>>>>>> The stubbed function has to behave like the real function, from the point
>>>>>>>>> of view of a caller calling with one of the special cases.
>>>>>>>>>
>>>>>>>>> Stubbed functions are used quite a bit in software prototyping or proof
>>>>>>>>> of concept.
>>>>>>>> It leaves out all the key details that proves it is the correct answer.
>>>>>>>>
>>>>>>> It's a stub. Aborted_Because_Non_halting_Behavior_Detected either returns true
>>>>>>> or false, and it always returns the same value for the same inputs. So if you only
>>>>>>> have one input to handle, it can be stubbed by a simple return true / return false.
>>>>>>>
>>>>>>> Unless it does something else as well. Then trying to stub it will expose
>>>>>>> that something else.
>>>>>>>>
>>>>>>>> The halt decider executes its input one step at a time until it detects
>>>>>>>> non-halting behavior or its input has terminated normally. When the halt
>>>>>>>> decider detects non-halting behavior it stops executing its input and
>>>>>>>> transitions to its own final state of:
>>>>>>>> NON_TERMINATING_BEHAVIOR_DETECTED. If non-halting behavior is never
>>>>>>>> detected then as soon as the input terminates the halt decider
>>>>>>>> transitions to its own final state of INPUT_HAS_TERMINATED.
>>>>>>>>
>>>>>>>> 2018-12-13 @ 7:00 PM solution.
>>>>>>>> The halt decider detects the non-halting behavior of the Linz H_Hat
>>>>>>>> equivalent when it calls the halt decider from the same machine address
>>>>>>>> a second time and there are no conditional branches in the H_Hat
>>>>>>>> execution trace that would terminate this otherwise infinite recursion.
>>>>>>>>
>>>>>>> Once you've stubbed the complex function (for a real decider) we can see
>>>>>>> these parts. As I've said, I think that will make clear to you the problem
>>>>>>> with your system.
>>>>>>> The key is that you need two tests, run the decider, then run H_Hat(H_Hat).
>>>>>>> The results need to be consistent.
>>>>>>>
>>>>>> As soon as I fix the bug with the local process context stacks I can
>>>>>> code the actual halt decider that does exactly what I claimed that it does.
>>>>>>
>>>>>> If it does exactly what I claimed that it does in the detailed
>>>>>> description of the execution trace then we can know that it does decide
>>>>>> H_Hat() correctly.
>>>>>>
>>>>>> In the mean time people could simply hypothesize that my detailed
>>>>>> execution trace is accurate and see that this does correctly decide
>>>>>> H_Hat (see below).
>>>>>> The halt decider executes its input one step at a time until it detects
>>>>>> non-halting behavior or its input has terminated normally. When the halt
>>>>>> decider detects non-halting behavior it stops executing its input and
>>>>>> transitions to its own final state of: NON_TERMINATING_BEHAVIOR_DETECTED.
>>>>>>
>>>>>> If non-halting behavior is never detected then as soon as the input
>>>>>> terminates the halt decider transitions to its own final state of
>>>>>> INPUT_HAS_TERMINATED.
>>>>>>
>>>>>> 2018-12-13 @ 7:00 PM solution.
>>>>>> The halt decider detects the non-halting behavior of the Linz H_Hat
>>>>>> equivalent when H_Hat calls the halt decider from the same machine
>>>>>> address a second time and there are no conditional branches in the H_Hat
>>>>>> execution trace that would terminate this otherwise infinite recursion.
>>>>>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>>
>>>>>> Stops executing and accepts any and all non-halting inputs and rejects
>>>>>> any and all halting inputs.
>>>>>>
>>>>> So how are you using the term "rejects?"
>>>>>
>>>> Intuitively, a decider should be a Turing machine that given an input,
>>>> halts and either accepts or rejects, relaying its answer in one of many
>>>> equivalent ways, such as halting at an ACCEPT or REJECT state, or
>>>> leaving its answer on the output tape.Yuval Filmus
>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>
>>>> Yuval Filmus top 0.04% overall Assistant Professor in the Department of
>>>> Computer Science at the Technion.
>>>>
>>> So "rejects" just means "returns true", as far as
>>> "Aborted_Because_Non_Halting_Behavior_Detected" is concerned.
>> True means that the input is accepted as not halting.
>>> No obstacle there to stubbing the function. So what is the obstacle?
>>>
>> A stub function seems to provide nothing more that a dogmatic assertion
>> that I (or it) is right.
>>
>> Here is the gist of the whole idea:
>> The conventional idea of a halt decider can be fooled by simply making
>> the input program do the opposite of whatever the halt decider decides.
>>
> As I thought. You need a new architecture if you are goign to get round
> Linz's stratagem.
>>
>> When the halt decider only makes its decision after the input program
>> has stopped running it cannot possibly do the opposite of whatever the
>> halt decider decides.
>>
>> This simple little change makes the halting problem decidable.
>>
> You haven't quite thought this through, however. If the halt decider
> take an input program, and emulates it, then stops that input program
> from running, then it can be stubbed by "return true". That's no good,
> we are agreed.
>
> The halt decider needs to stop all instances of the input program,
> globally.
>
The halting problem is "proved" to be undecidable on the basis of an
input that does the opposite of whatever the halt decider decides.
This "proof" is easily refuted by making a halt decider that makes its
halting decision AFTER the input has stopped running.
The halting problem is "proved" to be undecidable on the basis of an
input that does the opposite of whatever the halt decider decides.
This "proof" is easily refuted by making a halt decider that makes its
halting decision AFTER the input has stopped running.
The halting problem is "proved" to be undecidable on the basis of an
input that does the opposite of whatever the halt decider decides.
This "proof" is easily refuted by making a halt decider that makes its
halting decision AFTER the input has stopped running.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-31 02:26 +0000 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <87imarw2oy.fsf@bsb.me.uk> |
| In reply to | #24704 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > As I thought. You need a new architecture if you are goign to get round > Linz's stratagem. "Linz's stratagem" is rather dismissive, and since I don't think you read the book, it's a somewhat unwarranted usage. Linz give this proof for historical reasons and because it is widely seen in many places. It's not his in any sense. Linz's preferred proof is quite different, and one I doubt PO would understand. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-31 03:05 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <44ab2c00-fc0e-4092-afec-2972cbbbcec3n@googlegroups.com> |
| In reply to | #24711 |
On Saturday, 31 October 2020 at 02:26:40 UTC, Ben Bacarisse wrote: > Malcolm McLean <malcolm.ar...@gmail.com> writes: > > > As I thought. You need a new architecture if you are goign to get round > > Linz's stratagem. > "Linz's stratagem" is rather dismissive, and since I don't think you read the > book, it's a somewhat unwarranted usage. > > Linz give this proof for historical reasons and because it is widely > seen in many places. It's not his in any sense. > > Linz's preferred proof is quite different, and one I doubt PO would > understand. > I'm trying to emphasise that PO needs a different architecture if he's going to create two self-consistent routines. I can hardly say "refute the Linz proof" because that's not what he will be doing, though that's for later, if and when the self-conistent pair of programs are presented.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-31 12:23 +0000 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <87361uwpmv.fsf@bsb.me.uk> |
| In reply to | #24722 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > On Saturday, 31 October 2020 at 02:26:40 UTC, Ben Bacarisse wrote: >> Malcolm McLean <malcolm.ar...@gmail.com> writes: >> >> > As I thought. You need a new architecture if you are goign to get round >> > Linz's stratagem. >> "Linz's stratagem" is rather dismissive, and since I don't think you read the >> book, it's a somewhat unwarranted usage. >> >> Linz give this proof for historical reasons and because it is widely >> seen in many places. It's not his in any sense. >> >> Linz's preferred proof is quite different, and one I doubt PO would >> understand. >> > I'm trying to emphasise that PO needs a different architecture if he's going > to create two self-consistent routines. I can hardly say "refute the Linz proof" > because that's not what he will be doing, though that's for later, if and when > the self-conistent pair of programs are presented. You seem determined to steer PO away from being wrong about halting into being right about something else, but he has no interest in being right about something unimportant like a self-consistent M/M^ pair. What's more, now that he has declared that his "design" is of an actual halting decider, surely this one H/H^ case is now just so much fluff. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-31 09:22 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <4KednVmE57eX7gDCnZ2dnUU7-QvNnZ2d@giganews.com> |
| In reply to | #24722 |
On 10/31/2020 5:05 AM, Malcolm McLean wrote:
> On Saturday, 31 October 2020 at 02:26:40 UTC, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>
>>> As I thought. You need a new architecture if you are goign to get round
>>> Linz's stratagem.
>> "Linz's stratagem" is rather dismissive, and since I don't think you read the
>> book, it's a somewhat unwarranted usage.
>>
>> Linz give this proof for historical reasons and because it is widely
>> seen in many places. It's not his in any sense.
>>
>> Linz's preferred proof is quite different, and one I doubt PO would
>> understand.
>>
> I'm trying to emphasise that PO needs a different architecture if he's going
> to create two self-consistent routines. I can hardly say "refute the Linz proof"
> because that's not what he will be doing, though that's for later, if and when
> the self-conistent pair of programs are presented.
>
void H_Hat(u32 P)
{
if (!Halts(P, P)) // If it does not halt
HALT // then halt
else // if it halt
HERE: goto HERE; // Then loop forever
}
The generic strategy of all of the conventional halting problem proofs
work the same way as the above program: "Do the opposite of whatever the
halt decider decides".
This solution circuvents the method of the proofs
void H(u32 P)
{
if (Non_Halting_Detected_While_Running_it(P, P))
{
Stop running it.
Report Non Halting Detected. // AKA Does not halt
}
else
Report that it already stopped running. // AKA Halts
}
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-30 14:26 +0000 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <87o8kjvlgs.fsf@bsb.me.uk> |
| In reply to | #24663 |
olcott <NoOne@NoWhere.com> writes: > On 10/29/2020 9:16 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: <cut> >>>>> The non-halting decider that I defined accepts any and all non-halting >>>>> inputs and rejects any and all halting inputs. <cut> >> Where is the program you claim you can write? The "proving you are >> right" is not working out. You should try the "writing the code you >> said you could" plan instead. >> >> Of course I'm fine with you endlessly saying "this is how it will work" >> and "this show I could do it" because, as you can imagine, I would >> prefer you /not/ to write the code I'm saying can't be written! >> >> But so far, it's going well for me. How's it going for you? > > If you are not a learned-by-rote dogmatist you can understand... Why do you care what I understand? You have a clear and simple claim. You have all the "infrastructure" ready (it's a terrible choice, but its too late to change that now) and you've said you "just need to write the decider". Why are you wasting your time? Write it, post it, and be famous. Or, as I said, keep posting boasts about what it would work were you to ever get round to writing it. That works for me too, (and I suspect it's what you want as well). -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 10:49 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ! ] |
| Message-ID | <kvWdnTeVW--PqwHCnZ2dnUU7-XvNnZ2d@giganews.com> |
| In reply to | #24676 |
On 10/30/2020 9:26 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 10/29/2020 9:16 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: > <cut> >>>>>> The non-halting decider that I defined accepts any and all non-halting >>>>>> inputs and rejects any and all halting inputs. > <cut> >>> Where is the program you claim you can write? The "proving you are >>> right" is not working out. You should try the "writing the code you >>> said you could" plan instead. >>> >>> Of course I'm fine with you endlessly saying "this is how it will work" >>> and "this show I could do it" because, as you can imagine, I would >>> prefer you /not/ to write the code I'm saying can't be written! >>> >>> But so far, it's going well for me. How's it going for you? >> >> If you are not a learned-by-rote dogmatist you can understand... > > Why do you care what I understand? You have a clear and simple claim. > You have all the "infrastructure" ready (it's a terrible choice, but its > too late to change that now) and you've said you "just need to write the > decider". Why are you wasting your time? Now the claim has been divided into two different claims. (a) The claim since 2018-12-13 is that I will have a computer program that shows exactly how the Linz H_Hat equivalent is correctly decided. I have already described the details of the basis of this 2018-12-13 solution. You could tell from the details of the execution trace that I provided that it does correctly decide the Linz H_Hat. (b) My new claim is that I have defined a non-halting decider that accepts any and all non-halting inputs and rejects any and all halting inputs. You could tell from the details of its definition that it circumvents the "do the opposite of whatever the halt decider decides" halting problem trick. > Write it, post it, and be famous. > > Or, as I said, keep posting boasts about what it would work were you to > ever get round to writing it. That works for me too, (and I suspect > it's what you want as well). > I already proved my point two different ways. You made sure to erase this proof without looking at it. In the mean time I have to get rid of the bug in the local process context stacks before I can proceed to the last step of writing a partial halting decider that correctly decides halting of the Linz H_Hat() equivalnet. x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine The RASP is a random-access machine (RAM) model that, unlike the RAM, has its program in its "registers" together with its input. The registers are unbounded (infinite in capacity); whether the number of registers is finite is model-specific. Thus the RASP is to the RAM as the Universal Turing machine is to the Turing machine. The RASP is an example of the von Neumann architecture whereas the RAM is an example of the Harvard architecture. https://en.wikipedia.org/wiki/Random-access_stored-program_machine -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 12 of 25 — ← Prev page 1 … 10 11 [12] 13 14 … 25 Next page →
Back to top | Article view | comp.theory
csiph-web