Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #25604 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-11-21 13:19 -0600 |
| Last post | 2020-11-22 13:14 -0600 |
| Articles | 20 on this page of 137 — 8 participants |
Back to article view | Back to comp.theory
It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 13:19 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-21 13:06 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 15:35 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-21 23:46 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 18:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-22 01:14 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2] André G. Isaak <agisaak@gm.invalid> - 2020-11-22 03:48 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-22 08:17 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2] André G. Isaak <agisaak@gm.invalid> - 2020-11-22 07:58 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) olcott <NoOne@NoWhere.com> - 2020-11-22 10:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 10:10 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) olcott <NoOne@NoWhere.com> - 2020-11-22 11:47 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 13:14 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 12:28 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 13:44 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 12:56 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 14:23 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 13:28 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 16:21 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 16:25 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 18:09 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-22 17:35 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 20:03 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Alan Mackenzie <acm@muc.de> - 2020-11-23 12:54 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-23 07:09 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 08:38 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 07:55 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 10:19 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 09:52 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 12:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 08:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:33 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:31 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:14 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-23 12:08 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 11:50 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 13:04 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 04:00 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-23 07:08 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 08:19 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 09:49 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 09:44 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 02:26 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 21:30 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 15:22 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 09:47 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 11:08 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 10:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 13:07 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 02:49 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 21:06 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 22:45 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-24 21:58 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-24 23:05 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 07:17 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 08:02 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:01 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 09:19 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:55 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 11:37 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 13:03 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 12:13 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 14:27 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 13:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 14:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 14:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 21:05 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 15:24 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 17:32 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 17:18 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:19 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 20:55 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 18:26 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 00:26 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 18:49 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:30 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 20:43 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:18 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 04:12 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 22:30 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 09:22 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) olcott <NoOne@NoWhere.com> - 2020-11-26 08:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 10:43 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) olcott <NoOne@NoWhere.com> - 2020-11-26 09:49 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 09:09 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 17:21 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 11:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 10:29 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 12:41 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 13:47 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 13:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 16:02 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 15:12 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 13:42 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 15:56 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 14:14 -0800
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 16:20 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 19:11 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 18:25 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 20:17 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 17:22 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 16:34 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 18:09 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 17:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 19:06 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 18:10 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 23:11 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 17:41 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 01:34 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself) olcott <NoOne@NoWhere.com> - 2020-11-26 20:45 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:09 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself [verified]) olcott <NoOne@NoWhere.com> - 2020-11-27 12:14 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 11:58 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 13:21 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 16:35 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood) olcott <NoOne@NoWhere.com> - 2020-11-26 08:26 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 10:51 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 19:10 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 16:16 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 10:44 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 18:55 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 13:24 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 19:43 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 14:09 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Jeff Barnett <jbb@notatt.com> - 2020-11-25 14:30 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 21:24 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 21:03 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:52 -0500
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 21:53 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-25 16:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 02:21 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-25 20:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:02 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:34 +0000
Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 12:03 -0700
Re: It is known that a correct halt decider must return false (in this case)[V2](black cats are black) olcott <NoOne@NoWhere.com> - 2020-11-22 13:14 -0600
Page 5 of 7 — ← Prev page 1 2 3 4 [5] 6 7 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 22:30 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <7YednRDmR8LlsiLCnZ2dnUU7-VHNnZ2d@giganews.com> |
| In reply to | #26017 |
On 11/25/2020 10:12 PM, Mike Terry wrote:
> On 26/11/2020 02:43, olcott wrote:
>> On 11/25/2020 7:30 PM, Richard Damon wrote:
>>> On 11/25/20 7:49 PM, olcott wrote:
>>>
>>>> I am sure that Richard still does not get this:
>>>>
>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>> 1) There is the possibility that a halt decider
>>>>> might choose to quit enumerating the calculation
>>>>> steps earlier than the UTM
>>>>
>>>>> ...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.
>>>>
>>>>
>>>>
>>>
>>> I fully understand it, and as Mike said, it is not applicable to this
>>> problem.
>>>
>>> The key is he was talking about the steps taken INSIDE the emulation,
>>> which yes, there is no diference base on what is outside it.
>>>
>>> There IS a difference to what happens OUTSIDE the emulation, to the
>>> machine that is CALLING the UTM/Halt Decider.
>>>
>>> Now, because of the recursion that is happening, many of the machines
>>> are actually in both situations.
>>>
>>> Thus
>>>
>>> int H_UTM(P)
>>> {
>>> if(UTM(P, P))
>>> while(1) ;
>>> else
>>> HALT;
>>> }
>>>
>>> is a different computation from
>>>
>>> int H_Halt(P)
>>> {
>>> if(Halt_Detector(P,P))
>>> while(1);
>>> else
>>> HALT;
>>> }
>>>
>>> (irrespective of what P is so we are talking the recursive stuff yet)
>>
>>
>> That is an incorrect way of specifying it.
>> Here is the correct way.
>
> Richard does not specify the input data P for the calculation, so I
> would have said H_UTM(H_UTM) is a different computation from
> H_Halt(H_Halt). (Or that H_UTM is a different machine from H_Halt, or
> maybe supplied the main() setup/call to make the input clear. We all
> understand what was meant though...)
>
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> DebugTrace(P, P);
>> HALT;
>> }
>>
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = Halts(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> Halts(P, P);
>> HALT;
>> }
>>
> That's just asking for confusion, using H_Hat for two quite different
> machines.
>
> But... the two machines you show above DO have different calculations as
> Richard was saying. (I'm not sure if that's what you were trying to say.)
>
>
>>
>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>> ...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.
>>
>> Thus when Halts() decides to abort H_Hat it is the same H_Hat as the
>> H_Hat that DebugTrace(P, P) is merely emulating.
>>
> That's ridiculous - the emulations are not even looking at the same
> machine, let alone the same calculation. I don't think you understand
> what I said at all. (No wonder you sounded so uncharacteristically
> happy when I said it! Mystery explained... :) )
>
> I think I even put in a caveat that covered this exact scenario, because
> I suspected you would want to misinterpret what I said in this way. 8-/
>
>
> Mike.
> [Wow, 20 chars! Maybe a new record...]
>
01 void H_Hat(u32 P)
02 {
03 u32 Aborted = DebugTrace(P, P);
04 if (Aborted)
05 HALT
06 else
07 HERE: goto HERE;
08 }
The H_Hat() that calls DebugTrace() is computationally identical to the
H_Hat() that calls Halts() because neither one of them ever gets past
line 03.
You are the only one that I know smart enough to see this. Ben would
never say it if he did see it. Richard does not understand these things
well enough to see this.
--
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-26 09:22 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) |
| Message-ID | <kSOvH.220802$gR8.143048@fx45.iad> |
| In reply to | #26019 |
On 11/25/20 11:30 PM, olcott wrote:
>>
>
> 01 void H_Hat(u32 P)
> 02 {
> 03 u32 Aborted = DebugTrace(P, P);
> 04 if (Aborted)
> 05 HALT
> 06 else
> 07 HERE: goto HERE;
> 08 }
>
> The H_Hat() that calls DebugTrace() is computationally identical to the
> H_Hat() that calls Halts() because neither one of them ever gets past
> line 03.
>
> You are the only one that I know smart enough to see this. Ben would
> never say it if he did see it. Richard does not understand these things
> well enough to see this.
>
The only possible reason to NOT get past line 3 when calling Halts, (if
Halts is supposed to be a proper halt detector), is because Halts is
broken and doesn't meet its requirements.
YOu may complain that that isn't what Halts is supposed to be in this
example, but that is EXACTLY why I said you shouldn't use this naming style.
YOu have already been found 'Guilty' of trying to sneak in the comments
about one version of a function to when it was being used as a different
functions.
The use of obviously misleading names is a good sign that you are
intentionally trying to pull a scam here.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 08:33 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) |
| Message-ID | <IKmdnZkItY0jISLCnZ2dnUU7-RvNnZ2d@giganews.com> |
| In reply to | #26023 |
On 11/26/2020 8:22 AM, Richard Damon wrote:
> On 11/25/20 11:30 PM, olcott wrote:
>>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 u32 Aborted = DebugTrace(P, P);
>> 04 if (Aborted)
>> 05 HALT
>> 06 else
>> 07 HERE: goto HERE;
>> 08 }
>>
>> The H_Hat() that calls DebugTrace() is computationally identical to the
>> H_Hat() that calls Halts() because neither one of them ever gets past
>> line 03.
>>
>> You are the only one that I know smart enough to see this. Ben would
>> never say it if he did see it. Richard does not understand these things
>> well enough to see this.
>>
>
> The only possible reason to NOT get past line 3 when calling Halts, (if
> Halts is supposed to be a proper halt detector), is because Halts is
> broken and doesn't meet its requirements.
I am probably going to stop responding to you because you do not have
enough basic knowledge of things like infinite recursion to ever
actually understand what I am saying.
It is ridiculous to assume that a function designed to detect Halting
would be required rewrite the code that it is testing to remove the
infinite recursion of this code.
> YOu may complain that that isn't what Halts is supposed to be in this
> example, but that is EXACTLY why I said you shouldn't use this naming style.
>
> YOu have already been found 'Guilty' of trying to sneak in the comments
> about one version of a function to when it was being used as a different
> functions.
>
> The use of obviously misleading names is a good sign that you are
> intentionally trying to pull a scam here.
>
--
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-26 10:43 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) |
| Message-ID | <R2QvH.5642$0h3.1755@fx15.iad> |
| In reply to | #26025 |
On 11/26/20 9:33 AM, olcott wrote:
> On 11/26/2020 8:22 AM, Richard Damon wrote:
>> On 11/25/20 11:30 PM, olcott wrote:
>>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03 u32 Aborted = DebugTrace(P, P);
>>> 04 if (Aborted)
>>> 05 HALT
>>> 06 else
>>> 07 HERE: goto HERE;
>>> 08 }
>>>
>>> The H_Hat() that calls DebugTrace() is computationally identical to the
>>> H_Hat() that calls Halts() because neither one of them ever gets past
>>> line 03.
>>>
>>> You are the only one that I know smart enough to see this. Ben would
>>> never say it if he did see it. Richard does not understand these things
>>> well enough to see this.
>>>
>>
>> The only possible reason to NOT get past line 3 when calling Halts, (if
>> Halts is supposed to be a proper halt detector), is because Halts is
>> broken and doesn't meet its requirements.
>
> I am probably going to stop responding to you because you do not have
> enough basic knowledge of things like infinite recursion to ever
> actually understand what I am saying.
>
> It is ridiculous to assume that a function designed to detect Halting
> would be required rewrite the code that it is testing to remove the
> infinite recursion of this code.
>
WHERE DO I SAY RE-WRITE CODE. Maybe the way you are implementing your
halt detector is SO wrong that it has gotten itself into a jam, but then
that is YOUR problem.
My expectation is that when I execute the call Halts(P, I) that the
Halts function will try to determine if P(I) will complete in finite
time or not.
One way to attempt it would be, as you seem to be doing, is it step
through the code and try to detect non-halting behavior.
The key point that you seem to be missing, perhaps because you are doing
the stepping right, is when THAT halt decider decides that the code that
IT is running has shown non-halting behavior, it can just stop running
it and return to Halts caller, after all, all that simulation was being
done under its control, so it is free to just stop it and return with
the code for this code just won't stop.
One issue you may be running into is that you are just using the virtual
86 mode of the processor, and haven't taken enough care to make that
work recursively. It is harder to write a nested VM system than a
non-nested one, but that is what you will need to implement if that is
your plan (complicated by the fact that your program is probably running
as a protected mode application inside a real OS, that may limit what
you are able to do without loading OS extensions.
Maybe you have done this, we don't know because you seem to assume that
everyone but you is to stupid to comprehend this.
Jumping to the end, ultimately your Halts function, at least when it
claims to be a real halting decider, if you every think you get there,
is going to need to simulate this computation, detect that there is now
an potentially infinite recursion, stop that recursion and then figure
out what that mean the program under test would do. It then needs to
return that answer to its caller.
Since the program under test is the exact same computation as the
caller, we know that the answer, if the halt detecter worked, will match
what the caller ends up doing. Which as been shown, it will alwas=ys be
wrong.
Where you logic goes wrong is that when we look at where that infinite
recursion was detected, it was detected inside another call to Halts,
that if we gave it a bit more time to run, would have broken the
recursion itself, and returned to its caller. You 'logic' about
recursion without a conditional doesn't apply here, because the nested
halt detector provided the needed conditonal to teminate the recursion.
The ultimate problem is that your halt decider has no logic to break up
the trap of infinite recusion except to follow it, which will either
cause your halt decider to fail to make the decision in finite time, or
it will need to make it decision without have been able to see the
actual behavior of the machine to the return values, and thus easily wrong.
This is a fundamental flaw in the base design of you Halt Decider. This
flaw is well known. This might be called the Step 1 to working on a halt
decider. The next step is to look at what cases it doesn't handle,
figure out a method to try to handle them, and then move on to a Step 2
halt decider (which will have its own problems)
I have mentioned several time, one way to go to this Step 2. When you
build such a Halt Decider, there will still be many cases you can't
handle (I don't recall much talk about how you plan to deal with the
more mundane infinite loops, as you focus has been on this Recursion).
One thing that the Step 2 decider suggested give you, is that it
detects the Linz system, and allows you to define an alternate version
of the Halting Problem that deals with Linz. Because it IS an alternate
version, Linz doesn't claim to apply to it, nor does it impact a lot of
the math that uses the halting problem in it. But it is a reasonable
base for many practical questions.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 09:49 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) |
| Message-ID | <lbWdnUyeSpQZUyLCnZ2dnUU7-RHNnZ2d@giganews.com> |
| In reply to | #26026 |
On 11/26/2020 9:43 AM, Richard Damon wrote:
> On 11/26/20 9:33 AM, olcott wrote:
>> On 11/26/2020 8:22 AM, Richard Damon wrote:
>>> On 11/25/20 11:30 PM, olcott wrote:
>>>>>
>>>>
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03 u32 Aborted = DebugTrace(P, P);
>>>> 04 if (Aborted)
>>>> 05 HALT
>>>> 06 else
>>>> 07 HERE: goto HERE;
>>>> 08 }
>>>>
>>>> The H_Hat() that calls DebugTrace() is computationally identical to the
>>>> H_Hat() that calls Halts() because neither one of them ever gets past
>>>> line 03.
>>>>
>>>> You are the only one that I know smart enough to see this. Ben would
>>>> never say it if he did see it. Richard does not understand these things
>>>> well enough to see this.
>>>>
>>>
>>> The only possible reason to NOT get past line 3 when calling Halts, (if
>>> Halts is supposed to be a proper halt detector), is because Halts is
>>> broken and doesn't meet its requirements.
>>
>> I am probably going to stop responding to you because you do not have
>> enough basic knowledge of things like infinite recursion to ever
>> actually understand what I am saying.
>>
>> It is ridiculous to assume that a function designed to detect Halting
>> would be required rewrite the code that it is testing to remove the
>> infinite recursion of this code.
>>
>
> WHERE DO I SAY RE-WRITE CODE. Maybe the way you are implementing your
> halt detector is SO wrong that it has gotten itself into a jam, but then
> that is YOUR problem.
>
When you expect Halts() to return a value to H_Hat() that is exactly the
same as expecting DebugTrace() to return a value to H_Hat(), thus
proving that you must be clueless about how infinite recursion works.
int DebugTrace(u32 P, u32 I)
{
((int(*)(int))P)(I);
return 1;
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-11-26 09:09 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) |
| Message-ID | <4c2fa05d-3579-4065-b5dc-9056f26bb589n@googlegroups.com> |
| In reply to | #26028 |
On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
> On 11/26/2020 9:43 AM, Richard Damon wrote:
> > On 11/26/20 9:33 AM, olcott wrote:
> >> On 11/26/2020 8:22 AM, Richard Damon wrote:
> >>> On 11/25/20 11:30 PM, olcott wrote:
> >>>>>
> >>>>
> >>>> 01 void H_Hat(u32 P)
> >>>> 02 {
> >>>> 03 u32 Aborted = DebugTrace(P, P);
> >>>> 04 if (Aborted)
> >>>> 05 HALT
> >>>> 06 else
> >>>> 07 HERE: goto HERE;
> >>>> 08 }
> >>>>
> >>>> The H_Hat() that calls DebugTrace() is computationally identical to the
> >>>> H_Hat() that calls Halts() because neither one of them ever gets past
> >>>> line 03.
> >>>>
> >>>> You are the only one that I know smart enough to see this. Ben would
> >>>> never say it if he did see it. Richard does not understand these things
> >>>> well enough to see this.
> >>>>
> >>>
> >>> The only possible reason to NOT get past line 3 when calling Halts, (if
> >>> Halts is supposed to be a proper halt detector), is because Halts is
> >>> broken and doesn't meet its requirements.
> >>
> >> I am probably going to stop responding to you because you do not have
> >> enough basic knowledge of things like infinite recursion to ever
> >> actually understand what I am saying.
> >>
> >> It is ridiculous to assume that a function designed to detect Halting
> >> would be required rewrite the code that it is testing to remove the
> >> infinite recursion of this code.
> >>
> >
> > WHERE DO I SAY RE-WRITE CODE. Maybe the way you are implementing your
> > halt detector is SO wrong that it has gotten itself into a jam, but then
> > that is YOUR problem.
> >
> When you expect Halts() to return a value to H_Hat() that is exactly the
> same as expecting DebugTrace() to return a value to H_Hat(), thus
> proving that you must be clueless about how infinite recursion works.
>
>
> int DebugTrace(u32 P, u32 I)
> {
> ((int(*)(int))P)(I);
> return 1;
> }
>
> void H_Hat(u32 P)
> {
> u32 Aborted = DebugTrace(P, P);
> if (Aborted)
> HALT
> else
> HERE: goto HERE;
> }
>
> int main()
> {
> u32 P = (u32)H_Hat;
> DebugTrace(P, P);
> HALT;
> }
>
That's infinite recusion, right enough.
But if Halts() detects the infinite recursion and reports "Doesn't halt"
then it is no longer infinite recursion.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-26 17:21 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) |
| Message-ID | <87ft4w5913.fsf@bsb.me.uk> |
| In reply to | #26035 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
<cut>
>> int DebugTrace(u32 P, u32 I)
>> {
>> ((int(*)(int))P)(I);
>> return 1;
>> }
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> DebugTrace(P, P);
>> HALT;
>> }
(The indentation was lost before I replied, honest, guv.)
> That's infinite recusion, right enough.
> But if Halts() detects the infinite recursion and reports "Doesn't halt"
> then it is no longer infinite recursion.
Which is the key to PO's halting problem 2.0. A program is non-halting
not because it doesn't halt, but because it wouldn't halt if weren't
halted. Simples!
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 11:50 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <ELGdnQFzyJJHdyLCnZ2dnUU7-XPNnZ2d@giganews.com> |
| In reply to | #26036 |
On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
> <cut>
>>> int DebugTrace(u32 P, u32 I)
>>> {
>>> ((int(*)(int))P)(I);
>>> return 1;
>>> }
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = DebugTrace(P, P);
>>> if (Aborted)
>>> HALT
>>> else
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> u32 P = (u32)H_Hat;
>>> DebugTrace(P, P);
>>> HALT;
>>> }
>
> (The indentation was lost before I replied, honest, guv.)
>
>> That's infinite recusion, right enough.
>> But if Halts() detects the infinite recursion and reports "Doesn't halt"
>> then it is no longer infinite recursion.
>
> Which is the key to PO's halting problem 2.0. A program is non-halting
> not because it doesn't halt, but because it wouldn't halt if weren't
> halted. Simples!
>
Every program / (TMD being simulated) that does not halt unless it is
forced to halt is a non halting program / (TMD being simulated).
Every program / (TMD being simulated) that halts without being forced to
halt is a halting program / (TMD being simulated).
Thus dividing inputs into halting and not halting as the actual Halting
Problem itself requires.
The Halting problem is a problem in computer science. The problem is
looking at a computer program and finding out if the program is going to
run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-11-26 10:29 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <2c3095b6-3e45-457e-a3a5-eb01142720f3n@googlegroups.com> |
| In reply to | #26038 |
On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
> > Malcolm McLean <malcolm.ar...@gmail.com> writes:
> >
> >> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
> > <cut>
> >>> int DebugTrace(u32 P, u32 I)
> >>> {
> >>> ((int(*)(int))P)(I);
> >>> return 1;
> >>> }
> >>>
> >>> void H_Hat(u32 P)
> >>> {
> >>> u32 Aborted = DebugTrace(P, P);
> >>> if (Aborted)
> >>> HALT
> >>> else
> >>> HERE: goto HERE;
> >>> }
> >>>
> >>> int main()
> >>> {
> >>> u32 P = (u32)H_Hat;
> >>> DebugTrace(P, P);
> >>> HALT;
> >>> }
> >
> > (The indentation was lost before I replied, honest, guv.)
> >
> >> That's infinite recusion, right enough.
> >> But if Halts() detects the infinite recursion and reports "Doesn't halt"
> >> then it is no longer infinite recursion.
> >
> > Which is the key to PO's halting problem 2.0. A program is non-halting
> > not because it doesn't halt, but because it wouldn't halt if weren't
> > halted. Simples!
> >
> Every program / (TMD being simulated) that does not halt unless it is
> forced to halt is a non halting program / (TMD being simulated).
>
> Every program / (TMD being simulated) that halts without being forced to
> halt is a halting program / (TMD being simulated).
>
The point of the H_Hat proof is that "Halts()" is fed to itself. So if Halts() terminates
what would otherwise be an infinite recursion, as it must do if it is to be a
halt detector, the termination is also in the Halts() that is fed to Halts().
There's no way out. But I thought that had been agreed long ago.
>
> Thus dividing inputs into halting and not halting as the actual Halting
> Problem itself requires.
>
> The Halting problem is a problem in computer science. The problem is
> looking at a computer program and finding out if the program is going to
> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>
You've been mislead by the term "halting problem". There are plenty of
genuinely open problems in computer science, like whether large integers can
be factored other than by exhaustive search, or whether graphs can be laid
out on two dimensional visual representations in polynomial time. The
"halting problem", despite its name, is not one of these problems.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 12:41 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <wIudneo02KJXayLCnZ2dnUU7-YXNnZ2d@giganews.com> |
| In reply to | #26041 |
On 11/26/2020 12:29 PM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>
>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>> <cut>
>>>>> int DebugTrace(u32 P, u32 I)
>>>>> {
>>>>> ((int(*)(int))P)(I);
>>>>> return 1;
>>>>> }
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>> u32 Aborted = DebugTrace(P, P);
>>>>> if (Aborted)
>>>>> HALT
>>>>> else
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> u32 P = (u32)H_Hat;
>>>>> DebugTrace(P, P);
>>>>> HALT;
>>>>> }
>>>
>>> (The indentation was lost before I replied, honest, guv.)
>>>
>>>> That's infinite recusion, right enough.
>>>> But if Halts() detects the infinite recursion and reports "Doesn't halt"
>>>> then it is no longer infinite recursion.
>>>
>>> Which is the key to PO's halting problem 2.0. A program is non-halting
>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>> halted. Simples!
>>>
>> Every program / (TMD being simulated) that does not halt unless it is
>> forced to halt is a non halting program / (TMD being simulated).
>>
>> Every program / (TMD being simulated) that halts without being forced to
>> halt is a halting program / (TMD being simulated).
>>
> The point of the H_Hat proof is that "Halts()" is fed to itself. So if Halts() terminates
> what would otherwise be an infinite recursion, as it must do if it is to be a
> halt detector, the termination is also in the Halts() that is fed to Halts().
>
> There's no way out. But I thought that had been agreed long ago.
Those words seem incoherent to me.
>>
>> Thus dividing inputs into halting and not halting as the actual Halting
>> Problem itself requires.
>>
>> The Halting problem is a problem in computer science. The problem is
>> looking at a computer program and finding out if the program is going to
>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>
> You've been mislead by the term "halting problem". There are plenty of
> genuinely open problems in computer science, like whether large integers can
> be factored other than by exhaustive search, or whether graphs can be laid
> out on two dimensional visual representations in polynomial time. The
> "halting problem", despite its name, is not one of these problems.
>
The input to H will be the description (encoded in some form)
of M, say WM, as well as the input w. The requirement is then
that, given any (WM, w), the Turing machine H will halt with
either a yes or no answer.
H.q0 wMw ⊢* H.yes if M applied to w halts, and
H.q0 wMw ⊢* H.no if M applied to w would not halt.
(Linz 1990:318)
--
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-26 13:47 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <bLSvH.42347$1t6.41820@fx40.iad> |
| In reply to | #26042 |
On 11/26/20 1:41 PM, olcott wrote:
> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>
>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>> <cut>
>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>> {
>>>>>> ((int(*)(int))P)(I);
>>>>>> return 1;
>>>>>> }
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>> if (Aborted)
>>>>>> HALT
>>>>>> else
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 P = (u32)H_Hat;
>>>>>> DebugTrace(P, P);
>>>>>> HALT;
>>>>>> }
>>>>
>>>> (The indentation was lost before I replied, honest, guv.)
>>>>
>>>>> That's infinite recusion, right enough.
>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>> halt"
>>>>> then it is no longer infinite recursion.
>>>>
>>>> Which is the key to PO's halting problem 2.0. A program is non-halting
>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>> halted. Simples!
>>>>
>>> Every program / (TMD being simulated) that does not halt unless it is
>>> forced to halt is a non halting program / (TMD being simulated).
>>>
>>> Every program / (TMD being simulated) that halts without being forced to
>>> halt is a halting program / (TMD being simulated).
>>>
>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>> Halts() terminates
>> what would otherwise be an infinite recursion, as it must do if it is
>> to be a
>> halt detector, the termination is also in the Halts() that is fed to
>> Halts().
>>
>> There's no way out. But I thought that had been agreed long ago.
>
> Those words seem incoherent to me.
Sounds about right for you
>
>>>
>>> Thus dividing inputs into halting and not halting as the actual Halting
>>> Problem itself requires.
>>>
>>> The Halting problem is a problem in computer science. The problem is
>>> looking at a computer program and finding out if the program is going to
>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>
>> You've been mislead by the term "halting problem". There are plenty of
>> genuinely open problems in computer science, like whether large
>> integers can
>> be factored other than by exhaustive search, or whether graphs can be
>> laid
>> out on two dimensional visual representations in polynomial time. The
>> "halting problem", despite its name, is not one of these problems.
>>
>
> The input to H will be the description (encoded in some form)
> of M, say WM, as well as the input w. The requirement is then
> that, given any (WM, w), the Turing machine H will halt with
> either a yes or no answer.
>
> H.q0 wMw ⊢* H.yes if M applied to w halts, and
> H.q0 wMw ⊢* H.no if M applied to w would not halt.
> (Linz 1990:318)
Yes, that is the statement of the Halting Problem, but Linz 'solved' it
on one sense by showing that there was NO unversal solutions to the problem.
There can still be work on special cases, which don't need to be
universal, but that is really a different sort of problem.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 13:07 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <ycqdnZ03aq9uYSLCnZ2dnUU7-enNnZ2d@giganews.com> |
| In reply to | #26043 |
On 11/26/2020 12:47 PM, Richard Damon wrote:
> On 11/26/20 1:41 PM, olcott wrote:
>> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>>
>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>> <cut>
>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>> {
>>>>>>> ((int(*)(int))P)(I);
>>>>>>> return 1;
>>>>>>> }
>>>>>>>
>>>>>>> void H_Hat(u32 P)
>>>>>>> {
>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>> if (Aborted)
>>>>>>> HALT
>>>>>>> else
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> u32 P = (u32)H_Hat;
>>>>>>> DebugTrace(P, P);
>>>>>>> HALT;
>>>>>>> }
>>>>>
>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>
>>>>>> That's infinite recusion, right enough.
>>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>>> halt"
>>>>>> then it is no longer infinite recursion.
>>>>>
>>>>> Which is the key to PO's halting problem 2.0. A program is non-halting
>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>> halted. Simples!
>>>>>
>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>
>>>> Every program / (TMD being simulated) that halts without being forced to
>>>> halt is a halting program / (TMD being simulated).
>>>>
>>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>>> Halts() terminates
>>> what would otherwise be an infinite recursion, as it must do if it is
>>> to be a
>>> halt detector, the termination is also in the Halts() that is fed to
>>> Halts().
>>>
>>> There's no way out. But I thought that had been agreed long ago.
>>
>> Those words seem incoherent to me.
>
> Sounds about right for you
>>
>>>>
>>>> Thus dividing inputs into halting and not halting as the actual Halting
>>>> Problem itself requires.
>>>>
>>>> The Halting problem is a problem in computer science. The problem is
>>>> looking at a computer program and finding out if the program is going to
>>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>>
>>> You've been mislead by the term "halting problem". There are plenty of
>>> genuinely open problems in computer science, like whether large
>>> integers can
>>> be factored other than by exhaustive search, or whether graphs can be
>>> laid
>>> out on two dimensional visual representations in polynomial time. The
>>> "halting problem", despite its name, is not one of these problems.
>>>
>>
>> The input to H will be the description (encoded in some form)
>> of M, say WM, as well as the input w. The requirement is then
>> that, given any (WM, w), the Turing machine H will halt with
>> either a yes or no answer.
>>
>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>> (Linz 1990:318)
>
> Yes, that is the statement of the Halting Problem, but Linz 'solved' it
> on one sense by showing that there was NO unversal solutions to the problem.
>
> There can still be work on special cases, which don't need to be
> universal, but that is really a different sort of problem.
>
(1) The code below is obviously infinitely recursive.
(2) Halts() has identical behavior to DebugStep() until Halts() decides
to terminate its input.
∴ swapping function calls to Halts() for the two function calls to
DebugStep() makes the function call to Halts() from H_Hat infinitely
recursive.
∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
correct not halting decision.
int DebugTrace(u32 P, u32 I)
{
((int(*)(int))P)(I);
return 1;
}
01 void H_Hat(u32 P)
02 {
03 u32 Aborted = DebugTrace(P, P);
04 if (Aborted)
05 HALT
06 else
07 HERE: goto HERE;
08 }
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
--
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-26 16:02 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <DJUvH.77496$ql4.4250@fx39.iad> |
| In reply to | #26044 |
On 11/26/20 2:07 PM, olcott wrote:
> On 11/26/2020 12:47 PM, Richard Damon wrote:
>> On 11/26/20 1:41 PM, olcott wrote:
>>> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>>>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>>>
>>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>>> <cut>
>>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>>> {
>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>> return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>> if (Aborted)
>>>>>>>> HALT
>>>>>>>> else
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>> DebugTrace(P, P);
>>>>>>>> HALT;
>>>>>>>> }
>>>>>>
>>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>>
>>>>>>> That's infinite recusion, right enough.
>>>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>>>> halt"
>>>>>>> then it is no longer infinite recursion.
>>>>>>
>>>>>> Which is the key to PO's halting problem 2.0. A program is
>>>>>> non-halting
>>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>>> halted. Simples!
>>>>>>
>>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>>
>>>>> Every program / (TMD being simulated) that halts without being
>>>>> forced to
>>>>> halt is a halting program / (TMD being simulated).
>>>>>
>>>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>>>> Halts() terminates
>>>> what would otherwise be an infinite recursion, as it must do if it is
>>>> to be a
>>>> halt detector, the termination is also in the Halts() that is fed to
>>>> Halts().
>>>>
>>>> There's no way out. But I thought that had been agreed long ago.
>>>
>>> Those words seem incoherent to me.
>>
>> Sounds about right for you
>>>
>>>>>
>>>>> Thus dividing inputs into halting and not halting as the actual
>>>>> Halting
>>>>> Problem itself requires.
>>>>>
>>>>> The Halting problem is a problem in computer science. The problem is
>>>>> looking at a computer program and finding out if the program is
>>>>> going to
>>>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>>>
>>>> You've been mislead by the term "halting problem". There are plenty of
>>>> genuinely open problems in computer science, like whether large
>>>> integers can
>>>> be factored other than by exhaustive search, or whether graphs can be
>>>> laid
>>>> out on two dimensional visual representations in polynomial time. The
>>>> "halting problem", despite its name, is not one of these problems.
>>>>
>>>
>>> The input to H will be the description (encoded in some form)
>>> of M, say WM, as well as the input w. The requirement is then
>>> that, given any (WM, w), the Turing machine H will halt with
>>> either a yes or no answer.
>>>
>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>> (Linz 1990:318)
>>
>> Yes, that is the statement of the Halting Problem, but Linz 'solved' it
>> on one sense by showing that there was NO unversal solutions to the
>> problem.
>>
>> There can still be work on special cases, which don't need to be
>> universal, but that is really a different sort of problem.
>>
>
>
> (1) The code below is obviously infinitely recursive.
Yes.
>
> (2) Halts() has identical behavior to DebugStep() until Halts() decides
> to terminate its input.
Ok. Does it promise to always work in finite time?
>
> ∴ swapping function calls to Halts() for the two function calls to
> DebugStep() makes the function call to Halts() from H_Hat infinitely
> recursive.>
> ∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
> correct not halting decision.
>
If its indication is that it found infinite recursion instead of
claiming it has determined non-halting behavior, and it doesn't promise
to always make its decision in fintie time, then depending on exactly
what its indication is supposed to mean, it may be correct.
Halts does NOT meet the requirements of a classical halting detector.
> int DebugTrace(u32 P, u32 I)
> {
> ((int(*)(int))P)(I);
> return 1;
> }
>
> 01 void H_Hat(u32 P)
> 02 {
> 03 u32 Aborted = DebugTrace(P, P);
> 04 if (Aborted)
> 05 HALT
> 06 else
> 07 HERE: goto HERE;
> 08 }
>
> int main()
> {
> u32 P = (u32)H_Hat;
> DebugTrace(P, P);
> HALT;
> }
>
>
>
>
>
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 15:12 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <bJmdnTaeTNnMh13CnZ2dnUU7-V_NnZ2d@giganews.com> |
| In reply to | #26053 |
On 11/26/2020 3:02 PM, Richard Damon wrote:
> On 11/26/20 2:07 PM, olcott wrote:
>> On 11/26/2020 12:47 PM, Richard Damon wrote:
>>> On 11/26/20 1:41 PM, olcott wrote:
>>>> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>>>>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>>>>
>>>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>>>> <cut>
>>>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>>>> {
>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>> return 1;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>> {
>>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>>> if (Aborted)
>>>>>>>>> HALT
>>>>>>>>> else
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>>> DebugTrace(P, P);
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>
>>>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>>>
>>>>>>>> That's infinite recusion, right enough.
>>>>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>>>>> halt"
>>>>>>>> then it is no longer infinite recursion.
>>>>>>>
>>>>>>> Which is the key to PO's halting problem 2.0. A program is
>>>>>>> non-halting
>>>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>>>> halted. Simples!
>>>>>>>
>>>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>>>
>>>>>> Every program / (TMD being simulated) that halts without being
>>>>>> forced to
>>>>>> halt is a halting program / (TMD being simulated).
>>>>>>
>>>>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>>>>> Halts() terminates
>>>>> what would otherwise be an infinite recursion, as it must do if it is
>>>>> to be a
>>>>> halt detector, the termination is also in the Halts() that is fed to
>>>>> Halts().
>>>>>
>>>>> There's no way out. But I thought that had been agreed long ago.
>>>>
>>>> Those words seem incoherent to me.
>>>
>>> Sounds about right for you
>>>>
>>>>>>
>>>>>> Thus dividing inputs into halting and not halting as the actual
>>>>>> Halting
>>>>>> Problem itself requires.
>>>>>>
>>>>>> The Halting problem is a problem in computer science. The problem is
>>>>>> looking at a computer program and finding out if the program is
>>>>>> going to
>>>>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>> You've been mislead by the term "halting problem". There are plenty of
>>>>> genuinely open problems in computer science, like whether large
>>>>> integers can
>>>>> be factored other than by exhaustive search, or whether graphs can be
>>>>> laid
>>>>> out on two dimensional visual representations in polynomial time. The
>>>>> "halting problem", despite its name, is not one of these problems.
>>>>>
>>>>
>>>> The input to H will be the description (encoded in some form)
>>>> of M, say WM, as well as the input w. The requirement is then
>>>> that, given any (WM, w), the Turing machine H will halt with
>>>> either a yes or no answer.
>>>>
>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>> (Linz 1990:318)
>>>
>>> Yes, that is the statement of the Halting Problem, but Linz 'solved' it
>>> on one sense by showing that there was NO unversal solutions to the
>>> problem.
>>>
>>> There can still be work on special cases, which don't need to be
>>> universal, but that is really a different sort of problem.
>>>
>>
>>
>> (1) The code below is obviously infinitely recursive.
>
> Yes.
>
>>
>> (2) Halts() has identical behavior to DebugStep() until Halts() decides
>> to terminate its input.
>
> Ok. Does it promise to always work in finite time?
>>
>> ∴ swapping function calls to Halts() for the two function calls to
>> DebugStep() makes the function call to Halts() from H_Hat infinitely
>> recursive.>
>> ∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
>> correct not halting decision.
>>
>
> If its indication is that it found infinite recursion instead of
> claiming it has determined non-halting behavior, and it doesn't promise
> to always make its decision in fintie time, then depending on exactly
> what its indication is supposed to mean, it may be correct.
>
> Halts does NOT meet the requirements of a classical halting detector.
Halts() does meet the requirements of a classical partial halt decider
on input H_Hat.
>
>> int DebugTrace(u32 P, u32 I)
>> {
>> ((int(*)(int))P)(I);
>> return 1;
>> }
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 u32 Aborted = DebugTrace(P, P);
>> 04 if (Aborted)
>> 05 HALT
>> 06 else
>> 07 HERE: goto HERE;
>> 08 }
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> DebugTrace(P, P);
>> HALT;
>> }
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-11-26 13:42 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <62666bec-e2ed-4f84-8810-034b0f608fb8n@googlegroups.com> |
| In reply to | #26055 |
On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote: > > Halts() does meet the requirements of a classical partial halt decider > on input H_Hat. > No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the result. There is no way round this. As I thought we agreed long ago.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 15:56 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <C42dnQ5NJ54SuV3CnZ2dnUU7-IHNnZ2d@giganews.com> |
| In reply to | #26060 |
On 11/26/2020 3:42 PM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>
>> Halts() does meet the requirements of a classical partial halt decider
>> on input H_Hat.
>>
> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the
> result. There is no way round this. As I thought we agreed long ago.
>
You may have thought you understood it you did not:
Any input (TMD / DATA) that would never halt unless its (UTM) stopped
simulating it expresses behavior that is not halting behavior.
The invocation of Halts() on line 12 aborts the invocation of Halts() on
line 03 because it specifies infinite recursion. Line 03 is aborted
before it ever returns any value to H_Hat.
01 void H_Hat(u32 P)
02 {
03 u32 Aborted = Halts(P, P);
94 if (Aborted)
05 HALT
06 else
07 HERE: goto HERE;
08 }
09 int main()
10 {
11 u32 P = (u32)H_Hat;
12 Halts(P, P);
13 HALT;
14 }
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-11-26 14:14 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <2d8960d1-f245-44cd-8b44-5ea355ee5bd9n@googlegroups.com> |
| In reply to | #26062 |
On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
> > On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
> >>
> >> Halts() does meet the requirements of a classical partial halt decider
> >> on input H_Hat.
> >>
> > No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the
> > result. There is no way round this. As I thought we agreed long ago.
> >
> You may have thought you understood it you did not:
>
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.
>
> The invocation of Halts() on line 12 aborts the invocation of Halts() on
> line 03 because it specifies infinite recursion. Line 03 is aborted
> before it ever returns any value to H_Hat.
> 01 void H_Hat(u32 P)
> 02 {
> 03 u32 Aborted = Halts(P, P);
> 94 if (Aborted)
> 05 HALT
> 06 else
> 07 HERE: goto HERE;
> 08 }
> 09 int main()
> 10 {
> 11 u32 P = (u32)H_Hat;
> 12 Halts(P, P);
> 13 HALT;
> 14 }
>
H_Hat, as specified by Linz, calls the halt decider itself. So if the halt decider terminates
what would otherwise be infinite recursion, H_Hat does not generate infinite recursion.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 16:20 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <K8CdnQ7DMfK4t13CnZ2dnUU7-XfNnZ2d@giganews.com> |
| In reply to | #26065 |
On 11/26/2020 4:14 PM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
>> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
>>> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>>>
>>>> Halts() does meet the requirements of a classical partial halt decider
>>>> on input H_Hat.
>>>>
>>> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the
>>> result. There is no way round this. As I thought we agreed long ago.
>>>
>> You may have thought you understood it you did not:
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
>>
>> The invocation of Halts() on line 12 aborts the invocation of Halts() on
>> line 03 because it specifies infinite recursion. Line 03 is aborted
>> before it ever returns any value to H_Hat.
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 u32 Aborted = Halts(P, P);
>> 94 if (Aborted)
>> 05 HALT
>> 06 else
>> 07 HERE: goto HERE;
>> 08 }
>> 09 int main()
>> 10 {
>> 11 u32 P = (u32)H_Hat;
>> 12 Halts(P, P);
>> 13 HALT;
>> 14 }
>>
> H_Hat, as specified by Linz, calls the halt decider itself. So if the halt decider terminates
> what would otherwise be infinite recursion, H_Hat does not generate infinite recursion.
>
Any input (TMD / DATA) that would never halt unless its (UTM) stopped
simulating it expresses behavior that is not halting behavior.
When Halts() acts like the UTM specified above then it correctly decides
not halting on H_Hat using the above criteria.
--
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-26 19:11 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <hvXvH.51701$8v5.31186@fx33.iad> |
| In reply to | #26066 |
On 11/26/20 5:20 PM, olcott wrote:
> On 11/26/2020 4:14 PM, Malcolm McLean wrote:
>> On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
>>> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
>>>> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>>>>
>>>>> Halts() does meet the requirements of a classical partial halt decider
>>>>> on input H_Hat.
>>>>>
>>>> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat
>>>> inverts the
>>>> result. There is no way round this. As I thought we agreed long ago.
>>>>
>>> You may have thought you understood it you did not:
>>>
>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>> simulating it expresses behavior that is not halting behavior.
>>>
>>> The invocation of Halts() on line 12 aborts the invocation of Halts() on
>>> line 03 because it specifies infinite recursion. Line 03 is aborted
>>> before it ever returns any value to H_Hat.
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03 u32 Aborted = Halts(P, P);
>>> 94 if (Aborted)
>>> 05 HALT
>>> 06 else
>>> 07 HERE: goto HERE;
>>> 08 }
>
>>> 09 int main()
>>> 10 {
>>> 11 u32 P = (u32)H_Hat;
>>> 12 Halts(P, P);
>>> 13 HALT;
>>> 14 }
>>>
>> H_Hat, as specified by Linz, calls the halt decider itself. So if the
>> halt decider terminates
>> what would otherwise be infinite recursion, H_Hat does not generate
>> infinite recursion.
>>
>
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.
>
> When Halts() acts like the UTM specified above then it correctly decides
> not halting on H_Hat using the above criteria.
>
But, when tested H_Hat(H_Hat) will halt under these conditions (or the
Halt decider failed to meet its requirements to deliver the answer in
finite time) so Halts is NOT a correct halting decider.
If you logic said it was, it must be UNSOUND.
The key point here is the 'unless' which you seem to not want to test
properly.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-26 18:25 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) |
| Message-ID | <eMSdnemKcLvl2l3CnZ2dnUU7-K3NnZ2d@giganews.com> |
| In reply to | #26077 |
On 11/26/2020 6:11 PM, Richard Damon wrote:
> On 11/26/20 5:20 PM, olcott wrote:
>> On 11/26/2020 4:14 PM, Malcolm McLean wrote:
>>> On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
>>>> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
>>>>> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>>>>>
>>>>>> Halts() does meet the requirements of a classical partial halt decider
>>>>>> on input H_Hat.
>>>>>>
>>>>> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat
>>>>> inverts the
>>>>> result. There is no way round this. As I thought we agreed long ago.
>>>>>
>>>> You may have thought you understood it you did not:
>>>>
>>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>>> simulating it expresses behavior that is not halting behavior.
>>>>
>>>> The invocation of Halts() on line 12 aborts the invocation of Halts() on
>>>> line 03 because it specifies infinite recursion. Line 03 is aborted
>>>> before it ever returns any value to H_Hat.
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03 u32 Aborted = Halts(P, P);
>>>> 94 if (Aborted)
>>>> 05 HALT
>>>> 06 else
>>>> 07 HERE: goto HERE;
>>>> 08 }
>>
>>>> 09 int main()
>>>> 10 {
>>>> 11 u32 P = (u32)H_Hat;
>>>> 12 Halts(P, P);
>>>> 13 HALT;
>>>> 14 }
>>>>
>>> H_Hat, as specified by Linz, calls the halt decider itself. So if the
>>> halt decider terminates
>>> what would otherwise be infinite recursion, H_Hat does not generate
>>> infinite recursion.
>>>
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
>>
>> When Halts() acts like the UTM specified above then it correctly decides
>> not halting on H_Hat using the above criteria.
>>
>
> But, when tested H_Hat(H_Hat) will halt under these conditions (or the
H_Hat would never halt unless Halts stops simulating it thus perfectly
matching the required criteria for a "not halting" decision.
> Halt decider failed to meet its requirements to deliver the answer in
> finite time) so Halts is NOT a correct halting decider.
>
> If you logic said it was, it must be UNSOUND.
>
> The key point here is the 'unless' which you seem to not want to test
> properly.
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 5 of 7 — ← Prev page 1 2 3 4 [5] 6 7 Next page →
Back to top | Article view | comp.theory
csiph-web