Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #25604 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-11-21 13:19 -0600 |
| Last post | 2020-11-22 13:14 -0600 |
| Articles | 20 on this page of 137 — 8 participants |
Back to article view | Back to comp.theory
It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 13:19 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-21 13:06 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 15:35 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-21 23:46 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 18:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-22 01:14 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2] André G. Isaak <agisaak@gm.invalid> - 2020-11-22 03:48 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-22 08:17 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] André G. Isaak <agisaak@gm.invalid> - 2020-11-22 07:58 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) olcott <NoOne@NoWhere.com> - 2020-11-22 10:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 10:10 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) olcott <NoOne@NoWhere.com> - 2020-11-22 11:47 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 13:14 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 12:28 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 13:44 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 12:56 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 14:23 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 13:28 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 16:21 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 16:25 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 18:09 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-22 17:35 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 20:03 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Alan Mackenzie <acm@muc.de> - 2020-11-23 12:54 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-23 07:09 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 08:38 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 07:55 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 10:19 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 09:52 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 12:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 08:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:33 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:31 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:14 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-23 12:08 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 11:50 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 13:04 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 04:00 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-23 07:08 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 08:19 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 09:49 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 09:44 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 02:26 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 21:30 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 15:22 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 09:47 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 11:08 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 10:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 13:07 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 02:49 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 21:06 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 22:45 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-24 21:58 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-24 23:05 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 07:17 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 08:02 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:01 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 09:19 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:55 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 11:37 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 13:03 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 12:13 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 14:27 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 13:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 14:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 14:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 21:05 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 15:24 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 17:32 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 17:18 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:19 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 20:55 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 18:26 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 00:26 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 18:49 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:30 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 20:43 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:18 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 04:12 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 22:30 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 09:22 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) olcott <NoOne@NoWhere.com> - 2020-11-26 08:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 10:43 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) olcott <NoOne@NoWhere.com> - 2020-11-26 09:49 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 09:09 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 17:21 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 11:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 10:29 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 12:41 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 13:47 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 13:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 16:02 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 15:12 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 13:42 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 15:56 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 14:14 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 16:20 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 19:11 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 18:25 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 20:17 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 17:22 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 16:34 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 18:09 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 17:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 19:06 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 18:10 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 23:11 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 17:41 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 01:34 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself) olcott <NoOne@NoWhere.com> - 2020-11-26 20:45 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:09 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself [verified]) olcott <NoOne@NoWhere.com> - 2020-11-27 12:14 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 11:58 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 13:21 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 16:35 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood) olcott <NoOne@NoWhere.com> - 2020-11-26 08:26 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 10:51 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 19:10 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 16:16 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 10:44 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 18:55 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 13:24 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 19:43 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 14:09 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Jeff Barnett <jbb@notatt.com> - 2020-11-25 14:30 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 21:24 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 21:03 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:52 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 21:53 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-25 16:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 02:21 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-25 20:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:02 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:34 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 12:03 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](black cats are black) olcott <NoOne@NoWhere.com> - 2020-11-22 13:14 -0600
Page 1 of 7 [1] 2 3 4 5 6 7 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-21 13:19 -0600 |
| Subject | It is known that a correct halt decider must return false (in this case)[V2] |
| Message-ID | <uoGdnQXanKOz9STCnZ2dnUU7-XnNnZ2d@giganews.com> |
(1) It is known that the UTM simulation of a machine's Turing machine
description is equivalent to directly executing it.
01 void H_Hat(u32 P)
02 {
03 if (H(P, P))
04 HERE: goto HERE;
05 else
06 HALT
07 }
08 bool Halts(u32 P, u32 I)
09 {
10 bool Halted = false;
11 bool Aborted = false;
12 while (!Halted && !Aborted)
13 {
14 Halted = DebugStep(P, I);
15 Aborted = Needs_To_Be_Aborted();
16 }
17 return !Aborted;
18 }
19 int main()
20 {
21 u32 P = (u32)H_Hat;
22 Halts(P, P);
23 HALT;
24 }
(2) It is known that the above code is infinitely recursive if Halts()
acts like a UTM (by having its line 15 disabled) and simulates its input
returning true if and only if its input halts.
(3) On the basis of (1) and (2) It is known that a correct halt decider
(without line 15 disabled) must return false.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-11-21 13:06 -0800 |
| Message-ID | <266fc6d3-8e9e-4482-a927-a623ae0abe05n@googlegroups.com> |
| In reply to | #25604 |
On Saturday, 21 November 2020 at 19:19:18 UTC, olcott wrote:
> (1) It is known that the UTM simulation of a machine's Turing machine
> description is equivalent to directly executing it.
>
>
> 01 void H_Hat(u32 P)
> 02 {
> 03 if (H(P, P))
> 04 HERE: goto HERE;
> 05 else
> 06 HALT
> 07 }
>
>
> 08 bool Halts(u32 P, u32 I)
> 09 {
> 10 bool Halted = false;
> 11 bool Aborted = false;
> 12 while (!Halted && !Aborted)
> 13 {
> 14 Halted = DebugStep(P, I);
> 15 Aborted = Needs_To_Be_Aborted();
> 16 }
> 17 return !Aborted;
> 18 }
>
>
> 19 int main()
> 20 {
> 21 u32 P = (u32)H_Hat;
> 22 Halts(P, P);
> 23 HALT;
> 24 }
>
>
> (2) It is known that the above code is infinitely recursive if Halts()
> acts like a UTM (by having its line 15 disabled) and simulates its input
> returning true if and only if its input halts.
>
> (3) On the basis of (1) and (2) It is known that a correct halt decider
> (without line 15 disabled) must return false.
>
You need to disable the line when H_Hat() is run directly, but not when
Halt() is called directly.
THen you get consistent results.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-21 15:35 -0600 |
| Message-ID | <xPadnRHFgriwFSTCnZ2dnUU7-cPNnZ2d@giganews.com> |
| In reply to | #25611 |
On 11/21/2020 3:06 PM, Malcolm McLean wrote:
> On Saturday, 21 November 2020 at 19:19:18 UTC, olcott wrote:
>> (1) It is known that the UTM simulation of a machine's Turing machine
>> description is equivalent to directly executing it.
>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 if (H(P, P))
>> 04 HERE: goto HERE;
>> 05 else
>> 06 HALT
>> 07 }
>>
>>
>> 08 bool Halts(u32 P, u32 I)
>> 09 {
>> 10 bool Halted = false;
>> 11 bool Aborted = false;
>> 12 while (!Halted && !Aborted)
>> 13 {
>> 14 Halted = DebugStep(P, I);
>> 15 Aborted = Needs_To_Be_Aborted();
>> 16 }
>> 17 return !Aborted;
>> 18 }
>>
>>
>> 19 int main()
>> 20 {
>> 21 u32 P = (u32)H_Hat;
>> 22 Halts(P, P);
>> 23 HALT;
>> 24 }
>>
>>
>> (2) It is known that the above code is infinitely recursive if Halts()
>> acts like a UTM (by having its line 15 disabled) and simulates its input
>> returning true if and only if its input halts.
>>
>> (3) On the basis of (1) and (2) It is known that a correct halt decider
>> (without line 15 disabled) must return false.
>>
> You need to disable the line when H_Hat() is run directly, but not when
> Halt() is called directly.
> THen you get consistent results.
>
Bullshit on that. All that does is force the halt decider to give the
wrong answer some of the time.
It is just like you are saying to see how well your car really runs we
cannot simply just run the car we have to take out one of the spark
plugs first.
The Turing machine description of H_Hat() is either simulated by the
halt decider or simulated by a machine that is not a halt decider.
That the second case never halts proves by definition that the not
halting decision of the first case was necessary correct.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-21 23:46 +0000 |
| Message-ID | <87k0ueuvcb.fsf@bsb.me.uk> |
| In reply to | #25604 |
olcott <NoOne@NoWhere.com> writes:
> (1) It is known that the UTM simulation of a machine's Turing machine description is equivalent to directly executing it.
>
>
> 01 void H_Hat(u32 P)
> 02 {
> 03 if (H(P, P))
> 04 HERE: goto HERE;
> 05 else
> 06 HALT
> 07 }
You've got this the right way round now. When I told you you'd got it
wrong before you basically accused me of lying. And the name at least
makes sense this time. But it references an unknown function. Is that
a deliberate sleight of hand or just the fact that you don't do details?
> 08 bool Halts(u32 P, u32 I)
> 09 {
> 10 bool Halted = false;
> 11 bool Aborted = false;
> 12 while (!Halted && !Aborted)
> 13 {
> 14 Halted = DebugStep(P, I);
> 15 Aborted = Needs_To_Be_Aborted();
> 16 }
> 17 return !Aborted;
> 18 }
>
>
> 19 int main()
> 20 {
> 21 u32 P = (u32)H_Hat;
> 22 Halts(P, P);
> 23 HALT;
> 24 }
The program is incomplete as there is no H. (We know, in outline, what
the other two missing functions are supposed to do.) Is that just a
random cutting and pasting error, or was it deliberate?
> (2) It is known that the above code is infinitely recursive if Halts()
> acts like a UTM (by having its line 15 disabled) and simulates its
> input returning true if and only if its input halts.
If H always returns false, line 22 should behave the same regardless of
whether line 15 is there or not.
> (3) On the basis of (1) and (2) It is known that a correct halt
> decider (without line 15 disabled) must return false.
How can you claim to know what the right answer is since you don't show
us what H is.
Bottom line: is "Halts" your claimed halt decider? If so, why post it
again since you've been shown, over and over, one of the infinity of
cases it gets wrong?
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-21 18:07 -0600 |
| Message-ID | <kYidnRJqBY1YNiTCnZ2dnUU7-VHNnZ2d@giganews.com> |
| In reply to | #25619 |
On 11/21/2020 5:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> (1) It is known that the UTM simulation of a machine's Turing machine description is equivalent to directly executing it.
>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
fixed typo
>> 03 if (Halts(P, P))
>> 04 HERE: goto HERE;
>> 05 else
>> 06 HALT
>> 07 }
>
> You've got this the right way round now. When I told you you'd got it
> wrong before you basically accused me of lying.
If people saw their typos they wouldn't make them.
> And the name at least
> makes sense this time. But it references an unknown function. Is that
> a deliberate sleight of hand or just the fact that you don't do details?
typo corrected above and in V3.
>> 08 bool Halts(u32 P, u32 I)
>> 09 {
>> 10 bool Halted = false;
>> 11 bool Aborted = false;
>> 12 while (!Halted && !Aborted)
>> 13 {
>> 14 Halted = DebugStep(P, I);
>> 15 Aborted = Needs_To_Be_Aborted();
>> 16 }
>> 17 return !Aborted;
>> 18 }
>>
>>
>> 19 int main()
>> 20 {
>> 21 u32 P = (u32)H_Hat;
>> 22 Halts(P, P);
>> 23 HALT;
>> 24 }
>
> The program is incomplete as there is no H. (We know, in outline, what
> the other two missing functions are supposed to do.) Is that just a
> random cutting and pasting error, or was it deliberate?
It was a typo that is now corrected here and in V3.
>> (2) It is known that the above code is infinitely recursive if Halts()
>> acts like a UTM (by having its line 15 disabled) and simulates its
>> input returning true if and only if its input halts.
>
> If H always returns false, line 22 should behave the same regardless of
> whether line 15 is there or not.
H does not exist it was only a typo.
>> (3) On the basis of (1) and (2) It is known that a correct halt
>> decider (without line 15 disabled) must return false.
>
> How can you claim to know what the right answer is since you don't show
> us what H is.
>
> Bottom line: is "Halts" your claimed halt decider? If so, why post it
> again since you've been shown, over and over, one of the infinity of
> cases it gets wrong?
>
Swicth to V3 it has this typo corrected.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-22 01:14 +0000 |
| Message-ID | <875z5yur90.fsf@bsb.me.uk> |
| In reply to | #25623 |
olcott <NoOne@NoWhere.com> writes:
> On 11/21/2020 5:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> (1) It is known that the UTM simulation of a machine's Turing machine description is equivalent to directly executing it.
>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>
> fixed typo
>>> 03 if (Halts(P, P))
>>> 04 HERE: goto HERE;
>>> 05 else
>>> 06 HALT
>>> 07 }
>>
>> You've got this the right way round now. When I told you you'd got it
>> wrong before you basically accused me of lying.
>
> If people saw their typos they wouldn't make them.
Next time you think I am lying, mad or playing head games, just remember
how many times you've had to admit I was right.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-22 03:48 -0700 |
| Message-ID | <rpdflh$g15$1@dont-email.me> |
| In reply to | #25604 |
On 2020-11-21 12:19, olcott wrote:
> (1) It is known that the UTM simulation of a machine's Turing machine
> description is equivalent to directly executing it.
>
>
> 01 void H_Hat(u32 P)
> 02 {
> 03 if (H(P, P))
> 04 HERE: goto HERE;
> 05 else
> 06 HALT
> 07 }
>
>
> 08 bool Halts(u32 P, u32 I)
> 09 {
> 10 bool Halted = false;
> 11 bool Aborted = false;
> 12 while (!Halted && !Aborted)
> 13 {
> 14 Halted = DebugStep(P, I);
> 15 Aborted = Needs_To_Be_Aborted();
> 16 }
> 17 return !Aborted;
> 18 }
>
>
> 19 int main()
> 20 {
> 21 u32 P = (u32)H_Hat;
> 22 Halts(P, P);
> 23 HALT;
> 24 }
>
>
> (2) It is known that the above code is infinitely recursive if Halts()
> acts like a UTM (by having its line 15 disabled) and simulates its input
> returning true if and only if its input halts.
>
> (3) On the basis of (1) and (2) It is known that a correct halt decider
> (without line 15 disabled) must return false.
You need to stop conflating two different functions and calling both of
them Halt().
You have your Halt decider:
bool Halts(u32 P, u32 I) {
bool Halted = false;
bool Aborted = false;
while (!Halted && !Aborted) {
Halted = DebugStep(P, I);
Aborted = Needs_To_Be_Aborted();
}
return !Aborted;
}
And then you have your Simulator derived from Halt() by removing line 15:
bool Simulate(u32 P, u32 I) {
bool Halted = false;
bool Aborted = false;
while (!Halted && !Aborted) {
Halted = DebugStep(P, I);
}
return !Aborted;
}
Though of course your simulator doesn't really need the return.
These are entirely different functions. Calling both of them Halts() is
misleading. They do different things, and thus should exist as separate
functions, either of which could be called by some other routine.
H_Hat in the Linz proof (and other comparable proofs) is defined as a
function which (in your implementation) invokes a *halt decider*, not a
*simulator*, so if you insist for arcane reasons that we test the
behaviour of H_Hat(H_Hat) inside a simulator rather than simply running
it directly, we would call:
Simulate(H_Hat, H_Hat);
but H_Hat still needs to call Halts(), not Simulate(), because that's
the computation which H_Hat is defined to perform by Linz.
If you do things your way, by changing from 'halt detection mode' to
'simulator mode' by removing line 15 from the Halts() function which
H_Hat also calls, then you are not just altering which 'mode' you are
in; you are also fundamentally altering the computation performed by
H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that
your Halt detector using as input when Halts(H_Hat, H_Hat) is called,
effectively rendering your test of the behaviour of H_Hat(H_Hat) worthless.
The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe is
the behaviour of H_Hat(H_Hat) when it is run directly. Not when it is
run inside a halting detector; not when it is run in a simulator; and
definitely not when one of the 'Operating System' calls that it relies
on has been altered to do something else.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 08:17 -0600 |
| Message-ID | <TfidnQqBC9iS7ifCnZ2dnUU7-SHNnZ2d@giganews.com> |
| In reply to | #25651 |
On 11/22/2020 4:48 AM, André G. Isaak wrote:
> On 2020-11-21 12:19, olcott wrote:
>> (1) It is known that the UTM simulation of a machine's Turing machine
>> description is equivalent to directly executing it.
>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 if (Halts(P, P))
>> 04 HERE: goto HERE;
>> 05 else
>> 06 HALT
>> 07 }
>>
>>
>> 08 bool Halts(u32 P, u32 I)
>> 09 {
>> 10 bool Halted = false;
>> 11 bool Aborted = false;
>> 12 while (!Halted && !Aborted)
>> 13 {
>> 14 Halted = DebugStep(P, I);
>> 15 Aborted = Needs_To_Be_Aborted();
>> 16 }
>> 17 return !Aborted;
>> 18 }
>>
>>
>> 19 int main()
>> 20 {
>> 21 u32 P = (u32)H_Hat;
>> 22 Halts(P, P);
>> 23 HALT;
>> 24 }
>>
>>
>> (2) It is known that the above code is infinitely recursive if Halts()
>> acts like a UTM (by having its line 15 disabled) and simulates its
>> input returning true if and only if its input halts.
>>
>> (3) On the basis of (1) and (2) It is known that a correct halt
>> decider (without line 15 disabled) must return false.
>
> You need to stop conflating two different functions and calling both of
> them Halt().
>
> You have your Halt decider:
>
> bool Halts(u32 P, u32 I) {
> bool Halted = false;
> bool Aborted = false;
> while (!Halted && !Aborted) {
> Halted = DebugStep(P, I);
> Aborted = Needs_To_Be_Aborted();
> }
> return !Aborted;
> }
>
> And then you have your Simulator derived from Halt() by removing line 15:
>
> bool Simulate(u32 P, u32 I) {
> bool Halted = false;
> bool Aborted = false;
> while (!Halted && !Aborted) {
> Halted = DebugStep(P, I);
> }
> return !Aborted;
> }
>
> Though of course your simulator doesn't really need the return.
>
> These are entirely different functions. Calling both of them Halts() is
> misleading. They do different things, and thus should exist as separate
> functions, either of which could be called by some other routine.
OK, good idea.
> H_Hat in the Linz proof (and other comparable proofs) is defined as a
> function which (in your implementation) invokes a *halt decider*, not a
> *simulator*, so if you insist for arcane reasons that we test the
> behaviour of H_Hat(H_Hat) inside a simulator rather than simply running
> it directly, we would call:
>
> Simulate(H_Hat, H_Hat);
>
> but H_Hat still needs to call Halts(), not Simulate(), because that's
> the computation which H_Hat is defined to perform by Linz.
The ONLY purpose of the two different functions is to prove that when
Halts(main, NULL) invokes H_Hat(H_Hat) that it aborts H_Hat at its line
03 and decides not halting.
When Halts(H_Hat, H_Hat) is called it aborts the first H_Hat at its line
03. Yet when the Halt deciding ability is removed from Halts both of the
function calls are now infinitely recursive.
> If you do things your way, by changing from 'halt detection mode' to
> 'simulator mode' by removing line 15 from the Halts() function which
> H_Hat also calls, then you are not just altering which 'mode' you are
> in; you are also fundamentally altering the computation performed by
> H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that
It turns out that this is not the case because none of the H_Hat
computations ever receive any return value from Halts. None of them
every complete their execution of line 03.
All of the H_Hat(H_Hat) computations are state transition by state
transition identical. None of them ever complete their line 03.
Those aborted by the decider never repeat, those not aborted by the
decider infinitely repeat.
> your Halt detector using as input when Halts(H_Hat, H_Hat) is called,
> effectively rendering your test of the behaviour of H_Hat(H_Hat) worthless.
>
> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe is
> the behaviour of H_Hat(H_Hat) when it is run directly. Not when it is
> run inside a halting detector; not when it is run in a simulator; and
So you do not understand the computer science that guarantees that the
direct execution of a TM is equivalent to simulating the TMD of this
machine by a UTM?
The only equivalent way to specify a recursive function call using
Turing machines is to define H_Hat to be a UTM that executes its own TMD.
This is a mandatory aspect of the problem otherwise the equivalence
between the x86utm computation and the Turing machine computation is
broken.
> definitely not when one of the 'Operating System' calls that it relies
> on has been altered to do something else.
>
> André
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-22 07:58 -0700 |
| Message-ID | <rpduaa$k0r$1@dont-email.me> |
| In reply to | #25653 |
On 2020-11-22 07:17, olcott wrote:
> On 11/22/2020 4:48 AM, André G. Isaak wrote:
>> On 2020-11-21 12:19, olcott wrote:
>>> (1) It is known that the UTM simulation of a machine's Turing machine
>>> description is equivalent to directly executing it.
>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03 if (Halts(P, P))
>>> 04 HERE: goto HERE;
>>> 05 else
>>> 06 HALT
>>> 07 }
>>>
>>>
>>> 08 bool Halts(u32 P, u32 I)
>>> 09 {
>>> 10 bool Halted = false;
>>> 11 bool Aborted = false;
>>> 12 while (!Halted && !Aborted)
>>> 13 {
>>> 14 Halted = DebugStep(P, I);
>>> 15 Aborted = Needs_To_Be_Aborted();
>>> 16 }
>>> 17 return !Aborted;
>>> 18 }
>>>
>>>
>>> 19 int main()
>>> 20 {
>>> 21 u32 P = (u32)H_Hat;
>>> 22 Halts(P, P);
>>> 23 HALT;
>>> 24 }
>>>
>>>
>>> (2) It is known that the above code is infinitely recursive if
>>> Halts() acts like a UTM (by having its line 15 disabled) and
>>> simulates its input returning true if and only if its input halts.
>>>
>>> (3) On the basis of (1) and (2) It is known that a correct halt
>>> decider (without line 15 disabled) must return false.
>>
>> You need to stop conflating two different functions and calling both
>> of them Halt().
>>
>> You have your Halt decider:
>>
>> bool Halts(u32 P, u32 I) {
>> bool Halted = false;
>> bool Aborted = false;
>> while (!Halted && !Aborted) {
>> Halted = DebugStep(P, I);
>> Aborted = Needs_To_Be_Aborted();
>> }
>> return !Aborted;
>> }
>>
>> And then you have your Simulator derived from Halt() by removing line 15:
>>
>> bool Simulate(u32 P, u32 I) {
>> bool Halted = false;
>> bool Aborted = false;
>> while (!Halted && !Aborted) {
>> Halted = DebugStep(P, I);
>> }
>> return !Aborted;
>> }
>>
>> Though of course your simulator doesn't really need the return.
>>
>> These are entirely different functions. Calling both of them Halts()
>> is misleading. They do different things, and thus should exist as
>> separate functions, either of which could be called by some other
>> routine.
>
> OK, good idea.
>
>> H_Hat in the Linz proof (and other comparable proofs) is defined as a
>> function which (in your implementation) invokes a *halt decider*, not
>> a *simulator*, so if you insist for arcane reasons that we test the
>> behaviour of H_Hat(H_Hat) inside a simulator rather than simply
>> running it directly, we would call:
>>
>> Simulate(H_Hat, H_Hat);
>>
>> but H_Hat still needs to call Halts(), not Simulate(), because that's
>> the computation which H_Hat is defined to perform by Linz.
>
> The ONLY purpose of the two different functions is to prove that when
> Halts(main, NULL) invokes H_Hat(H_Hat) that it aborts H_Hat at its line
> 03 and decides not halting.
>
> When Halts(H_Hat, H_Hat) is called it aborts the first H_Hat at its line
> 03. Yet when the Halt deciding ability is removed from Halts both of the
> function calls are now infinitely recursive.
>
>> If you do things your way, by changing from 'halt detection mode' to
>> 'simulator mode' by removing line 15 from the Halts() function which
>> H_Hat also calls, then you are not just altering which 'mode' you are
>> in; you are also fundamentally altering the computation performed by
>> H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that
>
> It turns out that this is not the case because none of the H_Hat
> computations ever receive any return value from Halts. None of them
> every complete their execution of line 03.
H_Hat doesn't make use of the return value, but its behaviour still
depends on the presence of the abort code. Remove that, and you are
*changing* the definition of H_Hat.
A proper simulator running H_Hat doesn't do that. H_Hat should behave
identically when run in a simulator as when run natively.
> All of the H_Hat(H_Hat) computations are state transition by state
> transition identical. None of them ever complete their line 03.
> Those aborted by the decider never repeat, those not aborted by the
> decider infinitely repeat.
>
>> your Halt detector using as input when Halts(H_Hat, H_Hat) is called,
>> effectively rendering your test of the behaviour of H_Hat(H_Hat)
>> worthless.
>>
>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe
>> is the behaviour of H_Hat(H_Hat) when it is run directly. Not when it
>> is run inside a halting detector; not when it is run in a simulator; and
>
> So you do not understand the computer science that guarantees that the
> direct execution of a TM is equivalent to simulating the TMD of this
> machine by a UTM?
That's only true if your simulator is actually a reliable simulator.
If your simulator were a true simulator, one should be able to run
Halts(H_Hat, H_Hat) *within* the simulator and have it return a value of
true or false exactly as when it wasn't run inside the simulator. That's
not the case in your proposal. Similarly, one should be able to run
Simulate(H_Hat, H_Hat) *within* the simulator and one expects this to
behave differently from Halts(H_Hat, H_Hat) run *within* the simulator.
Again, this is not the case. That's because your simulator changes the
behaviour of an "operating system call" that other programs rely on.
This is no different from having a 'simulator' in which, e.g. a function
SUM(x, y) which is called by some of the programs it simulates is
replaced by a different function MULTIPLY(x, y) in the simulator.
Obviously, programs running in the 'simulator' which make use of SUM()
are not going to behave the same way in the 'simulator' as they do when
run directly because your 'simulator' doesn't actually provide a
faithful simulation.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 10:16 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) |
| Message-ID | <MbydnW5VOJVUEyfCnZ2dnUU7-TnNnZ2d@giganews.com> |
| In reply to | #25658 |
On 11/22/2020 8:58 AM, André G. Isaak wrote:
> On 2020-11-22 07:17, olcott wrote:
>> On 11/22/2020 4:48 AM, André G. Isaak wrote:
>>> On 2020-11-21 12:19, olcott wrote:
>>>> (1) It is known that the UTM simulation of a machine's Turing
>>>> machine description is equivalent to directly executing it.
>>>>
>>>>
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03 if (Halts(P, P))
>>>> 04 HERE: goto HERE;
>>>> 05 else
>>>> 06 HALT
>>>> 07 }
>>>>
>>>>
>>>> 08 bool Halts(u32 P, u32 I)
>>>> 09 {
>>>> 10 bool Halted = false;
>>>> 11 bool Aborted = false;
>>>> 12 while (!Halted && !Aborted)
>>>> 13 {
>>>> 14 Halted = DebugStep(P, I);
>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>> 16 }
>>>> 17 return !Aborted;
>>>> 18 }
>>>>
>>>>
>>>> 19 int main()
>>>> 20 {
>>>> 21 u32 P = (u32)H_Hat;
>>>> 22 Halts(P, P);
>>>> 23 HALT;
>>>> 24 }
>>>>
>>>>
>>>> (2) It is known that the above code is infinitely recursive if
>>>> Halts() acts like a UTM (by having its line 15 disabled) and
>>>> simulates its input returning true if and only if its input halts.
>>>>
>>>> (3) On the basis of (1) and (2) It is known that a correct halt
>>>> decider (without line 15 disabled) must return false.
>>>
>>> You need to stop conflating two different functions and calling both
>>> of them Halt().
>>>
>>> You have your Halt decider:
>>>
>>> bool Halts(u32 P, u32 I) {
>>> bool Halted = false;
>>> bool Aborted = false;
>>> while (!Halted && !Aborted) {
>>> Halted = DebugStep(P, I);
>>> Aborted = Needs_To_Be_Aborted();
>>> }
>>> return !Aborted;
>>> }
>>>
>>> And then you have your Simulator derived from Halt() by removing line
>>> 15:
>>>
>>> bool Simulate(u32 P, u32 I) {
>>> bool Halted = false;
>>> bool Aborted = false;
>>> while (!Halted && !Aborted) {
>>> Halted = DebugStep(P, I);
>>> }
>>> return !Aborted;
>>> }
>>>
>>> Though of course your simulator doesn't really need the return.
>>>
>>> These are entirely different functions. Calling both of them Halts()
>>> is misleading. They do different things, and thus should exist as
>>> separate functions, either of which could be called by some other
>>> routine.
>>
>> OK, good idea.
>>
>>> H_Hat in the Linz proof (and other comparable proofs) is defined as a
>>> function which (in your implementation) invokes a *halt decider*, not
>>> a *simulator*, so if you insist for arcane reasons that we test the
>>> behaviour of H_Hat(H_Hat) inside a simulator rather than simply
>>> running it directly, we would call:
>>>
>>> Simulate(H_Hat, H_Hat);
>>>
>>> but H_Hat still needs to call Halts(), not Simulate(), because that's
>>> the computation which H_Hat is defined to perform by Linz.
>>
>> The ONLY purpose of the two different functions is to prove that when
>> Halts(main, NULL) invokes H_Hat(H_Hat) that it aborts H_Hat at its
>> line 03 and decides not halting.
>>
>> When Halts(H_Hat, H_Hat) is called it aborts the first H_Hat at its
>> line 03. Yet when the Halt deciding ability is removed from Halts both
>> of the function calls are now infinitely recursive.
>>
>>> If you do things your way, by changing from 'halt detection mode' to
>>> 'simulator mode' by removing line 15 from the Halts() function which
>>> H_Hat also calls, then you are not just altering which 'mode' you are
>>> in; you are also fundamentally altering the computation performed by
>>> H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that
>>
>> It turns out that this is not the case because none of the H_Hat
>> computations ever receive any return value from Halts. None of them
>> every complete their execution of line 03.
>
> H_Hat doesn't make use of the return value, but its behaviour still
> depends on the presence of the abort code. Remove that, and you are
> *changing* the definition of H_Hat.
>
> A proper simulator running H_Hat doesn't do that. H_Hat should behave
> identically when run in a simulator as when run natively.
So in other words because Halts does gets the right answer and you have
been conditioned to believe that Halts cannot get the right answer you
conclude that Halts must be cheating.
>> All of the H_Hat(H_Hat) computations are state transition by state
>> transition identical. None of them ever complete their line 03.
>> Those aborted by the decider never repeat, those not aborted by the
>> decider infinitely repeat.
>>
>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is called,
>>> effectively rendering your test of the behaviour of H_Hat(H_Hat)
>>> worthless.
>>>
>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe
>>> is the behaviour of H_Hat(H_Hat) when it is run directly. Not when it
>>> is run inside a halting detector; not when it is run in a simulator; and
>>
>> So you do not understand the computer science that guarantees that the
>> direct execution of a TM is equivalent to simulating the TMD of this
>> machine by a UTM?
>
> That's only true if your simulator is actually a reliable simulator.
> If your simulator were a true simulator, one should be able to run
> Halts(H_Hat, H_Hat) *within* the simulator and have it return a value of
> true or false exactly as when it wasn't run inside the simulator. That's
In this case we can do that and it would get a correct answer.
When we simulate H_Hat(H_Hat) in this simulator we are doing things
behind the back of the halt decider so its answer is misleading.
It is for this reason that the simulator must act as if it was the UTM
for all code that is simulated. In this case the halt decider aborts the
above invocation at its line 3.
When the simulator acts as a UTM and simulates all of its input then
nothing can be done behind the back of the halt decider to make it seem
like the halt decider is making inconsistent halting decisions.
> not the case in your proposal. Similarly, one should be able to run
> Simulate(H_Hat, H_Hat) *within* the simulator and one expects this to
> behave differently from Halts(H_Hat, H_Hat) run *within* the simulator.
> Again, this is not the case. That's because your simulator changes the
> behaviour of an "operating system call" that other programs rely on.
>
> This is no different from having a 'simulator' in which, e.g. a function
> SUM(x, y) which is called by some of the programs it simulates is
> replaced by a different function MULTIPLY(x, y) in the simulator.
> Obviously, programs running in the 'simulator' which make use of SUM()
> are not going to behave the same way in the 'simulator' as they do when
> run directly because your 'simulator' doesn't actually provide a
> faithful simulation.
>
> André
>
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-22 10:10 -0700 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) |
| Message-ID | <rpe62b$dk9$1@dont-email.me> |
| In reply to | #25662 |
On 2020-11-22 09:16, olcott wrote: > On 11/22/2020 8:58 AM, André G. Isaak wrote: >> On 2020-11-22 07:17, olcott wrote: >>> On 11/22/2020 4:48 AM, André G. Isaak wrote: <snip> >> H_Hat doesn't make use of the return value, but its behaviour still >> depends on the presence of the abort code. Remove that, and you are >> *changing* the definition of H_Hat. >> >> A proper simulator running H_Hat doesn't do that. H_Hat should behave >> identically when run in a simulator as when run natively. > > So in other words because Halts does gets the right answer and you have > been conditioned to believe that Halts cannot get the right answer you > conclude that Halts must be cheating. Halts doesn't get the right answer. You claim it does because its result matches the behaviour of H_Hat(H_Hat) *only when* it is run inside your simulator which has the effect of changing the behaviour of the Halts() call *inside* H_Hat. If you ran it without the simulator such that it calls the normal Halts() you get the wrong answer. It's not Halts that is cheating. It's your Simulator with the one line of halts disabled that is cheating. >>> All of the H_Hat(H_Hat) computations are state transition by state >>> transition identical. None of them ever complete their line 03. >>> Those aborted by the decider never repeat, those not aborted by the >>> decider infinitely repeat. >>> >>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is >>>> called, effectively rendering your test of the behaviour of >>>> H_Hat(H_Hat) worthless. >>>> >>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe >>>> is the behaviour of H_Hat(H_Hat) when it is run directly. Not when >>>> it is run inside a halting detector; not when it is run in a >>>> simulator; and >>> >>> So you do not understand the computer science that guarantees that >>> the direct execution of a TM is equivalent to simulating the TMD of >>> this machine by a UTM? >> >> That's only true if your simulator is actually a reliable simulator. >> If your simulator were a true simulator, one should be able to run >> Halts(H_Hat, H_Hat) *within* the simulator and have it return a value >> of true or false exactly as when it wasn't run inside the simulator. >> That's > > In this case we can do that and it would get a correct answer. Not as far as I can tell. If you run Halts(H_Hat, H_Hat), it reports (erroneously), that H_Hat(H_Hat) doesn't halt. If you run Halts(H_Hat, H_Hat) *inside the simulator*, it won't report anything. It will simply hang. If something behaves differently inside the simulator than when run without the simulator, then the simulator is not a faithful simulator. > When we simulate H_Hat(H_Hat) in this simulator we are doing things > behind the back of the halt decider so its answer is misleading. I have no idea what it means to 'do something behind the back of the halt decider', but you seem to be acknowledging that how something behaves inside the simulator is misleading. Therefore how can you assess the predictions of your decider based on how things behave when run inside your simulator > It is for this reason that the simulator must act as if it was the UTM > for all code that is simulated. In this case the halt decider aborts the > above invocation at its line 3. How is line 3 supposed to get aborted in the simulator given that your simulator omits the line Aborted = Needs_To_Be_Aborted()? > When the simulator acts as a UTM and simulates all of its input then > nothing can be done behind the back of the halt decider to make it seem > like the halt decider is making inconsistent halting decisions. I can make no sense of the that paragraphs. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 11:47 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) |
| Message-ID | <s5udnVTv7MHYOSfCnZ2dnUU7-QnNnZ2d@giganews.com> |
| In reply to | #25663 |
On 11/22/2020 11:10 AM, André G. Isaak wrote: > On 2020-11-22 09:16, olcott wrote: >> On 11/22/2020 8:58 AM, André G. Isaak wrote: >>> On 2020-11-22 07:17, olcott wrote: >>>> On 11/22/2020 4:48 AM, André G. Isaak wrote: > > <snip> > >>> H_Hat doesn't make use of the return value, but its behaviour still >>> depends on the presence of the abort code. Remove that, and you are >>> *changing* the definition of H_Hat. >>> >>> A proper simulator running H_Hat doesn't do that. H_Hat should behave >>> identically when run in a simulator as when run natively. >> >> So in other words because Halts does gets the right answer and you >> have been conditioned to believe that Halts cannot get the right >> answer you conclude that Halts must be cheating. > > Halts doesn't get the right answer. You claim it does because its result > matches the behaviour of H_Hat(H_Hat) *only when* it is run inside your > simulator which has the effect of changing the behaviour of the Halts() > call *inside* H_Hat. If you ran it without the simulator such that it > calls the normal Halts() you get the wrong answer. > > It's not Halts that is cheating. It's your Simulator with the one line > of halts disabled that is cheating. > >>>> All of the H_Hat(H_Hat) computations are state transition by state >>>> transition identical. None of them ever complete their line 03. >>>> Those aborted by the decider never repeat, those not aborted by the >>>> decider infinitely repeat. >>>> >>>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is >>>>> called, effectively rendering your test of the behaviour of >>>>> H_Hat(H_Hat) worthless. >>>>> >>>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately >>>>> describe is the behaviour of H_Hat(H_Hat) when it is run directly. >>>>> Not when it is run inside a halting detector; not when it is run in >>>>> a simulator; and >>>> >>>> So you do not understand the computer science that guarantees that >>>> the direct execution of a TM is equivalent to simulating the TMD of >>>> this machine by a UTM? >>> >>> That's only true if your simulator is actually a reliable simulator. >>> If your simulator were a true simulator, one should be able to run >>> Halts(H_Hat, H_Hat) *within* the simulator and have it return a value >>> of true or false exactly as when it wasn't run inside the simulator. >>> That's >> >> In this case we can do that and it would get a correct answer. > > Not as far as I can tell. > > If you run Halts(H_Hat, H_Hat), it reports (erroneously), that > H_Hat(H_Hat) doesn't halt. I keep repeating this criterion measure as a challenge to everyone to find any input that it decides incorrectly. It seems that everyone continues to ignore this challenge because they understand that this criterion measure is necessarily correct. When-so-ever decider Halts() (adapted from a UTM) decides that: (a) its input (<P>,I) would never halt unless it stopped simulating it and it is the case that (b) its input (<P>,I) would never halt unless it stopped simulating it then Halts() has made a correct not-halting decision on this input. > If you run Halts(H_Hat, H_Hat) *inside the simulator*, it won't report > anything. It will simply hang. I see now that what you are referring to as the simulator its Halts() with its line 15 removed. I thought that you were referring to an actual UTM that would also simulate Halts(); > If something behaves differently inside the simulator than when run > without the simulator, then the simulator is not a faithful simulator. > In other words when-so-ever the halt decider decides its input correctly and aborts this input so that it remains a decider, it must be cheating because everyone knows that there is no such thing as a halt decider that decides this key input correctly. >> When we simulate H_Hat(H_Hat) in this simulator we are doing things >> behind the back of the halt decider so its answer is misleading. > > I have no idea what it means to 'do something behind the back of the > halt decider', We are simulating the execution of inputs such that the halt decider is not provided with the full execution trace of these inputs that are being simulated. Whatever execution of H_Hat(H_Hat) that it can see the halt decider aborts. When we execute H_Hat(H_Hat) in a simulator that is not a halt decider then the halt decider cannot see the execution trace of the first H_Hat. > but you seem to be acknowledging that how something > behaves inside the simulator is misleading. Therefore how can you assess > the predictions of your decider based on how things behave when run > inside your simulator If I decide that by turning on the ignition of my car that it will start running and I turn on the ignition to my car and it starts running then I have necessarily made a correct car starting decision. For this same (true by definition) reason the following is also true: When-so-ever decider Halts() (adapted from a UTM) decides that: (a) its input (<P>,I) would never halt unless it stopped simulating it and it is the case that (b) its input (<P>,I) would never halt unless it stopped simulating it then Halts() has made a correct not-halting decision on this input. >> It is for this reason that the simulator must act as if it was the UTM >> for all code that is simulated. In this case the halt decider aborts >> the above invocation at its line 3. > > How is line 3 supposed to get aborted in the simulator given that your > simulator omits the line Aborted = Needs_To_Be_Aborted()? We keep switching back and forth wheter a simulator is an actual UTM or merely Halts with line 15 removed. > >> When the simulator acts as a UTM and simulates all of its input then >> nothing can be done behind the back of the halt decider to make it >> seem like the halt decider is making inconsistent halting decisions. > > I can make no sense of the that paragraphs. > > André > > -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-22 13:14 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) |
| Message-ID | <NTxuH.2673$Gw2.1572@fx24.iad> |
| In reply to | #25664 |
On 11/22/20 12:47 PM, olcott wrote: > On 11/22/2020 11:10 AM, André G. Isaak wrote: >> >> Not as far as I can tell. >> >> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that >> H_Hat(H_Hat) doesn't halt. > > I keep repeating this criterion measure as a challenge to everyone to > find any input that it decides incorrectly. > > It seems that everyone continues to ignore this challenge because they > understand that this criterion measure is necessarily correct. > > When-so-ever decider Halts() (adapted from a UTM) decides that: > (a) its input (<P>,I) would never halt unless it stopped simulating it > and it is the case that > (b) its input (<P>,I) would never halt unless it stopped simulating it > then Halts() has made a correct not-halting decision on this input. > First, I will point out that your are changing the criteria of the halting problem, so you either need to accept the RIGHT definition or state that you are working on a different problem (and thus acknowledge that any result you get to apply to the classic problem without further proof to show they are). The proper statement of the halting problem is to make a program that correctly predicts in finite time whether a given program with given input will halt in finite time or run forever. ALWAYS the ultimate test of success is does the deciders answer match the actual machines performance. It also must ALWAY give the right answer in finite time for ANY program. The counter example for your decider is Linz H_Hat. The following is a program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as the input to a working UTM. This is the only possible trace for this case, if the decider decides that H_Hat(H_Hat) is non-halt, which is your stated answer, and Halts meets the requirements of a Halt Decider: 1) Enter H_Hat(H_Hat) 2) duplicate H_Hat (this step 'optimized' out in your machine) 3) Enter Halts(H_Hat, H_Hat) 4) Halts does its decision and decides tht H_Hat is non-halting 5) Halts returns false to indicate non-halting 6) H_Hat goes to the else clause 7) H_Hat Halts. Thus, Halts was wrong.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 12:28 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <I56dnUuP5fJWMCfCnZ2dnUU7-RfNnZ2d@giganews.com> |
| In reply to | #25665 |
On 11/22/2020 12:14 PM, Richard Damon wrote: > On 11/22/20 12:47 PM, olcott wrote: >> On 11/22/2020 11:10 AM, André G. Isaak wrote: >>> >>> Not as far as I can tell. >>> >>> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that >>> H_Hat(H_Hat) doesn't halt. >> >> I keep repeating this criterion measure as a challenge to everyone to >> find any input that it decides incorrectly. >> >> It seems that everyone continues to ignore this challenge because they >> understand that this criterion measure is necessarily correct. >> >> When-so-ever decider Halts() (adapted from a UTM) decides that: >> (a) its input (<P>,I) would never halt unless it stopped simulating it >> and it is the case that >> (b) its input (<P>,I) would never halt unless it stopped simulating it >> then Halts() has made a correct not-halting decision on this input. >> > > First, I will point out that your are changing the criteria of the > halting problem, so you either need to accept the RIGHT definition or > state that you are working on a different problem (and thus acknowledge > that any result you get to apply to the classic problem without further > proof to show they are). The proper statement of the halting problem is > to make a program that correctly predicts in finite time whether a given > program with given input will halt in finite time or run forever. ALWAYS > the ultimate test of success is does the deciders answer match the > actual machines performance. It also must ALWAY give the right answer in > finite time for ANY program. > > The counter example for your decider is Linz H_Hat. The following is a > program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as > the input to a working UTM. This is the only possible trace for this > case, if the decider decides that H_Hat(H_Hat) is non-halt, which is > your stated answer, and Halts meets the requirements of a Halt Decider: > > 1) Enter H_Hat(H_Hat) > 2) duplicate H_Hat (this step 'optimized' out in your machine) > 3) Enter Halts(H_Hat, H_Hat) > 4) Halts does its decision and decides tht H_Hat is non-halting > 5) Halts returns false to indicate non-halting > 6) H_Hat goes to the else clause > 7) H_Hat Halts. > > Thus, Halts was wrong. > Your false assumptions have never been any sort of rebuttal. When the halt decider has been defined on the basis of transforming a UTM into a decider: 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). 2) Halts does its decision and decides that H_Hat is non-halting and aborts H_Hat at its line 03. 3) Halts returns false to indicate non-halting. Thus Halts was right. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-22 13:44 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <QjyuH.13166$ZbR7.2118@fx01.iad> |
| In reply to | #25666 |
On 11/22/20 1:28 PM, olcott wrote: > On 11/22/2020 12:14 PM, Richard Damon wrote: >> First, I will point out that your are changing the criteria of the >> halting problem, so you either need to accept the RIGHT definition or >> state that you are working on a different problem (and thus acknowledge >> that any result you get to apply to the classic problem without further >> proof to show they are). The proper statement of the halting problem is >> to make a program that correctly predicts in finite time whether a given >> program with given input will halt in finite time or run forever. ALWAYS >> the ultimate test of success is does the deciders answer match the >> actual machines performance. It also must ALWAY give the right answer in >> finite time for ANY program. >> >> The counter example for your decider is Linz H_Hat. The following is a >> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as >> the input to a working UTM. This is the only possible trace for this >> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is >> your stated answer, and Halts meets the requirements of a Halt Decider: >> >> 1) Enter H_Hat(H_Hat) >> 2) duplicate H_Hat (this step 'optimized' out in your machine) >> 3) Enter Halts(H_Hat, H_Hat) >> 4) Halts does its decision and decides tht H_Hat is non-halting >> 5) Halts returns false to indicate non-halting >> 6) H_Hat goes to the else clause >> 7) H_Hat Halts. >> >> Thus, Halts was wrong. >> > > Your false assumptions have never been any sort of rebuttal. > > When the halt decider has been defined on the basis of transforming a > UTM into a decider: > > 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). > 2) Halts does its decision and decides that H_Hat is non-halting and > aborts H_Hat at its line 03. > 3) Halts returns false to indicate non-halting. > > Thus Halts was right. > > First, YOU don't get to say what are the definition of a halt decider if you which to use the term properly, based on classical theory. If you wish to go off on you own, you need to be clear about this and SAY that you are working in an alternate definition framework, and thus your results are not applicable to the classical theory or problems. You have started with a bad definition, and thus you get bad answers. If Halts 'aborted' this run in line 3, then Halts is NOT a decider, as it fails to meet the definition of a decider, as the decider need to return its answer to the context it was put in, that is H_Hat. Now, it could also be that you have improperly translated the problem from the Turing Machine Space that the Linz definition was in, so again, your system fails to meet its requirements. Basic fact, if you fail to meet the stipulations of a problem, your answer fails to be an answer, and you can't just change the stipulation/requirements of a problem without making it a fact that you are now working on a DIFFERENT problem. As I have stated multiple times, you need to make you choice and make it clear. Either you are working on the classical Halting Problem and thus working under the definitions and stipulations of that problem, or you are working on some other problem, which you need to clearly indicate and then also realize that your results are not applicable to the original problem statement. Your insistance on using the classical language and referring to classic proofs indicate to me, that you intend you work to be on the classical problem, thus you are under the classical requirements and you don't get to change them.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 12:56 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <aZOdnSMqDbXRKSfCnZ2dnUU7-R3NnZ2d@giganews.com> |
| In reply to | #25667 |
On 11/22/2020 12:44 PM, Richard Damon wrote: > On 11/22/20 1:28 PM, olcott wrote: >> On 11/22/2020 12:14 PM, Richard Damon wrote: > >>> First, I will point out that your are changing the criteria of the >>> halting problem, so you either need to accept the RIGHT definition or >>> state that you are working on a different problem (and thus acknowledge >>> that any result you get to apply to the classic problem without further >>> proof to show they are). The proper statement of the halting problem is >>> to make a program that correctly predicts in finite time whether a given >>> program with given input will halt in finite time or run forever. ALWAYS >>> the ultimate test of success is does the deciders answer match the >>> actual machines performance. It also must ALWAY give the right answer in >>> finite time for ANY program. >>> >>> The counter example for your decider is Linz H_Hat. The following is a >>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as >>> the input to a working UTM. This is the only possible trace for this >>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is >>> your stated answer, and Halts meets the requirements of a Halt Decider: >>> >>> 1) Enter H_Hat(H_Hat) >>> 2) duplicate H_Hat (this step 'optimized' out in your machine) >>> 3) Enter Halts(H_Hat, H_Hat) >>> 4) Halts does its decision and decides tht H_Hat is non-halting >>> 5) Halts returns false to indicate non-halting >>> 6) H_Hat goes to the else clause >>> 7) H_Hat Halts. >>> >>> Thus, Halts was wrong. >>> >> >> Your false assumptions have never been any sort of rebuttal. >> >> When the halt decider has been defined on the basis of transforming a >> UTM into a decider: >> >> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). >> 2) Halts does its decision and decides that H_Hat is non-halting and >> aborts H_Hat at its line 03. >> 3) Halts returns false to indicate non-halting. >> >> Thus Halts was right. >> >> > > First, YOU don't get to say what are the definition of a halt decider if > you which to use the term properly, based on classical theory. The term "definition" has two distinctly different contexts. (1) What does the term of the sort "halt decider" mean in computer science. (2) Exactly which state transitions can be plugged into the ⊢* wildcard state transitions such that Halts would correctly transition to its final state of Halts.yes if its input would halt on its input and Halts.no if is input would not halt on its input. Halts.q0 wMw ⊢* Halts.yes Halts.q0 wMw ⊢* Halts.no (1)(2)(3) are this second type of definition. If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when you say no you are wrong steps (4)(5)(6) do not correctly decide halting on H_Halt you have merely used the dishonest dodge known as the straw-man fallacy: "an intentionally misrepresented proposition that is set up because it is easier to defeat than an opponent's real argument." > If you wish to go off on you own, you need to be clear about this and > SAY that you are working in an alternate definition framework, and thus > your results are not applicable to the classical theory or problems. > > You have started with a bad definition, and thus you get bad answers. > > If Halts 'aborted' this run in line 3, then Halts is NOT a decider, as > it fails to meet the definition of a decider, as the decider need to > return its answer to the context it was put in, that is H_Hat. > > Now, it could also be that you have improperly translated the problem > from the Turing Machine Space that the Linz definition was in, so again, > your system fails to meet its requirements. > > Basic fact, if you fail to meet the stipulations of a problem, your > answer fails to be an answer, and you can't just change the > stipulation/requirements of a problem without making it a fact that you > are now working on a DIFFERENT problem. > > As I have stated multiple times, you need to make you choice and make it > clear. Either you are working on the classical Halting Problem and thus > working under the definitions and stipulations of that problem, or you > are working on some other problem, which you need to clearly indicate > and then also realize that your results are not applicable to the > original problem statement. > > Your insistance on using the classical language and referring to classic > proofs indicate to me, that you intend you work to be on the classical > problem, thus you are under the classical requirements and you don't get > to change them. > -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-22 14:23 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <5VyuH.12594$vo2.10615@fx02.iad> |
| In reply to | #25669 |
On 11/22/20 1:56 PM, olcott wrote: > On 11/22/2020 12:44 PM, Richard Damon wrote: >> On 11/22/20 1:28 PM, olcott wrote: >>> On 11/22/2020 12:14 PM, Richard Damon wrote: >> >>>> First, I will point out that your are changing the criteria of the >>>> halting problem, so you either need to accept the RIGHT definition or >>>> state that you are working on a different problem (and thus acknowledge >>>> that any result you get to apply to the classic problem without further >>>> proof to show they are). The proper statement of the halting problem is >>>> to make a program that correctly predicts in finite time whether a >>>> given >>>> program with given input will halt in finite time or run forever. >>>> ALWAYS >>>> the ultimate test of success is does the deciders answer match the >>>> actual machines performance. It also must ALWAY give the right >>>> answer in >>>> finite time for ANY program. >>>> >>>> The counter example for your decider is Linz H_Hat. The following is a >>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as >>>> the input to a working UTM. This is the only possible trace for this >>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is >>>> your stated answer, and Halts meets the requirements of a Halt Decider: >>>> >>>> 1) Enter H_Hat(H_Hat) >>>> 2) duplicate H_Hat (this step 'optimized' out in your machine) >>>> 3) Enter Halts(H_Hat, H_Hat) >>>> 4) Halts does its decision and decides tht H_Hat is non-halting >>>> 5) Halts returns false to indicate non-halting >>>> 6) H_Hat goes to the else clause >>>> 7) H_Hat Halts. >>>> >>>> Thus, Halts was wrong. >>>> >>> >>> Your false assumptions have never been any sort of rebuttal. >>> >>> When the halt decider has been defined on the basis of transforming a >>> UTM into a decider: >>> >>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). >>> 2) Halts does its decision and decides that H_Hat is non-halting and >>> aborts H_Hat at its line 03. >>> 3) Halts returns false to indicate non-halting. >>> >>> Thus Halts was right. >>> >>> >> >> First, YOU don't get to say what are the definition of a halt decider if >> you which to use the term properly, based on classical theory. > > The term "definition" has two distinctly different contexts. > (1) What does the term of the sort "halt decider" mean in computer science. > > (2) Exactly which state transitions can be plugged into the ⊢* wildcard > state transitions such that Halts would correctly transition to its > final state of Halts.yes if its input would halt on its input and > Halts.no if is input would not halt on its input. > > Halts.q0 wMw ⊢* Halts.yes > Halts.q0 wMw ⊢* Halts.no > > (1)(2)(3) are this second type of definition. > > If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when > you say no you are wrong steps (4)(5)(6) do not correctly decide halting > on H_Halt you have merely used the dishonest dodge known as the > straw-man fallacy: "an intentionally misrepresented proposition that is > set up because it is easier to defeat than an opponent's real argument." Yes, you get to 'define' the factors that implement your Halts. You don't get to define that they are 'Correct', you can presume them right and then test. The TEST for your Halts is still what the ACTUAL machine does, which shows Halts to be wrong. The above trace shows that Halts is wrong. Now, if Halts didn't end up in either of Halts.yes or Halts.no, then it failed to meet the requirements on it. That ending up at Halt.no is what puts you at step 4, and then by the definition of H_Hat, it moves 5, 6, and then 7. By your logic, I can 'define' that the states transition in Halts proves correctly that Peter Oslcott is a buffoon and any argument to the contray is just a strawman. >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 13:28 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <MsudnZCpVMZHJifCnZ2dnUU7-I-dnZ2d@giganews.com> |
| In reply to | #25673 |
On 11/22/2020 1:23 PM, Richard Damon wrote: > On 11/22/20 1:56 PM, olcott wrote: >> On 11/22/2020 12:44 PM, Richard Damon wrote: >>> On 11/22/20 1:28 PM, olcott wrote: >>>> On 11/22/2020 12:14 PM, Richard Damon wrote: >>> >>>>> First, I will point out that your are changing the criteria of the >>>>> halting problem, so you either need to accept the RIGHT definition or >>>>> state that you are working on a different problem (and thus acknowledge >>>>> that any result you get to apply to the classic problem without further >>>>> proof to show they are). The proper statement of the halting problem is >>>>> to make a program that correctly predicts in finite time whether a >>>>> given >>>>> program with given input will halt in finite time or run forever. >>>>> ALWAYS >>>>> the ultimate test of success is does the deciders answer match the >>>>> actual machines performance. It also must ALWAY give the right >>>>> answer in >>>>> finite time for ANY program. >>>>> >>>>> The counter example for your decider is Linz H_Hat. The following is a >>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as >>>>> the input to a working UTM. This is the only possible trace for this >>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is >>>>> your stated answer, and Halts meets the requirements of a Halt Decider: >>>>> >>>>> 1) Enter H_Hat(H_Hat) >>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine) >>>>> 3) Enter Halts(H_Hat, H_Hat) >>>>> 4) Halts does its decision and decides tht H_Hat is non-halting >>>>> 5) Halts returns false to indicate non-halting >>>>> 6) H_Hat goes to the else clause >>>>> 7) H_Hat Halts. >>>>> >>>>> Thus, Halts was wrong. >>>>> >>>> >>>> Your false assumptions have never been any sort of rebuttal. >>>> >>>> When the halt decider has been defined on the basis of transforming a >>>> UTM into a decider: >>>> >>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). >>>> 2) Halts does its decision and decides that H_Hat is non-halting and >>>> aborts H_Hat at its line 03. >>>> 3) Halts returns false to indicate non-halting. >>>> >>>> Thus Halts was right. >>>> >>>> >>> >>> First, YOU don't get to say what are the definition of a halt decider if >>> you which to use the term properly, based on classical theory. >> >> The term "definition" has two distinctly different contexts. >> (1) What does the term of the sort "halt decider" mean in computer science. >> >> (2) Exactly which state transitions can be plugged into the ⊢* wildcard >> state transitions such that Halts would correctly transition to its >> final state of Halts.yes if its input would halt on its input and >> Halts.no if is input would not halt on its input. >> >> Halts.q0 wMw ⊢* Halts.yes >> Halts.q0 wMw ⊢* Halts.no >> >> (1)(2)(3) are this second type of definition. >> >> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when >> you say no you are wrong steps (4)(5)(6) do not correctly decide halting >> on H_Halt you have merely used the dishonest dodge known as the >> straw-man fallacy: "an intentionally misrepresented proposition that is >> set up because it is easier to defeat than an opponent's real argument." > > Yes, you get to 'define' the factors that implement your Halts. You > don't get to define that they are 'Correct', you can presume them right > and then test. The TEST for your Halts is still what the ACTUAL machine > does, which shows Halts to be wrong. Forget about the (apparently overwhelming details of Halts and Simulates) and just focus on this: If the code that it does not abort is always infinitely recursive unless it aborts this code then the decision to abort this code is impossibly incorrect. This is the same thing as saying if a cat is black then we know it is a black cat. > The above trace shows that Halts is wrong. Now, if Halts didn't end up > in either of Halts.yes or Halts.no, then it failed to meet the > requirements on it. That ending up at Halt.no is what puts you at step > 4, and then by the definition of H_Hat, it moves 5, 6, and then 7. > > By your logic, I can 'define' that the states transition in Halts proves > correctly that Peter Oslcott is a buffoon and any argument to the > contray is just a strawman. > > >> -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-22 16:21 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <4DAuH.21599$oL7.5244@fx06.iad> |
| In reply to | #25674 |
On 11/22/20 2:28 PM, olcott wrote: > On 11/22/2020 1:23 PM, Richard Damon wrote: >> On 11/22/20 1:56 PM, olcott wrote: >>> On 11/22/2020 12:44 PM, Richard Damon wrote: >>>> On 11/22/20 1:28 PM, olcott wrote: >>>>> On 11/22/2020 12:14 PM, Richard Damon wrote: >>>> >>>>>> First, I will point out that your are changing the criteria of the >>>>>> halting problem, so you either need to accept the RIGHT definition or >>>>>> state that you are working on a different problem (and thus >>>>>> acknowledge >>>>>> that any result you get to apply to the classic problem without >>>>>> further >>>>>> proof to show they are). The proper statement of the halting >>>>>> problem is >>>>>> to make a program that correctly predicts in finite time whether a >>>>>> given >>>>>> program with given input will halt in finite time or run forever. >>>>>> ALWAYS >>>>>> the ultimate test of success is does the deciders answer match the >>>>>> actual machines performance. It also must ALWAY give the right >>>>>> answer in >>>>>> finite time for ANY program. >>>>>> >>>>>> The counter example for your decider is Linz H_Hat. The following >>>>>> is a >>>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine >>>>>> or as >>>>>> the input to a working UTM. This is the only possible trace for this >>>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is >>>>>> your stated answer, and Halts meets the requirements of a Halt >>>>>> Decider: >>>>>> >>>>>> 1) Enter H_Hat(H_Hat) >>>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine) >>>>>> 3) Enter Halts(H_Hat, H_Hat) >>>>>> 4) Halts does its decision and decides tht H_Hat is non-halting >>>>>> 5) Halts returns false to indicate non-halting >>>>>> 6) H_Hat goes to the else clause >>>>>> 7) H_Hat Halts. >>>>>> >>>>>> Thus, Halts was wrong. >>>>>> >>>>> >>>>> Your false assumptions have never been any sort of rebuttal. >>>>> >>>>> When the halt decider has been defined on the basis of transforming a >>>>> UTM into a decider: >>>>> >>>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). >>>>> 2) Halts does its decision and decides that H_Hat is non-halting and >>>>> aborts H_Hat at its line 03. >>>>> 3) Halts returns false to indicate non-halting. >>>>> >>>>> Thus Halts was right. >>>>> >>>>> >>>> >>>> First, YOU don't get to say what are the definition of a halt >>>> decider if >>>> you which to use the term properly, based on classical theory. >>> >>> The term "definition" has two distinctly different contexts. >>> (1) What does the term of the sort "halt decider" mean in computer >>> science. >>> >>> (2) Exactly which state transitions can be plugged into the ⊢* wildcard >>> state transitions such that Halts would correctly transition to its >>> final state of Halts.yes if its input would halt on its input and >>> Halts.no if is input would not halt on its input. >>> >>> Halts.q0 wMw ⊢* Halts.yes >>> Halts.q0 wMw ⊢* Halts.no >>> >>> (1)(2)(3) are this second type of definition. >>> >>> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when >>> you say no you are wrong steps (4)(5)(6) do not correctly decide halting >>> on H_Halt you have merely used the dishonest dodge known as the >>> straw-man fallacy: "an intentionally misrepresented proposition that is >>> set up because it is easier to defeat than an opponent's real argument." >> >> Yes, you get to 'define' the factors that implement your Halts. You >> don't get to define that they are 'Correct', you can presume them right >> and then test. The TEST for your Halts is still what the ACTUAL machine >> does, which shows Halts to be wrong. > > Forget about the (apparently overwhelming details of Halts and > Simulates) and just focus on this: > > If the code that it does not abort is always infinitely recursive unless > it aborts this code then the decision to abort this code is impossibly > incorrect. Yes, infinitely recurseive code does not halt. The issue is that in your H_Hat/Halts combo, it is the Halts that creates the infinite recursion, when it as a prerequisite to be finite in execution. The thing that you don't seem to understand is that the definition of a halt decider does not imply that the halt detector must just blindly simulate the provided code until it can determine that something it know as non-halting behavvior is detected. The fact that the recursion in NOT inevitably recursive can be seen because it IS possible to define a different halt decider that using a similar detection of recursion, rather that just giving up and saying the recursion is infinite, first asks itself if it assumed halting, does the system halt, in which case it can decide halting, else if it decides non-halting, does the system become non-halting, in which case it can return non-halting. This still has to decide which wrong answer to give to Linz (or you modify the problem to allow the decider to report that the machine is acting contradictory). You also still need to solve the problem of detecting non-recursive non-halting detection. Of course that fact that your logic has a flaw in it becomes obvious when we look at the actual results of running the code under proper conditions, as if and when Halts returns a non-halting result, the system almost immediately comes to a halt. The fact that your logic says that H_Hat(H_Hat) must not halt and we also have the proof that if Halts meets the requirements of a Halt Decider that H_Hat(H_Hat) does halt, shows that either Halts does not meet the requirements of a Halt Detector, there is some other logic error we are not seeing, or something has been done in the axioms of the system that make the logic system inconsistent. The one thing we can be sure of is that Halts is NOT a correcct Halting Decider for the classical Halting Problem. > > This is the same thing as saying if a cat is black then we know it is a > black cat. > Yes, if a cat is black, it is a black cat, but that doesn't prove that there ARE black cats. Also, your statement is actually more of like, I will define this cat as black, so it is a black cat, even though the cat is white, or maybe even a dog.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 16:25 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) |
| Message-ID | <xb2dnQr6lZjteCfCnZ2dnUU7-R3NnZ2d@giganews.com> |
| In reply to | #25675 |
On 11/22/2020 3:21 PM, Richard Damon wrote: > On 11/22/20 2:28 PM, olcott wrote: >> On 11/22/2020 1:23 PM, Richard Damon wrote: >>> On 11/22/20 1:56 PM, olcott wrote: >>>> On 11/22/2020 12:44 PM, Richard Damon wrote: >>>>> On 11/22/20 1:28 PM, olcott wrote: >>>>>> On 11/22/2020 12:14 PM, Richard Damon wrote: >>>>> >>>>>>> First, I will point out that your are changing the criteria of the >>>>>>> halting problem, so you either need to accept the RIGHT definition or >>>>>>> state that you are working on a different problem (and thus >>>>>>> acknowledge >>>>>>> that any result you get to apply to the classic problem without >>>>>>> further >>>>>>> proof to show they are). The proper statement of the halting >>>>>>> problem is >>>>>>> to make a program that correctly predicts in finite time whether a >>>>>>> given >>>>>>> program with given input will halt in finite time or run forever. >>>>>>> ALWAYS >>>>>>> the ultimate test of success is does the deciders answer match the >>>>>>> actual machines performance. It also must ALWAY give the right >>>>>>> answer in >>>>>>> finite time for ANY program. >>>>>>> >>>>>>> The counter example for your decider is Linz H_Hat. The following >>>>>>> is a >>>>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine >>>>>>> or as >>>>>>> the input to a working UTM. This is the only possible trace for this >>>>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is >>>>>>> your stated answer, and Halts meets the requirements of a Halt >>>>>>> Decider: >>>>>>> >>>>>>> 1) Enter H_Hat(H_Hat) >>>>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine) >>>>>>> 3) Enter Halts(H_Hat, H_Hat) >>>>>>> 4) Halts does its decision and decides tht H_Hat is non-halting >>>>>>> 5) Halts returns false to indicate non-halting >>>>>>> 6) H_Hat goes to the else clause >>>>>>> 7) H_Hat Halts. >>>>>>> >>>>>>> Thus, Halts was wrong. >>>>>>> >>>>>> >>>>>> Your false assumptions have never been any sort of rebuttal. >>>>>> >>>>>> When the halt decider has been defined on the basis of transforming a >>>>>> UTM into a decider: >>>>>> >>>>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat). >>>>>> 2) Halts does its decision and decides that H_Hat is non-halting and >>>>>> aborts H_Hat at its line 03. >>>>>> 3) Halts returns false to indicate non-halting. >>>>>> >>>>>> Thus Halts was right. >>>>>> >>>>>> >>>>> >>>>> First, YOU don't get to say what are the definition of a halt >>>>> decider if >>>>> you which to use the term properly, based on classical theory. >>>> >>>> The term "definition" has two distinctly different contexts. >>>> (1) What does the term of the sort "halt decider" mean in computer >>>> science. >>>> >>>> (2) Exactly which state transitions can be plugged into the ⊢* wildcard >>>> state transitions such that Halts would correctly transition to its >>>> final state of Halts.yes if its input would halt on its input and >>>> Halts.no if is input would not halt on its input. >>>> >>>> Halts.q0 wMw ⊢* Halts.yes >>>> Halts.q0 wMw ⊢* Halts.no >>>> >>>> (1)(2)(3) are this second type of definition. >>>> >>>> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when >>>> you say no you are wrong steps (4)(5)(6) do not correctly decide halting >>>> on H_Halt you have merely used the dishonest dodge known as the >>>> straw-man fallacy: "an intentionally misrepresented proposition that is >>>> set up because it is easier to defeat than an opponent's real argument." >>> >>> Yes, you get to 'define' the factors that implement your Halts. You >>> don't get to define that they are 'Correct', you can presume them right >>> and then test. The TEST for your Halts is still what the ACTUAL machine >>> does, which shows Halts to be wrong. >> >> Forget about the (apparently overwhelming details of Halts and >> Simulates) and just focus on this: >> >> If the code that it does not abort is always infinitely recursive unless >> it aborts this code then the decision to abort this code is impossibly >> incorrect. > > Yes, infinitely recurseive code does not halt. The issue is that in your > H_Hat/Halts combo, it is the Halts that creates the infinite recursion, > when it as a prerequisite to be finite in execution. The thing that you > don't seem to understand is that the definition of a halt decider does > not imply that the halt detector must just blindly simulate the provided > code until it can determine that something it know as non-halting > behavvior is detected. This definition of a halt decider allows utterly free reign in specifying the state transitions from H.0 to H.yes or H.no as long as H.yes indicates that wM is the Turing machine description that would halt on its input w and H.no indicates that wM is the Turing machine description that would not halt on its input w. H.q0 wMw ⊢* H.yes H.q0 wMw ⊢* H.no Thus when I specify these state transitions such that the invocation of Ĥ(Ĥ) would be infinitely recursive I am free to do so. I am allowed by the above defintion of a halt decider to specify the ⊢* wildcard state transitions such that the invocation of Ĥ(Ĥ) would be infinitely recursive. > The fact that the recursion in NOT inevitably recursive can be seen > because it IS possible to define a different halt decider that using a > similar detection of recursion, rather that just giving up and saying > the recursion is infinite, first asks itself if it assumed halting, does > the system halt, in which case it can decide halting, else if it decides > non-halting, does the system become non-halting, in which case it can > return non-halting. This still has to decide which wrong answer to give > to Linz (or you modify the problem to allow the decider to report that > the machine is acting contradictory). You also still need to solve the > problem of detecting non-recursive non-halting detection. > > Of course that fact that your logic has a flaw in it becomes obvious > when we look at the actual results of running the code under proper > conditions, as if and when Halts returns a non-halting result, the > system almost immediately comes to a halt. You construe proper conditions incorrectly. You cannot correctly justify why your "proper conditions" are required. > The fact that your logic says that H_Hat(H_Hat) must not halt and we > also have the proof that if Halts meets the requirements of a Halt > Decider that H_Hat(H_Hat) does halt, shows that either Halts does not > meet the requirements of a Halt Detector, A halt decider that simulates its input TMD until it detects that this simulation would never end <is> a valid halt decider architecture. It is foolish to argue otherwise. > there is some other logic > error we are not seeing, or something has been done in the axioms of the > system that make the logic system inconsistent. The one thing we can be > sure of is that Halts is NOT a correcct Halting Decider for the > classical Halting Problem. > >> >> This is the same thing as saying if a cat is black then we know it is a >> black cat. >> > > Yes, if a cat is black, it is a black cat, but that doesn't prove that > there ARE black cats. Also, your statement is actually more of like, I > will define this cat as black, so it is a black cat, even though the cat > is white, or maybe even a dog. > > -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 1 of 7 [1] 2 3 4 5 6 7 Next page →
Back to top | Article view | comp.theory
csiph-web