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 | 17 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 7 of 7 — ← Prev page 1 2 3 4 5 6 [7]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 10:44 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <7I6dnW3mdvVPFCPCnZ2dnUU7-a_NnZ2d@giganews.com> |
| In reply to | #25942 |
On 11/25/2020 10:16 AM, Mike Terry wrote:
> On 25/11/2020 03:58, olcott wrote:
>> On 11/24/2020 9:45 PM, Richard Damon wrote:
>>> On 11/24/20 10:06 PM, olcott wrote:
>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>
>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>
>>>>>>>>> Good grief, you are using the notation almost correctly! But you
>>>>>>>>> open
>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz
>>>>>>>>> explains.
>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>
>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>
>>>>>>>> Ĥ does not copy its input.
>>>>>>>
>>>>>>> Yes it does. You cited the book that tell you it does. If you
>>>>>>> don't
>>>>>>> accept the "hat" construction from Linz, you have nothing more to
>>>>>>> say
>>>>>>> about the proof.
>>>>>>
>>>>>> As I have told you hundreds of times I simplify the
>>>>>> counter-example to
>>>>>> make it conform to the general counter-example that does not copy its
>>>>>> input.
>>>>>
>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz
>>>>> does.
>>>>> Linz says of Ĥ "This new machine takes its input wM and copies it". I
>>>>> wrote exactly what Linz writes using the slightly different notation
>>>>> you
>>>>> have adopted:
>>>>>
>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>
>>>>> To keep denying that Ĥ copies its input is just silly. Just admit it
>>>>> and move. We can then talk about your x86 code, and why that's wrong.
>>>>
>>>> To say that this code copies itself is dishonest:
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Aborted = DebugTrace(P, P);
>>>> if (Aborted)
>>>> HALT
>>>> else
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>
>>> I see 1 P becoming 2 Ps, and a violation of the design if DebugTrace,
>>> via the program P it is emulating, happens to change its tape. Note that
>>> at this level of defintion, P does NOT yet need to be a representation
>>> of H_Hat, so it is possible to come up with a machine that this will
>>> process in a none equivalent matter to the Turing Machine Version, thus
>>> it is NOT the equivalent calculation.
>>>
>>>>
>>>>>>> Does this, in fact, mean you accept the proof as
>>>>>>> presented by Linz about actual Turing machines -- the one where Ĥ
>>>>>>> /does/
>>>>>>> copy its input?
>>>>>>
>>>>>> No it does not. It is quite crazy that you say this
>>>>>
>>>>> Take a deep breath. What is the usual end result when you have had to
>>>>> resort to thinking I'm saying crazy things? I am usually right,
>>>>> aren't
>>>>> I?
>>>>
>>>> I have already shown how the Linz equivalent code above has been
>>>> correctly decided.
>>>
>>> Only in your own mind.
>>>>
>>>>>> when I have shown you the actual execution trace of a concrete
>>>>>> example
>>>>>> of an equivalent H_Hat...
>>>>>
>>>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a tape
>>>>> containing the encoding of Ĥ. What matters for this post is the
>>>>> execution trace of the Turing machine Ĥ, not the execution trace of
>>>>> your
>>>>> x86 code. The TM execution trace is written like this:
>>>>
>>>> No that does not matter. What does matter is that my H_Hat is
>>>> computationally equivalent to the Linz Ĥ. It has the exact same
>>>> relation
>>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>>> element.
>>>
>>> As pointed above, it isn't, if Program P changes its tape, the execution
>>> equivalence is broken.
>>>
>>>>
>>>> You have already agreed that computational equivalence is good enough
>>>> and now you try to back out of this agreement (as I always expected).
>>>>
>>>
>>> I don't think anyone has complained about this optimization. What they
>>> HAVE complained about is that in if we want to make a change to the top
>>> level code to test a 'needed' clause, you won't allow the tape to remain
>>> per the original definition, even if at the top level we have a
>>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>>
>>
>> Only Mike has the capacity to understand this key aspect
>
> (LOL)
>
>> and he has not
>> yet provided me any feedback of my rebuttal of this.
>>
>> At least he explained why this sort of change is thought to be required.
>> Everyone else was incapable of providing any reasoning for their
>> requirement merely dogmatic assertions entirely bereft of any reasoning.
>>
>> It is an actual verifiable fact that the execution of H_Hat under a
>> simulator and the execution of H_Hat under a halt decider is perfectly
>> identical from H_Hat's point of view, thus not at all two different
>> computations as Mike has indicated.
>>
>> H_Hat does not decide to change its behavior between its simulation
>> under a UTM and its simulation under a halt decider because H_Hat is
>> utterly unaware of any difference.
>
> You know, I can't work out what you're actually claiming I've said so
> I'll just state two obvious points that aren't in any way controversial,
> and should cover anything I might have said previously:
>
> 1) There is the possibility that a halt decider might choose to quit
> enumerating the calculation steps earlier than the UTM - but of course
> the calculation itself is nothing to do with either of those emulations.
> And any perceived "change of behaviour" as a result of the halt
> decider aborting its emulation is not actually behaviour of H_Hat, it's
> different emulator behaviour. Aside from this, the behaviour OF THE
> SAME CALCULATION under different emulators will of course be the same up
> to the point where the emulators decide to stop enumerating the steps.
> (Duh!)
No one else gets this besides you and I.
> 2) Where a problem might come in is that if you change the TMDesc for
> H_Hat it becomes a different TMDesc H_Hat2. The computations
> H_Hat(H_Hat) and H_Hat2(H_Hat2) are two different computations, and may
> have different halting statuses. This includes changing H_Hat when
> making some change to the H machine in order to settle some what-if
> question concerning the behaviour of the specific input (H_Hat,H_Hat).
>
>
> Mike.
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
This is the x86utm equivalent TMD for H_Hat:
_H_Hat()
[000004f7](01) 55 push ebp
[000004f8](02) 8bec mov ebp,esp
[000004fa](01) 51 push ecx
[000004fb](03) 8b4508 mov eax,[ebp+08]
[000004fe](01) 50 push eax
[000004ff](03) 8b4d08 mov ecx,[ebp+08]
[00000502](01) 51 push ecx
[00000503](05) e86ffeffff call 00000377
[00000508](03) 83c408 add esp,+08
[0000050b](03) 8945fc mov [ebp-04],eax
[0000050e](04) 837dfc00 cmp dword [ebp-04],+00
[00000512](02) 7403 jz 00000517
[00000514](01) f4 hlt
[00000515](02) eb02 jmp 00000519
[00000517](02) ebfe jmp 00000517
[00000519](02) 8be5 mov esp,ebp
[0000051b](01) 5d pop ebp
[0000051c](01) c3 ret
The machine language and execution trace of H_Hat is identical** between:
(1) The above code.
(2) The x86utm based UTM equivalent DebugTrace().
(3) The x86utm based UTM equivalent DebugTrace() that has been adapted
to become a halt decider.
Up to the point where the decider terminates the infinite recursion of
H_Hat().
** The address of the called DebugTrace() varies between them.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-25 18:55 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <6NidnXhGvKA2NSPCnZ2dnUU78W3NnZ2d@brightview.co.uk> |
| In reply to | #25944 |
On 25/11/2020 16:44, olcott wrote:
> On 11/25/2020 10:16 AM, Mike Terry wrote:
>> On 25/11/2020 03:58, olcott wrote:
>>> On 11/24/2020 9:45 PM, Richard Damon wrote:
>>>> On 11/24/20 10:06 PM, olcott wrote:
>>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>>
>>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>>
>>>>>>>>>> Good grief, you are using the notation almost correctly! But you
>>>>>>>>>> open
>>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz
>>>>>>>>>> explains.
>>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>>
>>>>>>>>> Ĥ does not copy its input.
>>>>>>>>
>>>>>>>> Yes it does. You cited the book that tell you it does. If you
>>>>>>>> don't
>>>>>>>> accept the "hat" construction from Linz, you have nothing more
>>>>>>>> to say
>>>>>>>> about the proof.
>>>>>>>
>>>>>>> As I have told you hundreds of times I simplify the
>>>>>>> counter-example to
>>>>>>> make it conform to the general counter-example that does not copy
>>>>>>> its
>>>>>>> input.
>>>>>>
>>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz
>>>>>> does.
>>>>>> Linz says of Ĥ "This new machine takes its input wM and copies
>>>>>> it". I
>>>>>> wrote exactly what Linz writes using the slightly different notation
>>>>>> you
>>>>>> have adopted:
>>>>>>
>>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>>
>>>>>> To keep denying that Ĥ copies its input is just silly. Just admit it
>>>>>> and move. We can then talk about your x86 code, and why that's
>>>>>> wrong.
>>>>>
>>>>> To say that this code copies itself is dishonest:
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>> u32 Aborted = DebugTrace(P, P);
>>>>> if (Aborted)
>>>>> HALT
>>>>> else
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>
>>>> I see 1 P becoming 2 Ps, and a violation of the design if DebugTrace,
>>>> via the program P it is emulating, happens to change its tape. Note
>>>> that
>>>> at this level of defintion, P does NOT yet need to be a representation
>>>> of H_Hat, so it is possible to come up with a machine that this will
>>>> process in a none equivalent matter to the Turing Machine Version, thus
>>>> it is NOT the equivalent calculation.
>>>>
>>>>>
>>>>>>>> Does this, in fact, mean you accept the proof as
>>>>>>>> presented by Linz about actual Turing machines -- the one where Ĥ
>>>>>>>> /does/
>>>>>>>> copy its input?
>>>>>>>
>>>>>>> No it does not. It is quite crazy that you say this
>>>>>>
>>>>>> Take a deep breath. What is the usual end result when you have
>>>>>> had to
>>>>>> resort to thinking I'm saying crazy things? I am usually right,
>>>>>> aren't
>>>>>> I?
>>>>>
>>>>> I have already shown how the Linz equivalent code above has been
>>>>> correctly decided.
>>>>
>>>> Only in your own mind.
>>>>>
>>>>>>> when I have shown you the actual execution trace of a concrete
>>>>>>> example
>>>>>>> of an equivalent H_Hat...
>>>>>>
>>>>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a tape
>>>>>> containing the encoding of Ĥ. What matters for this post is the
>>>>>> execution trace of the Turing machine Ĥ, not the execution trace of
>>>>>> your
>>>>>> x86 code. The TM execution trace is written like this:
>>>>>
>>>>> No that does not matter. What does matter is that my H_Hat is
>>>>> computationally equivalent to the Linz Ĥ. It has the exact same
>>>>> relation
>>>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>>>> element.
>>>>
>>>> As pointed above, it isn't, if Program P changes its tape, the
>>>> execution
>>>> equivalence is broken.
>>>>
>>>>>
>>>>> You have already agreed that computational equivalence is good enough
>>>>> and now you try to back out of this agreement (as I always expected).
>>>>>
>>>>
>>>> I don't think anyone has complained about this optimization. What they
>>>> HAVE complained about is that in if we want to make a change to the top
>>>> level code to test a 'needed' clause, you won't allow the tape to
>>>> remain
>>>> per the original definition, even if at the top level we have a
>>>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>>>
>>>
>>> Only Mike has the capacity to understand this key aspect
>>
>> (LOL)
>>
>>> and he has not
>>> yet provided me any feedback of my rebuttal of this.
>>>
>>> At least he explained why this sort of change is thought to be required.
>>> Everyone else was incapable of providing any reasoning for their
>>> requirement merely dogmatic assertions entirely bereft of any reasoning.
>>>
>>> It is an actual verifiable fact that the execution of H_Hat under a
>>> simulator and the execution of H_Hat under a halt decider is perfectly
>>> identical from H_Hat's point of view, thus not at all two different
>>> computations as Mike has indicated.
>>>
>>> H_Hat does not decide to change its behavior between its simulation
>>> under a UTM and its simulation under a halt decider because H_Hat is
>>> utterly unaware of any difference.
>>
>> You know, I can't work out what you're actually claiming I've said so
>> I'll just state two obvious points that aren't in any way
>> controversial, and should cover anything I might have said previously:
>>
>> 1) There is the possibility that a halt decider might choose to quit
>> enumerating the calculation steps earlier than the UTM - but of course
>> the calculation itself is nothing to do with either of those
>> emulations. And any perceived "change of behaviour" as a result of
>> the halt decider aborting its emulation is not actually behaviour of
>> H_Hat, it's different emulator behaviour. Aside from this, the
>> behaviour OF THE SAME CALCULATION under different emulators will of
>> course be the same up to the point where the emulators decide to stop
>> enumerating the steps. (Duh!)
>
> No one else gets this besides you and I.
>
Nonsense.
>> 2) Where a problem might come in is that if you change the TMDesc for
>> H_Hat it becomes a different TMDesc H_Hat2. The computations
>> H_Hat(H_Hat) and H_Hat2(H_Hat2) are two different computations, and
>> may have different halting statuses. This includes changing H_Hat
>> when making some change to the H machine in order to settle some
>> what-if question concerning the behaviour of the specific input
>> (H_Hat,H_Hat).
>>
>>
>> Mike.
<.. snip claims nothing to do with my remark ..>
(if you want to introduce tangental material, start a new thread)
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 13:24 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <VuidnVnyUvzlMiPCnZ2dnUU7-evNnZ2d@giganews.com> |
| In reply to | #25955 |
On 11/25/2020 12:55 PM, Mike Terry wrote:
> On 25/11/2020 16:44, olcott wrote:
>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>> On 25/11/2020 03:58, olcott wrote:
>>>> On 11/24/2020 9:45 PM, Richard Damon wrote:
>>>>> On 11/24/20 10:06 PM, olcott wrote:
>>>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>>>
>>>>>>>>>>> Good grief, you are using the notation almost correctly! But
>>>>>>>>>>> you
>>>>>>>>>>> open
>>>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz
>>>>>>>>>>> explains.
>>>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>>>
>>>>>>>>>> Ĥ does not copy its input.
>>>>>>>>>
>>>>>>>>> Yes it does. You cited the book that tell you it does. If you
>>>>>>>>> don't
>>>>>>>>> accept the "hat" construction from Linz, you have nothing more
>>>>>>>>> to say
>>>>>>>>> about the proof.
>>>>>>>>
>>>>>>>> As I have told you hundreds of times I simplify the
>>>>>>>> counter-example to
>>>>>>>> make it conform to the general counter-example that does not copy
>>>>>>>> its
>>>>>>>> input.
>>>>>>>
>>>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz
>>>>>>> does.
>>>>>>> Linz says of Ĥ "This new machine takes its input wM and copies
>>>>>>> it". I
>>>>>>> wrote exactly what Linz writes using the slightly different notation
>>>>>>> you
>>>>>>> have adopted:
>>>>>>>
>>>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>>>
>>>>>>> To keep denying that Ĥ copies its input is just silly. Just
>>>>>>> admit it
>>>>>>> and move. We can then talk about your x86 code, and why that's
>>>>>>> wrong.
>>>>>>
>>>>>> To say that this code copies itself is dishonest:
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>> if (Aborted)
>>>>>> HALT
>>>>>> else
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>
>>>>> I see 1 P becoming 2 Ps, and a violation of the design if DebugTrace,
>>>>> via the program P it is emulating, happens to change its tape. Note
>>>>> that
>>>>> at this level of defintion, P does NOT yet need to be a representation
>>>>> of H_Hat, so it is possible to come up with a machine that this will
>>>>> process in a none equivalent matter to the Turing Machine Version,
>>>>> thus
>>>>> it is NOT the equivalent calculation.
>>>>>
>>>>>>
>>>>>>>>> Does this, in fact, mean you accept the proof as
>>>>>>>>> presented by Linz about actual Turing machines -- the one where Ĥ
>>>>>>>>> /does/
>>>>>>>>> copy its input?
>>>>>>>>
>>>>>>>> No it does not. It is quite crazy that you say this
>>>>>>>
>>>>>>> Take a deep breath. What is the usual end result when you have
>>>>>>> had to
>>>>>>> resort to thinking I'm saying crazy things? I am usually right,
>>>>>>> aren't
>>>>>>> I?
>>>>>>
>>>>>> I have already shown how the Linz equivalent code above has been
>>>>>> correctly decided.
>>>>>
>>>>> Only in your own mind.
>>>>>>
>>>>>>>> when I have shown you the actual execution trace of a concrete
>>>>>>>> example
>>>>>>>> of an equivalent H_Hat...
>>>>>>>
>>>>>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a tape
>>>>>>> containing the encoding of Ĥ. What matters for this post is the
>>>>>>> execution trace of the Turing machine Ĥ, not the execution trace of
>>>>>>> your
>>>>>>> x86 code. The TM execution trace is written like this:
>>>>>>
>>>>>> No that does not matter. What does matter is that my H_Hat is
>>>>>> computationally equivalent to the Linz Ĥ. It has the exact same
>>>>>> relation
>>>>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>>>>> element.
>>>>>
>>>>> As pointed above, it isn't, if Program P changes its tape, the
>>>>> execution
>>>>> equivalence is broken.
>>>>>
>>>>>>
>>>>>> You have already agreed that computational equivalence is good enough
>>>>>> and now you try to back out of this agreement (as I always expected).
>>>>>>
>>>>>
>>>>> I don't think anyone has complained about this optimization. What they
>>>>> HAVE complained about is that in if we want to make a change to the
>>>>> top
>>>>> level code to test a 'needed' clause, you won't allow the tape to
>>>>> remain
>>>>> per the original definition, even if at the top level we have a
>>>>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>>>>
>>>>
>>>> Only Mike has the capacity to understand this key aspect
>>>
>>> (LOL)
>>>
>>>> and he has not
>>>> yet provided me any feedback of my rebuttal of this.
>>>>
>>>> At least he explained why this sort of change is thought to be
>>>> required.
>>>> Everyone else was incapable of providing any reasoning for their
>>>> requirement merely dogmatic assertions entirely bereft of any
>>>> reasoning.
>>>>
>>>> It is an actual verifiable fact that the execution of H_Hat under a
>>>> simulator and the execution of H_Hat under a halt decider is perfectly
>>>> identical from H_Hat's point of view, thus not at all two different
>>>> computations as Mike has indicated.
>>>>
>>>> H_Hat does not decide to change its behavior between its simulation
>>>> under a UTM and its simulation under a halt decider because H_Hat is
>>>> utterly unaware of any difference.
>>>
>>> You know, I can't work out what you're actually claiming I've said so
>>> I'll just state two obvious points that aren't in any way
>>> controversial, and should cover anything I might have said previously:
>>>
>>> 1) There is the possibility that a halt decider might choose to quit
>>> enumerating the calculation steps earlier than the UTM - but of course
>>> the calculation itself is nothing to do with either of those
>>> emulations. And any perceived "change of behaviour" as a result of
>>> the halt decider aborting its emulation is not actually behaviour of
>>> H_Hat, it's different emulator behaviour. Aside from this, the
>>> behaviour OF THE SAME CALCULATION under different emulators will of
>>> course be the same up to the point where the emulators decide to stop
>>> enumerating the steps. (Duh!)
>>
>> No one else gets this besides you and I.
>>
>
> Nonsense.
>
On 11/25/2020 10:16 AM, Mike Terry wrote:
> And any perceived "change of behaviour" as a
> result of the halt decider aborting its emulation
> is not actually behaviour of H_Hat, it's different
> emulator behaviour.
On 11/25/2020 12:03 PM, Richard Damon wrote:
> First, If Mike was actually stating that there is no
> behavior change in H_Hat between it having a UTM or
> a Halt Decider as the operation it is use, I will
> disagree with it,
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-25 19:43 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <csadnWNv-b9_LiPCnZ2dnUU78SnNnZ2d@brightview.co.uk> |
| In reply to | #25956 |
On 25/11/2020 19:24, olcott wrote:
> On 11/25/2020 12:55 PM, Mike Terry wrote:
>> On 25/11/2020 16:44, olcott wrote:
>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>> On 25/11/2020 03:58, olcott wrote:
>>>>> On 11/24/2020 9:45 PM, Richard Damon wrote:
>>>>>> On 11/24/20 10:06 PM, olcott wrote:
>>>>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>>>>
>>>>>>>>>>>> Good grief, you are using the notation almost correctly!
>>>>>>>>>>>> But you
>>>>>>>>>>>> open
>>>>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz
>>>>>>>>>>>> explains.
>>>>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>>>>
>>>>>>>>>>> Ĥ does not copy its input.
>>>>>>>>>>
>>>>>>>>>> Yes it does. You cited the book that tell you it does. If you
>>>>>>>>>> don't
>>>>>>>>>> accept the "hat" construction from Linz, you have nothing more
>>>>>>>>>> to say
>>>>>>>>>> about the proof.
>>>>>>>>>
>>>>>>>>> As I have told you hundreds of times I simplify the
>>>>>>>>> counter-example to
>>>>>>>>> make it conform to the general counter-example that does not copy
>>>>>>>>> its
>>>>>>>>> input.
>>>>>>>>
>>>>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz
>>>>>>>> does.
>>>>>>>> Linz says of Ĥ "This new machine takes its input wM and copies
>>>>>>>> it". I
>>>>>>>> wrote exactly what Linz writes using the slightly different
>>>>>>>> notation
>>>>>>>> you
>>>>>>>> have adopted:
>>>>>>>>
>>>>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>>>>
>>>>>>>> To keep denying that Ĥ copies its input is just silly. Just
>>>>>>>> admit it
>>>>>>>> and move. We can then talk about your x86 code, and why that's
>>>>>>>> wrong.
>>>>>>>
>>>>>>> To say that this code copies itself is dishonest:
>>>>>>>
>>>>>>> void H_Hat(u32 P)
>>>>>>> {
>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>> if (Aborted)
>>>>>>> HALT
>>>>>>> else
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>
>>>>>> I see 1 P becoming 2 Ps, and a violation of the design if DebugTrace,
>>>>>> via the program P it is emulating, happens to change its tape. Note
>>>>>> that
>>>>>> at this level of defintion, P does NOT yet need to be a
>>>>>> representation
>>>>>> of H_Hat, so it is possible to come up with a machine that this will
>>>>>> process in a none equivalent matter to the Turing Machine Version,
>>>>>> thus
>>>>>> it is NOT the equivalent calculation.
>>>>>>
>>>>>>>
>>>>>>>>>> Does this, in fact, mean you accept the proof as
>>>>>>>>>> presented by Linz about actual Turing machines -- the one where Ĥ
>>>>>>>>>> /does/
>>>>>>>>>> copy its input?
>>>>>>>>>
>>>>>>>>> No it does not. It is quite crazy that you say this
>>>>>>>>
>>>>>>>> Take a deep breath. What is the usual end result when you have
>>>>>>>> had to
>>>>>>>> resort to thinking I'm saying crazy things? I am usually right,
>>>>>>>> aren't
>>>>>>>> I?
>>>>>>>
>>>>>>> I have already shown how the Linz equivalent code above has been
>>>>>>> correctly decided.
>>>>>>
>>>>>> Only in your own mind.
>>>>>>>
>>>>>>>>> when I have shown you the actual execution trace of a concrete
>>>>>>>>> example
>>>>>>>>> of an equivalent H_Hat...
>>>>>>>>
>>>>>>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a tape
>>>>>>>> containing the encoding of Ĥ. What matters for this post is the
>>>>>>>> execution trace of the Turing machine Ĥ, not the execution trace of
>>>>>>>> your
>>>>>>>> x86 code. The TM execution trace is written like this:
>>>>>>>
>>>>>>> No that does not matter. What does matter is that my H_Hat is
>>>>>>> computationally equivalent to the Linz Ĥ. It has the exact same
>>>>>>> relation
>>>>>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>>>>>> element.
>>>>>>
>>>>>> As pointed above, it isn't, if Program P changes its tape, the
>>>>>> execution
>>>>>> equivalence is broken.
>>>>>>
>>>>>>>
>>>>>>> You have already agreed that computational equivalence is good
>>>>>>> enough
>>>>>>> and now you try to back out of this agreement (as I always
>>>>>>> expected).
>>>>>>>
>>>>>>
>>>>>> I don't think anyone has complained about this optimization. What
>>>>>> they
>>>>>> HAVE complained about is that in if we want to make a change to
>>>>>> the top
>>>>>> level code to test a 'needed' clause, you won't allow the tape to
>>>>>> remain
>>>>>> per the original definition, even if at the top level we have a
>>>>>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>>>>>
>>>>>
>>>>> Only Mike has the capacity to understand this key aspect
>>>>
>>>> (LOL)
>>>>
>>>>> and he has not
>>>>> yet provided me any feedback of my rebuttal of this.
>>>>>
>>>>> At least he explained why this sort of change is thought to be
>>>>> required.
>>>>> Everyone else was incapable of providing any reasoning for their
>>>>> requirement merely dogmatic assertions entirely bereft of any
>>>>> reasoning.
>>>>>
>>>>> It is an actual verifiable fact that the execution of H_Hat under a
>>>>> simulator and the execution of H_Hat under a halt decider is perfectly
>>>>> identical from H_Hat's point of view, thus not at all two different
>>>>> computations as Mike has indicated.
>>>>>
>>>>> H_Hat does not decide to change its behavior between its simulation
>>>>> under a UTM and its simulation under a halt decider because H_Hat is
>>>>> utterly unaware of any difference.
>>>>
>>>> You know, I can't work out what you're actually claiming I've said so
>>>> I'll just state two obvious points that aren't in any way
>>>> controversial, and should cover anything I might have said previously:
>>>>
>>>> 1) There is the possibility that a halt decider might choose to quit
>>>> enumerating the calculation steps earlier than the UTM - but of course
>>>> the calculation itself is nothing to do with either of those
>>>> emulations. And any perceived "change of behaviour" as a result of
>>>> the halt decider aborting its emulation is not actually behaviour of
>>>> H_Hat, it's different emulator behaviour. Aside from this, the
>>>> behaviour OF THE SAME CALCULATION under different emulators will of
>>>> course be the same up to the point where the emulators decide to stop
>>>> enumerating the steps. (Duh!)
>>>
>>> No one else gets this besides you and I.
>>>
>>
>> Nonsense.
>>
>
> On 11/25/2020 10:16 AM, Mike Terry wrote:
>> And any perceived "change of behaviour" as a
>> result of the halt decider aborting its emulation
>> is not actually behaviour of H_Hat, it's different
>> emulator behaviour.
>
> On 11/25/2020 12:03 PM, Richard Damon wrote:
>> First, If Mike was actually stating that there is no
>> behavior change in H_Hat between it having a UTM or
>> a Halt Decider as the operation it is use, I will
>> disagree with it,
This is an example of you being too stupid to understand what people are
actually saying, and too lazy to be bothered to actually find out.
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 14:09 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <EJqdnWcy8YSNJyPCnZ2dnUU7-LPNnZ2d@giganews.com> |
| In reply to | #25960 |
On 11/25/2020 1:43 PM, Mike Terry wrote:
> On 25/11/2020 19:24, olcott wrote:
>> On 11/25/2020 12:55 PM, Mike Terry wrote:
>>> On 25/11/2020 16:44, olcott wrote:
>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>> On 25/11/2020 03:58, olcott wrote:
>>>>>> On 11/24/2020 9:45 PM, Richard Damon wrote:
>>>>>>> On 11/24/20 10:06 PM, olcott wrote:
>>>>>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Good grief, you are using the notation almost correctly!
>>>>>>>>>>>>> But you
>>>>>>>>>>>>> open
>>>>>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz
>>>>>>>>>>>>> explains.
>>>>>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ does not copy its input.
>>>>>>>>>>>
>>>>>>>>>>> Yes it does. You cited the book that tell you it does. If you
>>>>>>>>>>> don't
>>>>>>>>>>> accept the "hat" construction from Linz, you have nothing more
>>>>>>>>>>> to say
>>>>>>>>>>> about the proof.
>>>>>>>>>>
>>>>>>>>>> As I have told you hundreds of times I simplify the
>>>>>>>>>> counter-example to
>>>>>>>>>> make it conform to the general counter-example that does not copy
>>>>>>>>>> its
>>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz
>>>>>>>>> does.
>>>>>>>>> Linz says of Ĥ "This new machine takes its input wM and copies
>>>>>>>>> it". I
>>>>>>>>> wrote exactly what Linz writes using the slightly different
>>>>>>>>> notation
>>>>>>>>> you
>>>>>>>>> have adopted:
>>>>>>>>>
>>>>>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>>>>>
>>>>>>>>> To keep denying that Ĥ copies its input is just silly. Just
>>>>>>>>> admit it
>>>>>>>>> and move. We can then talk about your x86 code, and why that's
>>>>>>>>> wrong.
>>>>>>>>
>>>>>>>> To say that this code copies itself is dishonest:
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>> if (Aborted)
>>>>>>>> HALT
>>>>>>>> else
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>
>>>>>>> I see 1 P becoming 2 Ps, and a violation of the design if
>>>>>>> DebugTrace,
>>>>>>> via the program P it is emulating, happens to change its tape. Note
>>>>>>> that
>>>>>>> at this level of defintion, P does NOT yet need to be a
>>>>>>> representation
>>>>>>> of H_Hat, so it is possible to come up with a machine that this will
>>>>>>> process in a none equivalent matter to the Turing Machine Version,
>>>>>>> thus
>>>>>>> it is NOT the equivalent calculation.
>>>>>>>
>>>>>>>>
>>>>>>>>>>> Does this, in fact, mean you accept the proof as
>>>>>>>>>>> presented by Linz about actual Turing machines -- the one
>>>>>>>>>>> where Ĥ
>>>>>>>>>>> /does/
>>>>>>>>>>> copy its input?
>>>>>>>>>>
>>>>>>>>>> No it does not. It is quite crazy that you say this
>>>>>>>>>
>>>>>>>>> Take a deep breath. What is the usual end result when you have
>>>>>>>>> had to
>>>>>>>>> resort to thinking I'm saying crazy things? I am usually right,
>>>>>>>>> aren't
>>>>>>>>> I?
>>>>>>>>
>>>>>>>> I have already shown how the Linz equivalent code above has been
>>>>>>>> correctly decided.
>>>>>>>
>>>>>>> Only in your own mind.
>>>>>>>>
>>>>>>>>>> when I have shown you the actual execution trace of a concrete
>>>>>>>>>> example
>>>>>>>>>> of an equivalent H_Hat...
>>>>>>>>>
>>>>>>>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a
>>>>>>>>> tape
>>>>>>>>> containing the encoding of Ĥ. What matters for this post is the
>>>>>>>>> execution trace of the Turing machine Ĥ, not the execution
>>>>>>>>> trace of
>>>>>>>>> your
>>>>>>>>> x86 code. The TM execution trace is written like this:
>>>>>>>>
>>>>>>>> No that does not matter. What does matter is that my H_Hat is
>>>>>>>> computationally equivalent to the Linz Ĥ. It has the exact same
>>>>>>>> relation
>>>>>>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>>>>>>> element.
>>>>>>>
>>>>>>> As pointed above, it isn't, if Program P changes its tape, the
>>>>>>> execution
>>>>>>> equivalence is broken.
>>>>>>>
>>>>>>>>
>>>>>>>> You have already agreed that computational equivalence is good
>>>>>>>> enough
>>>>>>>> and now you try to back out of this agreement (as I always
>>>>>>>> expected).
>>>>>>>>
>>>>>>>
>>>>>>> I don't think anyone has complained about this optimization. What
>>>>>>> they
>>>>>>> HAVE complained about is that in if we want to make a change to
>>>>>>> the top
>>>>>>> level code to test a 'needed' clause, you won't allow the tape to
>>>>>>> remain
>>>>>>> per the original definition, even if at the top level we have a
>>>>>>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>>>>>>
>>>>>>
>>>>>> Only Mike has the capacity to understand this key aspect
>>>>>
>>>>> (LOL)
>>>>>
>>>>>> and he has not
>>>>>> yet provided me any feedback of my rebuttal of this.
>>>>>>
>>>>>> At least he explained why this sort of change is thought to be
>>>>>> required.
>>>>>> Everyone else was incapable of providing any reasoning for their
>>>>>> requirement merely dogmatic assertions entirely bereft of any
>>>>>> reasoning.
>>>>>>
>>>>>> It is an actual verifiable fact that the execution of H_Hat under a
>>>>>> simulator and the execution of H_Hat under a halt decider is
>>>>>> perfectly
>>>>>> identical from H_Hat's point of view, thus not at all two different
>>>>>> computations as Mike has indicated.
>>>>>>
>>>>>> H_Hat does not decide to change its behavior between its simulation
>>>>>> under a UTM and its simulation under a halt decider because H_Hat is
>>>>>> utterly unaware of any difference.
>>>>>
>>>>> You know, I can't work out what you're actually claiming I've said so
>>>>> I'll just state two obvious points that aren't in any way
>>>>> controversial, and should cover anything I might have said previously:
>>>>>
>>>>> 1) There is the possibility that a halt decider might choose to quit
>>>>> enumerating the calculation steps earlier than the UTM - but of course
>>>>> the calculation itself is nothing to do with either of those
>>>>> emulations. And any perceived "change of behaviour" as a result of
>>>>> the halt decider aborting its emulation is not actually behaviour of
>>>>> H_Hat, it's different emulator behaviour. Aside from this, the
>>>>> behaviour OF THE SAME CALCULATION under different emulators will of
>>>>> course be the same up to the point where the emulators decide to stop
>>>>> enumerating the steps. (Duh!)
>>>>
>>>> No one else gets this besides you and I.
>>>>
>>>
>>> Nonsense.
>>>
>>
>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>> And any perceived "change of behaviour" as a
>>> result of the halt decider aborting its emulation
>>> is not actually behaviour of H_Hat, it's different
>>> emulator behaviour.
>>
>> On 11/25/2020 12:03 PM, Richard Damon wrote:
>>> First, If Mike was actually stating that there is no
>>> behavior change in H_Hat between it having a UTM or
>>> a Halt Decider as the operation it is use, I will
>>> disagree with it,
>
> This is an example of you being too stupid to understand what people are
> actually saying, and too lazy to be bothered to actually find out.
>
>
> Mike.
>
You can be free to misinterpret that way.
Many many times Richard was saying the the execution of H_Hat was
incorrect because I did not show the return value that H_Hat received.
I had to simplify this for him and go over this code again and again
before he realized that H_Hat() does not receive a return value from
DebugTrace() because H_Hat() is stuck in infinite recursion.
I am still not sure that he gets this key point yet.
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2020-11-25 14:30 -0700 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <rpmiei$9f6$1@dont-email.me> |
| In reply to | #25963 |
On 11/25/2020 1:09 PM, olcott wrote:
> On 11/25/2020 1:43 PM, Mike Terry wrote:
>> On 25/11/2020 19:24, olcott wrote:
>>> On 11/25/2020 12:55 PM, Mike Terry wrote:
>>>> On 25/11/2020 16:44, olcott wrote:
>>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>>> On 25/11/2020 03:58, olcott wrote:
>>>>>>> On 11/24/2020 9:45 PM, Richard Damon wrote:
>>>>>>>> On 11/24/20 10:06 PM, olcott wrote:
>>>>>>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Good grief, you are using the notation almost correctly!
>>>>>>>>>>>>>> But you
>>>>>>>>>>>>>> open
>>>>>>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as
>>>>>>>>>>>>>> Linz
>>>>>>>>>>>>>> explains.
>>>>>>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ does not copy its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes it does. You cited the book that tell you it does. If you
>>>>>>>>>>>> don't
>>>>>>>>>>>> accept the "hat" construction from Linz, you have nothing more
>>>>>>>>>>>> to say
>>>>>>>>>>>> about the proof.
>>>>>>>>>>>
>>>>>>>>>>> As I have told you hundreds of times I simplify the
>>>>>>>>>>> counter-example to
>>>>>>>>>>> make it conform to the general counter-example that does not
>>>>>>>>>>> copy
>>>>>>>>>>> its
>>>>>>>>>>> input.
>>>>>>>>>>
>>>>>>>>>> You cited Linz and gave the desired behaviour of H exactly as
>>>>>>>>>> Linz
>>>>>>>>>> does.
>>>>>>>>>> Linz says of Ĥ "This new machine takes its input wM and copies
>>>>>>>>>> it". I
>>>>>>>>>> wrote exactly what Linz writes using the slightly different
>>>>>>>>>> notation
>>>>>>>>>> you
>>>>>>>>>> have adopted:
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>>>>>>
>>>>>>>>>> To keep denying that Ĥ copies its input is just silly. Just
>>>>>>>>>> admit it
>>>>>>>>>> and move. We can then talk about your x86 code, and why that's
>>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>>> To say that this code copies itself is dishonest:
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>> {
>>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>>> if (Aborted)
>>>>>>>>> HALT
>>>>>>>>> else
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>
>>>>>>>> I see 1 P becoming 2 Ps, and a violation of the design if
>>>>>>>> DebugTrace,
>>>>>>>> via the program P it is emulating, happens to change its tape. Note
>>>>>>>> that
>>>>>>>> at this level of defintion, P does NOT yet need to be a
>>>>>>>> representation
>>>>>>>> of H_Hat, so it is possible to come up with a machine that this
>>>>>>>> will
>>>>>>>> process in a none equivalent matter to the Turing Machine Version,
>>>>>>>> thus
>>>>>>>> it is NOT the equivalent calculation.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>>> Does this, in fact, mean you accept the proof as
>>>>>>>>>>>> presented by Linz about actual Turing machines -- the one
>>>>>>>>>>>> where Ĥ
>>>>>>>>>>>> /does/
>>>>>>>>>>>> copy its input?
>>>>>>>>>>>
>>>>>>>>>>> No it does not. It is quite crazy that you say this
>>>>>>>>>>
>>>>>>>>>> Take a deep breath. What is the usual end result when you have
>>>>>>>>>> had to
>>>>>>>>>> resort to thinking I'm saying crazy things? I am usually right,
>>>>>>>>>> aren't
>>>>>>>>>> I?
>>>>>>>>>
>>>>>>>>> I have already shown how the Linz equivalent code above has been
>>>>>>>>> correctly decided.
>>>>>>>>
>>>>>>>> Only in your own mind.
>>>>>>>>>
>>>>>>>>>>> when I have shown you the actual execution trace of a concrete
>>>>>>>>>>> example
>>>>>>>>>>> of an equivalent H_Hat...
>>>>>>>>>>
>>>>>>>>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a
>>>>>>>>>> tape
>>>>>>>>>> containing the encoding of Ĥ. What matters for this post is the
>>>>>>>>>> execution trace of the Turing machine Ĥ, not the execution
>>>>>>>>>> trace of
>>>>>>>>>> your
>>>>>>>>>> x86 code. The TM execution trace is written like this:
>>>>>>>>>
>>>>>>>>> No that does not matter. What does matter is that my H_Hat is
>>>>>>>>> computationally equivalent to the Linz Ĥ. It has the exact same
>>>>>>>>> relation
>>>>>>>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>>>>>>>> element.
>>>>>>>>
>>>>>>>> As pointed above, it isn't, if Program P changes its tape, the
>>>>>>>> execution
>>>>>>>> equivalence is broken.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> You have already agreed that computational equivalence is good
>>>>>>>>> enough
>>>>>>>>> and now you try to back out of this agreement (as I always
>>>>>>>>> expected).
>>>>>>>>>
>>>>>>>>
>>>>>>>> I don't think anyone has complained about this optimization. What
>>>>>>>> they
>>>>>>>> HAVE complained about is that in if we want to make a change to
>>>>>>>> the top
>>>>>>>> level code to test a 'needed' clause, you won't allow the tape to
>>>>>>>> remain
>>>>>>>> per the original definition, even if at the top level we have a
>>>>>>>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>>>>>>>
>>>>>>>
>>>>>>> Only Mike has the capacity to understand this key aspect
>>>>>>
>>>>>> (LOL)
>>>>>>
>>>>>>> and he has not
>>>>>>> yet provided me any feedback of my rebuttal of this.
>>>>>>>
>>>>>>> At least he explained why this sort of change is thought to be
>>>>>>> required.
>>>>>>> Everyone else was incapable of providing any reasoning for their
>>>>>>> requirement merely dogmatic assertions entirely bereft of any
>>>>>>> reasoning.
>>>>>>>
>>>>>>> It is an actual verifiable fact that the execution of H_Hat under a
>>>>>>> simulator and the execution of H_Hat under a halt decider is
>>>>>>> perfectly
>>>>>>> identical from H_Hat's point of view, thus not at all two different
>>>>>>> computations as Mike has indicated.
>>>>>>>
>>>>>>> H_Hat does not decide to change its behavior between its simulation
>>>>>>> under a UTM and its simulation under a halt decider because H_Hat is
>>>>>>> utterly unaware of any difference.
>>>>>>
>>>>>> You know, I can't work out what you're actually claiming I've said so
>>>>>> I'll just state two obvious points that aren't in any way
>>>>>> controversial, and should cover anything I might have said
>>>>>> previously:
>>>>>>
>>>>>> 1) There is the possibility that a halt decider might choose to quit
>>>>>> enumerating the calculation steps earlier than the UTM - but of
>>>>>> course
>>>>>> the calculation itself is nothing to do with either of those
>>>>>> emulations. And any perceived "change of behaviour" as a result of
>>>>>> the halt decider aborting its emulation is not actually behaviour of
>>>>>> H_Hat, it's different emulator behaviour. Aside from this, the
>>>>>> behaviour OF THE SAME CALCULATION under different emulators will of
>>>>>> course be the same up to the point where the emulators decide to stop
>>>>>> enumerating the steps. (Duh!)
>>>>>
>>>>> No one else gets this besides you and I.
>>>>>
>>>>
>>>> Nonsense.
>>>>
>>>
>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>> And any perceived "change of behaviour" as a
>>>> result of the halt decider aborting its emulation
>>>> is not actually behaviour of H_Hat, it's different
>>>> emulator behaviour.
>>>
>>> On 11/25/2020 12:03 PM, Richard Damon wrote:
>>>> First, If Mike was actually stating that there is no
>>>> behavior change in H_Hat between it having a UTM or
>>>> a Halt Decider as the operation it is use, I will
>>>> disagree with it,
>>
>> This is an example of you being too stupid to understand what people
>> are actually saying, and too lazy to be bothered to actually find out.
>>
>>
>> Mike.
>>
>
> You can be free to misinterpret that way.
> Many many times Richard was saying the the execution of H_Hat was
> incorrect because I did not show the return value that H_Hat received.
>
> I had to simplify this for him and go over this code again and again
> before he realized that H_Hat() does not receive a return value from
> DebugTrace() because H_Hat() is stuck in infinite recursion.
>
> I am still not sure that he gets this key point yet.
>
> int DebugTrace(u32 N, u32 M)
> {
> return ((int(*)(int))N)(M);
> }
>
>
> void H_Hat(u32 P)
> {
> u32 Aborted = DebugTrace(P, P);
> if (Aborted)
> HALT
> else
> HERE: goto HERE;
> }
You were given two choices above: you are 1) stupid or 2) lazy.
We all note that you jumped on stupid like a wild dog on a pork chop.
Chew carefully, you might choke.
--
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-25 21:24 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <AlEvH.30103$Uz.5082@fx46.iad> |
| In reply to | #25963 |
On 11/25/20 3:09 PM, olcott wrote:
> You can be free to misinterpret that way.
> Many many times Richard was saying the the execution of H_Hat was
> incorrect because I did not show the return value that H_Hat received.
>
> I had to simplify this for him and go over this code again and again
> before he realized that H_Hat() does not receive a return value from
> DebugTrace() because H_Hat() is stuck in infinite recursion.
>
> I am still not sure that he gets this key point yet.
>
> int DebugTrace(u32 N, u32 M)
> {
> return ((int(*)(int))N)(M);
> }
>
>
> void H_Hat(u32 P)
> {
> u32 Aborted = DebugTrace(P, P);
> if (Aborted)
> HALT
> else
> HERE: goto HERE;
> }
>
>
Actually, If you are refering the the Linz equivalent H_Hat (I think you
are, but you misuse terms so much that it hard to be sure). At least
once near the begining, when I presented my trace of how H_Hat(H_Hat)
would execute as a Real Turing Machine, you sepcifically objected to the
trace because you said, but we don't get to the else because Halts (That
was its name at the time) aborted the execution, so H_Hat didn't get a
chance to halt and show itself to be halting.
I will note that the above example has no halt decider in it, and
experiences Critical Underfined Behavior in the expression
((int(*)(int))N)(M); before we get into the recursion.
I never said that this program doesn't get stuck in a recursive loop.
I will also continue to put forward that when DebugTrace is supposed to
be a halt detector, any detected 'infinite recursion' isn't the 'fault'
of H_Hat, but is a sign that DebugTrace isn't meeting its requirements
to be a proper Halt Detector.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 21:03 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <DdOdnbL5_s-fhiLCnZ2dnUU7-InNnZ2d@giganews.com> |
| In reply to | #26004 |
On 11/25/2020 8:24 PM, Richard Damon wrote:
> On 11/25/20 3:09 PM, olcott wrote:
>
>> You can be free to misinterpret that way.
>> Many many times Richard was saying the the execution of H_Hat was
>> incorrect because I did not show the return value that H_Hat received.
>>
>> I had to simplify this for him and go over this code again and again
>> before he realized that H_Hat() does not receive a return value from
>> DebugTrace() because H_Hat() is stuck in infinite recursion.
>>
>> I am still not sure that he gets this key point yet.
>>
>> int DebugTrace(u32 N, u32 M)
>> {
>> return ((int(*)(int))N)(M);
>> }
>>
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>>
>
> Actually, If you are refering the the Linz equivalent H_Hat (I think you
> are, but you misuse terms so much that it hard to be sure). At least
> once near the begining, when I presented my trace of how H_Hat(H_Hat)
> would execute as a Real Turing Machine, you sepcifically objected to the
> trace because you said, but we don't get to the else because Halts (That
> was its name at the time) aborted the execution, so H_Hat didn't get a
> chance to halt and show itself to be halting.
>
> I will note that the above example has no halt decider in it, and
> experiences Critical Underfined Behavior in the expression
> ((int(*)(int))N)(M); before we get into the recursion.
>
I rewrote it, my first rewrite had a bug that both you and Mike caught.
int DebugTrace(u32 P, u32 I)
{
((int(*)(int))P)(I);
return 1;
}
> I never said that this program doesn't get stuck in a recursive loop.
If we rename DebugTrace() to Halts() it still gets stuck in infinite
recursion.
If Halts is smart enough to detect infinite recursion then the simplest
thing for it to do is to abort this infinite recursion.
If it simply aborts this infinite recursion then H_Hat does receive a
return value. If it does not abort the infinite recursion then H_Hat
does receive a return value. H_Hat does receive a return value either way.
Do you get this or do you think that Halts should also automatically
repair code that incorrectly specifies infinite recursion?
--
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-25 22:52 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <IDFvH.65359$J92.36085@fx48.iad> |
| In reply to | #26011 |
On 11/25/20 10:03 PM, olcott wrote:
> On 11/25/2020 8:24 PM, Richard Damon wrote:
>> On 11/25/20 3:09 PM, olcott wrote:
>>
>>> You can be free to misinterpret that way.
>>> Many many times Richard was saying the the execution of H_Hat was
>>> incorrect because I did not show the return value that H_Hat received.
>>>
>>> I had to simplify this for him and go over this code again and again
>>> before he realized that H_Hat() does not receive a return value from
>>> DebugTrace() because H_Hat() is stuck in infinite recursion.
>>>
>>> I am still not sure that he gets this key point yet.
>>>
>>> int DebugTrace(u32 N, u32 M)
>>> {
>>> return ((int(*)(int))N)(M);
>>> }
>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = DebugTrace(P, P);
>>> if (Aborted)
>>> HALT
>>> else
>>> HERE: goto HERE;
>>> }
>>>
>>>
>>
>> Actually, If you are refering the the Linz equivalent H_Hat (I think you
>> are, but you misuse terms so much that it hard to be sure). At least
>> once near the begining, when I presented my trace of how H_Hat(H_Hat)
>> would execute as a Real Turing Machine, you sepcifically objected to the
>> trace because you said, but we don't get to the else because Halts (That
>> was its name at the time) aborted the execution, so H_Hat didn't get a
>> chance to halt and show itself to be halting.
>>
>> I will note that the above example has no halt decider in it, and
>> experiences Critical Underfined Behavior in the expression
>> ((int(*)(int))N)(M); before we get into the recursion.
>>
>
> I rewrote it, my first rewrite had a bug that both you and Mike caught.
>
> int DebugTrace(u32 P, u32 I)
> {
> ((int(*)(int))P)(I);
> return 1;
> }
>
>> I never said that this program doesn't get stuck in a recursive loop.
>
> If we rename DebugTrace() to Halts() it still gets stuck in infinite
> recursion.
>
> If Halts is smart enough to detect infinite recursion then the simplest
> thing for it to do is to abort this infinite recursion.
>
> If it simply aborts this infinite recursion then H_Hat does receive a
> return value. If it does not abort the infinite recursion then H_Hat
> does receive a return value. H_Hat does receive a return value either way.
>
> Do you get this or do you think that Halts should also automatically
> repair code that incorrectly specifies infinite recursion?
>
So is this what you are proposing:
void H_Hat(u32 P)
{
u32 aborted = Halts(P, P);
if(aborted)
HALT;
else
HERE: goto HERE;
}
We now have a function called Halts(u32 P, u32 I), that works by
stepping through and emulating the program. (But we no longer have code
for it, so going by specs)
It will stop that emulation if it detect infintite recursion.
You next paragraph seems garbled, I am not sure what you ACTUALLY mean.
You talk about abort or not, but either way H_hat gets a return value.
If you abort the WHOLE program it won't so that isn't what you mean, but
then what does not aborting mean which will still give an answer to
H_Hat? Not sure where 'repair code' comes from.
I will assume that you mean that it will terminate the emulation on
deteciton of the infinite recursion, and return a 1 to its caller, and
return a 0 if the emulation completes to a halt.
The big question is you have added some halt detection code but it is
very incomplete, I presume you are not yet calling this a halt detector
(even though it is called Halts) so it is not yet under the constraint
of answering in finite time (since there may be other causes of infinite
execution than just infinite recursion).
Note, that is the answer to H_Hat with infinite recursion detection only.
In this case, since Halts is not providing assurances of finite
execution time, and is not promising that its answer matches that actual
halting status of the program, it is fine for it to detect the infinite
recursion, at which point H_Hat will halt.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-25 21:53 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) |
| Message-ID | <875z5t6r32.fsf@bsb.me.uk> |
| In reply to | #25887 |
olcott <NoOne@NoWhere.com> writes: > On 11/24/2020 8:49 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct. >>>>>>> >>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and >>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt. >>>>>>> (Linz 1990:318) >>>>>> >>>>>> Good grief, you are using the notation almost correctly! But you open >>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz explains. >>>>>> Basically, Ĥ is constructed so that >>>>>> >>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no >>>>> >>>>> Ĥ does not copy its input. >>>> >>>> Yes it does. You cited the book that tell you it does. If you don't >>>> accept the "hat" construction from Linz, you have nothing more to say >>>> about the proof. >>> >>> As I have told you hundreds of times I simplify the counter-example to >>> make it conform to the general counter-example that does not copy its >>> input. >> >> You cited Linz and gave the desired behaviour of H exactly as Linz does. >> Linz says of Ĥ "This new machine takes its input wM and copies it". I >> wrote exactly what Linz writes using the slightly different notation you >> have adopted: >> >> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no >> >> To keep denying that Ĥ copies its input is just silly. Just admit it >> and move. We can then talk about your x86 code, and why that's wrong. > > To say that this code copies itself is dishonest: > > void H_Hat(u32 P) H_Hat is not Ĥ. You said "Ĥ does not copy its input" after a direct reference to Linz who says "This new machine takes its input wM and copies it". You made a silly mistake. Please just admit it and move on. Ideally, you would also address the consequences of the TM traces I wrote out that shows what happens after Ĥ copies its input. >> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a tape >> containing the encoding of Ĥ. What matters for this post is the >> execution trace of the Turing machine Ĥ, not the execution trace of your >> x86 code. The TM execution trace is written like this: > > No that does not matter. What does matter is that my H_Hat is > computationally equivalent to the Linz Ĥ. It has the exact same > relation between Halts and H_Hat as H has to Ĥ. That was the only > required element. Ĥ copies it's input. You were wrong to say that it does not. Admitting that one mistake would go along way to persuading people you are an honest interlocutor. > You have already agreed that computational equivalence is good enough > and now you try to back out of this agreement (as I always expected). Oh dear. Another staggeringly silly remark. Computational equivalence is "black box" equivalence. One function/algorithm/machine might work by copying it's input, and another might go about the same task in an entirely different way. The are computationally equivalent based on the results (for given inputs) not on the actions they take to get there. (I am happy to go deeper, and explain how it is that "computational equivalence" can be used inside functions to show why it is that your code also "copies its input", but I won't while you continue to dig yourself into the "Ĥ does not copy its input" hole.) -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 16:07 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) |
| Message-ID | <JNWdnaMeNcwPSCPCnZ2dnUU7-fPNnZ2d@giganews.com> |
| In reply to | #25972 |
On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>
>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>> (Linz 1990:318)
>>>>>>>
>>>>>>> Good grief, you are using the notation almost correctly! But you open
>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz explains.
>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>
>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>
>>>>>> Ĥ does not copy its input.
>>>>>
>>>>> Yes it does. You cited the book that tell you it does. If you don't
>>>>> accept the "hat" construction from Linz, you have nothing more to say
>>>>> about the proof.
>>>>
>>>> As I have told you hundreds of times I simplify the counter-example to
>>>> make it conform to the general counter-example that does not copy its
>>>> input.
>>>
>>> You cited Linz and gave the desired behaviour of H exactly as Linz does.
>>> Linz says of Ĥ "This new machine takes its input wM and copies it". I
>>> wrote exactly what Linz writes using the slightly different notation you
>>> have adopted:
>>>
>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>
>>> To keep denying that Ĥ copies its input is just silly. Just admit it
>>> and move. We can then talk about your x86 code, and why that's wrong.
>>
>> To say that this code copies itself is dishonest:
>>
>> void H_Hat(u32 P)
>
> H_Hat is not Ĥ. You said "Ĥ does not copy its input" after a direct
> reference to Linz who says "This new machine takes its input wM and
> copies it". You made a silly mistake. Please just admit it and move
> on.
What I said in the post that you are responding to is this:
On 11/24/2020 9:06 PM, olcott wrote:
> To say that this code copies itself is dishonest:
>
> void H_Hat(u32 P)
> {
> u32 Aborted = DebugTrace(P, P);
> if (Aborted)
> HALT
> else
> HERE: goto HERE;
> }
Thus your comment above is objectively verified as counter-factual.
> Ideally, you would also address the consequences of the TM traces I
> wrote out that shows what happens after Ĥ copies its input.
>
>>> H_Hat is not Ĥ. Ĥ is a Turing machine which can be run with a tape
>>> containing the encoding of Ĥ. What matters for this post is the
>>> execution trace of the Turing machine Ĥ, not the execution trace of your
>>> x86 code. The TM execution trace is written like this:
>>
>> No that does not matter. What does matter is that my H_Hat is
>> computationally equivalent to the Linz Ĥ. It has the exact same
>> relation between Halts and H_Hat as H has to Ĥ. That was the only
>> required element.
>
> Ĥ copies it's input. You were wrong to say that it does not. Admitting
> that one mistake would go along way to persuading people you are an
> honest interlocutor.
>
>> You have already agreed that computational equivalence is good enough
>> and now you try to back out of this agreement (as I always expected).
>
> Oh dear. Another staggeringly silly remark. Computational equivalence
> is "black box" equivalence. One function/algorithm/machine might work
> by copying it's input, and another might go about the same task in an
> entirely different way. The are computationally equivalent based on the
> results (for given inputs) not on the actions they take to get there.
>
> (I am happy to go deeper, and explain how it is that "computational
> equivalence" can be used inside functions to
> show why it is that your
> code also "copies its input", but I won't while you continue to dig
> yourself into the "Ĥ does not copy its input" hole.)
>
By "copies its input" I mean copying all the bytes of the machine
language at the address specified by P. The following code very
obviously does not do that.
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
_H_Hat()
[000004f7](01) 55 push ebp
[000004f8](02) 8bec mov ebp,esp
[000004fa](01) 51 push ecx
[000004fb](03) 8b4508 mov eax,[ebp+08]
[000004fe](01) 50 push eax
[000004ff](03) 8b4d08 mov ecx,[ebp+08]
[00000502](01) 51 push ecx
[00000503](05) e86ffeffff call 00000377
[00000508](03) 83c408 add esp,+08
[0000050b](03) 8945fc mov [ebp-04],eax
[0000050e](04) 837dfc00 cmp dword [ebp-04],+00
[00000512](02) 7403 jz 00000517
[00000514](01) f4 hlt
[00000515](02) eb02 jmp 00000519
[00000517](02) ebfe jmp 00000517
[00000519](02) 8be5 mov esp,ebp
[0000051b](01) 5d pop ebp
[0000051c](01) c3 ret
--
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-26 02:21 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) |
| Message-ID | <87lfeo6eoi.fsf@bsb.me.uk> |
| In reply to | #25974 |
olcott <NoOne@NoWhere.com> writes:
> On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>
>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>> (Linz 1990:318)
>>>>>>>>
>>>>>>>> Good grief, you are using the notation almost correctly! But you open
>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz explains.
>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>
>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>
>>>>>>> Ĥ does not copy its input.
>>>>>>
>>>>>> Yes it does. You cited the book that tell you it does. If you don't
>>>>>> accept the "hat" construction from Linz, you have nothing more to say
>>>>>> about the proof.
>>>>>
>>>>> As I have told you hundreds of times I simplify the counter-example to
>>>>> make it conform to the general counter-example that does not copy its
>>>>> input.
>>>>
>>>> You cited Linz and gave the desired behaviour of H exactly as Linz does.
>>>> Linz says of Ĥ "This new machine takes its input wM and copies it". I
>>>> wrote exactly what Linz writes using the slightly different notation you
>>>> have adopted:
>>>>
>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>
>>>> To keep denying that Ĥ copies its input is just silly. Just admit it
>>>> and move. We can then talk about your x86 code, and why that's wrong.
>>>
>>> To say that this code copies itself is dishonest:
>>>
>>> void H_Hat(u32 P)
>>
>> H_Hat is not Ĥ. You said "Ĥ does not copy its input" after a direct
>> reference to Linz who says "This new machine takes its input wM and
>> copies it". You made a silly mistake. Please just admit it and move
>> on.
>
>
> What I said in the post that you are responding to is this:
>
> On 11/24/2020 9:06 PM, olcott wrote:
>> To say that this code copies itself is dishonest:
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>
> Thus your comment above is objectively verified as counter-factual.
As usual, I can't tell if you are dumb or dishonest.
You were wrong to say "Ĥ does not copy its input" but you won't admit
it. Your attempts to get me to talk about H_Hat is a diversion from
your very simple and obvious error: Ĥ /does/ copy its input.
As I said, I /will/ explain why you are wrong about H_Hat as well, but
not while you refuse to admit your mistake about Ĥ.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 20:50 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) |
| Message-ID | <I42dnS9L4IVviiLCnZ2dnUU7-aXNnZ2d@giganews.com> |
| In reply to | #26006 |
On 11/25/2020 8:21 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>
>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>
>>>>>>>>> Good grief, you are using the notation almost correctly! But you open
>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz explains.
>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>
>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>
>>>>>>>> Ĥ does not copy its input.
>>>>>>>
>>>>>>> Yes it does. You cited the book that tell you it does. If you don't
>>>>>>> accept the "hat" construction from Linz, you have nothing more to say
>>>>>>> about the proof.
>>>>>>
>>>>>> As I have told you hundreds of times I simplify the counter-example to
>>>>>> make it conform to the general counter-example that does not copy its
>>>>>> input.
>>>>>
>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz does.
>>>>> Linz says of Ĥ "This new machine takes its input wM and copies it". I
>>>>> wrote exactly what Linz writes using the slightly different notation you
>>>>> have adopted:
>>>>>
>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>
>>>>> To keep denying that Ĥ copies its input is just silly. Just admit it
>>>>> and move. We can then talk about your x86 code, and why that's wrong.
>>>>
>>>> To say that this code copies itself is dishonest:
>>>>
>>>> void H_Hat(u32 P)
>>>
>>> H_Hat is not Ĥ. You said "Ĥ does not copy its input" after a direct
>>> reference to Linz who says "This new machine takes its input wM and
>>> copies it". You made a silly mistake. Please just admit it and move
>>> on.
>>
>>
>> What I said in the post that you are responding to is this:
>>
>> On 11/24/2020 9:06 PM, olcott wrote:
>>> To say that this code copies itself is dishonest:
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = DebugTrace(P, P);
>>> if (Aborted)
>>> HALT
>>> else
>>> HERE: goto HERE;
>>> }
>>
>> Thus your comment above is objectively verified as counter-factual.
>
> As usual, I can't tell if you are dumb or dishonest.
>
When I say something and your reply ignores what I just said and refers
to some other conversation as if it was responding to what I just said
this is very deceipitful.
--
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-27 17:02 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) |
| Message-ID | <87sg8u4try.fsf@bsb.me.uk> |
| In reply to | #26008 |
olcott <NoOne@NoWhere.com> writes:
> On 11/25/2020 8:21 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>>>
>>>>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w does not halt.
>>>>>>>>>>> (Linz 1990:318)
>>>>>>>>>>
>>>>>>>>>> Good grief, you are using the notation almost correctly! But you open
>>>>>>>>>> with a falsehood. H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz explains.
>>>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>>>
>>>>>>>>> Ĥ does not copy its input.
>>>>>>>>
>>>>>>>> Yes it does. You cited the book that tell you it does. If you don't
>>>>>>>> accept the "hat" construction from Linz, you have nothing more to say
>>>>>>>> about the proof.
>>>>>>>
>>>>>>> As I have told you hundreds of times I simplify the counter-example to
>>>>>>> make it conform to the general counter-example that does not copy its
>>>>>>> input.
>>>>>>
>>>>>> You cited Linz and gave the desired behaviour of H exactly as Linz does.
>>>>>> Linz says of Ĥ "This new machine takes its input wM and copies it". I
>>>>>> wrote exactly what Linz writes using the slightly different notation you
>>>>>> have adopted:
>>>>>>
>>>>>> Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>>>
>>>>>> To keep denying that Ĥ copies its input is just silly. Just admit it
>>>>>> and move. We can then talk about your x86 code, and why that's wrong.
>>>>>
>>>>> To say that this code copies itself is dishonest:
>>>>>
>>>>> void H_Hat(u32 P)
>>>>
>>>> H_Hat is not Ĥ. You said "Ĥ does not copy its input" after a direct
>>>> reference to Linz who says "This new machine takes its input wM and
>>>> copies it". You made a silly mistake. Please just admit it and move
>>>> on.
>>>
>>>
>>> What I said in the post that you are responding to is this:
>>>
>>> On 11/24/2020 9:06 PM, olcott wrote:
>>>> To say that this code copies itself is dishonest:
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Aborted = DebugTrace(P, P);
>>>> if (Aborted)
>>>> HALT
>>>> else
>>>> HERE: goto HERE;
>>>> }
>>>
>>> Thus your comment above is objectively verified as counter-factual.
>>
>> As usual, I can't tell if you are dumb or dishonest.
>
> When I say something and your reply ignores what I just said and
> refers to some other conversation as if it was responding to what I
> just said this is very deceipitful.
No, it means it is either a non-answer or a diversion. But suit
yourself. I am very happy that the record will show you cited Linz's H
and then said "Ĥ does not copy its input". That you refused to admit
that this was wrong is just fine by me. The more silly errors, childish
repetition, and outright lies linked to your name the better.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-23 17:34 +0000 |
| 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 | <cJ6dnWAZMckAbybCnZ2dnUU78R8AAAAA@brightview.co.uk> |
| In reply to | #25698 |
On 23/11/2020 13:08, olcott wrote: > On 11/23/2020 5:00 AM, André G. Isaak wrote: >> On 2020-11-22 12:04, olcott wrote: >>> On 11/22/2020 12:50 PM, André G. Isaak wrote: >>>> On 2020-11-22 11:28, olcott wrote: >>>>> 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). >>>> >>>> H_Hat(H_Hat) and Halts(H_Hat, H_Hat) are entirely different >>>> computations. How exactly does entering H_Hat(H_Hat) "actually >>>> specify" Halts(H_Hat, H_Hat)? >>> >>> When the halt decider is the whole emulation system then no code can >>> do anything that the halt decider cannot see. This aspect of the >>> x86utm operating system is already fully operational. >> >> This seems to go back to your claim that somehow your system >> automatically invokes Halts(main, NULL). >> >> This is an entirely nonsensical position. If you invoke Halts(main, >> NULL), then your Halt decider is not being asked about H_Hat(H_Hat). >> It is being asked about main(). Any functions in main() are simply >> part of the description that Halts() is being asked to evaluate rather >> than functions actually being executed. >> >> The fact that you need to invoke Halts(main, NULL) to get the correct >> behaviour for H_Hat(H_Hat) inside of main simply demonstrates that >> your simulator is not an accurate simulator. If it were, the behaviour >> of H_Hat(H_Hat) within main where main is *not* an input to Halts() >> would be identical to the behaviour of H_Hat(H_Hat) when it is >> emulated inside Halts(). >> >> André >> >> > > The bottom line is that I did show to H_Hat() would be decided correctly > > On 11/20/2020 9:30 PM, Mike Terry wrote: >> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >> described. This is all baby stuff. [So the correct halting decision >> for the input is non-halting]. > > https://groups.google.com/g/comp.theory/c/1uKuMgjxJTM/m/c3HEt-UWAAAJ STOP QUOTING ME OUT OF CONTEXT. THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position to falsely support your own. The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you gave (but have omitted from your misreprestation), in which Halts() was specified to be a pure UTM: no NeedsToBeAborted() calls etc.. OF COURSE that particular H_Hat() never halts, and nobody would say otherwise. Your H_Hat() above contains a Needs_To_Be_Aborted() call, making it A COMPLETELY DIFFERENT H_Hat. You must understand that just because you use the same label for two different objects, that does not actually make them the same object! I suggest to you that /deliberately/ misrepresenting someones position on a topic is a form of "bearing false witness" against that person, and so I'll be charitable and assume you are doing it because you have simply misunderstood the thread you are quoting. I expect you to stop this behaviour now you are aware. Mike.
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-22 12:03 -0700 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) |
| Message-ID | <rpecmj$tf7$1@dont-email.me> |
| In reply to | #25664 |
On 2020-11-22 10:47, olcott wrote: > 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(); Yes, that's because that's what *YOU* seem to be insisting upon. You reject the idea that we can simulate (as opposed to running the halt decider) the behaviour of H_Hat(H_Hat) such that line 15 *is* present in the call to Halts() within H_Hat. You insist that when we simulate this, line 15 is somehow turned off "globally" and that you must either run *everything* inside Halts() with line 15 globally present, or run everything inside Simulate() with line 15 globally absent. But if Halts() and Simulates() are different functions, then H_Hat() can be defined such that it always calls Halts() and never calls Simulates(), which is what the H ~ H_Hat relationship requires. So when we Simulate(H_Hat, H_Hat), Simulates() calls H_Hat(H_Hat) which calls Halts(H_Hat, H_Hat). You seem to want it to be the case that if (H_Hat, H_Hat) is used as the input to Simulate() that H_Hat suddenly starts calling Simulate(H_Hat, H_Hat) instead of Halts(H_Hat, H_Hat) 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 13:14 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](black cats are black) |
| Message-ID | <vsOdncsIWN8EJSfCnZ2dnUU7-dnNnZ2d@giganews.com> |
| In reply to | #25670 |
On 11/22/2020 1:03 PM, André G. Isaak wrote: > On 2020-11-22 10:47, olcott wrote: >> 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(); > > Yes, that's because that's what *YOU* seem to be insisting upon. You > reject the idea that we can simulate (as opposed to running the halt > decider) the behaviour of H_Hat(H_Hat) such that line 15 *is* present in > the call to Halts() within H_Hat. I reject the idea that making changes the state transitions that I specified is any rebuttal to the state transtions that I specified. The fact that you can screw up an otherwise correct halt decider is not the slightest trace of evidence that the original halt dedcider was not correct. > You insist that when we simulate this, line 15 is somehow turned off > "globally" and that you must either run *everything* inside Halts() with > line 15 globally present, or run everything inside Simulate() with line > 15 globally absent. Yes this is the only conclusive way to prove that the halt decider is correct. 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. No amount of convoluted nonsence counts as any sort of rebuttal to this. > But if Halts() and Simulates() are different functions, then H_Hat() can > be defined such that it always calls Halts() and never calls > Simulates(), which is what the H ~ H_Hat relationship requires. > > So when we Simulate(H_Hat, H_Hat), Simulates() calls H_Hat(H_Hat) which > calls Halts(H_Hat, H_Hat). > > You seem to want it to be the case that if (H_Hat, H_Hat) is used as the > input to Simulate() that H_Hat suddenly starts calling Simulate(H_Hat, > H_Hat) instead of Halts(H_Hat, H_Hat) > > André > 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. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [standalone]
Page 7 of 7 — ← Prev page 1 2 3 4 5 6 [7]
Back to top | Article view | comp.theory
csiph-web