Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #155812 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-10-20 11:33 -0500 |
| Last post | 2020-11-06 20:34 -0800 |
| Articles | 20 on this page of 256 — 15 participants |
Back to article view | Back to comp.lang.c
The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 11:33 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-20 19:11 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 13:40 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 14:19 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-20 14:26 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 17:41 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:19 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:21 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:27 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:30 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:43 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:08 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:12 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:21 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Jeff Barnett <jbb@notatt.com> - 2020-10-22 11:59 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:17 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:21 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:44 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-22 17:59 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 20:15 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:28 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 22:22 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 21:51 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 06:29 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 09:10 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 08:30 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 09:52 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 09:04 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 10:06 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:48 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 11:04 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 12:00 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:12 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 12:35 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 14:04 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-23 15:34 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 17:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 21:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 17:37 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:43 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 17:49 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:06 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:10 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:35 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:46 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-23 18:53 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 13:06 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 02:57 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-20 22:07 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 16:28 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 16:52 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 11:48 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 20:30 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 15:27 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] André G. Isaak <agisaak@gm.invalid> - 2020-10-21 14:57 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 16:12 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] André G. Isaak <agisaak@gm.invalid> - 2020-10-21 15:54 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 17:20 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 18:28 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 03:28 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:20 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 23:10 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 17:55 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 03:38 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] olcott <NoOne@NoWhere.com> - 2020-10-21 21:54 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ HP proof refutation ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 04:38 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-21 23:33 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-22 08:00 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 09:36 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 08:07 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:52 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-22 16:25 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:09 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:32 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:33 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:19 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 13:30 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:34 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:09 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-22 21:27 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:31 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 20:36 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:18 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:04 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 00:12 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:57 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:12 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:55 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:20 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 15:56 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 16:58 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Richard Damon <Richard@Damon-Family.org> - 2020-10-23 21:35 -0400
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 20:45 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-23 19:54 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:22 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:01 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:35 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 12:37 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-25 12:10 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:27 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:42 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 03:18 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 03:21 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:28 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-23 21:03 -0700
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-23 23:13 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:08 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 15:48 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:20 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 11:30 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-26 10:43 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 12:44 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 13:13 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:46 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 15:43 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:27 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 09:53 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] Mostowski Collapse <janburse@fastmail.fm> - 2020-10-27 21:07 +0100
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:57 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-27 04:53 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided olcott <NoOne@NoWhere.com> - 2020-10-27 10:20 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] key definitions provided André G. Isaak <agisaak@gm.invalid> - 2020-10-27 12:53 -0600
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 10:28 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 11:00 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 11:05 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 13:36 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] olcott <NoOne@NoWhere.com> - 2020-10-27 14:44 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-28 18:31 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 07:55 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 10:49 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:41 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 10:59 -0500
Re: The key aspects of x86utm are now finally complete [ defining a non-halting decider ] olcott <NoOne@NoWhere.com> - 2020-10-29 12:48 -0500
Re: The key aspects of x86utm are now finally complete [ I dare you to prove that I am wrong ] André G. Isaak <agisaak@gm.invalid> - 2020-10-27 13:57 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 23:02 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Tim Woodall <news001@woodall.me.uk> - 2020-10-23 07:05 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:45 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:30 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-23 13:03 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 15:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 08:43 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:19 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 18:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 19:29 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 20:26 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:06 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 00:38 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:46 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 18:54 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:52 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 10:41 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:46 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 09:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 10:33 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] olcott <NoOne@NoWhere.com> - 2020-10-25 13:42 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation Key Details] olcott <NoOne@NoWhere.com> - 2020-10-25 16:07 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 14:16 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 15:56 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 16:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 12:23 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 18:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 18:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 11:16 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 01:21 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 01:06 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 19:39 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 04:27 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 22:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 23:02 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 16:58 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 01:03 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-24 08:04 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 11:25 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 10:36 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 17:37 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 12:49 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 19:32 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 13:42 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 20:00 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 20:44 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 15:41 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 21:57 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:05 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-24 22:44 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:01 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-26 16:11 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:12 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 14:53 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:01 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 16:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 20:35 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:08 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 17:45 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 13:03 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction olcott <NoOne@NoWhere.com> - 2020-10-26 13:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 00:06 +0000
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-26 17:16 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 20:11 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-26 22:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 03:18 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 14:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:24 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 16:31 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 18:00 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Richard Damon <Richard@Damon-Family.org> - 2020-10-24 19:48 -0400
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-24 19:29 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-25 01:07 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-25 10:07 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 12:26 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 10:44 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-22 09:09 -0700
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 20:41 +0100
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 18:55 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 10:40 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 11:38 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-23 12:40 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-21 22:42 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-21 16:56 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-22 00:25 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-21 23:26 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ refutation of HP proofs ] olcott <NoOne@NoWhere.com> - 2020-10-21 21:14 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 15:13 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 14:34 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:28 -0500
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] André G. Isaak <agisaak@gm.invalid> - 2020-10-22 15:34 -0600
Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] olcott <NoOne@NoWhere.com> - 2020-10-22 16:47 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 17:54 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] olcott <NoOne@NoWhere.com> - 2020-10-22 11:57 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 18:05 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2020-10-22 12:55 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-10-22 19:59 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2020-10-22 19:13 +0000
Stop crossposting you imbecil spammer (Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ]) Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 14:01 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) [ definition of H ] audating801@gmail.com - 2020-11-06 20:34 -0800
Page 11 of 13 — ← Prev page 1 … 9 10 [11] 12 13 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-24 15:41 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <mMudnUKTk4ASDAnCnZ2dnUU7-TPNnZ2d@giganews.com> |
| In reply to | #156029 |
On 10/24/2020 2:44 PM, Mike Terry wrote:
> On 24/10/2020 20:05, olcott wrote:
>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>> On 24/10/2020 19:42, olcott wrote:
>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then your
>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its input
>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>> program can be constructed on the the basis of this halt
>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz proof.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> program because its input program would otherwise cause the
>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other program
>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of whatever it
>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat() cannot
>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The end result of this slight change is that the halting
>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever stated
>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>
>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>> whether P
>>>>>>>>>>>>> would actually be aborted if it executes under the UTM within
>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>
>>>>>>>>>>>>> However, another program CAN be constructed on the basis of
>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>
>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>
>>>>>>>>>>>> Wrong.
>>>>>>>>>>>
>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>> example of
>>>>>>>>>>> such a function:
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>> {
>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>> {
>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was aborted
>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>> }
>>>>>>>>>>> else
>>>>>>>>>>> {
>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>> }
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> and for completeness, here is the function being invoked from
>>>>>>>>>>> main():
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>
>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>> HALT;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>> H_Hat
>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>> "halted"
>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no subtle
>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>> programming
>>>>>>>>>>> language.
>>>>>>>>>>>
>>>>>>>>>>> (To save you making a silly response, yes IF we were to run the
>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>> aborted the
>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of course we
>>>>>>>>>>> would
>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>> irrelevent
>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>> conditions
>>>>>>>>>>> just as I described.)
>>>>>>>>>>>
>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>> contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> DebugTrace() either reports that it has aborted the execution
>>>>>>>>>>>> of its
>>>>>>>>>>>> input or it reports that its input has not been aborted after
>>>>>>>>>>>> its
>>>>>>>>>>>> input
>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>
>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>> DebugTrace()
>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>> discussing.
>>>>>>>>>>> I'll just take it they're the same thing, and continue saying
>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>
>>>>>>>>>> OK good. I like that. Make the function say what it really means.
>>>>>>>>>> That is good software engineering.
>>>>>>>>>>
>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>
>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and so is
>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>
>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>> self-reference
>>>>>>>>>> from
>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>
>>>>>>>>> Maybe, and that would be the right thing to do if your solution is
>>>>>>>>> wrong. In any case, if you can't refute the Linz proof without
>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>> problem is
>>>>>>>> undecidable by finding another way to define the halt decider that
>>>>>>>> cannot be contradicted.
>>>>>>>
>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>> of a
>>>>>>> halt decider. If you change this definition you are not
>>>>>>> discussing HP.
>>>>>>
>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>> incorrectly for any of its inputs then the halting problem cannot be
>>>>>> shown to be undecidable:
>>>>>>
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>
>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>
>>>> Unless you can concretely show how this function would get the wrong
>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>
>>>
>>> In your code, the function answers "non halting behaviour detected"
>>> for input which actually halts, and so by any reasonable definition of
>>> the words, it has decided incorrectly.
>>
>> Bullshit. The actual question that it always correctly answers is:
>> Does the input have to be aborted to prevent infinite execution?
>
> I provided the traces which back up what I said, so it's not bullshit.
> You have snipped them because you don't want to look stupid, so I'm
> going to restore them:
>
> H_Hat machine trace
> -------------------
>
> H_Hat starts (main() calls H_Hat(H_Hat))
> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
> Was_Its_Execution_Aborted decides the emulated program ..
> .. will never terminate if not aborted
> Was_Its_Execution_Aborted stops emulating and returns ABORTED
> H_Hat *halts*
>
> OK, so the H_Hat calculation halts...
In this case we have an outer instance of H_Hat() an inner instance of
H_Hat(). The outer instance of H_Hat() is executed in the master UTM
process context of x86utm.
This outer instance of H_Hat() invokes
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
creates the inner instance of H_Hat() in its own process context and
executes it. It then returns true to the outer instance of H_Hat() after
aborting the inner instance.
> H machine trace
>
> ---------------
> H starts (main() calls H(H_Hat,H_Hat))
> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
> Was_Its_Execution_Aborted decides the emulated program ..
> .. will never terminate if not aborted
> Was_Its_Execution_Aborted stops emulating and returns ABORTED
> H halts, with EAX=0 [= *NOT_HALT* decision]
>
In this case we have an instance of H() and an instance of H_Hat(). The
instance of H() is executed in the master UTM process context of x86utm.
H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
which creates the instance of H_Hat() and executes it. It then returns
true to H() after aborting the instance of _H_Hat().
> And when H calls Aborted_Because_Non_Halting_Behavior_Detected [which is
> yet another name for the same function Was_Its_Execution_Aborted] for
> the calculation which YOU'VE AGREED actually halts,
> Aborted_Because_Non_Halting_Behavior_Detected() answers "aborted".
>
> This is an example of your function returning the wrong answer. Duh!
>
> You can try to dismiss by changing the names of functions making them
> longer and longer, and snipping out the traces in your reply, but you
> don't fool me! :)
>
> (Alternatively, you could actually try to explain why
> Aborted_Because_Non_Halting_Behavior_Detected () returned "aborted" for
> a terminating input calculation.)
>
> Mike.
>
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-24 21:57 +0100 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <OuidnZ3qfN3fCAnCnZ2dnUU78UnNnZ2d@brightview.co.uk> |
| In reply to | #156033 |
On 24/10/2020 21:41, olcott wrote:
> On 10/24/2020 2:44 PM, Mike Terry wrote:
>> On 24/10/2020 20:05, olcott wrote:
>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>> On 24/10/2020 19:42, olcott wrote:
>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then your
>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its input
>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this halt
>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>> program because its input program would otherwise cause
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other program
>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of whatever it
>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat() cannot
>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The end result of this slight change is that the halting
>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever stated
>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM within
>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> However, another program CAN be constructed on the basis of
>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>> example of
>>>>>>>>>>>> such a function:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>> {
>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>> {
>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was aborted
>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>> }
>>>>>>>>>>>> else
>>>>>>>>>>>> {
>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>> }
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> and for completeness, here is the function being invoked from
>>>>>>>>>>>> main():
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>
>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>> HALT;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>>> H_Hat
>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>> "halted"
>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no subtle
>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>> programming
>>>>>>>>>>>> language.
>>>>>>>>>>>>
>>>>>>>>>>>> (To save you making a silly response, yes IF we were to run the
>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>> aborted the
>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of course we
>>>>>>>>>>>> would
>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>> irrelevent
>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>> conditions
>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>
>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the execution
>>>>>>>>>>>>> of its
>>>>>>>>>>>>> input or it reports that its input has not been aborted after
>>>>>>>>>>>>> its
>>>>>>>>>>>>> input
>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>
>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>> discussing.
>>>>>>>>>>>> I'll just take it they're the same thing, and continue saying
>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>
>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>> means.
>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>
>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>
>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and so is
>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>
>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>> self-reference
>>>>>>>>>>> from
>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>
>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>> solution is
>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof without
>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>> problem is
>>>>>>>>> undecidable by finding another way to define the halt decider that
>>>>>>>>> cannot be contradicted.
>>>>>>>>
>>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>>> of a
>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>> discussing HP.
>>>>>>>
>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>> incorrectly for any of its inputs then the halting problem cannot be
>>>>>>> shown to be undecidable:
>>>>>>>
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>
>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>
>>>>> Unless you can concretely show how this function would get the wrong
>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>
>>>>
>>>> In your code, the function answers "non halting behaviour detected"
>>>> for input which actually halts, and so by any reasonable definition of
>>>> the words, it has decided incorrectly.
>>>
>>> Bullshit. The actual question that it always correctly answers is:
>>> Does the input have to be aborted to prevent infinite execution?
>>
>> I provided the traces which back up what I said, so it's not bullshit.
>> You have snipped them because you don't want to look stupid, so I'm
>> going to restore them:
>>
>> H_Hat machine trace
>> -------------------
>>
>> H_Hat starts (main() calls H_Hat(H_Hat))
>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>> Was_Its_Execution_Aborted decides the emulated program ..
>> .. will never terminate if not aborted
>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>> H_Hat *halts*
>>
>> OK, so the H_Hat calculation halts...
>
> In this case we have an outer instance of H_Hat() an inner instance of
> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
> process context of x86utm.
>
> This outer instance of H_Hat() invokes
> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
> creates the inner instance of H_Hat() in its own process context and
> executes it. It then returns true to the outer instance of H_Hat() after
> aborting the inner instance.
..*and then terminates*
The calculation H_Hat(H_Hat) halts. So if
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
was "non-halting behaviour" it was wrong.
No point in saying this over and over....
>
>> H machine trace
>>
>> ---------------
>> H starts (main() calls H(H_Hat,H_Hat))
>> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>> Was_Its_Execution_Aborted decides the emulated program ..
>> .. will never terminate if not aborted
>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>> H halts, with EAX=0 [= *NOT_HALT* decision]
>>
>
> In this case we have an instance of H() and an instance of H_Hat(). The
> instance of H() is executed in the master UTM process context of x86utm.
>
> H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
> which creates the instance of H_Hat() and executes it. It then returns
> true to H() after aborting the instance of _H_Hat().
Again, returning true to H is supposed to say it detected non-halting
behaviour, but the calculation it is examining actually halts.
There, I said it again! :) (last time, really...)
>
>
>> And when H calls Aborted_Because_Non_Halting_Behavior_Detected [which
>> is yet another name for the same function Was_Its_Execution_Aborted]
>> for the calculation which YOU'VE AGREED actually halts,
>> Aborted_Because_Non_Halting_Behavior_Detected() answers "aborted".
>>
>> This is an example of your function returning the wrong answer. Duh!
>>
>> You can try to dismiss by changing the names of functions making them
>> longer and longer, and snipping out the traces in your reply, but you
>> don't fool me! :)
>>
>> (Alternatively, you could actually try to explain why
>> Aborted_Because_Non_Halting_Behavior_Detected () returned "aborted"
>> for a terminating input calculation.)
>>
>> Mike.
>>
>
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-24 16:05 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <9PadnUYvRqiLCgnCnZ2dnUU7-ePNnZ2d@giganews.com> |
| In reply to | #156035 |
On 10/24/2020 3:57 PM, Mike Terry wrote:
> On 24/10/2020 21:41, olcott wrote:
>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>> On 24/10/2020 20:05, olcott wrote:
>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its input
>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this halt
>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>> program because its input program would otherwise cause
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of whatever it
>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The end result of this slight change is that the halting
>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever stated
>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> However, another program CAN be constructed on the basis of
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>> example of
>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>> {
>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was aborted
>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>> }
>>>>>>>>>>>>> else
>>>>>>>>>>>>> {
>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>> }
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> and for completeness, here is the function being invoked from
>>>>>>>>>>>>> main():
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>
>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no subtle
>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>> programming
>>>>>>>>>>>>> language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to run
>>>>>>>>>>>>> the
>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>> course we
>>>>>>>>>>>>> would
>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>> conditions
>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the execution
>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>> input or it reports that its input has not been aborted after
>>>>>>>>>>>>>> its
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>> I'll just take it they're the same thing, and continue saying
>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>
>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>> means.
>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>
>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>
>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and so is
>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>
>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>> self-reference
>>>>>>>>>>>> from
>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>
>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>> solution is
>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof without
>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>> problem is
>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>> that
>>>>>>>>>> cannot be contradicted.
>>>>>>>>>
>>>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>>>> of a
>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>> discussing HP.
>>>>>>>>
>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>> cannot be
>>>>>>>> shown to be undecidable:
>>>>>>>>
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>
>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>
>>>>>> Unless you can concretely show how this function would get the wrong
>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>
>>>>>
>>>>> In your code, the function answers "non halting behaviour detected"
>>>>> for input which actually halts, and so by any reasonable definition of
>>>>> the words, it has decided incorrectly.
>>>>
>>>> Bullshit. The actual question that it always correctly answers is:
>>>> Does the input have to be aborted to prevent infinite execution?
>>>
>>> I provided the traces which back up what I said, so it's not bullshit.
>>> You have snipped them because you don't want to look stupid, so I'm
>>> going to restore them:
>>>
>>> H_Hat machine trace
>>> -------------------
>>>
>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>> Was_Its_Execution_Aborted decides the emulated program ..
>>> .. will never terminate if not aborted
>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>> H_Hat *halts*
>>>
>>> OK, so the H_Hat calculation halts...
>>
>> In this case we have an outer instance of H_Hat() an inner instance of
>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>> process context of x86utm.
>>
>> This outer instance of H_Hat() invokes
>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>> creates the inner instance of H_Hat() in its own process context and
>> executes it. It then returns true to the outer instance of H_Hat() after
>> aborting the inner instance.
>
> ..*and then terminates*
>
> The calculation H_Hat(H_Hat) halts. So if
> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
> was "non-halting behaviour" it was wrong.
>
> No point in saying this over and over....
When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any
level of outer or inner invocations the H_Hat(H_Hat) never terminates.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-24 22:44 +0100 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <ZaqdnRg2ha6lPQnCnZ2dnUU78IudnZ2d@brightview.co.uk> |
| In reply to | #156036 |
On 24/10/2020 22:05, olcott wrote:
> On 10/24/2020 3:57 PM, Mike Terry wrote:
>> On 24/10/2020 21:41, olcott wrote:
>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>> On 24/10/2020 20:05, olcott wrote:
>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this halt
>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>> program because its input program would otherwise cause
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of whatever it
>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the halting
>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> However, another program CAN be constructed on the basis of
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was aborted
>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>> else
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> and for completeness, here is the function being invoked from
>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>> would
>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue saying
>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>
>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>> means.
>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>> from
>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>> solution is
>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof without
>>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>>> wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>> problem is
>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>> that
>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>
>>>>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>>>>> of a
>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>> discussing HP.
>>>>>>>>>
>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>> cannot be
>>>>>>>>> shown to be undecidable:
>>>>>>>>>
>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>
>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>
>>>>>>> Unless you can concretely show how this function would get the wrong
>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>
>>>>>>
>>>>>> In your code, the function answers "non halting behaviour detected"
>>>>>> for input which actually halts, and so by any reasonable
>>>>>> definition of
>>>>>> the words, it has decided incorrectly.
>>>>>
>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>
>>>> I provided the traces which back up what I said, so it's not bullshit.
>>>> You have snipped them because you don't want to look stupid, so I'm
>>>> going to restore them:
>>>>
>>>> H_Hat machine trace
>>>> -------------------
>>>>
>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>> .. will never terminate if not aborted
>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>> H_Hat *halts*
>>>>
>>>> OK, so the H_Hat calculation halts...
>>>
>>> In this case we have an outer instance of H_Hat() an inner instance of
>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>> process context of x86utm.
>>>
>>> This outer instance of H_Hat() invokes
>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>> creates the inner instance of H_Hat() in its own process context and
>>> executes it. It then returns true to the outer instance of H_Hat() after
>>> aborting the inner instance.
>>
>> ..*and then terminates*
>>
>> The calculation H_Hat(H_Hat) halts. So if
>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>> was "non-halting behaviour" it was wrong.
>>
>> No point in saying this over and over....
>
> When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any
> level of outer or inner invocations the H_Hat(H_Hat) never terminates.
Wrong. (Read the trace)
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-24 17:01 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <wL2dnRlvFe6iOQnCnZ2dnUU7-KXNnZ2d@giganews.com> |
| In reply to | #156040 |
On 10/24/2020 4:44 PM, Mike Terry wrote:
> On 24/10/2020 22:05, olcott wrote:
>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>> On 24/10/2020 21:41, olcott wrote:
>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this
>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise cause
>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> and for completeness, here is the function being invoked
>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>> from
>>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>> solution is
>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>> without
>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>> problem is
>>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>>> that
>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>
>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>>>>>> of a
>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>> discussing HP.
>>>>>>>>>>
>>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>> cannot be
>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>
>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>>
>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>> wrong
>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>
>>>>>>>
>>>>>>> In your code, the function answers "non halting behaviour detected"
>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>> definition of
>>>>>>> the words, it has decided incorrectly.
>>>>>>
>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>
>>>>> I provided the traces which back up what I said, so it's not bullshit.
>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>> going to restore them:
>>>>>
>>>>> H_Hat machine trace
>>>>> -------------------
>>>>>
>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>> .. will never terminate if not aborted
>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>> H_Hat *halts*
>>>>>
>>>>> OK, so the H_Hat calculation halts...
>>>>
>>>> In this case we have an outer instance of H_Hat() an inner instance of
>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>> process context of x86utm.
>>>>
>>>> This outer instance of H_Hat() invokes
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>> creates the inner instance of H_Hat() in its own process context and
>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>> after
>>>> aborting the inner instance.
>>>
>>> ..*and then terminates*
>>>
>>> The calculation H_Hat(H_Hat) halts. So if
>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>>> was "non-halting behaviour" it was wrong.
>>>
>>> No point in saying this over and over....
>>
>> When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any
>> level of outer or inner invocations the H_Hat(H_Hat) never terminates.
>
> Wrong. (Read the trace)
>
Your trace is based on false assumptions my trace is based on working
code. Although I don't have the halt decider code completed yet because
the x86utm operating system is completed I can see exactly how the halt
deciding code would work.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-26 16:11 +0000 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <OLWdnc92IvjWaAvCnZ2dnUU78LednZ2d@brightview.co.uk> |
| In reply to | #156042 |
On 24/10/2020 23:01, olcott wrote:
> On 10/24/2020 4:44 PM, Mike Terry wrote:
>> On 24/10/2020 22:05, olcott wrote:
>>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>>> On 24/10/2020 21:41, olcott wrote:
>>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this
>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider
>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise
>>>>>>>>>>>>>>>>>>>>> cause
>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of
>>>>>>>>>>>>>>>>>> Does_It_Halt().
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>> "aborted"
>>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> and for completeness, here is the function being invoked
>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted"
>>>>>>>>>>>>>>>> (nonzero),
>>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>>> without
>>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>>> problem is
>>>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>>>> that
>>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP)
>>>>>>>>>>>> definition
>>>>>>>>>>>> of a
>>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>>> discussing HP.
>>>>>>>>>>>
>>>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>>> cannot be
>>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>>
>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>>
>>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>>>
>>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>>> wrong
>>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>>
>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>
>>>>>>>>
>>>>>>>> In your code, the function answers "non halting behaviour detected"
>>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>>> definition of
>>>>>>>> the words, it has decided incorrectly.
>>>>>>>
>>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>>
>>>>>> I provided the traces which back up what I said, so it's not
>>>>>> bullshit.
>>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>>> going to restore them:
>>>>>>
>>>>>> H_Hat machine trace
>>>>>> -------------------
>>>>>>
>>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>> .. will never terminate if not aborted
>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>> H_Hat *halts*
>>>>>>
>>>>>> OK, so the H_Hat calculation halts...
>>>>>
>>>>> In this case we have an outer instance of H_Hat() an inner instance of
>>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>>> process context of x86utm.
>>>>>
>>>>> This outer instance of H_Hat() invokes
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>>> creates the inner instance of H_Hat() in its own process context and
>>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>>> after
>>>>> aborting the inner instance.
>>>>
>>>> ..*and then terminates*
>>>>
>>>> The calculation H_Hat(H_Hat) halts. So if
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>>>> was "non-halting behaviour" it was wrong.
>>>>
>>>> No point in saying this over and over....
>>>
>>> When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any
>>> level of outer or inner invocations the H_Hat(H_Hat) never terminates.
>>
>> Wrong. (Read the trace)
>>
>
> Your trace is based on false assumptions my trace is based on working
> code. Although I don't have the halt decider code completed yet because
> the x86utm operating system is completed I can see exactly how the halt
> deciding code would work.
>
What are the false assumptions? It is not ok in a discussion to say
"you're wrong because you've made a false assumption, but I'm not going
to say what that is!".
My trace /is/ based on the assumption that Was_Its_Execution_Aborted()
detects non-halting behaviour and returns ABORTS to H() and H_Hat(). Is
that my false assumption?
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 14:12 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <WpednY_5lpsxggrCnZ2dnUU7-QnNnZ2d@giganews.com> |
| In reply to | #156104 |
On 10/26/2020 11:11 AM, Mike Terry wrote:
> On 24/10/2020 23:01, olcott wrote:
>> On 10/24/2020 4:44 PM, Mike Terry wrote:
>>> On 24/10/2020 22:05, olcott wrote:
>>>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>>>> On 24/10/2020 21:41, olcott wrote:
>>>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this
>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider
>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise
>>>>>>>>>>>>>>>>>>>>>> cause
>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of
>>>>>>>>>>>>>>>>>>> Does_It_Halt().
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>>> "aborted"
>>>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here
>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> and for completeness, here is the function being invoked
>>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted"
>>>>>>>>>>>>>>>>> (nonzero),
>>>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>>>> without
>>>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your
>>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP)
>>>>>>>>>>>>> definition
>>>>>>>>>>>>> of a
>>>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>>>> discussing HP.
>>>>>>>>>>>>
>>>>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>>>> cannot be
>>>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>>>
>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P,
>>>>>>>>>>>> u32 I)
>>>>>>>>>>>
>>>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>>>>
>>>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>>>> wrong
>>>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>>>
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> In your code, the function answers "non halting behaviour
>>>>>>>>> detected"
>>>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>>>> definition of
>>>>>>>>> the words, it has decided incorrectly.
>>>>>>>>
>>>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>>>
>>>>>>> I provided the traces which back up what I said, so it's not
>>>>>>> bullshit.
>>>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>>>> going to restore them:
>>>>>>>
>>>>>>> H_Hat machine trace
>>>>>>> -------------------
>>>>>>>
>>>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>>> .. will never terminate if not aborted
>>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>>> H_Hat *halts*
>>>>>>>
>>>>>>> OK, so the H_Hat calculation halts...
>>>>>>
>>>>>> In this case we have an outer instance of H_Hat() an inner
>>>>>> instance of
>>>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>>>> process context of x86utm.
>>>>>>
>>>>>> This outer instance of H_Hat() invokes
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>>>> creates the inner instance of H_Hat() in its own process context and
>>>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>>>> after
>>>>>> aborting the inner instance.
>>>>>
>>>>> ..*and then terminates*
>>>>>
>>>>> The calculation H_Hat(H_Hat) halts. So if
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>>>>> was "non-halting behaviour" it was wrong.
>>>>>
>>>>> No point in saying this over and over....
>>>>
>>>> When-so-ever H_Hat(H_Hat) is executed and it is never aborted at any
>>>> level of outer or inner invocations the H_Hat(H_Hat) never terminates.
>>>
>>> Wrong. (Read the trace)
>>>
>>
>> Your trace is based on false assumptions my trace is based on working
>> code. Although I don't have the halt decider code completed yet because
>> the x86utm operating system is completed I can see exactly how the halt
>> deciding code would work.
>>
>
> What are the false assumptions? It is not ok in a discussion to say
> "you're wrong because you've made a false assumption, but I'm not going
> to say what that is!".
>
> My trace /is/ based on the assumption that Was_Its_Execution_Aborted()
> detects non-halting behaviour and returns ABORTS to H() and H_Hat(). Is
> that my false assumption?
>
> Mike.
void H_Hat(u32 M)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
MOV_EAX_1 // Execution of M(M) has been aborted
else
{
MOV_EAX_0 // M(M) has halted
HERE: goto HERE;
}
HALT
}
void H(u32 M, u32 N)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
MOV_EAX_1 // Execution of M(N) has been aborted
else
MOV_EAX_0 // M(N) has halted
HALT
}
int main()
{
u32 M = (u32)H_Hat;
H(M, M);
H_Hat(M);
HALT
}
In each of the two cases above:
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
Does provide the correct decision for its input.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 14:53 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <06qdnZHnuPfItArCnZ2dnUU7-QPNnZ2d@giganews.com> |
| In reply to | #156117 |
On 10/26/2020 2:38 PM, Mike Terry wrote:
> On 26/10/2020 19:12, olcott wrote:
>> On 10/26/2020 11:11 AM, Mike Terry wrote:
>>> On 24/10/2020 23:01, olcott wrote:
> [... snip ...]
>>>>
>>>> Your trace is based on false assumptions my trace is based on working
>>>> code. Although I don't have the halt decider code completed yet because
>>>> the x86utm operating system is completed I can see exactly how the halt
>>>> deciding code would work.
>>>>
>>>
>>> What are the false assumptions? It is not ok in a discussion to say
>>> "you're wrong because you've made a false assumption, but I'm not
>>> going to say what that is!".
>>>
>>> My trace /is/ based on the assumption that Was_Its_Execution_Aborted()
>>> detects non-halting behaviour and returns ABORTS to H() and H_Hat().
>>> Is that my false assumption?
>>>
>>> Mike.
>>
>>
>> void H_Hat(u32 M)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>> MOV_EAX_1 // Execution of M(M) has been aborted
>> else
>> {
>> MOV_EAX_0 // M(M) has halted
>> HERE: goto HERE;
>> }
>> HALT
>> }
>>
>>
>> void H(u32 M, u32 N)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>> MOV_EAX_1 // Execution of M(N) has been aborted
>> else
>> MOV_EAX_0 // M(N) has halted
>> HALT
>> }
>>
>>
>> int main()
>> {
>> u32 M = (u32)H_Hat;
>> H(M, M);
>> H_Hat(M);
>> HALT
>> }
>>
>> In each of the two cases above:
>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>> Does provide the correct decision for its input.
>>
>
> So what was my false assumption you were referring to?
> Mike.
This answer may be too difficult to understand without an actual
execution trace of fully operational code. I have already explained it
again and again and no one has understood.
The key summation of all of these execution trace answers is that
bool Aborted_Because_Non_Halting_Behavior_Detected(M, M)
always decides its input correctly and cannot be shown otherwise.
The prior reply to you is much much easier to understand and is a key
test of your sincerity in forming mutual understanding.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 16:01 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <IaOdnfLQANyOpArCnZ2dnUU7-V3NnZ2d@giganews.com> |
| In reply to | #156121 |
On 10/26/2020 3:50 PM, Malcolm McLean wrote:
> On Monday, 26 October 2020 at 19:54:05 UTC, olcott wrote:
>> On 10/26/2020 2:38 PM, Mike Terry wrote:
>>> On 26/10/2020 19:12, olcott wrote:
>>>> On 10/26/2020 11:11 AM, Mike Terry wrote:
>>>>> On 24/10/2020 23:01, olcott wrote:
>>> [... snip ...]
>>>>>>
>>>>>> Your trace is based on false assumptions my trace is based on working
>>>>>> code. Although I don't have the halt decider code completed yet because
>>>>>> the x86utm operating system is completed I can see exactly how the halt
>>>>>> deciding code would work.
>>>>>>
>>>>>
>>>>> What are the false assumptions? It is not ok in a discussion to say
>>>>> "you're wrong because you've made a false assumption, but I'm not
>>>>> going to say what that is!".
>>>>>
>>>>> My trace /is/ based on the assumption that Was_Its_Execution_Aborted()
>>>>> detects non-halting behaviour and returns ABORTS to H() and H_Hat().
>>>>> Is that my false assumption?
>>>>>
>>>>> Mike.
>>>>
>>>>
>>>> void H_Hat(u32 M)
>>>> {
>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>>>> MOV_EAX_1 // Execution of M(M) has been aborted
>>>> else
>>>> {
>>>> MOV_EAX_0 // M(M) has halted
>>>> HERE: goto HERE;
>>>> }
>>>> HALT
>>>> }
>>>>
>>>>
>>>> void H(u32 M, u32 N)
>>>> {
>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>>>> MOV_EAX_1 // Execution of M(N) has been aborted
>>>> else
>>>> MOV_EAX_0 // M(N) has halted
>>>> HALT
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>> u32 M = (u32)H_Hat;
>>>> H(M, M);
>>>> H_Hat(M);
>>>> HALT
>>>> }
>>>>
>>>> In each of the two cases above:
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>> Does provide the correct decision for its input.
>>>>
>>>
>>> So what was my false assumption you were referring to?
>>> Mike.
>> This answer may be too difficult to understand without an actual
>> execution trace of fully operational code. I have already explained it
>> again and again and no one has understood.
>>
>> The key summation of all of these execution trace answers is that
>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, M)
>> always decides its input correctly and cannot be shown otherwise.
>>
> So the code is this
>
> int eax = 1;
>
> bool Aborted_Because_Non_Halting_Behaviour_Detected(u32 *program, U32 *input)
> {
> if (program == H_Hat && input == H_Hat)
> {
> eax = 0;
> return true;
> }
> /* rest of logic unimportant */
> }
>
> void H_Hat(u32 *input)
> {
> if (Aborted_Because_Non_Halting_Behaviour_Detected(input, input))
> return;
> else
> while(1);
> }
>
> int main(void)
> {
> Aborted_Because_Non_Halting_Beahviour_Detected(H_Hat, H_hat);
> if (eax == 0)
> printf("aborted\n");
> else
> printf("Not aborted\n");
> eax = 1;
> H_Hat(H_Hat);
> if (eax == 0)
> printf("aborted\n");
> else
> printf("Not aborted\n");
> }
>
You have only shown how to encode this function incorrectly:
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
You have not shown any input where the following design necessarily gets
the wrong answer:
The redefined halt decider UTM executes its subordinate UTM one state
transition at a time until it detects non-halting behavior or its
subordinate UTM has terminated normally.
If the halt decider UTM detects non-halting behavior of its subordinate
UTM it simply stops executing the subordinate and transitions to its own
final state of ABORTED_NON_TERMINATING_BEHAVIOR.
If the subordinate UTM terminates normally the halt decider UTM
transitions to its own final state of SUBORDINATE_HAS_TERMINATED.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 16:31 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <4PCdnRWFxu2t3QrCnZ2dnUU7-dXNnZ2d@giganews.com> |
| In reply to | #156124 |
On 10/26/2020 4:08 PM, Malcolm McLean wrote:
> On Monday, 26 October 2020 at 21:01:15 UTC, olcott wrote:
>> On 10/26/2020 3:50 PM, Malcolm McLean wrote:
>>> On Monday, 26 October 2020 at 19:54:05 UTC, olcott wrote:
>>>> On 10/26/2020 2:38 PM, Mike Terry wrote:
>>>>> On 26/10/2020 19:12, olcott wrote:
>>>>>> On 10/26/2020 11:11 AM, Mike Terry wrote:
>>>>>>> On 24/10/2020 23:01, olcott wrote:
>>>>> [... snip ...]
>>>>>>>>
>>>>>>>> Your trace is based on false assumptions my trace is based on working
>>>>>>>> code. Although I don't have the halt decider code completed yet because
>>>>>>>> the x86utm operating system is completed I can see exactly how the halt
>>>>>>>> deciding code would work.
>>>>>>>>
>>>>>>>
>>>>>>> What are the false assumptions? It is not ok in a discussion to say
>>>>>>> "you're wrong because you've made a false assumption, but I'm not
>>>>>>> going to say what that is!".
>>>>>>>
>>>>>>> My trace /is/ based on the assumption that Was_Its_Execution_Aborted()
>>>>>>> detects non-halting behaviour and returns ABORTS to H() and H_Hat().
>>>>>>> Is that my false assumption?
>>>>>>>
>>>>>>> Mike.
>>>>>>
>>>>>>
>>>>>> void H_Hat(u32 M)
>>>>>> {
>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>>>>>> MOV_EAX_1 // Execution of M(M) has been aborted
>>>>>> else
>>>>>> {
>>>>>> MOV_EAX_0 // M(M) has halted
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>>
>>>>>> void H(u32 M, u32 N)
>>>>>> {
>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(M, M))
>>>>>> MOV_EAX_1 // Execution of M(N) has been aborted
>>>>>> else
>>>>>> MOV_EAX_0 // M(N) has halted
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 M = (u32)H_Hat;
>>>>>> H(M, M);
>>>>>> H_Hat(M);
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>> In each of the two cases above:
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>>>> Does provide the correct decision for its input.
>>>>>>
>>>>>
>>>>> So what was my false assumption you were referring to?
>>>>> Mike.
>>>> This answer may be too difficult to understand without an actual
>>>> execution trace of fully operational code. I have already explained it
>>>> again and again and no one has understood.
>>>>
>>>> The key summation of all of these execution trace answers is that
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, M)
>>>> always decides its input correctly and cannot be shown otherwise.
>>>>
>>> So the code is this
>>>
>>> int eax = 1;
>>>
>>> bool Aborted_Because_Non_Halting_Behaviour_Detected(u32 *program, U32 *input)
>>> {
>>> if (program == H_Hat && input == H_Hat)
>>> {
>>> eax = 0;
>>> return true;
>>> }
>>> /* rest of logic unimportant */
>>> }
>>>
>>> void H_Hat(u32 *input)
>>> {
>>> if (Aborted_Because_Non_Halting_Behaviour_Detected(input, input))
>>> return;
>>> else
>>> while(1);
>>> }
>>>
>>> int main(void)
>>> {
>>> Aborted_Because_Non_Halting_Beahviour_Detected(H_Hat, H_hat);
>>> if (eax == 0)
>>> printf("aborted\n");
>>> else
>>> printf("Not aborted\n");
>>> eax = 1;
>>> H_Hat(H_Hat);
>>> if (eax == 0)
>>> printf("aborted\n");
>>> else
>>> printf("Not aborted\n");
>>> }
>>>
>> You have only shown how to encode this function incorrectly:
>>
> It's a function. So it always behaves the same way when called with the
> same arguments. Therefore it can be replaced with this stub.
> That's useless for a real halt decider, but we only need one which works
> on one set of inputs - H_Hat, H_Hat.
>>
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>> You have not shown any input where the following design necessarily gets
>> the wrong answer:
>>
> I'm not disagreeing with you. I'm trying to clarify what you say.
>
Great!
Please try and find a counter-example where a halt decider defined as
follows would necessarily fail, or agree that the conventional halting
problem proof trick no longer works on such a halt decider:
The redefined halt decider UTM executes its subordinate UTM one state
transition at a time until it detects non-halting behavior or its
subordinate UTM has terminated normally.
If the halt decider UTM detects non-halting behavior of its subordinate
UTM it simply stops executing the subordinate and transitions to its own
final state of ABORTED_NON_TERMINATING_BEHAVIOR.
If the subordinate UTM terminates normally the halt decider UTM
transitions to its own final state of SUBORDINATE_HAS_TERMINATED.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 16:35 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <ROednbivfvyY3ArCnZ2dnUU7-VnNnZ2d@giganews.com> |
| In reply to | #156124 |
On 10/26/2020 4:26 PM, Keith Thompson wrote: > Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > [...] >>> You have only shown how to encode this function incorrectly: >>> >> It's a function. So it always behaves the same way when called with the >> same arguments. > > That is not generally true of C functions, whose behavior can depend on > data defined outside the function. > > Malcolm has his own meaning for the word "function", which is > inconsistent with the C meaning of the word. > > Malcolm, please make it clear when you're using your own definition of > "function", and what that definition is -- especially when C code is > begin discussed. Readers of comp.theory might not be familiar with the > way you use words. > Upon a suggestion of another poster we can hypothetically assume that the x86utm language does not provide any user code access to global data. This change would seem to make what Malcolm said true. -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 20:35 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <6-SdnRjlAoL45ArCnZ2dnUU7-cudnZ2d@giganews.com> |
| In reply to | #156124 |
On 10/26/2020 7:59 PM, Richard Damon wrote: > On 10/26/20 5:26 PM, Keith Thompson wrote: >> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >> [...] >>>> You have only shown how to encode this function incorrectly: >>>> >>> It's a function. So it always behaves the same way when called with the >>> same arguments. >> >> That is not generally true of C functions, whose behavior can depend on >> data defined outside the function. >> >> Malcolm has his own meaning for the word "function", which is >> inconsistent with the C meaning of the word. >> >> Malcolm, please make it clear when you're using your own definition of >> "function", and what that definition is -- especially when C code is >> begin discussed. Readers of comp.theory might not be familiar with the >> way you use words. >> > > BUT, a Turing Machine will always give the same output for the same > machine and same input. > > A C function can only give differing outputs if there is state hidden > elsewhere, for a Turing machine, that state would be explicit in the > machine or input. > Good answer, better than mine. -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-24 17:08 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <XvqdnaMd-fRJOAnCnZ2dnUU7-Q_NnZ2d@giganews.com> |
| In reply to | #156035 |
On 10/24/2020 3:57 PM, Mike Terry wrote:
> On 24/10/2020 21:41, olcott wrote:
>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>> On 24/10/2020 20:05, olcott wrote:
>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its input
>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this halt
>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>> program because its input program would otherwise cause
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of whatever it
>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The end result of this slight change is that the halting
>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever stated
>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> However, another program CAN be constructed on the basis of
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>> example of
>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>> {
>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was aborted
>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>> }
>>>>>>>>>>>>> else
>>>>>>>>>>>>> {
>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>> }
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> and for completeness, here is the function being invoked from
>>>>>>>>>>>>> main():
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>
>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no subtle
>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>> programming
>>>>>>>>>>>>> language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to run
>>>>>>>>>>>>> the
>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>> course we
>>>>>>>>>>>>> would
>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>> conditions
>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the execution
>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>> input or it reports that its input has not been aborted after
>>>>>>>>>>>>>> its
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>> I'll just take it they're the same thing, and continue saying
>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>
>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>> means.
>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>
>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>
>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and so is
>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>
>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>> self-reference
>>>>>>>>>>>> from
>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>
>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>> solution is
>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof without
>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>> problem is
>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>> that
>>>>>>>>>> cannot be contradicted.
>>>>>>>>>
>>>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>>>> of a
>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>> discussing HP.
>>>>>>>>
>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>> cannot be
>>>>>>>> shown to be undecidable:
>>>>>>>>
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>
>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>
>>>>>> Unless you can concretely show how this function would get the wrong
>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>
>>>>>
>>>>> In your code, the function answers "non halting behaviour detected"
>>>>> for input which actually halts, and so by any reasonable definition of
>>>>> the words, it has decided incorrectly.
>>>>
>>>> Bullshit. The actual question that it always correctly answers is:
>>>> Does the input have to be aborted to prevent infinite execution?
>>>
>>> I provided the traces which back up what I said, so it's not bullshit.
>>> You have snipped them because you don't want to look stupid, so I'm
>>> going to restore them:
>>>
>>> H_Hat machine trace
>>> -------------------
>>>
>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>> Was_Its_Execution_Aborted decides the emulated program ..
>>> .. will never terminate if not aborted
>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>> H_Hat *halts*
>>>
>>> OK, so the H_Hat calculation halts...
>>
>> In this case we have an outer instance of H_Hat() an inner instance of
>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>> process context of x86utm.
>>
>> This outer instance of H_Hat() invokes
>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>> creates the inner instance of H_Hat() in its own process context and
>> executes it. It then returns true to the outer instance of H_Hat() after
>> aborting the inner instance.
>
> ..*and then terminates*
>
> The calculation H_Hat(H_Hat) halts. So if
> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
> was "non-halting behaviour" it was wrong.
>
> No point in saying this over and over....
>
>
>>
>>> H machine trace
>>>
>>> ---------------
>>> H starts (main() calls H(H_Hat,H_Hat))
>>> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>> Was_Its_Execution_Aborted decides the emulated program ..
>>> .. will never terminate if not aborted
>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>> H halts, with EAX=0 [= *NOT_HALT* decision]
>>>
>>
>> In this case we have an instance of H() and an instance of H_Hat(). The
>> instance of H() is executed in the master UTM process context of x86utm.
>>
>> H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>> which creates the instance of H_Hat() and executes it. It then returns
>> true to H() after aborting the instance of _H_Hat().
>
> Again, returning true to H is supposed to say it detected non-halting
> behaviour, but the calculation it is examining actually halts.
>
> There, I said it again! :) (last time, really...)
Apparently this whole inner invocation of H_Hat() and outer invocation
of H_Hat() is against your religion. None-the-less an actual execution
trace would show that the outer invocation does abort the inner
invocation thus allowing the outer invocation to terminate normally.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-24 17:45 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <Yo-dnRiBK5MJMwnCnZ2dnUU7-d_NnZ2d@giganews.com> |
| In reply to | #156043 |
On 10/24/2020 5:16 PM, Malcolm McLean wrote: > On Saturday, 24 October 2020 at 23:08:28 UTC+1, olcott wrote: >> On 10/24/2020 3:57 PM, Mike Terry wrote: >> >>> >>> There, I said it again! :) (last time, really...) >> Apparently this whole inner invocation of H_Hat() and outer invocation >> of H_Hat() is against your religion. None-the-less an actual execution >> trace would show that the outer invocation does abort the inner >> invocation thus allowing the outer invocation to terminate normally. >> > The outer invocation H_Hat is the function we are interested in. If it > terminates normally, that's another way of saying it halts. So H() must > return "not aborted". The outer invocation of H_Hat() is an entirely different process having much more data than the inner invocation. > have you been following my posts? Yes I read all of the ones replying to me and all but one of the others. > The way round this problem is to > say the H aborts itself. i.e. it smashes the machine (abortion is equivalent > to taking a sledgehammed to the machine). Now H_Hat doesn't halt. > In the invocation of H_Hat(H_Hat) the inner process tree including an inner Aborted_Because_Non_Halting_Behavior_Detected(M, N) process are aborted before any of them can complete. So even though both instances of H_Hat() have identical source code because they do not have identical data they can have different execution traces. Because the inner H_Hat() is forced to terminate before it gets any return value from its instance of Aborted_Because_Non_Halting_Behavior_Detected(M, N) the outer instance of H_Hat() can have a different execution trace and terminate normally. -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 13:03 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <GJ-dnb_eE6sUkgrCnZ2dnUU7-L3NnZ2d@giganews.com> |
| In reply to | #156043 |
On 10/26/2020 11:29 AM, Mike Terry wrote:
> On 24/10/2020 23:08, olcott wrote:
>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>> On 24/10/2020 21:41, olcott wrote:
>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this
>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise cause
>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of Does_It_Halt().
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides "aborted"
>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> and for completeness, here is the function being invoked
>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted" (nonzero),
>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>> from
>>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>> solution is
>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>> without
>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>> problem is
>>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>>> that
>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>
>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP) definition
>>>>>>>>>>> of a
>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>> discussing HP.
>>>>>>>>>>
>>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>> cannot be
>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>
>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>>
>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>> wrong
>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>
>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>
>>>>>>>
>>>>>>> In your code, the function answers "non halting behaviour detected"
>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>> definition of
>>>>>>> the words, it has decided incorrectly.
>>>>>>
>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>
>>>>> I provided the traces which back up what I said, so it's not bullshit.
>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>> going to restore them:
>>>>>
>>>>> H_Hat machine trace
>>>>> -------------------
>>>>>
>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>> .. will never terminate if not aborted
>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>> H_Hat *halts*
>>>>>
>>>>> OK, so the H_Hat calculation halts...
>>>>
>>>> In this case we have an outer instance of H_Hat() an inner instance of
>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>> process context of x86utm.
>>>>
>>>> This outer instance of H_Hat() invokes
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>> creates the inner instance of H_Hat() in its own process context and
>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>> after
>>>> aborting the inner instance.
>>>
>>> ..*and then terminates*
>>>
>>> The calculation H_Hat(H_Hat) halts. So if
>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>>> was "non-halting behaviour" it was wrong.
>>>
>>> No point in saying this over and over....
>>>
>>>
>>>>
>>>>> H machine trace
>>>>>
>>>>> ---------------
>>>>> H starts (main() calls H(H_Hat,H_Hat))
>>>>> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>> .. will never terminate if not aborted
>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>> H halts, with EAX=0 [= *NOT_HALT* decision]
>>>>>
>>>>
>>>> In this case we have an instance of H() and an instance of H_Hat(). The
>>>> instance of H() is executed in the master UTM process context of
>>>> x86utm.
>>>>
>>>> H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
>>>> which creates the instance of H_Hat() and executes it. It then returns
>>>> true to H() after aborting the instance of _H_Hat().
>>>
>>> Again, returning true to H is supposed to say it detected non-halting
>>> behaviour, but the calculation it is examining actually halts.
>>>
>>> There, I said it again! :) (last time, really...)
>> Apparently this whole inner invocation of H_Hat() and outer invocation
>> of H_Hat() is against your religion.
>
> Why do you say that? I understand perfectly about outer and inner
> invocations of H_Hat(). I understand it better than you, because I lack
> your confusions on what's going on.
>
> Incidentally, I believe I've realised where you are going wrong in your
> thinking! (If I'm right, it will come out in your answer to the
> question below...)
>
>> None-the-less an actual execution
>> trace would show that the outer invocation does abort the inner
>> invocation thus allowing the outer invocation to terminate normally.
>
> That's fine.
>
> If the outer invocation aborts the inner invocation, that implies that
> the H_Hat(H_Hat) calculation halts.
None of the invocations of H_Hat() would ever halt unless they are
aborted. That is why this is the correct halt decider question:
bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
When the return value of true is provided for the (M, N) input this
return value is correct. Every other return value from
bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
does not occur because every other
bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
has had its execution terminated before it ever returns any value.
Therefore we can conclude that
bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
Is a halt decider function that cannot be shown to be incorrect.
> [When I say a calculation halts, I
> mean that there is a number n such that after n steps the calculation
> reaches a halt state. It is nothing to do with anything being emulated,
> or run on some physical computer.]
>
> Do you agree with this?
>
> Mike.
No. I pointed out the false assumptions.
The one time that
bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
returns its decision value this decision value is correct.
There are no other times that it reteuns its decsion value.
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 13:14 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction |
| Message-ID | <qu-dnWnPetCUjwrCnZ2dnUU7-KFQAAAA@giganews.com> |
| In reply to | #156112 |
On 10/26/2020 1:03 PM, olcott wrote:
> On 10/26/2020 11:29 AM, Mike Terry wrote:
>> On 24/10/2020 23:08, olcott wrote:
>>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>>> On 24/10/2020 21:41, olcott wrote:
>>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of this
>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider
>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise
>>>>>>>>>>>>>>>>>>>>> cause
>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of
>>>>>>>>>>>>>>>>>> Does_It_Halt().
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>> "aborted"
>>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides "halted"
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here is an
>>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> and for completeness, here is the function being invoked
>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted"
>>>>>>>>>>>>>>>> (nonzero),
>>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>>> without
>>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your solution is
>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>>> problem is
>>>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>>>> that
>>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP)
>>>>>>>>>>>> definition
>>>>>>>>>>>> of a
>>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>>> discussing HP.
>>>>>>>>>>>
>>>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>>> cannot be
>>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>>
>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>>
>>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>>>
>>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>>> wrong
>>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>>
>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>
>>>>>>>>
>>>>>>>> In your code, the function answers "non halting behaviour detected"
>>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>>> definition of
>>>>>>>> the words, it has decided incorrectly.
>>>>>>>
>>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>>
>>>>>> I provided the traces which back up what I said, so it's not
>>>>>> bullshit.
>>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>>> going to restore them:
>>>>>>
>>>>>> H_Hat machine trace
>>>>>> -------------------
>>>>>>
>>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>> .. will never terminate if not aborted
>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>> H_Hat *halts*
>>>>>>
>>>>>> OK, so the H_Hat calculation halts...
>>>>>
>>>>> In this case we have an outer instance of H_Hat() an inner instance of
>>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>>> process context of x86utm.
>>>>>
>>>>> This outer instance of H_Hat() invokes
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>>> creates the inner instance of H_Hat() in its own process context and
>>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>>> after
>>>>> aborting the inner instance.
>>>>
>>>> ..*and then terminates*
>>>>
>>>> The calculation H_Hat(H_Hat) halts. So if
>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>>>> was "non-halting behaviour" it was wrong.
>>>>
>>>> No point in saying this over and over....
>>>>
>>>>
>>>>>
>>>>>> H machine trace
>>>>>>
>>>>>> ---------------
>>>>>> H starts (main() calls H(H_Hat,H_Hat))
>>>>>> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>> .. will never terminate if not aborted
>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>> H halts, with EAX=0 [= *NOT_HALT* decision]
>>>>>>
>>>>>
>>>>> In this case we have an instance of H() and an instance of H_Hat().
>>>>> The
>>>>> instance of H() is executed in the master UTM process context of
>>>>> x86utm.
>>>>>
>>>>> H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat,
>>>>> H_Hat)
>>>>> which creates the instance of H_Hat() and executes it. It then returns
>>>>> true to H() after aborting the instance of _H_Hat().
>>>>
>>>> Again, returning true to H is supposed to say it detected non-halting
>>>> behaviour, but the calculation it is examining actually halts.
>>>>
>>>> There, I said it again! :) (last time, really...)
>>> Apparently this whole inner invocation of H_Hat() and outer invocation
>>> of H_Hat() is against your religion.
>>
>> Why do you say that? I understand perfectly about outer and inner
>> invocations of H_Hat(). I understand it better than you, because I
>> lack your confusions on what's going on.
>>
>> Incidentally, I believe I've realised where you are going wrong in
>> your thinking! (If I'm right, it will come out in your answer to the
>> question below...)
>>
>>> None-the-less an actual execution
>>> trace would show that the outer invocation does abort the inner
>>> invocation thus allowing the outer invocation to terminate normally.
>>
>> That's fine.
>>
>> If the outer invocation aborts the inner invocation, that implies that
>> the H_Hat(H_Hat) calculation halts.
>
CORRECTION
> None of the invocations of H_Hat() would ever halt unless they are
> aborted.
In both cases the input H_Hat would not halt unless it has been aborted:
H_Hat(H_Hat)
H(H_Hat, H_Hat)
> That is why this is the correct halt decider question:
> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>
> When the return value of true is provided for the (M, N) input this
> return value is correct. Every other return value from
> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
> does not occur because every other
> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
> has had its execution terminated before it ever returns any value.
>
> Therefore we can conclude that
> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
> Is a halt decider function that cannot be shown to be incorrect.
>
>> [When I say a calculation halts, I mean that there is a number n such
>> that after n steps the calculation reaches a halt state. It is
>> nothing to do with anything being emulated, or run on some physical
>> computer.]
>>
>> Do you agree with this?
>>
>> Mike.
>
>
> No. I pointed out the false assumptions.
> The one time that
> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
> returns its decision value this decision value is correct.
> There are no other times that it reteuns its decsion value.
>
>
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-27 00:06 +0000 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction |
| Message-ID | <Ke2dnaoWbqkW-QrCnZ2dnUU78bXNnZ2d@brightview.co.uk> |
| In reply to | #156115 |
On 26/10/2020 18:14, olcott wrote:
> On 10/26/2020 1:03 PM, olcott wrote:
>> On 10/26/2020 11:29 AM, Mike Terry wrote:
>>> On 24/10/2020 23:08, olcott wrote:
>>>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>>>> On 24/10/2020 21:41, olcott wrote:
>>>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible for
>>>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined, then
>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of
>>>>>>>>>>>>>>>>>>>>>> this halt
>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider
>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise
>>>>>>>>>>>>>>>>>>>>>> cause
>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of
>>>>>>>>>>>>>>>>>>> Does_It_Halt().
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as asking
>>>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>>> "aborted"
>>>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here
>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> and for completeness, here is the function being
>>>>>>>>>>>>>>>>> invoked from
>>>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted"
>>>>>>>>>>>>>>>>> (nonzero),
>>>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of the C
>>>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.) That's
>>>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets the
>>>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>> the halting decision and tosses this solution in the trash.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>>>> without
>>>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your
>>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>> undecidable by finding another way to define the halt decider
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP)
>>>>>>>>>>>>> definition
>>>>>>>>>>>>> of a
>>>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>>>> discussing HP.
>>>>>>>>>>>>
>>>>>>>>>>>> As long as a halt decider cannot be shown to make this decision
>>>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>>>> cannot be
>>>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>>>
>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P,
>>>>>>>>>>>> u32 I)
>>>>>>>>>>>
>>>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>>>> conforms with the Linz conclusion, and does not refute anything.
>>>>>>>>>>
>>>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>>>> wrong
>>>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>>>
>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> In your code, the function answers "non halting behaviour
>>>>>>>>> detected"
>>>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>>>> definition of
>>>>>>>>> the words, it has decided incorrectly.
>>>>>>>>
>>>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>>>
>>>>>>> I provided the traces which back up what I said, so it's not
>>>>>>> bullshit.
>>>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>>>> going to restore them:
>>>>>>>
>>>>>>> H_Hat machine trace
>>>>>>> -------------------
>>>>>>>
>>>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>>> .. will never terminate if not aborted
>>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>>> H_Hat *halts*
>>>>>>>
>>>>>>> OK, so the H_Hat calculation halts...
>>>>>>
>>>>>> In this case we have an outer instance of H_Hat() an inner
>>>>>> instance of
>>>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>>>> process context of x86utm.
>>>>>>
>>>>>> This outer instance of H_Hat() invokes
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>>>> creates the inner instance of H_Hat() in its own process context and
>>>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>>>> after
>>>>>> aborting the inner instance.
>>>>>
>>>>> ..*and then terminates*
>>>>>
>>>>> The calculation H_Hat(H_Hat) halts. So if
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says there
>>>>> was "non-halting behaviour" it was wrong.
>>>>>
>>>>> No point in saying this over and over....
>>>>>
>>>>>
>>>>>>
>>>>>>> H machine trace
>>>>>>>
>>>>>>> ---------------
>>>>>>> H starts (main() calls H(H_Hat,H_Hat))
>>>>>>> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>>> .. will never terminate if not aborted
>>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>>> H halts, with EAX=0 [= *NOT_HALT* decision]
>>>>>>>
>>>>>>
>>>>>> In this case we have an instance of H() and an instance of
>>>>>> H_Hat(). The
>>>>>> instance of H() is executed in the master UTM process context of
>>>>>> x86utm.
>>>>>>
>>>>>> H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat,
>>>>>> H_Hat)
>>>>>> which creates the instance of H_Hat() and executes it. It then
>>>>>> returns
>>>>>> true to H() after aborting the instance of _H_Hat().
>>>>>
>>>>> Again, returning true to H is supposed to say it detected non-halting
>>>>> behaviour, but the calculation it is examining actually halts.
>>>>>
>>>>> There, I said it again! :) (last time, really...)
>>>> Apparently this whole inner invocation of H_Hat() and outer invocation
>>>> of H_Hat() is against your religion.
>>>
>>> Why do you say that? I understand perfectly about outer and inner
>>> invocations of H_Hat(). I understand it better than you, because I
>>> lack your confusions on what's going on.
>>>
>>> Incidentally, I believe I've realised where you are going wrong in
>>> your thinking! (If I'm right, it will come out in your answer to the
>>> question below...)
>>>
>>>> None-the-less an actual execution
>>>> trace would show that the outer invocation does abort the inner
>>>> invocation thus allowing the outer invocation to terminate normally.
>>>
>>> That's fine.
>>>
>>> If the outer invocation aborts the inner invocation, that implies
>>> that the H_Hat(H_Hat) calculation halts.
>>
>
> CORRECTION
>> None of the invocations of H_Hat() would ever halt unless they are
>> aborted.
>
> In both cases the input H_Hat would not halt unless it has been aborted:
> H_Hat(H_Hat)
> H(H_Hat, H_Hat)
>
Talking about what /would/ happen if xxxxx is confusing the discussion,
I think.
By now you must know for your ACTUAL FINAL coded H and H_Hat: Does the
calculation H_Hat(H_Hat) halt?
I'm not talking about what its internal
Aborted_Because_Non_Halting_Behavior_Detected(M, N) routine does, or
what happens in any internal emulations of anything.
>
>> That is why this is the correct halt decider question:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
It is only the correct halt decider question if it actually relates to
the halting of calculation (M,N). Otherwise it is not a halt decider,
it's a "Internal routine aborted something" decider.
Mike.
>>
>> When the return value of true is provided for the (M, N) input this
>> return value is correct. Every other return value from
>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>> does not occur because every other
>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>> has had its execution terminated before it ever returns any value.
>>
>> Therefore we can conclude that
>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>> Is a halt decider function that cannot be shown to be incorrect.
>>
>>> [When I say a calculation halts, I mean that there is a number n such
>>> that after n steps the calculation reaches a halt state. It is
>>> nothing to do with anything being emulated, or run on some physical
>>> computer.]
>>>
>>> Do you agree with this?
>>>
>>> Mike.
>>
>>
>> No. I pointed out the false assumptions.
>> The one time that
>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>> returns its decision value this decision value is correct.
>> There are no other times that it reteuns its decsion value.
>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <Keith.S.Thompson+u@gmail.com> |
|---|---|
| Date | 2020-10-26 17:16 -0700 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] correction |
| Message-ID | <878sbsv7zo.fsf@nosuchdomain.example.com> |
| In reply to | #156131 |
Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
[SNIP]
Mike, and everyone else, please drop the comp.lang.* newsgroups when
you post a followup to one of olcott's articles.
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 20:11 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <FLGdnaP7s91R7grCnZ2dnUU7-eXNnZ2d@giganews.com> |
| In reply to | #156131 |
On 10/26/2020 7:06 PM, Mike Terry wrote:
> On 26/10/2020 18:14, olcott wrote:
>> On 10/26/2020 1:03 PM, olcott wrote:
>>> On 10/26/2020 11:29 AM, Mike Terry wrote:
>>>> On 24/10/2020 23:08, olcott wrote:
>>>>> On 10/24/2020 3:57 PM, Mike Terry wrote:
>>>>>> On 24/10/2020 21:41, olcott wrote:
>>>>>>> On 10/24/2020 2:44 PM, Mike Terry wrote:
>>>>>>>> On 24/10/2020 20:05, olcott wrote:
>>>>>>>>> On 10/24/2020 2:00 PM, Mike Terry wrote:
>>>>>>>>>> On 24/10/2020 19:42, olcott wrote:
>>>>>>>>>>> On 10/24/2020 1:32 PM, Mike Terry wrote:
>>>>>>>>>>>> On 24/10/2020 18:49, olcott wrote:
>>>>>>>>>>>>> On 10/24/2020 11:37 AM, Mike Terry wrote:
>>>>>>>>>>>>>> On 24/10/2020 16:36, olcott wrote:
>>>>>>>>>>>>>>> On 10/24/2020 9:38 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>> On 24/10/2020 07:03, olcott wrote:
>>>>>>>>>>>>>>>>> On 10/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>> On 23/10/2020 00:05, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 10/22/2020 5:14 PM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>> On 22/10/2020 17:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/22/2020 10:25 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>>> On 22/10/2020 15:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/22/2020 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/22/20 12:33 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The difference is that it is no longer possible
>>>>>>>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>>>>>>>>>>>>> to do
>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H() decides. This transforms an
>>>>>>>>>>>>>>>>>>>>>>>>> undecidable
>>>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>>>> into a decidable problem.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If H_Hat no longer does what the proof defined,
>>>>>>>>>>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>>> demonstration
>>>>>>>>>>>>>>>>>>>>>>>> is no longer applicable to the proof.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not its
>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>>>>>>>>>> program can be constructed on the the basis of
>>>>>>>>>>>>>>>>>>>>>>> this halt
>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever the halt decider
>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This is how H() and H_Hat() are defined in the Linz
>>>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If the halt decider is to report whether or not it
>>>>>>>>>>>>>>>>>>>>>>> aborted its
>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>> program because its input program would otherwise
>>>>>>>>>>>>>>>>>>>>>>> cause
>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>> to get stuck in infinite execution then this other
>>>>>>>>>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>>>> longer
>>>>>>>>>>>>>>>>>>>>>>> fool its halt decider and do the opposite of
>>>>>>>>>>>>>>>>>>>>>>> whatever it
>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If H() aborts the execution of H_Hat() then H_Hat()
>>>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>>>> continue to
>>>>>>>>>>>>>>>>>>>>>>> execute because H() has complete control over H_Hat.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The end result of this slight change is that the
>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>> can no
>>>>>>>>>>>>>>>>>>>>>>> longer be shown to be undecidable.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is suspicious that in none of this have you ever
>>>>>>>>>>>>>>>>>>>>>> stated
>>>>>>>>>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>>>>>>>>>> actually wrong in the Linz proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>>>> bool Does_It_Halt(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>>> another program can be constructed on the basis of
>>>>>>>>>>>>>>>>>>>>> Does_It_Halt()
>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever Does_It_Halt() decides.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, regardless of the internal details of
>>>>>>>>>>>>>>>>>>>> Does_It_Halt().
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When the halting problem is defined as:
>>>>>>>>>>>>>>>>>>>>> bool Was_Its_Execution_Aborted(u32 P, u32 I)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> another program CANNOT be constructed on the basis of
>>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that does the opposite of
>>>>>>>>>>>>>>>>>>>>> whatever
>>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() decides.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Sure, if you interpret your question literally as
>>>>>>>>>>>>>>>>>>>> asking
>>>>>>>>>>>>>>>>>>>> whether P
>>>>>>>>>>>>>>>>>>>> would actually be aborted if it executes under the UTM
>>>>>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted()!
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> However, another program CAN be constructed on the
>>>>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted() that:
>>>>>>>>>>>>>>>>>>>> - halts if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>>>> "aborted"
>>>>>>>>>>>>>>>>>>>> - loops if Was_Its_Execution_Aborted() decides
>>>>>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (right?)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, right. To avoid a silly pantomine argument, here
>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>> example of
>>>>>>>>>>>>>>>>>> such a function:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int H_Hat(u32 M)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> if (Was_Its_Execution_Aborted(M, M))
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) was
>>>>>>>>>>>>>>>>>> aborted
>>>>>>>>>>>>>>>>>> HALT; // so we halt
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> // Was_Its_Execution_Aborted says that M(M) halted
>>>>>>>>>>>>>>>>>> HERE: goto HERE; // so we loop
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> and for completeness, here is the function being
>>>>>>>>>>>>>>>>>> invoked from
>>>>>>>>>>>>>>>>>> main():
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 M = (u32)H_Hat;
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H_Hat(M); // run H_Hat with input H_Hat
>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You see, H_Hat /is/ constructed so that if
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted(M, M) returns "aborted"
>>>>>>>>>>>>>>>>>> (nonzero),
>>>>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>>>>> will halt, and if Was_Its_Execution_Aborted(M, M) returns
>>>>>>>>>>>>>>>>>> "halted"
>>>>>>>>>>>>>>>>>> (zero), H_Hat will loop. Just like I said. Thre is no
>>>>>>>>>>>>>>>>>> subtle
>>>>>>>>>>>>>>>>>> philosophical point here, just beginner knowledge of
>>>>>>>>>>>>>>>>>> the C
>>>>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>>>>> language.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (To save you making a silly response, yes IF we were to
>>>>>>>>>>>>>>>>>> run the
>>>>>>>>>>>>>>>>>> program under a debugger or emulator of some kind, and we
>>>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>>>> run at the "if (Abort)" statement or earlier, then of
>>>>>>>>>>>>>>>>>> course we
>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>> not get to see what it actually does next. (Duh.)
>>>>>>>>>>>>>>>>>> That's
>>>>>>>>>>>>>>>>>> irrelevent
>>>>>>>>>>>>>>>>>> because regardless of this, H_Hat as constructed meets
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> conditions
>>>>>>>>>>>>>>>>>> just as I described.)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> > There is no way to make the revised halting question
>>>>>>>>>>>>>>>>>> contradictory.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> DebugTrace() either reports that it has aborted the
>>>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>> input or it reports that its input has not been aborted
>>>>>>>>>>>>>>>>>>> after
>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>> has terminated.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> > [A quick observation: you've flipped to talking about
>>>>>>>>>>>>>>>>>> DebugTrace()
>>>>>>>>>>>>>>>>>> rather than Was_Its_Execution_Aborted() which we were
>>>>>>>>>>>>>>>>>> discussing.
>>>>>>>>>>>>>>>>>> I'll just take it they're the same thing, and continue
>>>>>>>>>>>>>>>>>> saying
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted().]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> OK good. I like that. Make the function say what it really
>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>> That is good software engineering.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I never said otherwise.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> BUT bear in mind that H (as opposed to
>>>>>>>>>>>>>>>>>> Was_Its_Execution_Aborted())
>>>>>>>>>>>>>>>>>> plays the role in all this of a Linz *Halt Decider*, and
>>>>>>>>>>>>>>>>>> so is
>>>>>>>>>>>>>>>>>> required to deliver its HD decision *HALT* or *NOT_HALT*.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, not at all. Not in the least little bit.
>>>>>>>>>>>>>>>>> This takes my solution of removing the pathological
>>>>>>>>>>>>>>>>> self-reference
>>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>>> the halting decision and tosses this solution in the
>>>>>>>>>>>>>>>>> trash.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Maybe, and that would be the right thing to do if your
>>>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>>>> wrong. In any case, if you can't refute the Linz proof
>>>>>>>>>>>>>>>> without
>>>>>>>>>>>>>>>> changing the meaning of "Halt Decider", then your
>>>>>>>>>>>>>>>> solution is
>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am refuting that the Linz proof proves that the halting
>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>> undecidable by finding another way to define the halt
>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> cannot be contradicted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Linz halt decider corresponds to the correct (HP)
>>>>>>>>>>>>>> definition
>>>>>>>>>>>>>> of a
>>>>>>>>>>>>>> halt decider. If you change this definition you are not
>>>>>>>>>>>>>> discussing HP.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As long as a halt decider cannot be shown to make this
>>>>>>>>>>>>> decision
>>>>>>>>>>>>> incorrectly for any of its inputs then the halting problem
>>>>>>>>>>>>> cannot be
>>>>>>>>>>>>> shown to be undecidable:
>>>>>>>>>>>>>
>>>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P,
>>>>>>>>>>>>> u32 I)
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz proof shows HP to be undecidable. Your refuting code
>>>>>>>>>>>> conforms with the Linz conclusion, and does not refute
>>>>>>>>>>>> anything.
>>>>>>>>>>>
>>>>>>>>>>> Unless you can concretely show how this function would get the
>>>>>>>>>>> wrong
>>>>>>>>>>> answer all of your rebuttal is ultimately totally vacuous:
>>>>>>>>>>>
>>>>>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> In your code, the function answers "non halting behaviour
>>>>>>>>>> detected"
>>>>>>>>>> for input which actually halts, and so by any reasonable
>>>>>>>>>> definition of
>>>>>>>>>> the words, it has decided incorrectly.
>>>>>>>>>
>>>>>>>>> Bullshit. The actual question that it always correctly answers is:
>>>>>>>>> Does the input have to be aborted to prevent infinite execution?
>>>>>>>>
>>>>>>>> I provided the traces which back up what I said, so it's not
>>>>>>>> bullshit.
>>>>>>>> You have snipped them because you don't want to look stupid, so I'm
>>>>>>>> going to restore them:
>>>>>>>>
>>>>>>>> H_Hat machine trace
>>>>>>>> -------------------
>>>>>>>>
>>>>>>>> H_Hat starts (main() calls H_Hat(H_Hat))
>>>>>>>> H_Hat calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>>>> .. will never terminate if not aborted
>>>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>>>> H_Hat *halts*
>>>>>>>>
>>>>>>>> OK, so the H_Hat calculation halts...
>>>>>>>
>>>>>>> In this case we have an outer instance of H_Hat() an inner
>>>>>>> instance of
>>>>>>> H_Hat(). The outer instance of H_Hat() is executed in the master UTM
>>>>>>> process context of x86utm.
>>>>>>>
>>>>>>> This outer instance of H_Hat() invokes
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) which
>>>>>>> creates the inner instance of H_Hat() in its own process context and
>>>>>>> executes it. It then returns true to the outer instance of H_Hat()
>>>>>>> after
>>>>>>> aborting the inner instance.
>>>>>>
>>>>>> ..*and then terminates*
>>>>>>
>>>>>> The calculation H_Hat(H_Hat) halts. So if
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat) says
>>>>>> there
>>>>>> was "non-halting behaviour" it was wrong.
>>>>>>
>>>>>> No point in saying this over and over....
>>>>>>
>>>>>>
>>>>>>>
>>>>>>>> H machine trace
>>>>>>>>
>>>>>>>> ---------------
>>>>>>>> H starts (main() calls H(H_Hat,H_Hat))
>>>>>>>> H calls Was_Its_Execution_Aborted(H_Hat,H_Hat)
>>>>>>>> Was_Its_Execution_Aborted emulates H_Hat(H_Hat)
>>>>>>>> Was_Its_Execution_Aborted decides the emulated program ..
>>>>>>>> .. will never terminate if not aborted
>>>>>>>> Was_Its_Execution_Aborted stops emulating and returns ABORTED
>>>>>>>> H halts, with EAX=0 [= *NOT_HALT* decision]
>>>>>>>>
>>>>>>>
>>>>>>> In this case we have an instance of H() and an instance of
>>>>>>> H_Hat(). The
>>>>>>> instance of H() is executed in the master UTM process context of
>>>>>>> x86utm.
>>>>>>>
>>>>>>> H() invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat,
>>>>>>> H_Hat)
>>>>>>> which creates the instance of H_Hat() and executes it. It then
>>>>>>> returns
>>>>>>> true to H() after aborting the instance of _H_Hat().
>>>>>>
>>>>>> Again, returning true to H is supposed to say it detected non-halting
>>>>>> behaviour, but the calculation it is examining actually halts.
>>>>>>
>>>>>> There, I said it again! :) (last time, really...)
>>>>> Apparently this whole inner invocation of H_Hat() and outer invocation
>>>>> of H_Hat() is against your religion.
>>>>
>>>> Why do you say that? I understand perfectly about outer and inner
>>>> invocations of H_Hat(). I understand it better than you, because I
>>>> lack your confusions on what's going on.
>>>>
>>>> Incidentally, I believe I've realised where you are going wrong in
>>>> your thinking! (If I'm right, it will come out in your answer to the
>>>> question below...)
>>>>
>>>>> None-the-less an actual execution
>>>>> trace would show that the outer invocation does abort the inner
>>>>> invocation thus allowing the outer invocation to terminate normally.
>>>>
>>>> That's fine.
>>>>
>>>> If the outer invocation aborts the inner invocation, that implies
>>>> that the H_Hat(H_Hat) calculation halts.
>>>
>>
>> CORRECTION
>>> None of the invocations of H_Hat() would ever halt unless they are
>>> aborted.
>>
>> In both cases the input H_Hat would not halt unless it has been aborted:
>> H_Hat(H_Hat)
>> H(H_Hat, H_Hat)
>>
>
> Talking about what /would/ happen if xxxxx is confusing the discussion,
> I think.
That is the problem with posting my results a little bit prematurely.
If I simply provided the execution trace of exactly what each one of the
virtual machines actually does in each one of their process contexts
then it would not be possible to simply disagree that these are the
actual execution traces.
Since each process context has its own unique memory address and I have
updated the x86utm operating system to have some Output() functions I
will be able to provide this execution trace fairly soon.
> By now you must know for your ACTUAL FINAL coded H and H_Hat: Does the
> calculation H_Hat(H_Hat) halt?
The key thing to realize is that this function cannot be shown to ever
provide an incorrect return value:
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
All of the other things are simply dodges.
In your case not a dishonest dodge.
> I'm not talking about what its internal
> Aborted_Because_Non_Halting_Behavior_Detected(M, N) routine does, or
> what happens in any internal emulations of anything.
The key thing to realize is that this function cannot be shown to ever
provide an incorrect return value:
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
This requires knowing in a very complex recursive invocation sequence
exactly which instance of that function is returning a value and exactly
which instance of H_Hat is its actual input.
It turns out that the outermost invocation of
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
bases its decision on its first parmeter.
>>> That is why this is the correct halt decider question:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>
> It is only the correct halt decider question if it actually relates to
> the halting of calculation (M,N). Otherwise it is not a halt decider,
> it's a "Internal routine aborted something" decider.
This function cannot be shown to ever return an incorrect value:
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> Mike.
>
>>>
>>> When the return value of true is provided for the (M, N) input this
>>> return value is correct. Every other return value from
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>>> does not occur because every other
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>>> has had its execution terminated before it ever returns any value.
>>>
>>> Therefore we can conclude that
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>>> Is a halt decider function that cannot be shown to be incorrect.
>>>
>>>> [When I say a calculation halts, I mean that there is a number n such
>>>> that after n steps the calculation reaches a halt state. It is
>>>> nothing to do with anything being emulated, or run on some physical
>>>> computer.]
>>>>
>>>> Do you agree with this?
>>>>
>>>> Mike.
>>>
>>>
>>> No. I pointed out the false assumptions.
>>> The one time that
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(M, N)
>>> returns its decision value this decision value is correct.
>>> There are no other times that it reteuns its decsion value.
>>>
>>>
>>
>>
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-26 22:38 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete [ HP proof refutation has been provided ] |
| Message-ID | <cYSdnQ9W-cO9CwrCnZ2dnUU7-Y3NnZ2d@giganews.com> |
| In reply to | #156133 |
On 10/26/2020 9:48 PM, Mike Terry wrote:
> On 27/10/2020 01:11, olcott wrote:
>> On 10/26/2020 7:06 PM, Mike Terry wrote:
>>> On 26/10/2020 18:14, olcott wrote:
>>>> On 10/26/2020 1:03 PM, olcott wrote:
> [... snip ...]
>>>>>
>>>>
>>>> CORRECTION
>>>>> None of the invocations of H_Hat() would ever halt unless they are
>>>>> aborted.
>>>>
>>>> In both cases the input H_Hat would not halt unless it has been
>>>> aborted:
>>>> H_Hat(H_Hat)
>>>> H(H_Hat, H_Hat)
>>>>
>>>
>>> Talking about what /would/ happen if xxxxx is confusing the
>>> discussion, I think.
>>
>> That is the problem with posting my results a little bit prematurely.
>> If I simply provided the execution trace of exactly what each one of the
>> virtual machines actually does in each one of their process contexts
>> then it would not be possible to simply disagree that these are the
>> actual execution traces.
>
> Nobody has simply disagreed with any execution traces, because you have
> not provided any,
I have provided complete description of all of the key elements of the
execution trace such that it can be understood
bool Aborted_Because_Non_Halting_Behavior_Detected(H_hat, H_Hat)
does return the correct value. It is a fact that I did totally prove
this point as long as the actual execution is as I have described.
It is also reasonably likely that this detailed description may been too
difficult to understand.
> and more to the point you have refused to answer
> questions about your code like whether H_Hat(H_Hat) halts. So this is
> not an issue.
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat)
does provide the correct return value. It cannot be shown that it ever
does not provide the correct return value.
>> Since each process context has its own unique memory address and I have
>> updated the x86utm operating system to have some Output() functions I
>> will be able to provide this execution trace fairly soon.
>>
>>> By now you must know for your ACTUAL FINAL coded H and H_Hat: Does
>>> the calculation H_Hat(H_Hat) halt?
>
> [... snip non-reply ...]
> So, for your ACTUAL FINAL coded H and H_Hat: Does the calculation
> H_Hat(H_Hat) halt?
>
>>
>> The key thing to realize is that this function cannot be shown to ever
>> provide an incorrect return value:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>
> Since you have refused to provide any spec for
> Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I), or to
I provided the complete description of the execution trace that proves
that it decides (H_Hat, H_Hat) correctly. That this answer was too
difficult for you to understand is no evidence what-so-ever that I not
provide a complete answer.
I acknowledge that if you don't understand an answer that you would have
no direct evidence that it is an answer. That is easily fixed. I just
have to finish writing the code that fully implements this answer.
> define what "return an incorrect value" means, no wonder! It is a
> meaningless claim until you clarify exactly what it means.
This statement is seeming to be quite disingenuous at this point.
Which line of H decides H(H_Hat, H_Hat) correctly: {04, 06} ?
Any answer not from this set: {04, 06} indicates that you are trying to
dodge the idea of "return an incorrect value" and you always knew all
along exactly what I meant.
void H_Hat(u32 M)
{
if (!Halts(M, M))
MOV_EAX_0 // Does not Halt
else
{
MOV_EAX_1 // Halts
HERE: goto HERE;
}
HALT
}
01 void H(u32 M, u32 N)
02 {
03 if (!Halts(M, M))
04 MOV_EAX_0 // Does not Halt
05 else
06 MOV_EAX_1 // Halts
07 HALT
08 }
int main()
{
u32 M = (u32)H_Hat;
H(M, M);
HALT
}
> ok, in one response you did say "yes" when I asked if it meant "return a
> value that disagrees with its spec", but you've never given a spec! And
> I don't believe that's actually what you mean anyway, but that's all
> you've revealed.
I have given the complete spec as a detailed description of the
execution trace of how Aborted_Because_Non_Halting_Behavior_Detected()
decides (H_Hat, H_Hat) very many times now.
It is either that it is too difficult for you to understand or you don't
believe that my description is accurate. If it is not too difficult for
you to understand then you could evaluate it hypothetically while I
write the actual code. If it is too difficult for you to understand ten
I will shortly have the code.
> And without that spec, the relationship of that function to the Linz
> halting proof is unknown. The HP proof requires answering the halting
> question, not some new undefined question you've come up with!
>
> The REAL key thing is whether your H, H^ are correctly related (as in
> the Linz proof), and whether H correctly decides the halting for H^
> running with input H^. THAT is what you've always said you were going
> to deliver.
I have done that a bunch of times now. It is OK if what I said is too
complex to understand. I will write the actual code and then make its
execution trace only show the key decision points.
> Are you admitting that your H, H^ won't do that after all?
>
> Mike
>
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
Page 11 of 13 — ← Prev page 1 … 9 10 [11] 12 13 Next page →
Back to top | Article view | comp.lang.c
csiph-web