Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #25683 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-11-22 19:24 -0600 |
| Last post | 2020-12-02 02:50 +0000 |
| Articles | 20 on this page of 210 — 9 participants |
Back to article view | Back to comp.theory
It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-22 19:24 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 20:56 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-23 03:14 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-22 21:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-23 04:03 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-22 22:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Misrepresentation of MTs position) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:09 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 03:39 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-23 22:55 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-23 23:22 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-23 23:23 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:07 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-23 11:37 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:42 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-23 11:53 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 13:39 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) olcott <NoOne@NoWhere.com> - 2020-11-23 13:35 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 14:58 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) olcott <NoOne@NoWhere.com> - 2020-11-23 14:12 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 15:54 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 18:47 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-23 13:00 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 16:24 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) olcott <NoOne@NoWhere.com> - 2020-11-25 11:18 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)(Here is Proof) olcott <NoOne@NoWhere.com> - 2020-11-23 13:21 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 21:02 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 15:29 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 16:45 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 15:47 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 16:57 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 16:06 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 17:35 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 16:38 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 17:45 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 16:51 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 18:02 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 17:31 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 19:55 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 19:08 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 20:38 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 20:28 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 22:28 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Jeff Barnett <jbb@notatt.com> - 2020-11-23 15:47 -0700
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 23:51 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 18:37 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 20:04 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 19:20 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 20:49 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 02:53 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 22:18 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 15:41 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) olcott <NoOne@NoWhere.com> - 2020-11-24 09:51 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 16:19 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 10:32 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 16:48 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 11:18 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 11:34 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 13:20 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 19:30 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 13:41 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 23:37 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 18:03 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 01:40 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 20:10 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 03:20 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](first step) olcott <NoOne@NoWhere.com> - 2020-11-24 21:34 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) olcott <NoOne@NoWhere.com> - 2020-11-24 14:44 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 02:04 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) olcott <NoOne@NoWhere.com> - 2020-11-24 20:21 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:10 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) olcott <NoOne@NoWhere.com> - 2020-11-24 14:29 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) olcott <NoOne@NoWhere.com> - 2020-11-24 10:46 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 17:04 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 17:05 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) olcott <NoOne@NoWhere.com> - 2020-11-24 11:19 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-24 18:08 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) olcott <NoOne@NoWhere.com> - 2020-11-24 12:27 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 13:42 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 13:31 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2020-11-24 12:31 -0800
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 15:46 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2020-11-24 17:22 -0800
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) olcott <NoOne@NoWhere.com> - 2020-11-24 19:35 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:14 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) olcott <NoOne@NoWhere.com> - 2020-11-24 14:48 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 16:45 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](infallible) olcott <NoOne@NoWhere.com> - 2020-11-25 11:21 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](infallible) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 21:25 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) olcott <NoOne@NoWhere.com> - 2020-11-25 15:55 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 23:31 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) olcott <NoOne@NoWhere.com> - 2020-11-25 17:47 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 00:33 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) olcott <NoOne@NoWhere.com> - 2020-11-25 18:51 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 01:38 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) olcott <NoOne@NoWhere.com> - 2020-11-25 20:14 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](impossibly incorrect) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 04:27 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-25 22:39 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 15:48 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 10:07 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 16:30 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 10:41 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 17:08 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 11:34 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 19:36 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 13:58 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 20:28 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 14:32 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 20:43 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 14:48 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 14:50 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 21:12 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 15:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 21:27 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 15:48 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-27 01:44 +0000
Re: It is known that a correct halt decider must return false (in olcott <NoOne@nospicedham.NoWhere.com> - 2020-11-26 20:55 -0600
Re: It is known that a correct halt decider must return false (in Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-27 20:12 +0000
Re: It is known that a correct halt decider must return false (in olcott <NoOne@NoWhere.com> - 2020-11-27 14:24 -0600
Re: It is known that a correct halt decider must return false (logical foundation) olcott <NoOne@NoWhere.com> - 2020-11-27 14:29 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 16:14 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 15:31 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 21:57 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 16:05 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-27 01:10 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 21:04 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 22:48 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) olcott <NoOne@NoWhere.com> - 2020-11-27 09:23 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 11:28 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) olcott <NoOne@NoWhere.com> - 2020-11-27 10:43 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 12:50 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) olcott <NoOne@NoWhere.com> - 2020-11-27 12:32 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) olcott <NoOne@NoWhere.com> - 2020-11-27 12:36 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 13:48 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) olcott <NoOne@NoWhere.com> - 2020-11-27 13:23 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](line-of-demarcation) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 16:34 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-27 20:28 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) olcott <NoOne@NoWhere.com> - 2020-11-27 14:36 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) olcott <NoOne@NoWhere.com> - 2020-11-27 14:40 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-11-27 21:03 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](emulation levels) olcott <NoOne@NoWhere.com> - 2020-11-27 15:12 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 17:49 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](x86 as a formal language) olcott <NoOne@NoWhere.com> - 2020-11-26 17:01 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) olcott <NoOne@NoWhere.com> - 2020-11-29 16:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-30 00:38 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) olcott <NoOne@NoWhere.com> - 2020-11-29 19:16 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-30 02:38 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) olcott <NoOne@NoWhere.com> - 2020-11-29 21:12 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-30 03:23 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) olcott <NoOne@NoWhere.com> - 2020-11-29 21:53 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Jeff Barnett <jbb@notatt.com> - 2020-11-29 21:31 -0700
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-30 21:28 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](infinite recursion slaps them in the face and they deny it) olcott <NoOne@NoWhere.com> - 2020-11-30 15:31 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Richard Damon <Richard@Damon-Family.org> - 2020-11-30 10:36 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) olcott <NoOne@NoWhere.com> - 2020-11-30 09:55 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Richard Damon <Richard@Damon-Family.org> - 2020-11-30 12:56 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) olcott <NoOne@NoWhere.com> - 2020-11-30 12:10 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](recursive emulation ≡ recursive invocation) Richard Damon <Richard@Damon-Family.org> - 2020-11-30 15:34 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 03:53 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-23 23:29 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 15:53 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-24 10:27 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 00:16 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) olcott <NoOne@NoWhere.com> - 2020-11-24 18:30 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:17 -0500
Re: It is known that a correct halt decider must return false (This is the whole thing) olcott <NoOne@NoWhere.com> - 2020-11-24 22:43 -0600
Re: It is known that a correct halt decider must return false (This is the whole thing) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:53 -0500
Re: It is known that a correct halt decider must return false (This is the whole thing) olcott <NoOne@NoWhere.com> - 2020-11-24 23:12 -0600
Re: It is known that a correct halt decider must return false (This is the whole thing) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 07:39 -0500
Re: It is known that a correct halt decider must return false (This is the whole thing) olcott <NoOne@NoWhere.com> - 2020-11-25 08:17 -0600
Re: It is known that a correct halt decider must return false (This is the whole thing) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:14 -0500
Re: It is known that a correct halt decider must return false (This is the whole thing) olcott <NoOne@NoWhere.com> - 2020-11-25 09:52 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Linz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 22:16 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) olcott <NoOne@NoWhere.com> - 2020-11-25 16:25 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 18:35 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) olcott <NoOne@NoWhere.com> - 2020-11-25 17:59 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 19:55 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) olcott <NoOne@NoWhere.com> - 2020-11-25 19:03 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 21:55 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) olcott <NoOne@NoWhere.com> - 2020-11-25 21:06 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:34 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2020-11-25 15:53 -0800
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) olcott <NoOne@NoWhere.com> - 2020-11-25 18:09 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:09 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2020-11-25 20:40 -0800
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) olcott <NoOne@NoWhere.com> - 2020-11-25 22:58 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 02:06 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) olcott <NoOne@NoWhere.com> - 2020-11-25 20:33 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:00 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) olcott <NoOne@NoWhere.com> - 2020-11-25 21:08 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:31 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) olcott <NoOne@NoWhere.com> - 2020-11-27 12:28 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-28 03:02 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-27 21:53 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-28 16:02 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-28 10:14 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-28 08:18 -0800
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-28 10:25 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-30 01:42 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-29 20:26 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-01 01:30 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Do You Really Still Not Get This?) olcott <NoOne@NoWhere.com> - 2020-11-30 19:43 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Do You Really Still Not Get This?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-02 02:42 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Do You Really Still Not Get This?) olcott <NoOne@NoWhere.com> - 2020-12-01 20:56 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](Do You Really Still Not Get This?) Richard Damon <Richard@Damon-Family.org> - 2020-12-01 22:40 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](Do You Really Still Not Get This?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-03 02:16 +0000
Re: It is known that a correct halt decider must return false (in this case)[V4](Do You Really Still Not Get This?) olcott <NoOne@NoWhere.com> - 2020-12-02 20:37 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Richard Damon <Richard@Damon-Family.org> - 2020-11-30 21:09 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-30 22:02 -0600
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Richard Damon <Richard@Damon-Family.org> - 2020-12-01 06:51 -0500
Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-02 02:50 +0000
Page 10 of 11 — ← Prev page 1 … 8 9 [10] 11 Next page →
| From | "dklei...@gmail.com" <dkleinecke@gmail.com> |
|---|---|
| Date | 2020-11-25 15:53 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <a96f0b13-00c4-482d-8069-06194379e897n@googlegroups.com> |
| In reply to | #25977 |
On Wednesday, November 25, 2020 at 2:25:27 PM UTC-8, olcott wrote:
> You start with the assumption: "Pete is wrong".
> Based on this assumption you conclude that Pete is wrong".
> You make sure to always skip all the steps in-between.
>
> The first step of proof that "Pete is right" is understanding that
> H_Hat() never receives a return value from DebugStep().
That's true in any empty way. Is DebugStep a thinko for DebufTrace?
> int DebugTrace(u32 N, u32 M)
> {
> ((int(*)(int))N)(M);
> return 1;
> }
// So DebugTrace always returns 1 regardless of its inputs.
> void H_Hat(u32 P)
> {
> u32 Aborted = DebugTrace(P, P);
// Setting initial value of Aborted to 1
> if (Aborted)
> HALT
// Execution always reaches here but I don't know what "HALT" signifies. Perhaps I am using the wrong version of C
> else
> HERE: goto HERE;
// Never happens.
> }
>
>
> int main()
> {
> u32 P = (u32)H_Hat;
> DebugTrace(P, P);
> HALT;
// I still don't know what HALT does.
> }
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 18:09 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <bImdncgVvYW8byPCnZ2dnUU7-IfNnZ2d@giganews.com> |
| In reply to | #25985 |
On 11/25/2020 5:53 PM, dklei...@gmail.com wrote:
> On Wednesday, November 25, 2020 at 2:25:27 PM UTC-8, olcott wrote:
>> You start with the assumption: "Pete is wrong".
>> Based on this assumption you conclude that Pete is wrong".
>> You make sure to always skip all the steps in-between.
>>
>> The first step of proof that "Pete is right" is understanding that
>> H_Hat() never receives a return value from DebugStep().
>
> That's true in any empty way. Is DebugStep a thinko for DebufTrace?
>
I can't make out what you are saying.
That H_Hat() never gets a return value fro DebugTrace() is true in a
logical necessity kind of way.
>> int DebugTrace(u32 N, u32 M)
>> {
>> ((int(*)(int))N)(M);
>> return 1;
>> }
>
> // So DebugTrace always returns 1 regardless of its inputs.
Only if its input ever halts.
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>
> // Setting initial value of Aborted to 1
>
>> if (Aborted)
>> HALT
>
> // Execution always reaches here but I don't know what "HALT" signifies. Perhaps I am using the wrong version of C
Execution NEVER reaches here
#define HALT __asm hlt // Force the program to Halt
>> else
>> HERE: goto HERE;
>
> // Never happens.
>
>> }
>>
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> DebugTrace(P, P);
>> HALT;
>
> // I still don't know what HALT does.
#define HALT __asm hlt // Force the program to Halt
>
>> }
The code is infinitely recursive.
It calls DebugTrace() to call H_Hat
to call DebugTrace() to call H_Hat...
--
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 20:09 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <1fDvH.3859$jL.1576@fx13.iad> |
| In reply to | #25987 |
On 11/25/20 7:09 PM, olcott wrote:
> On 11/25/2020 5:53 PM, dklei...@gmail.com wrote:
>> On Wednesday, November 25, 2020 at 2:25:27 PM UTC-8, olcott wrote:
>>> You start with the assumption: "Pete is wrong".
>>> Based on this assumption you conclude that Pete is wrong".
>>> You make sure to always skip all the steps in-between.
>>>
>>> The first step of proof that "Pete is right" is understanding that
>>> H_Hat() never receives a return value from DebugStep().
>>
>> That's true in any empty way. Is DebugStep a thinko for DebufTrace?
>>
>
> I can't make out what you are saying.
>
> That H_Hat() never gets a return value fro DebugTrace() is true in a
> logical necessity kind of way.
>
>>> int DebugTrace(u32 N, u32 M)
>>> {
>>> ((int(*)(int))N)(M);
>>> return 1;
>>> }
>> // So DebugTrace always returns 1 regardless of its inputs.
>
> Only if its input ever halts.
>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = DebugTrace(P, P);
>>
>> // Setting initial value of Aborted to 1
>>
>>> if (Aborted)
>>> HALT
>>
>
>> // Execution always reaches here but I don't know what "HALT"
>> signifies. Perhaps I am using the wrong version of C
>
> Execution NEVER reaches here
> #define HALT __asm hlt // Force the program to Halt
>
>>> else
>>> HERE: goto HERE;
>>
>> // Never happens.
>>
>>> }
>>>
>>>
>>> int main()
>>> {
>>> u32 P = (u32)H_Hat;
>>> DebugTrace(P, P);
>>> HALT;
>>
>
>> // I still don't know what HALT does.
> #define HALT __asm hlt // Force the program to Halt
This actually cause a bit of a problem unless there is a lot of virtual
machine stuff going on out of sight, because if H_Hat halts, then the
processor halts, and DebugStep won't return.
You may want to rethink your mapping between Turing and x86, and make a
function that represents a Turing Machine use a return statement to
represent a HALT in the Turing machine. Maybe also give it a value to
indicate which state it is HALTING in, so all Turing machines use the
same signature to get around the Undefined Behavior currently in DebugStep.
I might suggest a prototype something like
int TM(void *p)
For machines that take a representation as an input, they need to cast
that pointer with something like:
int TM(void *P)
{
int (*rep)(void *) = (int(*)(void *))(p)
...
This will get around a lot of the Undefined Behavior issues in the
current code, and is just implementation defined, and will work as long
as we are in a memory model where data pointer and code pointers are of
the same representation, which is true for most 32 and 64 bit code. (It
fails for medium and compact models which are only actually used for 16
bit code)
>
>>
>>> }
>
> The code is infinitely recursive.
> It calls DebugTrace() to call H_Hat
> to call DebugTrace() to call H_Hat...
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | "dklei...@gmail.com" <dkleinecke@gmail.com> |
|---|---|
| Date | 2020-11-25 20:40 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <b398f8b3-79ce-4915-91eb-9d5597d22589n@googlegroups.com> |
| In reply to | #25987 |
On Wednesday, November 25, 2020 at 4:09:13 PM UTC-8, olcott wrote:
> On 11/25/2020 5:53 PM, dklei...@gmail.com wrote:
> > On Wednesday, November 25, 2020 at 2:25:27 PM UTC-8, olcott wrote:
> >> You start with the assumption: "Pete is wrong".
> >> Based on this assumption you conclude that Pete is wrong".
> >> You make sure to always skip all the steps in-between.
> >>
> >> The first step of proof that "Pete is right" is understanding that
> >> H_Hat() never receives a return value from DebugStep().
> >
> > That's true in any empty way. Is DebugStep a thinko for DebufTrace?
> >
> I can't make out what you are saying.
>
> That H_Hat() never gets a return value fro DebugTrace() is true in a
> logical necessity kind of way.
> >> int DebugTrace(u32 N, u32 M)
> >> {
> >> ((int(*)(int))N)(M);
> >> return 1;
> >> }
> >
> > // So DebugTrace always returns 1 regardless of its inputs.
> Only if its input ever halts.
> >> void H_Hat(u32 P)
> >> {
> >> u32 Aborted = DebugTrace(P, P);
> >
> > // Setting initial value of Aborted to 1
> >
> >> if (Aborted)
> >> HALT
> >
>
> > // Execution always reaches here but I don't know what "HALT" signifies. Perhaps I am using the wrong version of C
> Execution NEVER reaches here
> #define HALT __asm hlt // Force the program to Halt
> >> else
> >> HERE: goto HERE;
> >
> > // Never happens.
> >
> >> }
> >>
> >>
> >> int main()
> >> {
> >> u32 P = (u32)H_Hat;
> >> DebugTrace(P, P);
> >> HALT;
> >
>
> > // I still don't know what HALT does.
> #define HALT __asm hlt // Force the program to Halt
>
> >
> >> }
>
> The code is infinitely recursive.
> It calls DebugTrace() to call H_Hat
> to call DebugTrace() to call H_Hat...
OK - what does the assembly instruction "hlt" do? It
didn't exist in the assembly language of any processor
known to me.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 22:58 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <1Oadna1B_8hAqCLCnZ2dnUU7-TXNnZ2d@giganews.com> |
| In reply to | #26021 |
On 11/25/2020 10:40 PM, dklei...@gmail.com wrote:
> On Wednesday, November 25, 2020 at 4:09:13 PM UTC-8, olcott wrote:
>> On 11/25/2020 5:53 PM, dklei...@gmail.com wrote:
>>> On Wednesday, November 25, 2020 at 2:25:27 PM UTC-8, olcott wrote:
>>>> You start with the assumption: "Pete is wrong".
>>>> Based on this assumption you conclude that Pete is wrong".
>>>> You make sure to always skip all the steps in-between.
>>>>
>>>> The first step of proof that "Pete is right" is understanding that
>>>> H_Hat() never receives a return value from DebugStep().
>>>
>>> That's true in any empty way. Is DebugStep a thinko for DebufTrace?
>>>
>> I can't make out what you are saying.
>>
>> That H_Hat() never gets a return value fro DebugTrace() is true in a
>> logical necessity kind of way.
>>>> int DebugTrace(u32 N, u32 M)
>>>> {
>>>> ((int(*)(int))N)(M);
>>>> return 1;
>>>> }
>>>
>>> // So DebugTrace always returns 1 regardless of its inputs.
>> Only if its input ever halts.
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Aborted = DebugTrace(P, P);
>>>
>>> // Setting initial value of Aborted to 1
>>>
>>>> if (Aborted)
>>>> HALT
>>>
>>
>>> // Execution always reaches here but I don't know what "HALT" signifies. Perhaps I am using the wrong version of C
>> Execution NEVER reaches here
>> #define HALT __asm hlt // Force the program to Halt
>>>> else
>>>> HERE: goto HERE;
>>>
>>> // Never happens.
>>>
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>> u32 P = (u32)H_Hat;
>>>> DebugTrace(P, P);
>>>> HALT;
>>>
>>
>>> // I still don't know what HALT does.
>> #define HALT __asm hlt // Force the program to Halt
>>
>>>
>>>> }
>>
>> The code is infinitely recursive.
>> It calls DebugTrace() to call H_Hat
>> to call DebugTrace() to call H_Hat...
>
> OK - what does the assembly instruction "hlt" do? It
> didn't exist in the assembly language of any processor
> known to me.
>
https://css.csail.mit.edu/6.858/2014/readings/i386.pdf
search for "hlt"
It is very handy for x86 halting problem proofs.
--
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:06 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <87r1og6fd0.fsf@bsb.me.uk> |
| In reply to | #25977 |
olcott <NoOne@NoWhere.com> writes:
> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
<cut>
>>>>> 08 bool Halts(u32 P, u32 I)
>>>>> 09 {
>>>>> 10 bool Halted = false;
>>>>> 11 bool Aborted = false;
>>>>> 12 while (!Halted && !Aborted)
>>>>> 13 {
>>>>> 14 Halted = DebugStep(P, I);
>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>> 16 }
>>>>> 17 return !Aborted;
>>>>> 18 }
>>>>
>>>> Given
>>>>
>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>
>>>> The confounding example for Halts is the computation
>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>
>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>
>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>> the wrong answer (as you know perfectly well).
>
> You start with the assumption: "Pete is wrong".
I start with the definition of what a halt decider is (in your model
using quasi-C): a function F such that F(P, I) is true iff P(I) is a
finite computation and false otherwise.
You refuse to either confirm or deny that you accept this definition,
but we know you reject it due to your redefining the criteria for
making a correct halting decision.
> Based on this assumption you conclude that Pete is wrong".
Based on the definition, I give an example P and I such that your
claimed halting decider Halts(P, I) does not meet the specification for
a halt decider. That should be the end of it, especially as you do not
deny the facts of the matter, namely that
(a) Halts(Confound_Halts, Confound_Halts) returns false, and
(b) Confound_Halts(Confound_Halts) is a finite computation.
> You make sure to always skip all the steps in-between.
>
> The first step of proof that "Pete is right" is understanding that
> H_Hat() never receives a return value from DebugStep().
Yes, I know the steps very well. I've explained why its a junk argument
that has nothing to do with the halting problem, but let me do that
again for anyone whose brain is still working....
You start by getting people to agree that computation X (below) is not
finite ("infinite recursion in DebugStep").
Then you go on to show a decider that correctly reports that X is not
finite (Halts above). Sometimes the computation X even uses a function
called Halts, just to keep things as unclear as possible.
The final step, however, will always be that I show you a computation Y
(Confound_Halts(Confound_Halts) in this case) that your purported
decider gets wrong.
There is sometimes an optional extra step (not taken this time round)
where you explain why the wrong answer is the right one because you've
redefined the criteria.
> int DebugTrace(u32 N, u32 M)
> {
> ((int(*)(int))N)(M);
> 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;
> }
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 20:33 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) |
| Message-ID | <g4udnSi9pZyZiSLCnZ2dnUU7-VvNnZ2d@giganews.com> |
| In reply to | #26003 |
On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
> <cut>
>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>> 09 {
>>>>>> 10 bool Halted = false;
>>>>>> 11 bool Aborted = false;
>>>>>> 12 while (!Halted && !Aborted)
>>>>>> 13 {
>>>>>> 14 Halted = DebugStep(P, I);
>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>> 16 }
>>>>>> 17 return !Aborted;
>>>>>> 18 }
>>>>>
>>>>> Given
>>>>>
>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>
>>>>> The confounding example for Halts is the computation
>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>
>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>
>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>> the wrong answer (as you know perfectly well).
>>
>> You start with the assumption: "Pete is wrong".
>
> I start with the definition of what a halt decider is (in your model
> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
> finite computation and false otherwise.
>
To actually understand me you have to start with the first step by
understanding that in the following code DebugTrace() never returns a
value to to H_Hat().
Richard has never actually gotten past this first step.
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 | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-25 22:00 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) |
| Message-ID | <oTEvH.833$PP.527@fx07.iad> |
| In reply to | #26005 |
On 11/25/20 9:33 PM, olcott wrote:
> To actually understand me you have to start with the first step by
> understanding that in the following code DebugTrace() never returns a
> value to to H_Hat().
>
> Richard has never actually gotten past this first step.
>
>
> 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;
> }
Does this mean that you admit that if I run as a real Turing Machine the
equivalent of
H_Hat(H_Hat) that you admit that DebugTrace does not answer in finite time?
And thus DebugTrace FAILS at being a proper Halt Decider?
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 21:08 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) |
| Message-ID | <DdOdnaz5_s--gSLCnZ2dnUU7-ImdnZ2d@giganews.com> |
| In reply to | #26010 |
On 11/25/2020 9:00 PM, Richard Damon wrote:
> On 11/25/20 9:33 PM, olcott wrote:
>
>> To actually understand me you have to start with the first step by
>> understanding that in the following code DebugTrace() never returns a
>> value to to H_Hat().
>>
>> Richard has never actually gotten past this first step.
>>
>>
>> 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;
>> }
>
>
> Does this mean that you admit that if I run as a real Turing Machine the
> equivalent of
>
> H_Hat(H_Hat) that you admit that DebugTrace does not answer in finite time?
>
> And thus DebugTrace FAILS at being a proper Halt Decider?
>
>
No. It would maybe make me admit that you simply don't understand these
things well enough.
--
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:31 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) |
| Message-ID | <87h7pa4sfp.fsf@bsb.me.uk> |
| In reply to | #26005 |
olcott "Ĥ does not copy its input" <NoOne@NoWhere.com> writes:
> On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>> <cut>
>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>> 09 {
>>>>>>> 10 bool Halted = false;
>>>>>>> 11 bool Aborted = false;
>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>> 13 {
>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>> 16 }
>>>>>>> 17 return !Aborted;
>>>>>>> 18 }
>>>>>>
>>>>>> Given
>>>>>>
>>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>
>>>>>> The confounding example for Halts is the computation
>>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>>
>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>
>>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>>> the wrong answer (as you know perfectly well).
>>>
>>> You start with the assumption: "Pete is wrong".
>>
>> I start with the definition of what a halt decider is (in your model
>> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
>> finite computation and false otherwise.
>
> To actually understand me you have to start with the first step by
> understanding that in the following code DebugTrace() never returns a
> value to to H_Hat().
Yes, it's obvious, and I've said so on at least two occasions, though
sometimes the function names were different. (You love to give
different function the same name, and similar functions different names.
It all adds the swirling mass of confusion in which you try to hide your
ruse.)
I note you declined another opportunity say you know what the halting
problem and you have also never denied the facts that you cut from the
post you are replying to:
A halt decider is a function F such that F(P, I) is true iff P(I) is a
finite computation and false otherwise.
Do you agree?
(a) Halts(Confound_Halts, Confound_Halts) returns false, and
(b) Confound_Halts(Confound_Halts) is a finite computation.
Therefore Halts is not a halt decider. Which of the these do you
disagree with?
> 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;
> }
In case you missed it the previous times I told you, yes, this code is
non-halting. See the difference between an honest interlocutor and
yourself? If your question is clear, I will answer it. You, on the
other hand, duck and dive, evade and distract. Maybe you will change
and ANSWER THE QUESTIONS ABOVE.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-27 12:28 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) |
| Message-ID | <S5WdnU3dSYfY2FzCnZ2dnUU7-cPNnZ2d@giganews.com> |
| In reply to | #26098 |
On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
> olcott "Ĥ does not copy its input" <NoOne@NoWhere.com> writes:
>
>> On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>> <cut>
>>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>>> 09 {
>>>>>>>> 10 bool Halted = false;
>>>>>>>> 11 bool Aborted = false;
>>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>>> 13 {
>>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>>> 16 }
>>>>>>>> 17 return !Aborted;
>>>>>>>> 18 }
>>>>>>>
>>>>>>> Given
>>>>>>>
>>>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>>
>>>>>>> The confounding example for Halts is the computation
>>>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>>>
>>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>>
>>>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>>>> the wrong answer (as you know perfectly well).
>>>>
>>>> You start with the assumption: "Pete is wrong".
>>>
>>> I start with the definition of what a halt decider is (in your model
>>> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
>>> finite computation and false otherwise.
>>
>> To actually understand me you have to start with the first step by
>> understanding that in the following code DebugTrace() never returns a
>> value to to H_Hat().
>
> Yes, it's obvious, and I've said so on at least two occasions, though
> sometimes the function names were different. (You love to give
> different function the same name, and similar functions different names.
> It all adds the swirling mass of confusion in which you try to hide your
> ruse.)
>
Progressive refinement makes my words easier to understand.
Sometimes this progressive refinement to make my words easier to
understand requires reformulting what I am saying.
> I note you declined another opportunity say you know what the halting
> problem and you have also never denied the facts that you cut from the
> post you are replying to:
As you as I encounter your first crucial misunderstanding I igrore all
of your words after that and focus on correctly this key misunderstanding.
> A halt decider is a function F such that F(P, I) is true iff P(I) is a
> finite computation and false otherwise.
>
> Do you agree?
>
> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
> (b) Confound_Halts(Confound_Halts) is a finite computation.
Your failure to understand that this is a logical necessity is no actual
rebuttal what-so-ever that it is not a logical necessity:
Any input (TMD / DATA) that would never halt unless
its simulator stopped simulating it expresses behavior
that is not halting behavior.
When Halts simulates Confound_Halts(Confound_Halts) Halts it decides
that Confound_Halts(Confound_Halts) would never halt unless Halts
stopped simulating it.
> Therefore Halts is not a halt decider. Which of the these do you
> disagree with?
>
>> 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;
>> }
>
> In case you missed it the previous times I told you, yes, this code is
> non-halting. See the difference between an honest interlocutor and
> yourself? If your question is clear, I will answer it. You, on the
> other hand, duck and dive, evade and distract. Maybe you will change
> and ANSWER THE QUESTIONS ABOVE.
>
--
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-28 03:02 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1a) |
| Message-ID | <87zh322ngm.fsf@bsb.me.uk> |
| In reply to | #26104 |
olcott <NoOne@NoWhere.com> writes:
> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
>> olcott "Ĥ does not copy its input" <NoOne@NoWhere.com> writes:
>>
>>> On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>> <cut>
>>>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>>>> 09 {
>>>>>>>>> 10 bool Halted = false;
>>>>>>>>> 11 bool Aborted = false;
>>>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>>>> 13 {
>>>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>>>> 16 }
>>>>>>>>> 17 return !Aborted;
>>>>>>>>> 18 }
>>>>>>>>
>>>>>>>> Given
>>>>>>>>
>>>>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>>>
>>>>>>>> The confounding example for Halts is the computation
>>>>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>>>>
>>>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>>>
>>>>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>>>>> the wrong answer (as you know perfectly well).
>>>>>
>>>>> You start with the assumption: "Pete is wrong".
>>>>
>>>> I start with the definition of what a halt decider is (in your model
>>>> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
>>>> finite computation and false otherwise.
>>>
>>> To actually understand me you have to start with the first step by
>>> understanding that in the following code DebugTrace() never returns a
>>> value to to H_Hat().
>>
>> Yes, it's obvious, and I've said so on at least two occasions, though
>> sometimes the function names were different.
<cut>
>> I note you declined another opportunity say you know what the halting
>> problem and you have also never denied the facts that you cut from the
>> post you are replying to:
>
> As you as I encounter your first crucial misunderstanding I igrore all
> of your words after that and focus on correctly this key
> misunderstanding.
This is a feeble excuse to avoid answering a few simple questions. Why
must avoid answering? The trouble is that you don't disagree with me,
but you dare not say so explicitly or game will be up. Let's see how
that works:
>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>> finite computation and false otherwise.
>>
>> Do you agree?
Ignored yet again. That's because you know this is what a halt decider
is (in this context) and that your proposed function isn't one.
>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>> (b) Confound_Halts(Confound_Halts) is a finite computation.
>
> Your failure to understand that this is a logical necessity is no
> actual rebuttal what-so-ever that it is not a logical necessity:
>
> Any input (TMD / DATA) that would never halt unless
> its simulator stopped simulating it expresses behavior
> that is not halting behavior.
Again an evasion, and for the same reason. You gave (a) so you can't
retract it, and you know (b) is also a fact.
By the way, you are correct. My failure to understand that something is
a logical necessity is in no way a rebuttal that it is one. But why
would I? A computation that would not halt if its simulation were not
halted is indeed a non-halting computation. But a computation that
would not halt and one that is halted are different computations.
Confound_Halts(Confound_Halts) is a computation that does halt. It's
just a word game to say that it only halts because it's simulation had
to be halted in the course of determining the return value from Halts.
The halting status (and therefore the correct halting decision) is not
dependent on why a computation is finite, only that it is.
> When Halts simulates Confound_Halts(Confound_Halts) Halts it decides
> that Confound_Halts(Confound_Halts) would never halt unless Halts
> stopped simulating it.
Halts(Confound_Halts, Confound_Halts) returns false, according to you,
making Confound_Halts(Confound_Halts) a finite computation. How this
determination is made by Halts makes no difference. The determination
was made and false returned (again, according to you). You would love
it if readers took the fact that Halts has a particular /reason/ for
returning false, namely that the execution would not otherwise
terminate, as excusing the fact that false is the wrong answer.
>> Therefore Halts is not a halt decider. Which of the these do you
>> disagree with?
No answer? What a surprise!
>>> 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;
>>> }
>>
>> In case you missed it the previous times I told you, yes, this code is
>> non-halting. See the difference between an honest interlocutor and
>> yourself? If your question is clear, I will answer it. You, on the
>> other hand, duck and dive, evade and distract. Maybe you will change
>> and ANSWER THE QUESTIONS ABOVE.
Not a single one of my questions answered.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-27 21:53 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <6eSdnYuLBrIuVFzCnZ2dnUU7-cPNnZ2d@giganews.com> |
| In reply to | #26142 |
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
>>> olcott "Ĥ does not copy its input" <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>> <cut>
>>>>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>>>>> 09 {
>>>>>>>>>> 10 bool Halted = false;
>>>>>>>>>> 11 bool Aborted = false;
>>>>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>>>>> 13 {
>>>>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>>>>> 16 }
>>>>>>>>>> 17 return !Aborted;
>>>>>>>>>> 18 }
>>>>>>>>>
>>>>>>>>> Given
>>>>>>>>>
>>>>>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>>>>
>>>>>>>>> The confounding example for Halts is the computation
>>>>>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>>>>>
>>>>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>>>>
>>>>>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>>>>>> the wrong answer (as you know perfectly well).
>>>>>>
>>>>>> You start with the assumption: "Pete is wrong".
>>>>>
>>>>> I start with the definition of what a halt decider is (in your model
>>>>> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
>>>>> finite computation and false otherwise.
>>>>
>>>> To actually understand me you have to start with the first step by
>>>> understanding that in the following code DebugTrace() never returns a
>>>> value to to H_Hat().
>>>
>>> Yes, it's obvious, and I've said so on at least two occasions, though
>>> sometimes the function names were different.
> <cut>
>>> I note you declined another opportunity say you know what the halting
>>> problem and you have also never denied the facts that you cut from the
>>> post you are replying to:
>>
>> As you as I encounter your first crucial misunderstanding I igrore all
>> of your words after that and focus on correctly this key
>> misunderstanding.
>
> This is a feeble excuse to avoid answering a few simple questions. Why
> must avoid answering? The trouble is that you don't disagree with me,
> but you dare not say so explicitly or game will be up. Let's see how
> that works:
>
>>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>>> finite computation and false otherwise.
>>>
>>> Do you agree?
>
I never answer yes or no questions with a yes or no answer.
I always answer yes or no questions with a complete explanation that
derives a yes or no answer. I answered the above question this way in my
next answer.
> Ignored yet again. That's because you know this is what a halt decider
> is (in this context) and that your proposed function isn't one.
>
>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>> (b) Confound_Halts(Confound_Halts) is a finite computation.
>>
>> Your failure to understand that this is a logical necessity is no
>> actual rebuttal what-so-ever that it is not a logical necessity:
>>
>> Any input (TMD / DATA) that would never halt unless
>> its simulator stopped simulating it expresses behavior
>> that is not halting behavior.
>
> Again an evasion, and for the same reason. You gave (a) so you can't
> retract it, and you know (b) is also a fact.
It is not an evasion it is a step-by-step proof that I am correct and
you always skip these steps and leap to the conclusion that I am incorrect.
> By the way, you are correct. My failure to understand that something is
> a logical necessity is in no way a rebuttal that it is one. But why
> would I?
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation. But a computation that
> would not halt and one that is halted are different computations.
Yes, that is the exact dichotomy required by the actual halting problem.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (!Input_Halts)
HALT
else
HERE: goto HERE;
}
Halts(H_Hat, H_Hat) does correctly decide that its input would not halt
unless Halts stopped simulating it, then Halts(H_Hat, H_Hat) itself halts.
> Confound_Halts(Confound_Halts) is a computation that does halt. It's
> just a word game to say that it only halts because it's simulation had
> to be halted in the course of determining the return value from Halts.
Not so much. In this case H_Hat never gets any return value from Halts
so it can't possibly do the opposite of whatever Halts decides and Halts
does have to stop simulating H_Hat or H_Hat would have never halted.
> The halting status (and therefore the correct halting decision) is not
> dependent on why a computation is finite, only that it is.
>
>> When Halts simulates Confound_Halts(Confound_Halts) Halts it decides
>> that Confound_Halts(Confound_Halts) would never halt unless Halts
>> stopped simulating it.
>
> Halts(Confound_Halts, Confound_Halts) returns false, according to you,
> making Confound_Halts(Confound_Halts) a finite computation.
No not at all. Halts is a finite computation. The input to Halts is only
finite because Halts forced it to be finite, otherwise it is infinite.
> How this
> determination is made by Halts makes no difference. The determination
The input to Halts is only finite because Halts forced it to be finite,
otherwise it is infinite.
> was made and false returned (again, according to you). You would love
> it if readers took the fact that Halts has a particular /reason/ for
> returning false, namely that the execution would not otherwise
> terminate, as excusing the fact that false is the wrong answer.
The input to Halts is only finite because Halts forced it to be finite,
otherwise it is infinite.
>>> Therefore Halts is not a halt decider. Which of the these do you
>>> disagree with?
>
> No answer? What a surprise!
I just proved that Halts does decide (H_Hat, H_Hat) correctly because
the input to Halts is only finite because Halts forced it to be finite,
otherwise it is infinite.
>>>> 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;
>>>> }
>>>
>>> In case you missed it the previous times I told you, yes, this code is
>>> non-halting. See the difference between an honest interlocutor and
>>> yourself? If your question is clear, I will answer it. You, on the
>>> other hand, duck and dive, evade and distract. Maybe you will change
>>> and ANSWER THE QUESTIONS ABOVE.
>
> Not a single one of my questions answered.
>
I answer yes or no questions with a complete explanation.
If you can have the discipline to very very carefully analyze my answers
as if there was a real chance that I am correct then it should be quite
easy to verify in your own mind that I am actually correct.
This is the key to understanding that I am correct.
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation.
When the simulator stops simulating H_Hat before H_Hat ever gets any
return value from Halts this makes it impossible for H_Hat to do the
opposite of whatever Halts decides, thus making all the conventional HP
proofs lose their entire basis.
--
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-28 16:02 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <OZSdnZrs5rQf6V_CnZ2dnUU78RnNnZ2d@brightview.co.uk> |
| In reply to | #26145 |
On 28/11/2020 03:53, olcott wrote:
> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
>>>> olcott "Ĥ does not copy its input" <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>> <cut>
>>>>>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>>>>>> 09 {
>>>>>>>>>>> 10 bool Halted = false;
>>>>>>>>>>> 11 bool Aborted = false;
>>>>>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>>>>>> 13 {
>>>>>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>>>>>> 16 }
>>>>>>>>>>> 17 return !Aborted;
>>>>>>>>>>> 18 }
>>>>>>>>>>
>>>>>>>>>> Given
>>>>>>>>>>
>>>>>>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>>>>>
>>>>>>>>>> The confounding example for Halts is the computation
>>>>>>>>>> Confound_Halts(Confound_Halts) whose halting status is not
>>>>>>>>>> correctly
>>>>>>>>>> determined by the function call Halts(Confound_Halts,
>>>>>>>>>> Confound_Halts).
>>>>>>>>>
>>>>>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>>>>>
>>>>>>>> But Confound_Halts(Confound_Halts) is a finite computation, so
>>>>>>>> that's
>>>>>>>> the wrong answer (as you know perfectly well).
>>>>>>>
>>>>>>> You start with the assumption: "Pete is wrong".
>>>>>>
>>>>>> I start with the definition of what a halt decider is (in your model
>>>>>> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
>>>>>> finite computation and false otherwise.
>>>>>
>>>>> To actually understand me you have to start with the first step by
>>>>> understanding that in the following code DebugTrace() never returns a
>>>>> value to to H_Hat().
>>>>
>>>> Yes, it's obvious, and I've said so on at least two occasions, though
>>>> sometimes the function names were different.
>> <cut>
>>>> I note you declined another opportunity say you know what the halting
>>>> problem and you have also never denied the facts that you cut from the
>>>> post you are replying to:
>>>
>>> As you as I encounter your first crucial misunderstanding I igrore all
>>> of your words after that and focus on correctly this key
>>> misunderstanding.
>>
>> This is a feeble excuse to avoid answering a few simple questions. Why
>> must avoid answering? The trouble is that you don't disagree with me,
>> but you dare not say so explicitly or game will be up. Let's see how
>> that works:
>>
>>>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>>>> finite computation and false otherwise.
>>>>
>>>> Do you agree?
>>
>
> I never answer yes or no questions with a yes or no answer.
> I always answer yes or no questions with a complete explanation that
> derives a yes or no answer. I answered the above question this way in my
> next answer.
Well that's exactly what cranks do. (And tricksters looking for ways to
mislead their audience, while maintaining a pretense of "hey, I'm not
lying!! Show me exactly where I lied!!".)
I suggest you change this policy to
a) Answer the question with yes or no
b) If you feel the need to explain further, then explain further
c) If you feel the question doesn't have a yes/no answer, just say
so and explain why.
Your refusal to say yes/no is a fear of commitment, because you know
ultimately you will fail if forced into a logical debate, and just want
to avoid being pinned down. Why not at least have the intellectual
honesty to answer questions put to you directly!
Besides, answering questions directly is part of normal civil discourse.
When you buy your burger and are asked "would you like chips with
that?" do you respond with an explanation of how five years ago you were
diagnosed with some medical condition (which implies you're allergic to
starch)? The civil way of behaving here is to just answer yes or no and
move on. Anything else is an attempt to stall proceedings and avoid
genuine communication.
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-28 10:14 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <9_edndwKu-T16l_CnZ2dnUU7-W_NnZ2d@giganews.com> |
| In reply to | #26153 |
On 11/28/2020 10:02 AM, Mike Terry wrote:
> On 28/11/2020 03:53, olcott wrote:
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
>>>>> olcott "Ĥ does not copy its input" <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/25/2020 8:06 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>> <cut>
>>>>>>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>>>>>>> 09 {
>>>>>>>>>>>> 10 bool Halted = false;
>>>>>>>>>>>> 11 bool Aborted = false;
>>>>>>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>>>>>>> 13 {
>>>>>>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>>>>>>> 16 }
>>>>>>>>>>>> 17 return !Aborted;
>>>>>>>>>>>> 18 }
>>>>>>>>>>>
>>>>>>>>>>> Given
>>>>>>>>>>>
>>>>>>>>>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while
>>>>>>>>>>> (1); }
>>>>>>>>>>>
>>>>>>>>>>> The confounding example for Halts is the computation
>>>>>>>>>>> Confound_Halts(Confound_Halts) whose halting status is not
>>>>>>>>>>> correctly
>>>>>>>>>>> determined by the function call Halts(Confound_Halts,
>>>>>>>>>>> Confound_Halts).
>>>>>>>>>>
>>>>>>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>>>>>>
>>>>>>>>> But Confound_Halts(Confound_Halts) is a finite computation, so
>>>>>>>>> that's
>>>>>>>>> the wrong answer (as you know perfectly well).
>>>>>>>>
>>>>>>>> You start with the assumption: "Pete is wrong".
>>>>>>>
>>>>>>> I start with the definition of what a halt decider is (in your model
>>>>>>> using quasi-C): a function F such that F(P, I) is true iff P(I) is a
>>>>>>> finite computation and false otherwise.
>>>>>>
>>>>>> To actually understand me you have to start with the first step by
>>>>>> understanding that in the following code DebugTrace() never returns a
>>>>>> value to to H_Hat().
>>>>>
>>>>> Yes, it's obvious, and I've said so on at least two occasions, though
>>>>> sometimes the function names were different.
>>> <cut>
>>>>> I note you declined another opportunity say you know what the halting
>>>>> problem and you have also never denied the facts that you cut from the
>>>>> post you are replying to:
>>>>
>>>> As you as I encounter your first crucial misunderstanding I igrore all
>>>> of your words after that and focus on correctly this key
>>>> misunderstanding.
>>>
>>> This is a feeble excuse to avoid answering a few simple questions. Why
>>> must avoid answering? The trouble is that you don't disagree with me,
>>> but you dare not say so explicitly or game will be up. Let's see how
>>> that works:
>>>
>>>>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>>>>> finite computation and false otherwise.
>>>>>
>>>>> Do you agree?
>>>
>>
>> I never answer yes or no questions with a yes or no answer.
>> I always answer yes or no questions with a complete explanation that
>> derives a yes or no answer. I answered the above question this way in my
>> next answer.
>
>
> Well that's exactly what cranks do. (And tricksters looking for ways to
> mislead their audience, while maintaining a pretense of "hey, I'm not
> lying!! Show me exactly where I lied!!".)
>
Correctly answering questions that are based on fundamental
misconceptions requires answering these questions outside the scope of
the fundamental misconception.
> I suggest you change this policy to
> a) Answer the question with yes or no
> b) If you feel the need to explain further, then explain further
> c) If you feel the question doesn't have a yes/no answer, just say
> so and explain why.
I can't do this because these people have a religious conviction that
their yes or no question that is based on a fundamental misconception is
a correct question.
I have to prove step-by-step detail-by-detail that their question is
based on a fundamental misconception or they simply reject whatever I
say out-of-hand without review.
> Your refusal to say yes/no is a fear of commitment, because you know
> ultimately you will fail if forced into a logical debate, and just want
> to avoid being pinned down. Why not at least have the intellectual
> honesty to answer questions put to you directly!
No this is not the case.
> Besides, answering questions directly is part of normal civil discourse.
> When you buy your burger and are asked "would you like chips with
> that?" do you respond with an explanation of how five years ago you were
> diagnosed with some medical condition (which implies you're allergic to
> starch)? The civil way of behaving here is to just answer yes or no and
> move on. Anything else is an attempt to stall proceedings and avoid
> genuine communication.
>
>
> Mike.
>
If you can have the discipline to very very carefully analyze my answers
as if there was a real chance that I am correct then it should be quite
easy to verify in your own mind that I am actually correct.
This is the key to understanding that I am correct.
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation.
When the simulator stops simulating H_Hat before H_Hat ever gets any
return value from Halts this makes it impossible for H_Hat to do the
opposite of whatever Halts decides, thus making all the conventional HP
proofs lose their entire basis.
--
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-28 08:18 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <c8774d84-55d2-46cc-b69b-fae8ea88f4f7n@googlegroups.com> |
| In reply to | #26153 |
On Saturday, 28 November 2020 at 16:02:13 UTC, Mike Terry wrote: > > Besides, answering questions directly is part of normal civil discourse. > When you buy your burger and are asked "would you like chips with > that?" do you respond with an explanation of how five years ago you were > diagnosed with some medical condition (which implies you're allergic to > starch)? The civil way of behaving here is to just answer yes or no and > move on. Anything else is an attempt to stall proceedings and avoid > genuine communication. > The civil thing to do is to say "I'd love some chips with that, but I have an allergy to starch". Then the "crew" member feels that they have done their best and the attempt to sell chips was forlorn. You'd understand that if you had ever worked for McDonald's.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-28 10:25 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <c4udnT-PC4Nu5F_CnZ2dnUU7-e2dnZ2d@giganews.com> |
| In reply to | #26155 |
On 11/28/2020 10:18 AM, Malcolm McLean wrote: > On Saturday, 28 November 2020 at 16:02:13 UTC, Mike Terry wrote: >> >> Besides, answering questions directly is part of normal civil discourse. >> When you buy your burger and are asked "would you like chips with >> that?" do you respond with an explanation of how five years ago you were >> diagnosed with some medical condition (which implies you're allergic to >> starch)? The civil way of behaving here is to just answer yes or no and >> move on. Anything else is an attempt to stall proceedings and avoid >> genuine communication. >> > The civil thing to do is to say "I'd love some chips with that, but I have > an allergy to starch". Then the "crew" member feels that they have done > their best and the attempt to sell chips was forlorn. > > You'd understand that if you had ever worked for McDonald's. > THE ONLY REASON THAT MOST EVERYONE HERE DOES NOT ALREADY KNOW THAT I AM CORRECT IS THAT THEY MAKE SURE TO IGNORE THESE WORDS: If you can have the discipline to very very carefully analyze my answers as if there was a real chance that I am correct then it should be quite easy to verify in your own mind that I am actually correct. This is the key to understanding that I am correct. On 11/27/2020 9:02 PM, Ben Bacarisse wrote: > A computation that would not halt if its simulation were not > halted is indeed a non-halting computation. When the simulator stops simulating H_Hat before H_Hat ever gets any return value from Halts this makes it impossible for H_Hat to do the opposite of whatever Halts decides, thus making all the conventional HP proofs lose their entire basis. -- 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-30 01:42 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <87blff1uyv.fsf@bsb.me.uk> |
| In reply to | #26145 |
olcott <NoOne@NoWhere.com> writes:
> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
<cut>
>>>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>>>> finite computation and false otherwise.
>>>>
>>>> Do you agree?
>
> I never answer yes or no questions with a yes or no answer.
Let's skip this for the moment because, amazingly (and probably
unwisely), you are very clear later on. Since that's crux, let's skip
to it.
For reference (moved from higher up) here is your code:
08 bool Halts(u32 P, u32 I)
09 {
10 bool Halted = false;
11 bool Aborted = false;
12 while (!Halted && !Aborted)
13 {
14 Halted = DebugStep(P, I);
15 Aborted = Needs_To_Be_Aborted();
16 }
17 return !Aborted;
18 }
And here is my reply:
void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
<cut>
>> Halts(Confound_Halts, Confound_Halts) returns false, according to you,
>> making Confound_Halts(Confound_Halts) a finite computation.
>
> No not at all. Halts is a finite computation.
As required and not in doubt.
> The input to Halts is only finite because Halts forced it to be
> finite, otherwise it is infinite.
The input to Halts is, as you say, finite. You got there at last! So
you do, in fact, agree with both these key facts:
(a) Halts(Confound_Halts, Confound_Halts) returns false, and
(b) Confound_Halts(Confound_Halts) is a finite computation.
You could just have said "yes" many posts ago.
>> How this
>> determination is made by Halts makes no difference. The determination
>
> The input to Halts is only finite because Halts forced it to be
> finite, otherwise it is infinite.
Yes, the input to Halts is a finite computation. You finally accept
that explicitly.
>>>> Therefore Halts is not a halt decider. Which of the these do you
>>>> disagree with?
>>
>> No answer? What a surprise!
>
> I just proved that Halts does decide (H_Hat, H_Hat) correctly...
Don't put up a straw man at this late stage!. You need to address /my/
confounding example. That way you can't change the code behind my back.
You've posted so many variations of function with the same name that
debate about them is almost impossible.
But you /have/ been clear about my confounding example: you agree with
both (a) and (b). The only sticking point remaining is that you won't
agree that
A halt decider is a function F such that F(P, I) is true iff P(I) is a
finite computation and false otherwise.
for the obvious reason that because of (a) and (b) your Halts is not a
halting decider /in this sense/. You need to change the meaning of the
question "is P(I) a finite computation?" so your Halts can be declared
to get the right answer.
But the irony is that it doesn't matter. Imagine a hypothetical world
where you have published your halt decider (in full) and your are now
world famous giving (post Covid) lectures on why Turing was wrong, when
someone in a lecture stands up a proposes the "Bacarisse halting
problem", exactly as written above. What do you do? You can't say its
the same problem because the audience will jeer at you since it clearly
isn't. After all, part way through the lecture you've said explicitly
(as above) that Confound_Halts(Confound_Halts) is a finite computation.
All you can say is "I guess I've found the problem I need to spend the
next two decades on".
Whether my wording is "the halting problem" as you (mis)understand it or
not, it is /a/ halting problem, and you can't solve it!
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-29 20:26 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <YOKdnRHmh7_AxVnCnZ2dnUU7-QudnZ2d@giganews.com> |
| In reply to | #26207 |
On 11/29/2020 7:42 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
> <cut>
>>>>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>>>>> finite computation and false otherwise.
>>>>>
>>>>> Do you agree?
>>
>> I never answer yes or no questions with a yes or no answer.
>
> Let's skip this for the moment because, amazingly (and probably
> unwisely), you are very clear later on. Since that's crux, let's skip
> to it.
>
> For reference (moved from higher up) here is your code:
>
> 08 bool Halts(u32 P, u32 I)
> 09 {
> 10 bool Halted = false;
> 11 bool Aborted = false;
> 12 while (!Halted && !Aborted)
> 13 {
> 14 Halted = DebugStep(P, I);
> 15 Aborted = Needs_To_Be_Aborted();
> 16 }
> 17 return !Aborted;
> 18 }
>
> And here is my reply:
>
> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>
> <cut>
>>> Halts(Confound_Halts, Confound_Halts) returns false, according to you,
>>> making Confound_Halts(Confound_Halts) a finite computation.
>>
>> No not at all. Halts is a finite computation.
>
> As required and not in doubt.
>
>> The input to Halts is only finite because Halts forced it to be
>> finite, otherwise it is infinite.
>
> The input to Halts is, as you say, finite. You got there at last! So
> you do, in fact, agree with both these key facts:
>
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation.
Just like there is no exception to this rule:
∀n ∈ ℕ ((n > 5) → (N > 3))
Every computation that would not halt if its simulation were not halted
is by logical necessity a non-halting computation.
--
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-12-01 01:30 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](keys to understanding) |
| Message-ID | <871rgaz520.fsf@bsb.me.uk> |
| In reply to | #26210 |
olcott <NoOne@NoWhere.com> writes:
> On 11/29/2020 7:42 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>> On 11/27/2020 11:31 AM, Ben Bacarisse wrote:
>> <cut>
>>>>>> A halt decider is a function F such that F(P, I) is true iff P(I) is a
>>>>>> finite computation and false otherwise.
>>>>>>
>>>>>> Do you agree?
>>>
>>> I never answer yes or no questions with a yes or no answer.
>>
>> Let's skip this for the moment because, amazingly (and probably
>> unwisely), you are very clear later on. Since that's crux, let's skip
>> to it.
>>
>> For reference (moved from higher up) here is your code:
>>
>> 08 bool Halts(u32 P, u32 I)
>> 09 {
>> 10 bool Halted = false;
>> 11 bool Aborted = false;
>> 12 while (!Halted && !Aborted)
>> 13 {
>> 14 Halted = DebugStep(P, I);
>> 15 Aborted = Needs_To_Be_Aborted();
>> 16 }
>> 17 return !Aborted;
>> 18 }
>>
>> And here is my reply:
>>
>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>
>> <cut>
>>>> Halts(Confound_Halts, Confound_Halts) returns false, according to you,
>>>> making Confound_Halts(Confound_Halts) a finite computation.
>>>
>>> No not at all. Halts is a finite computation.
>>
>> As required and not in doubt.
>>
>>> The input to Halts is only finite because Halts forced it to be
>>> finite, otherwise it is infinite.
>>
>> The input to Halts is, as you say, finite. You got there at last! So
>> you do, in fact, agree with both these key facts:
Oh you cut the awkward facts! I am not surprised. Here they are:
(a) Halts(Confound_Halts, Confound_Halts) returns false
(b) Confound_Halts(Confound_Halts) a finite computation.
You appear to agree to both. The inputs to Halts represent the
computation Confound_Halts run with input Confound_Halts which is, you
appear to say right there, a finite computation. (Mind you, it is a
finite computation whether you agree with that fact or not. I just
thought we'd moved forward with you agreeing that it is.)
A halt decider (in this context) is a function F such that F(P, I) is
true iff P(I) is a finite computation and false otherwise so Halts
clearly fails.
One thing is crystal clear. Whatever you claim Halts is, it is not a
halt decider in the sense above. If it is a decider at all, it does not
partition the set of computations -- the pairs (P, I) -- into those that
are finite and those that are not.
> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> A computation that would not halt if its simulation were not
>> halted is indeed a non-halting computation.
Yes, but if Confound_Halts(Confound_Halts) were simulated (accurately)
it would halt. It would halt as soon as Halts returns false, as you say
it does. It is not a non-halting computation.
> Just like there is no exception to this rule:
> ∀n ∈ ℕ ((n > 5) → (N > 3))
>
> Every computation that would not halt if its simulation were not
> halted is by logical necessity a non-halting computation.
Confound_Halts(Confound_Halts) does halt. Any proper simulation of that
computation must also halt. The antecedent of the "logical necessity"
is false.
--
Ben.
[toc] | [prev] | [next] | [standalone]
Page 10 of 11 — ← Prev page 1 … 8 9 [10] 11 Next page →
Back to top | Article view | comp.theory
csiph-web