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 9 of 11 — ← Prev page 1 … 7 8 [9] 10 11 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 10:27 -0600 |
| Message-ID | <Weqdnbjny8LJqSDCnZ2dnUU7-d_NnZ2d@giganews.com> |
| In reply to | #25801 |
On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> All that I have right now is a DebugTrace() of all the user specified
>>>> code. This provides a very obvious basis for a halt decider's correct
>>>> halting decision of the H_Hat code specified in this execution trace.
>>>
>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or dumb,
>>> dumb or lying? I can never quite tell.
>>>
>>> Having only the code that loops around the single stepping DebugTrace()
>>> (presumably a simple modification to someone else's emulator) is exactly
>>> the wrong basis for a halt decider. Its the version that makes the
>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>> computation you are analysing is irrelevant because it's not built on a
>>> finite decider.
>>>
>>> Only when you add the impossible "abort if needed" code would you have
>>> anything that even resembles a decider. But it's not a halt decider,
>>> because that code has ITS OWN "HAT" computation which it decides
>>> incorrectly.
>>
>> No it does not and you know that it does not.
>
> If you dare post the code, I'll show you, explicitly (again).
The simplified code that I posted never has been the actual code. The
actual code is far too complex to use as an example.
Line 14 requires an enormously complex set up to enable x86utm to be a
multi-tasking operating system. This was the most difficult part of the
development whole x86utm operating system.
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 }
>> It neither has its own H_Hat computation and the one H_Hat that exists
>> is decided correctly and you know that it is decided correctly.
>
> Of course it has it's own -- you don't get to say I can't write one if I
> want.
There is only one set of machine code in the whole system that comprises
the intruction of H_Hat. I have very great disrespect for people that
deny easily verifiable facts.
> Your ruse -- to use one H_Hat and two different called functions
> is simply dishonest.
It is fricking fully operational code.
> You know about it now, but you keep pushing it
> because you have nothing else. Twenty years and this is all you have.
Your only rebuttal seems to be based on denying easily verifiable facts.
> Any time you fancy posting what you think is a halt decider (even if it
> refers to impossible-to-write code like your "needs_to_be_aborted"
> function), I will post the confounding example.
Whataboutism, also known as whataboutery, is a variant of the tu quoque
logical fallacy that attempts to discredit an opponent's position by
charging them with hypocrisy without directly refuting or disproving
their argument.
Whataboutism is particularly associated with Soviet and Russian
propaganda. https://en.wikipedia.org/wiki/Whataboutism
This is the input to the decider that we are talking about diverting
away from this is the same kind of dishonest dodge used by Soviet
propaganda.
01 void H_Hat(u32 P)
02 {
03 if (Halts(P, P))
04 HERE: goto HERE;
05 else
06 HALT
07 }
> You dare not even try
> because you know I'm right. Need we add intellectual cowardice to your
> character traits?
>
--
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-25 00:16 +0000 |
| Message-ID | <87tute8f4h.fsf@bsb.me.uk> |
| In reply to | #25806 |
olcott <NoOne@NoWhere.com> writes:
> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>
>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or dumb,
>>>> dumb or lying? I can never quite tell.
>>>>
>>>> Having only the code that loops around the single stepping DebugTrace()
>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>> the wrong basis for a halt decider. Its the version that makes the
>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>> computation you are analysing is irrelevant because it's not built on a
>>>> finite decider.
>>>>
>>>> Only when you add the impossible "abort if needed" code would you have
>>>> anything that even resembles a decider. But it's not a halt decider,
>>>> because that code has ITS OWN "HAT" computation which it decides
>>>> incorrectly.
>>>
>>> No it does not and you know that it does not.
>>
>> If you dare post the code, I'll show you, explicitly (again).
>
> The simplified code that I posted never has been the actual code. The
> actual code is far too complex to use as an example.
>
> Line 14 requires an enormously complex set up to enable x86utm to be a
> multi-tasking operating system. This was the most difficult part of
> the development whole x86utm operating system.
(And line 15 is harder still. It's either impossible or it must get an
infinity of cases wrong. Curiously, though, it doesn't matter. I am
happy to assume that it is 100% accurate -- no false positives or
negatives.)
> 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).
>>> It neither has its own H_Hat computation and the one H_Hat that exists
>>> is decided correctly and you know that it is decided correctly.
>>
>> Of course it has it's own -- you don't get to say I can't write one if I
>> want.
>
> There is only one set of machine code in the whole system that
> comprises the intruction of H_Hat. I have very great disrespect for
> people that deny easily verifiable facts.
You have written, at various times, at least half a dozen subtly
different functions called H_Hat. But that does not matter, because you
don't get to pick the confounding example, I do.
>> Your ruse -- to use one H_Hat and two different called functions
>> is simply dishonest.
>
> It is fricking fully operational code.
So what? It's still a ruse, and it's still the case that a sound
Needs_To_Be_Aborted function can't be written.
To be clear: the ruse is to say that the correct answer for the halting
status of a computation is to be determined by the behaviour of a
/different/ computation -- often shown using the same function names (to
add to the smoke and mirrors) -- but a different one none the less.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 18:30 -0600 |
| Message-ID | <2aidnV9e3qQaOCDCnZ2dnUU7-c3NnZ2d@giganews.com> |
| In reply to | #25867 |
On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>
>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or dumb,
>>>>> dumb or lying? I can never quite tell.
>>>>>
>>>>> Having only the code that loops around the single stepping DebugTrace()
>>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>> computation you are analysing is irrelevant because it's not built on a
>>>>> finite decider.
>>>>>
>>>>> Only when you add the impossible "abort if needed" code would you have
>>>>> anything that even resembles a decider. But it's not a halt decider,
>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>> incorrectly.
>>>>
>>>> No it does not and you know that it does not.
>>>
>>> If you dare post the code, I'll show you, explicitly (again).
>>
>> The simplified code that I posted never has been the actual code. The
>> actual code is far too complex to use as an example.
>>
>> Line 14 requires an enormously complex set up to enable x86utm to be a
>> multi-tasking operating system. This was the most difficult part of
>> the development whole x86utm operating system.
>
> (And line 15 is harder still. It's either impossible or it must get an
> infinity of cases wrong. Curiously, though, it doesn't matter. I am
> happy to assume that it is 100% accurate -- no false positives or
> negatives.)
>
>> 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.
Clearly you have not been paying any attention at all.
I have shown the complete execution trace basis for Halts to correctly
decide any any all instances like your Confound_Halts, quite a few times
now. The best one is in the original post of this thread.
--
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-24 23:17 -0500 |
| Message-ID | <wVkvH.8783$OP2.1118@fx18.iad> |
| In reply to | #25871 |
On 11/24/20 7:30 PM, olcott wrote:
> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>> specified
>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>> correct
>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>> trace.
>>>>>>
>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or
>>>>>> dumb,
>>>>>> dumb or lying? I can never quite tell.
>>>>>>
>>>>>> Having only the code that loops around the single stepping
>>>>>> DebugTrace()
>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>> exactly
>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>> on a
>>>>>> finite decider.
>>>>>>
>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>> have
>>>>>> anything that even resembles a decider. But it's not a halt decider,
>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>> incorrectly.
>>>>>
>>>>> No it does not and you know that it does not.
>>>>
>>>> If you dare post the code, I'll show you, explicitly (again).
>>>
>>> The simplified code that I posted never has been the actual code. The
>>> actual code is far too complex to use as an example.
>>>
>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>> multi-tasking operating system. This was the most difficult part of
>>> the development whole x86utm operating system.
>>
>> (And line 15 is harder still. It's either impossible or it must get an
>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>> happy to assume that it is 100% accurate -- no false positives or
>> negatives.)
>>
>>> 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.
At which point the if skips the while loop and the machine halts, so the
decider was wrong.
>
> Clearly you have not been paying any attention at all.
Clearly YOU haven't been.
>
> I have shown the complete execution trace basis for Halts to correctly
> decide any any all instances like your Confound_Halts, quite a few times
> now. The best one is in the original post of this thread.
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 22:43 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <n_udnTA2IcmUfCDCnZ2dnUU7-LfNnZ2d@giganews.com> |
| In reply to | #25909 |
On 11/24/2020 10:17 PM, Richard Damon wrote:
> On 11/24/20 7:30 PM, olcott wrote:
>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>> specified
>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>> correct
>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>> trace.
>>>>>>>
>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or
>>>>>>> dumb,
>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>
>>>>>>> Having only the code that loops around the single stepping
>>>>>>> DebugTrace()
>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>> exactly
>>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>>> on a
>>>>>>> finite decider.
>>>>>>>
>>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>>> have
>>>>>>> anything that even resembles a decider. But it's not a halt decider,
>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>> incorrectly.
>>>>>>
>>>>>> No it does not and you know that it does not.
>>>>>
>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>
>>>> The simplified code that I posted never has been the actual code. The
>>>> actual code is far too complex to use as an example.
>>>>
>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>> multi-tasking operating system. This was the most difficult part of
>>>> the development whole x86utm operating system.
>>>
>>> (And line 15 is harder still. It's either impossible or it must get an
>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>> happy to assume that it is 100% accurate -- no false positives or
>>> negatives.)
>>>
>>>> 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.
>
> At which point the if skips the while loop and the machine halts, so the
> decider was wrong.
Only because we change the question from:
Does the input halt on its input?
to
Must the input be aborted to prevent its otherwise infinite execution?
Are the key counter-examples of the HP proofs made halting decidable.
--
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-24 23:53 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <FrlvH.13948$lo15.12878@fx35.iad> |
| In reply to | #25912 |
On 11/24/20 11:43 PM, olcott wrote:
> On 11/24/2020 10:17 PM, Richard Damon wrote:
>> On 11/24/20 7:30 PM, olcott wrote:
>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>> specified
>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>> correct
>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>> trace.
>>>>>>>>
>>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or
>>>>>>>> dumb,
>>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>>
>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>> DebugTrace()
>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>> exactly
>>>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>>>> on a
>>>>>>>> finite decider.
>>>>>>>>
>>>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>>>> have
>>>>>>>> anything that even resembles a decider. But it's not a halt
>>>>>>>> decider,
>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>> incorrectly.
>>>>>>>
>>>>>>> No it does not and you know that it does not.
>>>>>>
>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>
>>>>> The simplified code that I posted never has been the actual code. The
>>>>> actual code is far too complex to use as an example.
>>>>>
>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>> multi-tasking operating system. This was the most difficult part of
>>>>> the development whole x86utm operating system.
>>>>
>>>> (And line 15 is harder still. It's either impossible or it must get an
>>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>>> happy to assume that it is 100% accurate -- no false positives or
>>>> negatives.)
>>>>
>>>>> 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.
>>
>> At which point the if skips the while loop and the machine halts, so the
>> decider was wrong.
>
> Only because we change the question from:
>
> Does the input halt on its input?
> to
> Must the input be aborted to prevent its otherwise infinite execution?
>
> Are the key counter-examples of the HP proofs made halting decidable.
>
But, as has been shown, this are truly exact opposites, at least if you
want your results to apply to the same thing as the conventional halting
problem. If you agree that you are working on a different question, and
thus your results do not apply to things based on the conventional
halting problem, go ahead and change it, so the the aborting of a
recursively nested version of the code allows you to decide that the
machine is 'need to be aborted'. Just remeber if you do, that you can't
claim any of this applies to the conventional halting problem or things
based on it.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 23:12 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <sK2dnVNE0sAgeiDCnZ2dnUU7-QXNnZ2d@giganews.com> |
| In reply to | #25914 |
On 11/24/2020 10:53 PM, Richard Damon wrote:
> On 11/24/20 11:43 PM, olcott wrote:
>> On 11/24/2020 10:17 PM, Richard Damon wrote:
>>> On 11/24/20 7:30 PM, olcott wrote:
>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>> specified
>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>> correct
>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>> trace.
>>>>>>>>>
>>>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or
>>>>>>>>> dumb,
>>>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>>>
>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>> DebugTrace()
>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>> exactly
>>>>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>>>>> on a
>>>>>>>>> finite decider.
>>>>>>>>>
>>>>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>>>>> have
>>>>>>>>> anything that even resembles a decider. But it's not a halt
>>>>>>>>> decider,
>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>> incorrectly.
>>>>>>>>
>>>>>>>> No it does not and you know that it does not.
>>>>>>>
>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>
>>>>>> The simplified code that I posted never has been the actual code. The
>>>>>> actual code is far too complex to use as an example.
>>>>>>
>>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>> the development whole x86utm operating system.
>>>>>
>>>>> (And line 15 is harder still. It's either impossible or it must get an
>>>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>> negatives.)
>>>>>
>>>>>> 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.
>>>
>>> At which point the if skips the while loop and the machine halts, so the
>>> decider was wrong.
>>
>> Only because we change the question from:
>>
>> Does the input halt on its input?
>> to
>> Must the input be aborted to prevent its otherwise infinite execution?
>>
>> Are the key counter-examples of the HP proofs made halting decidable.
>>
>
> But, as has been shown, this are truly exact opposites,
A program that only halts if it is aborted has opposite halting behavior
to a program that halts without being aborted.
--
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 07:39 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <IfsvH.106027$1R4.16061@fx44.iad> |
| In reply to | #25919 |
On 11/25/20 12:12 AM, olcott wrote: > On 11/24/2020 10:53 PM, Richard Damon wrote: >> On 11/24/20 11:43 PM, olcott wrote: >>> Only because we change the question from: >>> >>> Does the input halt on its input? >>> to >>> Must the input be aborted to prevent its otherwise infinite execution? >>> >>> Are the key counter-examples of the HP proofs made halting decidable. >>> >> >> But, as has been shown, this are truly exact opposites, > > A program that only halts if it is aborted has opposite halting behavior > to a program that halts without being aborted. Yes, a program that ONLY halts if it is aborted is the opposite of a pogrmam that halts without being aborted. A program that haltes because it was aborted is something very different. It might have halted anyway if given more time. The key words here are things like MUST and ONLY. Just because you come up with some 'logical' justification that make it seems like it needs to be. The REAL test is to actually run it and see. If the actual program when run does halt, then the logic has been proved to be unsound. Yes, proving a given computation is indeed non-halting can be difficult, even impossible (otherwise we COULD have halting deciders), but very many cases can be proven with a few simple rules. Things like repeating state or loops with no way out (absolutely no way out, not even an OS monetering them with the ability to abort them), so we can answer many cases, and in particular, if we can find the halting behavior, we can disprove the non-halting determination. >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 08:17 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <N6adnVpAzJ_1-iPCnZ2dnUU7-T_NnZ2d@giganews.com> |
| In reply to | #25923 |
On 11/25/2020 6:39 AM, Richard Damon wrote:
> On 11/25/20 12:12 AM, olcott wrote:
>> On 11/24/2020 10:53 PM, Richard Damon wrote:
>>> On 11/24/20 11:43 PM, olcott wrote:
>
>>>> Only because we change the question from:
>>>>
>>>> Does the input halt on its input?
>>>> to
>>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>>
>>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>>
>>>
>>> But, as has been shown, this are truly exact opposites,
>>
>> A program that only halts if it is aborted has opposite halting behavior
>> to a program that halts without being aborted.
>
> Yes, a program that ONLY halts if it is aborted is the opposite of a
> pogrmam that halts without being aborted.
>
> A program that haltes because it was aborted is something very
> different. It might have halted anyway if given more time.
There are a set of programs that can be determined in advance to never
halt. Here is one of them:
int main()
{
HERE: goto HERE;
}
> The key words here are things like MUST and ONLY. Just because you come
> up with some 'logical' justification that make it seems like it needs to
> be. The REAL test is to actually run it and see. If the actual program
> when run does halt, then the logic has been proved to be unsound.
There are a set of computations that can be determined in advance that
will never halt and this can be determined with 100% logical certainty.
> Yes, proving a given computation is indeed non-halting can be difficult,
> even impossible (otherwise we COULD have halting deciders), but very
This kind of pure speculation is no sort of counter-example proof of
undecidability.
> many cases can be proven with a few simple rules. Things like repeating
> state or loops with no way out (absolutely no way out, not even an OS
> monetering them with the ability to abort them), so we can answer many
> cases, and in particular, if we can find the halting behavior, we can
> disprove the non-halting determination.
--
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 10:14 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <3xuvH.199083$oL7.71453@fx06.iad> |
| In reply to | #25928 |
On 11/25/20 9:17 AM, olcott wrote:
> On 11/25/2020 6:39 AM, Richard Damon wrote:
>> On 11/25/20 12:12 AM, olcott wrote:
>>> On 11/24/2020 10:53 PM, Richard Damon wrote:
>>>> On 11/24/20 11:43 PM, olcott wrote:
>>
>>>>> Only because we change the question from:
>>>>>
>>>>> Does the input halt on its input?
>>>>> to
>>>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>>>
>>>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>>>
>>>>
>>>> But, as has been shown, this are truly exact opposites,
>>>
>>> A program that only halts if it is aborted has opposite halting behavior
>>> to a program that halts without being aborted.
>>
>> Yes, a program that ONLY halts if it is aborted is the opposite of a
>> pogrmam that halts without being aborted.
>>
>> A program that haltes because it was aborted is something very
>> different. It might have halted anyway if given more time.
>
> There are a set of programs that can be determined in advance to never
> halt. Here is one of them:
>
> int main()
> {
> HERE: goto HERE;
> }
>
Never denied that.
>> The key words here are things like MUST and ONLY. Just because you come
>> up with some 'logical' justification that make it seems like it needs to
>> be. The REAL test is to actually run it and see. If the actual program
>> when run does halt, then the logic has been proved to be unsound.
>
> There are a set of computations that can be determined in advance that
> will never halt and this can be determined with 100% logical certainty.
>
Never denied that, there is a set of computation that can be determined
in adanced that will never halt. That set might not include every
computation that WILL not halt. (in fact, because the halting problem
HAS been proved to be unsolvable, we know that there will be members in
the set of non-halting computations that can not be proven to be
non-halting).
>> Yes, proving a given computation is indeed non-halting can be difficult,
>> even impossible (otherwise we COULD have halting deciders), but very
>
> This kind of pure speculation is no sort of counter-example proof of
> undecidability.
Until you can PROVE that you can decide EVERY case correctly, you don't
have ground to stand on. I can stand on the grounds of Linz (and
others_, and say the statement is proven.
Since we have a case that your machine still does not decide correctly,
by the criteria of the classical halting problem, which by your
arguments, you seem to be working on, you counter proof is disproved.
The traces you have provided, in part because they are only partial
since you haven't finished, show one of two failures. Either you fail by
failing to proved the answer to the computation asking for it, or you
fail by giving it the wrong answer (you say it will be non-halting when
it actually halts).
As I have said many times before, if you CLEARLY state that you admit to
be working on a different problem, and that therefore your results are
not applicable to the classical halting problem or the theories based on
it, then we can look at your alternate definition.
>
>> many cases can be proven with a few simple rules. Things like repeating
>> state or loops with no way out (absolutely no way out, not even an OS
>> monetering them with the ability to abort them), so we can answer many
>> cases, and in particular, if we can find the halting behavior, we can
>> disprove the non-halting determination.
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 09:52 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (This is the whole thing) |
| Message-ID | <uO6dnXXxyv1M4CPCnZ2dnUU7-YXNnZ2d@giganews.com> |
| In reply to | #25932 |
On 11/25/2020 9:14 AM, Richard Damon wrote:
> On 11/25/20 9:17 AM, olcott wrote:
>> On 11/25/2020 6:39 AM, Richard Damon wrote:
>>> On 11/25/20 12:12 AM, olcott wrote:
>>>> On 11/24/2020 10:53 PM, Richard Damon wrote:
>>>>> On 11/24/20 11:43 PM, olcott wrote:
>>>
>>>>>> Only because we change the question from:
>>>>>>
>>>>>> Does the input halt on its input?
>>>>>> to
>>>>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>>>>
>>>>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>>>>
>>>>>
>>>>> But, as has been shown, this are truly exact opposites,
>>>>
>>>> A program that only halts if it is aborted has opposite halting behavior
>>>> to a program that halts without being aborted.
>>>
>>> Yes, a program that ONLY halts if it is aborted is the opposite of a
>>> pogrmam that halts without being aborted.
>>>
>>> A program that haltes because it was aborted is something very
>>> different. It might have halted anyway if given more time.
>>
>> There are a set of programs that can be determined in advance to never
>> halt. Here is one of them:
>>
>> int main()
>> {
>> HERE: goto HERE;
>> }
>>
>
> Never denied that.
>
>>> The key words here are things like MUST and ONLY. Just because you come
>>> up with some 'logical' justification that make it seems like it needs to
>>> be. The REAL test is to actually run it and see. If the actual program
>>> when run does halt, then the logic has been proved to be unsound.
>>
>> There are a set of computations that can be determined in advance that
>> will never halt and this can be determined with 100% logical certainty.
>>
>
> Never denied that, there is a set of computation that can be determined
> in adanced that will never halt. That set might not include every
> computation that WILL not halt. (in fact, because the halting problem
> HAS been proved to be unsolvable, we know that there will be members in
> the set of non-halting computations that can not be proven to be
> non-halting).
(1)I did correctly show how to decide halting for the x86utm
computational equivalent of a simplified form of the Linz Ĥ.
(2) This simplified form of the Linz H_Hat is the basis for all of the
conventional halting problem proofs.
∴ I have proved that none of these conventional proofs (including Linz)
have any basis for their conclusion.
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
All of the current rebuttals take the form that because Halts() does
correct decide its input and it is common knowledge that this is
impossible therefore Halts must be incorrect.
>>> Yes, proving a given computation is indeed non-halting can be difficult,
>>> even impossible (otherwise we COULD have halting deciders), but very
>>
>> This kind of pure speculation is no sort of counter-example proof of
>> undecidability.
>
> Until you can PROVE that you can decide EVERY case correctly, you don't
> have ground to stand on. I can stand on the grounds of Linz (and
> others_, and say the statement is proven.
Yes if you ignore the verified fact that the above code is decided
correctly you can bury your head in the sand and say that Linz still
applies.
> Since we have a case that your machine still does not decide correctly,
> by the criteria of the classical halting problem, which by your
> arguments, you seem to be working on, you counter proof is disproved.
We have no such case. You said that Halts must be wrong BECAUSE it gets
the correct answer.
> The traces you have provided, in part because they are only partial
> since you haven't finished, show one of two failures. Either you fail by
> failing to proved the answer to the computation asking for it,
Simply ignoring my rebuttals is not any actual rebuttal at all, you seem
to thinks that it is. I have asked you this at least three times and and
you simply ignore my question.
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
int DebugTrace(u32 N, u32 M)
{
return ((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;
}
--
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-25 22:16 +0000 |
| Message-ID | <87zh355bfu.fsf@bsb.me.uk> |
| In reply to | #25871 |
olcott <NoOne@NoWhere.com> writes:
> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>>
>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or dumb,
>>>>>> dumb or lying? I can never quite tell.
>>>>>>
>>>>>> Having only the code that loops around the single stepping DebugTrace()
>>>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>> computation you are analysing is irrelevant because it's not built on a
>>>>>> finite decider.
>>>>>>
>>>>>> Only when you add the impossible "abort if needed" code would you have
>>>>>> anything that even resembles a decider. But it's not a halt decider,
>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>> incorrectly.
>>>>>
>>>>> No it does not and you know that it does not.
>>>>
>>>> If you dare post the code, I'll show you, explicitly (again).
>>>
>>> The simplified code that I posted never has been the actual code. The
>>> actual code is far too complex to use as an example.
>>>
>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>> multi-tasking operating system. This was the most difficult part of
>>> the development whole x86utm operating system.
>>
>> (And line 15 is harder still. It's either impossible or it must get an
>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>> happy to assume that it is 100% accurate -- no false positives or
>> negatives.)
>>
>>> 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).
A halt decider is a function F, such that F(P, I) is true if and only if
P(I) is a finite computation and false otherwise.
> Clearly you have not been paying any attention at all.
Everyone now knows you have your own silly definition of what the right
answer is because you have made the mistake of being clear.
I am not posting this in the hope that you will suddenly accept that you
are wrong, I am posting it just to keep the record straight.
Confound_Halts(Confound_Halts) is one of the problem computations for
the hypothetical halt decider you posted.
Remarkably, this is true even of we assume a perfect implementation of
Needs_To_Be_Aborted. Think about that for a moment. The problem that
Needs_To_Be_Aborted has to solve is, more or less, equivalent to the
halting problem itself, yet we can't write a correct halt decider even
when we assume it. This is of course why the original proof by
contradiction works.
> I have shown the complete execution trace basis for Halts to correctly
> decide any any all instances like your Confound_Halts, quite a few
> times now.
You tell me that Halts(Confound_Halts, Confound_Halts) returns false and
I am happy to take your word for it. The trace is not needed to confirm
that. The problem is your insistence that the wrong answer is the right
one.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 16:25 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <6Y6dnaUGHOdNRCPCnZ2dnUU7-fPNnZ2d@giganews.com> |
| In reply to | #25975 |
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:
>>>
>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>>>
>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying or dumb,
>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>
>>>>>>> Having only the code that loops around the single stepping DebugTrace()
>>>>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>> computation you are analysing is irrelevant because it's not built on a
>>>>>>> finite decider.
>>>>>>>
>>>>>>> Only when you add the impossible "abort if needed" code would you have
>>>>>>> anything that even resembles a decider. But it's not a halt decider,
>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>> incorrectly.
>>>>>>
>>>>>> No it does not and you know that it does not.
>>>>>
>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>
>>>> The simplified code that I posted never has been the actual code. The
>>>> actual code is far too complex to use as an example.
>>>>
>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>> multi-tasking operating system. This was the most difficult part of
>>>> the development whole x86utm operating system.
>>>
>>> (And line 15 is harder still. It's either impossible or it must get an
>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>> happy to assume that it is 100% accurate -- no false positives or
>>> negatives.)
>>>
>>>> 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".
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().
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;
}
--
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 18:35 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <0TBvH.159998$gR8.40967@fx45.iad> |
| In reply to | #25977 |
On 11/25/20 5:25 PM, olcott wrote:
> 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:
>>>>
>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>> specified
>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>> correct
>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>> trace.
>>>>>>>>
>>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying
>>>>>>>> or dumb,
>>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>>
>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>> DebugTrace()
>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>> exactly
>>>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>> built on a
>>>>>>>> finite decider.
>>>>>>>>
>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>> you have
>>>>>>>> anything that even resembles a decider. But it's not a halt
>>>>>>>> decider,
>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>> incorrectly.
>>>>>>>
>>>>>>> No it does not and you know that it does not.
>>>>>>
>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>
>>>>> The simplified code that I posted never has been the actual code. The
>>>>> actual code is far too complex to use as an example.
>>>>>
>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>> multi-tasking operating system. This was the most difficult part of
>>>>> the development whole x86utm operating system.
>>>>
>>>> (And line 15 is harder still. It's either impossible or it must get an
>>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>>> happy to assume that it is 100% accurate -- no false positives or
>>>> negatives.)
>>>>
>>>>> 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".
> Based on this assumption you conclude that Pete is wrong".
> You make sure to always skip all the steps in-between.
The counter does NOT start with the assumption of Pete is wrong, the
counter starts with the knowledge that we have a test we can run to see
what happens, (And happens to know one that this Halts will fail), and
then runs the test and sees the failure.
>
> The first step of proof that "Pete is right" is understanding that
> H_Hat() never receives a return value from DebugStep().
>
But it isn't Confounds_Halts problem that Halts never gave its answer in
its emulation to those that needed it for Halts to figure the answer. It
is Halts problem to figure out how to do it, and it did it wrong.
Yes, you 'proof' seems to start with the (baseless) assumption that you
have the right answer, but never establishes that there even is one.
>
> 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;
> }
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 17:59 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <edGdnZFDhqBRciPCnZ2dnUU7-fnNnZ2d@giganews.com> |
| In reply to | #25983 |
On 11/25/2020 5:35 PM, Richard Damon wrote:
> On 11/25/20 5:25 PM, olcott wrote:
>> 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:
>>>>>
>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>> specified
>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>> correct
>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>> trace.
>>>>>>>>>
>>>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying
>>>>>>>>> or dumb,
>>>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>>>
>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>> DebugTrace()
>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>> exactly
>>>>>>>>> the wrong basis for a halt decider. Its the version that makes the
>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>>> built on a
>>>>>>>>> finite decider.
>>>>>>>>>
>>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>>> you have
>>>>>>>>> anything that even resembles a decider. But it's not a halt
>>>>>>>>> decider,
>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>> incorrectly.
>>>>>>>>
>>>>>>>> No it does not and you know that it does not.
>>>>>>>
>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>
>>>>>> The simplified code that I posted never has been the actual code. The
>>>>>> actual code is far too complex to use as an example.
>>>>>>
>>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>> the development whole x86utm operating system.
>>>>>
>>>>> (And line 15 is harder still. It's either impossible or it must get an
>>>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>> negatives.)
>>>>>
>>>>>> 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".
>> Based on this assumption you conclude that Pete is wrong".
>> You make sure to always skip all the steps in-between.
>
> The counter does NOT start with the assumption of Pete is wrong, the
Both Ben and Jeff start with the assumption that "Pete is wrong" and
from this assumption they conclude that "Pete is wrong" making sure to
avoid any reasoning in-between.
> counter starts with the knowledge that we have a test we can run to see
> what happens, (And happens to know one that this Halts will fail), and
> then runs the test and sees the failure.
In your case my examples were not written clearly enough.
>>
>> The first step of proof that "Pete is right" is understanding that
>> H_Hat() never receives a return value from DebugStep().
>>
>
> But it isn't Confounds_Halts problem that Halts never gave its answer in
Again I tell you that the relationship between Halts() and H_Hat is the
same as the relationship between DebugTrace() and H_Hat.
H_Hat never gets any answer from either one of them entirely on the
basis the a fault of H_Hat.
> its emulation to those that needed it for Halts to figure the answer. It
> is Halts problem to figure out how to do it, and it did it wrong.
>
> Yes, you 'proof' seems to start with the (baseless) assumption that you
> have the right answer, but never establishes that there even is one.
>
>>
>> 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;
>> }
>>
>>
>>
>
--
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 19:55 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <c2DvH.160002$gR8.79102@fx45.iad> |
| In reply to | #25986 |
On 11/25/20 6:59 PM, olcott wrote:
> On 11/25/2020 5:35 PM, Richard Damon wrote:
>> On 11/25/20 5:25 PM, olcott wrote:
>>> 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:
>>>>>>
>>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>>> specified
>>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>>> correct
>>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>>> trace.
>>>>>>>>>>
>>>>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying
>>>>>>>>>> or dumb,
>>>>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>>>>
>>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>>> DebugTrace()
>>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>>> exactly
>>>>>>>>>> the wrong basis for a halt decider. Its the version that
>>>>>>>>>> makes the
>>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>>>> built on a
>>>>>>>>>> finite decider.
>>>>>>>>>>
>>>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>>>> you have
>>>>>>>>>> anything that even resembles a decider. But it's not a halt
>>>>>>>>>> decider,
>>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>>> incorrectly.
>>>>>>>>>
>>>>>>>>> No it does not and you know that it does not.
>>>>>>>>
>>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>>
>>>>>>> The simplified code that I posted never has been the actual code.
>>>>>>> The
>>>>>>> actual code is far too complex to use as an example.
>>>>>>>
>>>>>>> Line 14 requires an enormously complex set up to enable x86utm to
>>>>>>> be a
>>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>>> the development whole x86utm operating system.
>>>>>>
>>>>>> (And line 15 is harder still. It's either impossible or it must
>>>>>> get an
>>>>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>>> negatives.)
>>>>>>
>>>>>>> 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".
>>> Based on this assumption you conclude that Pete is wrong".
>>> You make sure to always skip all the steps in-between.
>>
>> The counter does NOT start with the assumption of Pete is wrong, the
>
> Both Ben and Jeff start with the assumption that "Pete is wrong" and
> from this assumption they conclude that "Pete is wrong" making sure to
> avoid any reasoning in-between.
But I am not they (not sure they really are starting that way either).
We all start KNOWING you are wrong, but the arguements aren't based on
that. Otherwise the response would just be Linz says your wrong.
>
>> counter starts with the knowledge that we have a test we can run to see
>> what happens, (And happens to know one that this Halts will fail), and
>> then runs the test and sees the failure.
>
> In your case my examples were not written clearly enough.
Since ultimately, to my understand, you really only have one 'example'
of a Halting Decider you need to present, so all you really need to do
is show it.
A big part of the issue is that you want to try to first reason out with
people so they will accept your arguements before you want to let them
test you decider. The problem is that they don't need to accept your
logic to test it, the just need to know what it actually does.
Now, if you were to change your tack and accept that you are not
thinking of the same halting problem that everyone else uses, make that
clear to everyone, and by doing so accept that you results aren't
applicable to anything that wants the classic halting problem, then you
would need to explain your ideas about why and what and really define
the problem you are trying to solve.
One big piece of that is that if you are no longer working on the
classical halting problem, Linz can just go away if you define your
problem right. This sort of seems what you are trying to do, only you
aren't accepting that you are doing a different problem.
You CAN'T just define yourself around Linz and still be doing the
classical halting problem.
>
>>>
>>> The first step of proof that "Pete is right" is understanding that
>>> H_Hat() never receives a return value from DebugStep().
>>>
>>
>> But it isn't Confounds_Halts problem that Halts never gave its answer in
>
> Again I tell you that the relationship between Halts() and H_Hat is the
> same as the relationship between DebugTrace() and H_Hat.
>
> H_Hat never gets any answer from either one of them entirely on the
> basis the a fault of H_Hat.
Since it is Halts responsibility to give an answer to any and every
quetion posed to it, it gets hard to blame the lowly input that just
came to be tested.
>
>> its emulation to those that needed it for Halts to figure the answer. It
>> is Halts problem to figure out how to do it, and it did it wrong.
>>
>> Yes, you 'proof' seems to start with the (baseless) assumption that you
>> have the right answer, but never establishes that there even is one.
>>
>>>
>>> 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;
>>> }
>>>
>>>
>>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 19:03 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <0NmdnQTOBvJLYyPCnZ2dnUU7-YOdnZ2d@giganews.com> |
| In reply to | #25993 |
On 11/25/2020 6:55 PM, Richard Damon wrote:
> On 11/25/20 6:59 PM, olcott wrote:
>> On 11/25/2020 5:35 PM, Richard Damon wrote:
>>> On 11/25/20 5:25 PM, olcott wrote:
>>>> 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:
>>>>>>>
>>>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>>>> specified
>>>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>>>> correct
>>>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>>>> trace.
>>>>>>>>>>>
>>>>>>>>>>> Gosh. Is that a lie, or is that just very, very stupid? Lying
>>>>>>>>>>> or dumb,
>>>>>>>>>>> dumb or lying? I can never quite tell.
>>>>>>>>>>>
>>>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>>>> DebugTrace()
>>>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>>>> exactly
>>>>>>>>>>> the wrong basis for a halt decider. Its the version that
>>>>>>>>>>> makes the
>>>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER. The "HAT"
>>>>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>>>>> built on a
>>>>>>>>>>> finite decider.
>>>>>>>>>>>
>>>>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>>>>> you have
>>>>>>>>>>> anything that even resembles a decider. But it's not a halt
>>>>>>>>>>> decider,
>>>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>>>> incorrectly.
>>>>>>>>>>
>>>>>>>>>> No it does not and you know that it does not.
>>>>>>>>>
>>>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>>>
>>>>>>>> The simplified code that I posted never has been the actual code.
>>>>>>>> The
>>>>>>>> actual code is far too complex to use as an example.
>>>>>>>>
>>>>>>>> Line 14 requires an enormously complex set up to enable x86utm to
>>>>>>>> be a
>>>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>>>> the development whole x86utm operating system.
>>>>>>>
>>>>>>> (And line 15 is harder still. It's either impossible or it must
>>>>>>> get an
>>>>>>> infinity of cases wrong. Curiously, though, it doesn't matter. I am
>>>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>>>> negatives.)
>>>>>>>
>>>>>>>> 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".
>>>> Based on this assumption you conclude that Pete is wrong".
>>>> You make sure to always skip all the steps in-between.
>>>
>>> The counter does NOT start with the assumption of Pete is wrong, the
>>
>> Both Ben and Jeff start with the assumption that "Pete is wrong" and
>> from this assumption they conclude that "Pete is wrong" making sure to
>> avoid any reasoning in-between.
>
> But I am not they (not sure they really are starting that way either).
>
> We all start KNOWING you are wrong, but the arguements aren't based on
> that. Otherwise the response would just be Linz says your wrong.
>>
>>> counter starts with the knowledge that we have a test we can run to see
>>> what happens, (And happens to know one that this Halts will fail), and
>>> then runs the test and sees the failure.
>>
>> In your case my examples were not written clearly enough.
>
> Since ultimately, to my understand, you really only have one 'example'
> of a Halting Decider you need to present, so all you really need to do
> is show it.
>
> A big part of the issue is that you want to try to first reason out with
> people so they will accept your arguements before you want to let them
> test you decider. The problem is that they don't need to accept your
> logic to test it, the just need to know what it actually does.
>
> Now, if you were to change your tack and accept that you are not
> thinking of the same halting problem that everyone else uses, make that
> clear to everyone, and by doing so accept that you results aren't
> applicable to anything that wants the classic halting problem, then you
> would need to explain your ideas about why and what and really define
> the problem you are trying to solve.
>
> One big piece of that is that if you are no longer working on the
> classical halting problem, Linz can just go away if you define your
> problem right. This sort of seems what you are trying to do, only you
> aren't accepting that you are doing a different problem.
>
> You CAN'T just define yourself around Linz and still be doing the
> classical halting problem.
>
>>
>>>>
>>>> The first step of proof that "Pete is right" is understanding that
>>>> H_Hat() never receives a return value from DebugStep().
>>>>
>>>
>>> But it isn't Confounds_Halts problem that Halts never gave its answer in
>>
>> Again I tell you that the relationship between Halts() and H_Hat is the
>> same as the relationship between DebugTrace() and H_Hat.
>>
>> H_Hat never gets any answer from either one of them entirely on the
>> basis the a fault of H_Hat.
>
> Since it is Halts responsibility to give an answer to any and every
> quetion posed to it, it gets hard to blame the lowly input that just
> came to be tested.
>
Clearly you have a fundamental lack of understanding of infinite
recursion.
>>
>>> its emulation to those that needed it for Halts to figure the answer. It
>>> is Halts problem to figure out how to do it, and it did it wrong.
>>>
>>> Yes, you 'proof' seems to start with the (baseless) assumption that you
>>> have the right answer, but never establishes that there even is one.
>>>
>>>>
>>>> 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;
>>>> }
>>>>
>>>>
>>>>
>>>
>>
>>
>
--
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 21:55 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <TOEvH.65056$J92.17423@fx48.iad> |
| In reply to | #25995 |
On 11/25/20 8:03 PM, olcott wrote: > On 11/25/2020 6:55 PM, Richard Damon wrote: > >> Since it is Halts responsibility to give an answer to any and every >> quetion posed to it, it gets hard to blame the lowly input that just >> came to be tested. >> > > Clearly you have a fundamental lack of understanding of infinite recursion. I have no problems understanding infinite recursion, what you seem to miss is that when the halt decider is in the loop,it can be the need break of the recursion that keeps H_Hat from being non-halting (and is relying on the finite execution requirements on the Halt Decider). It is the Halt Deciders problem with figuring out how to decide this case that causing the issues. An 'infinite recursion' that happens inside the 'must be finite' call to the halt decider does NOT allow a higher level halts decider to call this H_Hat non-halting. Lets draw a simple execution nesting tree: 1) A call to Halts(P, I) 2) P(I) exeuctes, and in it 3) calls Halts(P1, I1) 4) P1(I1) executes, which maybe 5) calls Halts(P2, I2) ... Any non-halting behavior at inside level 3 or 4 can not be used as a reason to call level 2 non-halting, because each call to Halts is required to be of finite execution, so it is Halts reponsibility to resolve any such infinite execution and still return the right answer. Remember Halts is claimed to be a UNIVERSAL Halt Decider, thus is says it is willing to take on all comers, even those who in its mind are cheating. For the call the Halts at layer 1 to call its input non-halting, it needs to find the non-halting behavior IN layer 2. Now if layer 2 calls layer 3 an infinite number of times (not recursive but iterative) then that iteration loop will be in layer 2 and can be cause to call P(I) non-halting. Note it also doesn't matter if P==P1 and I==I1, the execution at layer 4 is distinct, and NO non-halting behavior there can cause P(I) in layer 2 to be non-halting. One of the problems with your algorithm is that you are detecting the infinite recursion at layers 3 or 4, and then using that to say that this is evidence of P(I) at layer 2 is non-halting, when actually either the Halts at layer 3 will catch the problem and abort the looping, or the Halts will fail to meet is requirement of making its decision in finite time While in the second case, it IS true that P(I) was a non-halting computation, Halts has still shown itself to fail to meet its requirements.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-25 21:06 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <DdOdna35_s86hiLCnZ2dnUU7-ImdnZ2d@giganews.com> |
| In reply to | #26009 |
On 11/25/2020 8:55 PM, Richard Damon wrote:
> On 11/25/20 8:03 PM, olcott wrote:
>> On 11/25/2020 6:55 PM, Richard Damon wrote:
>
>>
>>> Since it is Halts responsibility to give an answer to any and every
>>> quetion posed to it, it gets hard to blame the lowly input that just
>>> came to be tested.
>>>
>>
>> Clearly you have a fundamental lack of understanding of infinite recursion.
>
> I have no problems understanding infinite recursion, what you seem to
> miss is that when the halt decider is in the loop,it can be the need
> break of the recursion that keeps H_Hat from being non-halting (and is
> relying on the finite execution requirements on the Halt Decider).
>
> It is the Halt Deciders problem with figuring out how to decide this
> case that causing the issues.
>
> An 'infinite recursion' that happens inside the 'must be finite' call to
> the halt decider does NOT allow a higher level halts decider to call
> this H_Hat non-halting.
>
>
> Lets draw a simple execution nesting tree:
>
> 1) A call to Halts(P, I)
>
> 2) P(I) exeuctes, and in it
>
> 3) calls Halts(P1, I1)
>
> 4) P1(I1) executes, which maybe
>
> 5) calls Halts(P2, I2)
> ...
void H_Hat(u32 P)
{
u32 Aborted = Halts(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
Halts(P, P);
HALT;
}
There is only one reasonable choice here. The Halts in main() aborts 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 22:34 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1) |
| Message-ID | <0nFvH.65057$J92.9800@fx48.iad> |
| In reply to | #26012 |
On 11/25/20 10:06 PM, olcott wrote:
> On 11/25/2020 8:55 PM, Richard Damon wrote:
>> On 11/25/20 8:03 PM, olcott wrote:
>>> On 11/25/2020 6:55 PM, Richard Damon wrote:
>>
>>>
>>>> Since it is Halts responsibility to give an answer to any and every
>>>> quetion posed to it, it gets hard to blame the lowly input that just
>>>> came to be tested.
>>>>
>>>
>>> Clearly you have a fundamental lack of understanding of infinite
>>> recursion.
>>
>> I have no problems understanding infinite recursion, what you seem to
>> miss is that when the halt decider is in the loop,it can be the need
>> break of the recursion that keeps H_Hat from being non-halting (and is
>> relying on the finite execution requirements on the Halt Decider).
>>
>> It is the Halt Deciders problem with figuring out how to decide this
>> case that causing the issues.
>>
>> An 'infinite recursion' that happens inside the 'must be finite' call to
>> the halt decider does NOT allow a higher level halts decider to call
>> this H_Hat non-halting.
>>
>>
>> Lets draw a simple execution nesting tree:
>>
>> 1) A call to Halts(P, I)
>>
>> 2) P(I) exeuctes, and in it
>>
>> 3) calls Halts(P1, I1)
>>
>> 4) P1(I1) executes, which maybe
>>
>> 5) calls Halts(P2, I2)
>> ...
>
> void H_Hat(u32 P)
> {
> u32 Aborted = Halts(P, P);
> if (Aborted)
> HALT
> else
> HERE: goto HERE;
> }
>
> int main()
> {
> u32 P = (u32)H_Hat;
> Halts(P, P);
> HALT;
> }
>
> There is only one reasonable choice here. The Halts in main() aborts H_Hat.
>
>
WHICH H_Hat? and is it saying that H_Hat has non-halting behavior?
If it does so, it is WRONG because when it sees the recursion at level 4
above, that recursion has been 'protected' by an intermedary decider
with a finite limit.
This is seens by the running of H_Hat(H_Hat) which will proceed as follows:
1) Enter H_Hat(H_Hat)
2) Call Halts(H_Hat, H_Hat)
3) Halts run, and per above decides that its input is non-halting
4) returns with aborted set true
5) go to else clause
6) Halts
Thus we see that H_Hat(H_Hat) is a halting behavior, which says that
Halts got the answer wrong.
Again, the error is that your detection system misses that there IS a
conditional between every instruction at level 3 and deeper with respect
to deciding if the level 2 program has non-halting behavior.
Becuase there IS a conditional, the rule of a loop/recusion without a
conditional does not apply.
[toc] | [prev] | [next] | [standalone]
Page 9 of 11 — ← Prev page 1 … 7 8 [9] 10 11 Next page →
Back to top | Article view | comp.theory
csiph-web