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 1 of 11 [1] 2 3 … 11 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 19:24 -0600 |
| Subject | It is known that a correct halt decider must return false (in this case)[V4](Linz) |
| Message-ID | <TqWdnXCuh8jFkibCnZ2dnUU7-QfNnZ2d@giganews.com> |
The following shows exactly how the Peter Linz H would correctly decide
halting on the Peter Linz Ĥ. This is fully operational code that has
been executed in the x86utm operating system that I wrote.
To make the Linz counter-example conform to the standard halting problem
counter-examples the input is not copied as it is in Linz.
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company.
x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
The x86 language is computationally equivalent to a UTM for all
computations that do not require more memory than is available.
Recursion can be directly simulated by a UTM that simulates its own
Turing machine Description. Infinite recursion would repeat the same
state transitions every time the UTM simulates its own Turing machine
Description.
// Defined at the bottom of page 319 of Linz
void Ĥ(u32 P)
{
u32 Input_Halts = H(P, P);
if (!Input_Halts)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)Ĥ;
H(P, P);
HALT;
}
Disassembled x86 machine language of the above pair of C functions.
Ĥ()
[000004f7](01) 55 push ebp
[000004f8](02) 8bec mov ebp,esp
[000004fa](01) 51 push ecx
[000004fb](03) 8b4508 mov eax,[ebp+08]
[000004fe](01) 50 push eax
[000004ff](03) 8b4d08 mov ecx,[ebp+08]
[00000502](01) 51 push ecx
[00000503](05) e86ffeffff call 00000377
[00000508](03) 83c408 add esp,+08
[0000050b](03) 8945fc mov [ebp-04],eax
[0000050e](04) 837dfc00 cmp dword [ebp-04],+00
[00000512](02) 7403 jz 00000517
[00000514](01) f4 hlt
[00000515](02) eb02 jmp 00000519
[00000517](02) ebfe jmp 00000517
[00000519](02) 8be5 mov esp,ebp
[0000051b](01) 5d pop ebp
[0000051c](01) c3 ret
_main()
[00000527](01) 55 push ebp
[00000528](02) 8bec mov ebp,esp
[0000052a](01) 51 push ecx
[0000052b](07) c745fcf7040000 mov [ebp-04],000004f7
[00000532](03) 8b45fc mov eax,[ebp-04]
[00000535](01) 50 push eax
[00000536](03) 8b4dfc mov ecx,[ebp-04]
[00000539](01) 51 push ecx
[0000053a](05) e838feffff call 00000377
[0000053f](03) 83c408 add esp,+08
[00000542](01) f4 hlt
[00000543](02) 8be5 mov esp,ebp
[00000545](01) 5d pop ebp
[00000546](01) c3 ret
Output_Debug_Trace() [00010abc] size(148) capacity(65536)
[00000527](01) 55 push ebp
[00000528](02) 8bec mov ebp,esp
[0000052a](01) 51 push ecx
[0000052b](07) c745fcf7040000 mov [ebp-04],000004f7
[00000532](03) 8b45fc mov eax,[ebp-04]
[00000535](01) 50 push eax
[00000536](03) 8b4dfc mov ecx,[ebp-04]
[00000539](01) 51 push ecx
[0000053a](05) e838feffff call 00000377
[000004f7](01) 55 push ebp
[000004f8](02) 8bec mov ebp,esp
[000004fa](01) 51 push ecx
[000004fb](03) 8b4508 mov eax,[ebp+08]
[000004fe](01) 50 push eax
[000004ff](03) 8b4d08 mov ecx,[ebp+08]
[00000502](01) 51 push ecx
[00000503](05) e86ffeffff call 00000377
[000004f7](01) 55 push ebp
[000004f8](02) 8bec mov ebp,esp
[000004fa](01) 51 push ecx
[000004fb](03) 8b4508 mov eax,[ebp+08]
[000004fe](01) 50 push eax
[000004ff](03) 8b4d08 mov ecx,[ebp+08]
[00000502](01) 51 push ecx
[00000503](05) e86ffeffff call 00000377
25 instructions
The above is where the halt decider aborts the whole Ĥ(Ĥ) invocation
sequence because the halt decider detects infinite recursion.
In this case infinite recursion is a function call to the same function
from the same machine address without any conditional branch
instructions that would terminate this recursion.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-22 20:56 -0500 |
| Message-ID | <CFEuH.1740$se1.1735@fx27.iad> |
| In reply to | #25683 |
On 11/22/20 8:24 PM, olcott wrote:
> The following shows exactly how the Peter Linz H would correctly decide
> halting on the Peter Linz Ĥ. This is fully operational code that has
> been executed in the x86utm operating system that I wrote.
What Peter Linz H? The paper does NOT present any indication of how H is
supposed to do it job. It shows a simple outline of a start state that
moves in some unspecified manner to one of two output states.
It is only something in YOUR mind that somehow says this must be
something based on a UTM.
>
> To make the Linz counter-example conform to the standard halting problem
> counter-examples the input is not copied as it is in Linz.
Omitting the copy says this can NOT possible be a Turing Machine as in
the definition of Linz. What other 'standard Halting Problem' are you
refering to.
All the verison I know you pass to the Halt Decider, a representation of
the program and a representation of the input, that is Two Things.
The Linz counter example, and the similer ones, you have a program that
is passed a representation of itself. Since the Halting Decider needs
two representations, you need to in some way dupicate the counter
example input to provide these two seperate input.
>
> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company.
>
> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> The x86 language is computationally equivalent to a UTM for all
> computations that do not require more memory than is available.
Again, a von Neumann machine can't be a UTM since it is not even a
Turing Machine.
There also isn't anything that would be called the x86 'language'. Yes,
the x86 processor is computationally equivalent to a Turing Machine,
within resource limits. We can use a number of languages on an x86
processor. Maybe you mean by x86 language the x86 assembly language, ok,
but you do understand that there really isn't *A* x86 assembly language
that is actually used on anything. It is a short hand for a wide family
of processors and assembly languages.
> Recursion can be directly simulated by a UTM that simulates its own
> Turing machine Description. Infinite recursion would repeat the same
> state transitions every time the UTM simulates its own Turing machine
> Description.
Yes, you can write broken code in many forms.
>
> // Defined at the bottom of page 319 of Linz
> void Ĥ(u32 P)
> {
> u32 Input_Halts = H(P, P);
> if (!Input_Halts)
> HALT
> else
> HERE: goto HERE;
> }
>
>
> int main()
> {
> u32 P = (u32)Ĥ;
> H(P, P);
> HALT;
> }
>
>
> Disassembled x86 machine language of the above pair of C functions.
>
> Ĥ()
> [000004f7](01) 55 push ebp
> [000004f8](02) 8bec mov ebp,esp
> [000004fa](01) 51 push ecx
> [000004fb](03) 8b4508 mov eax,[ebp+08]
> [000004fe](01) 50 push eax
> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
> [00000502](01) 51 push ecx
> [00000503](05) e86ffeffff call 00000377
> [00000508](03) 83c408 add esp,+08
> [0000050b](03) 8945fc mov [ebp-04],eax
> [0000050e](04) 837dfc00 cmp dword [ebp-04],+00
> [00000512](02) 7403 jz 00000517
> [00000514](01) f4 hlt
> [00000515](02) eb02 jmp 00000519
> [00000517](02) ebfe jmp 00000517
> [00000519](02) 8be5 mov esp,ebp
> [0000051b](01) 5d pop ebp
> [0000051c](01) c3 ret
>
> _main()
> [00000527](01) 55 push ebp
> [00000528](02) 8bec mov ebp,esp
> [0000052a](01) 51 push ecx
> [0000052b](07) c745fcf7040000 mov [ebp-04],000004f7
> [00000532](03) 8b45fc mov eax,[ebp-04]
> [00000535](01) 50 push eax
> [00000536](03) 8b4dfc mov ecx,[ebp-04]
> [00000539](01) 51 push ecx
> [0000053a](05) e838feffff call 00000377
> [0000053f](03) 83c408 add esp,+08
> [00000542](01) f4 hlt
> [00000543](02) 8be5 mov esp,ebp
> [00000545](01) 5d pop ebp
> [00000546](01) c3 ret
>
>
>
> Output_Debug_Trace() [00010abc] size(148) capacity(65536)
> [00000527](01) 55 push ebp
> [00000528](02) 8bec mov ebp,esp
> [0000052a](01) 51 push ecx
> [0000052b](07) c745fcf7040000 mov [ebp-04],000004f7
> [00000532](03) 8b45fc mov eax,[ebp-04]
> [00000535](01) 50 push eax
> [00000536](03) 8b4dfc mov ecx,[ebp-04]
> [00000539](01) 51 push ecx
> [0000053a](05) e838feffff call 00000377
> [000004f7](01) 55 push ebp
> [000004f8](02) 8bec mov ebp,esp
> [000004fa](01) 51 push ecx
> [000004fb](03) 8b4508 mov eax,[ebp+08]
> [000004fe](01) 50 push eax
> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
> [00000502](01) 51 push ecx
> [00000503](05) e86ffeffff call 00000377
> [000004f7](01) 55 push ebp
> [000004f8](02) 8bec mov ebp,esp
> [000004fa](01) 51 push ecx
> [000004fb](03) 8b4508 mov eax,[ebp+08]
> [000004fe](01) 50 push eax
> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
> [00000502](01) 51 push ecx
> [00000503](05) e86ffeffff call 00000377
> 25 instructions
>
> The above is where the halt decider aborts the whole Ĥ(Ĥ) invocation
> sequence because the halt decider detects infinite recursion.
>
> In this case infinite recursion is a function call to the same function
> from the same machine address without any conditional branch
> instructions that would terminate this recursion.
>
>
Yes, your trace shows that YOUR H has a flaw of infinite recursion when
evaluation a machine that has a copy of itself in it.
By the trace, there appears to be no code in H to detect this situation
so it just keep running, and then some magic force not shown anywhere
aborts the computation, so H actually never returned an answer, thus H
has FAILED at its job to be a Halt Decider.
Maybe you have created a system that is a Halter, which will just abort
any program that it determines will never halt. That might have some
use, but isn't the Halt Decider from Linz.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-23 03:14 +0000 |
| Message-ID | <87v9dwsr1m.fsf@bsb.me.uk> |
| In reply to | #25685 |
Richard Damon <Richard@Damon-Family.org> writes: > Maybe you have created a system that is a Halter, which will just abort > any program that it determines will never halt. That might have some > use, but isn't the Halt Decider from Linz. The irony is that that algorith -- the algorithm that determines if a computation must be aborted -- is also impossible. He's not written it yet so we are focusing on the wrapper function that he's call variously H and Halts, but as I told PO some time ago, that code must end up "aborting" an infinity to computations that are, in fact, finite. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 21:33 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <vNCdnT2ISMM4sCbCnZ2dnUU7-LPNnZ2d@giganews.com> |
| In reply to | #25688 |
On 11/22/2020 9:14 PM, Ben Bacarisse wrote: > Richard Damon <Richard@Damon-Family.org> writes: > >> Maybe you have created a system that is a Halter, which will just abort >> any program that it determines will never halt. That might have some >> use, but isn't the Halt Decider from Linz. > > The irony is that that algorith -- the algorithm that determines if a > computation must be aborted -- is also impossible. He's not written it > yet IT IS IN THE FIRST POST OF THIS THREAD. This is my 2018-12-13 solution. We merely scan the complete execution trace after each instruction is executed and see if there have been any function calls to the same function from the same address without any intervening conditional branch instructions. Here is what Mike said about correctly deciding H_Hat: On 11/20/2020 9:30 PM, Mike Terry wrote: > input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as > described. This is all baby stuff. [So the correct halting decision > for the input is non-halting]. -- 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-23 04:03 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <878sassos3.fsf@bsb.me.uk> |
| In reply to | #25690 |
olcott <NoOne@NoWhere.com> writes: > On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >> Richard Damon <Richard@Damon-Family.org> writes: >> >>> Maybe you have created a system that is a Halter, which will just abort >>> any program that it determines will never halt. That might have some >>> use, but isn't the Halt Decider from Linz. >> >> The irony is that that algorith -- the algorithm that determines if a >> computation must be aborted -- is also impossible. He's not written >> it yet > > IT IS IN THE FIRST POST OF THIS THREAD. You have not yet written it (so you said) which it why you have not yet noticed that it won't work. If you have written it, then you need to do more testing, (or ask an expert to tell you why it won't work). > This is my 2018-12-13 solution. (You have no solution.) > We merely scan the complete execution trace after each instruction is > executed and see if there have been any function calls to the same > function from the same address without any intervening conditional > branch instructions. Yes, it's true you can be wrong the other way as well -- your test could simply fail to spot many non-finite computations, so the H (or Halts) built from it would not always return. But being wrong in another way to the one I pointed does not make you right. If you want H/Halts to be a decider it must always return. That means your decision to abort must not miss any non-halting cases. To do that, it must also incorrectly abort an infinity of halting cases. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-22 22:07 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <n76dnQpEpLL-qCbCnZ2dnUU7-IPNnZ2d@giganews.com> |
| In reply to | #25693 |
On 11/22/2020 10:03 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>> Richard Damon <Richard@Damon-Family.org> writes: >>> >>>> Maybe you have created a system that is a Halter, which will just abort >>>> any program that it determines will never halt. That might have some >>>> use, but isn't the Halt Decider from Linz. >>> >>> The irony is that that algorith -- the algorithm that determines if a >>> computation must be aborted -- is also impossible. He's not written >>> it yet >> >> IT IS IN THE FIRST POST OF THIS THREAD. > > You have not yet written it (so you said) which it why you have not yet > noticed that it won't work. If you have written it, then you need to do > more testing, (or ask an expert to tell you why it won't work). > Here is what Mike said about my way of correctly deciding H_Hat: Here is what Mike said about my way of correctly deciding H_Hat: Here is what Mike said about my way of correctly deciding H_Hat: Here is what Mike said about my way of correctly deciding H_Hat: Here is what Mike said about my way of correctly deciding H_Hat: On 11/20/2020 9:30 PM, Mike Terry wrote: > input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as > described. This is all baby stuff. [So the correct halting decision > for the input is non-halting]. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-23 17:09 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Misrepresentation of MTs position) |
| Message-ID | <_tudndD2L5JBcSbCnZ2dnUU78W1QAAAA@brightview.co.uk> |
| In reply to | #25694 |
On 23/11/2020 04:07, olcott wrote: > On 11/22/2020 10:03 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>> Richard Damon <Richard@Damon-Family.org> writes: >>>> >>>>> Maybe you have created a system that is a Halter, which will just >>>>> abort >>>>> any program that it determines will never halt. That might have some >>>>> use, but isn't the Halt Decider from Linz. >>>> >>>> The irony is that that algorith -- the algorithm that determines if a >>>> computation must be aborted -- is also impossible. He's not written >>>> it yet >>> >>> IT IS IN THE FIRST POST OF THIS THREAD. >> >> You have not yet written it (so you said) which it why you have not yet >> noticed that it won't work. If you have written it, then you need to do >> more testing, (or ask an expert to tell you why it won't work). >> > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: > > On 11/20/2020 9:30 PM, Mike Terry wrote: >> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >> described. This is all baby stuff. [So the correct halting decision >> for the input is non-halting]. STOP QUOTING ME OUT OF CONTEXT. THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position to falsely support your own. The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you gave (but have omitted from your misreprestation), in which Halts() was specified to be a pure UTM: no NeedsToBeAborted() calls etc.. OF COURSE that particular H_Hat() never halts, and nobody would say otherwise. Your H_Hat() above contains a Needs_To_Be_Aborted() call, making it A COMPLETELY DIFFERENT H_Hat. You must understand that just because you use the same label for two different objects, that does not actually make them the same object! I suggest to you that /deliberately/ misrepresenting someones position on a topic is a form of "bearing false witness" against that person, and so I'll be charitable and assume you are doing it because you have simply misunderstood the thread you are quoting. I expect you to stop this behaviour now you are aware. Mike.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-24 03:39 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <87o8jnpgnf.fsf@bsb.me.uk> |
| In reply to | #25694 |
olcott <NoOne@NoWhere.com> writes: > On 11/22/2020 10:03 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>> Richard Damon <Richard@Damon-Family.org> writes: >>>> >>>>> Maybe you have created a system that is a Halter, which will just abort >>>>> any program that it determines will never halt. That might have some >>>>> use, but isn't the Halt Decider from Linz. >>>> >>>> The irony is that that algorith -- the algorithm that determines if a >>>> computation must be aborted -- is also impossible. He's not written >>>> it yet >>> >>> IT IS IN THE FIRST POST OF THIS THREAD. >> >> You have not yet written it (so you said) which it why you have not yet >> noticed that it won't work. If you have written it, then you need to do >> more testing, (or ask an expert to tell you why it won't work). >> > Here is what Mike said about my way of correctly deciding H_Hat: Do you really think the lying about other people's position helps your case one iota? No, in fact it is shameful behaviour which, sadly, is no longer unusual for you. I suspect you know you have nothing, so lying is all you have left. You lied two years about having H and H^ "fully encoded as actual Turing machines" "exactly and precisely as in Linz" when you had no such thing, and you have nothing now so you lie about Mike's position. > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: > Here is what Mike said about my way of correctly deciding H_Hat: Oh, and you are being childish again, too. Grow up. > On 11/20/2020 9:30 PM, Mike Terry wrote: >> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >> described. This is all baby stuff. [So the correct halting decision >> for the input is non-halting]. If anyone with a proper newsreader needs to confirm you mendacity, the link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk> Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from that post is non-halting -- it calls a function that is not a decider but one that just simulates the computation of applying the argument to itself. Tellingly, that post did not include any code you could reasonably call a halt decider because you now know that as soon as you show that code, I (or indeed anyone else but you) will produce the confounding example for it. The H_Hat you show is in fact irrelevant since it calls a function that is not even a decider (let alone a halt decider), but you hope naive readers will be fooled by the silly name you gave it: Halts. You didn't show the function you actually claim (erroneously, of course) to be a halt decider in that post. That function, also called Halts in a deliberate attempt to muddy the waters, gets the right answer for the H_Hat(H_Hat) case written with the other Halts. But it gets the wrong answer for a similar computation built from it. Why? Because anytime you dare to post any code the claims to be a halt decider, someone will instantly post the confounding example, AND IT WILL USE YOUR HALT DECIDER, AND NOT ANOTHER FUNCTION WITH THE SAME NAME. Of course you did not respond to the points I made about the impossibility of the code you have not yet shown anyone -- the code that decides a computation must be aborted. That code is as impossible as a halt decider, unless it gets an infinity of cases wrong. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 22:55 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <A4KdnTD-OPS7DyHCnZ2dnUU7-V_NnZ2d@giganews.com> |
| In reply to | #25779 |
On 11/23/2020 9:39 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 11/22/2020 10:03 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>> >>>>>> Maybe you have created a system that is a Halter, which will just abort >>>>>> any program that it determines will never halt. That might have some >>>>>> use, but isn't the Halt Decider from Linz. >>>>> >>>>> The irony is that that algorith -- the algorithm that determines if a >>>>> computation must be aborted -- is also impossible. He's not written >>>>> it yet >>>> >>>> IT IS IN THE FIRST POST OF THIS THREAD. >>> >>> You have not yet written it (so you said) which it why you have not yet >>> noticed that it won't work. If you have written it, then you need to do >>> more testing, (or ask an expert to tell you why it won't work). >>> >> Here is what Mike said about my way of correctly deciding H_Hat: > > Do you really think the lying about other people's position helps your > case one iota? No, in fact it is shameful behaviour which, sadly, is no > longer unusual for you. I suspect you know you have nothing, so lying > is all you have left. You lied two years about having H and H^ "fully > encoded as actual Turing machines" "exactly and precisely as in Linz" > when you had no such thing, and you have nothing now so you lie about > Mike's position. > >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: > > Oh, and you are being childish again, too. Grow up. > >> On 11/20/2020 9:30 PM, Mike Terry wrote: >>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>> described. This is all baby stuff. [So the correct halting decision >>> for the input is non-halting]. > > If anyone with a proper newsreader needs to confirm you mendacity, the > link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk> > > Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from > that post is non-halting -- it calls a function that is not a decider > but one that just simulates the computation of applying the argument to > itself. Mike did not understand that the execution of H_Hat under a simulator and under a halt decider are identical executions. In both cases H_Hat has no way to tell the difference, thus H_Hat cannot change its behavior under the two cases because H_Hat never reaches the point where it would get a different return value from Halts. Mike still does not understand this yet that does not make his misunderstanding correct and my understanding incorrect. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 23:22 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <HqednfLNjZQ4BSHCnZ2dnUU7-TudnZ2d@giganews.com> |
| In reply to | #25779 |
On 11/23/2020 9:39 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 11/22/2020 10:03 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>> >>>>>> Maybe you have created a system that is a Halter, which will just abort >>>>>> any program that it determines will never halt. That might have some >>>>>> use, but isn't the Halt Decider from Linz. >>>>> >>>>> The irony is that that algorith -- the algorithm that determines if a >>>>> computation must be aborted -- is also impossible. He's not written >>>>> it yet >>>> >>>> IT IS IN THE FIRST POST OF THIS THREAD. >>> >>> You have not yet written it (so you said) which it why you have not yet >>> noticed that it won't work. If you have written it, then you need to do >>> more testing, (or ask an expert to tell you why it won't work). >>> >> Here is what Mike said about my way of correctly deciding H_Hat: > > Do you really think the lying about other people's position helps your > case one iota? No, in fact it is shameful behaviour which, sadly, is no > longer unusual for you. I suspect you know you have nothing, so lying > is all you have left. You lied two years about having H and H^ "fully > encoded as actual Turing machines" "exactly and precisely as in Linz" > when you had no such thing, and you have nothing now so you lie about > Mike's position. > >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: > > Oh, and you are being childish again, too. Grow up. > >> On 11/20/2020 9:30 PM, Mike Terry wrote: >>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>> described. This is all baby stuff. [So the correct halting decision >>> for the input is non-halting]. > > If anyone with a proper newsreader needs to confirm you mendacity, the > link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk> > > Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from > that post is non-halting -- it calls a function that is not a decider > but one that just simulates the computation of applying the argument to > itself. Mike did not understand that the execution of H_Hat under a simulator and under a halt decider are identical executions. In both cases H_Hat has no way to tell the difference, thus H_Hat cannot change its behavior under the two cases because H_Hat never reaches the point where it would get a different return value from Halts. Mike still does not understand this yet that does not make his misunderstanding correct and my understanding incorrect. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 23:23 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <Hqedne3NjZRUBSHCnZ2dnUU7-TsAAAAA@giganews.com> |
| In reply to | #25779 |
On 11/23/2020 9:39 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 11/22/2020 10:03 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>> >>>>>> Maybe you have created a system that is a Halter, which will just abort >>>>>> any program that it determines will never halt. That might have some >>>>>> use, but isn't the Halt Decider from Linz. >>>>> >>>>> The irony is that that algorith -- the algorithm that determines if a >>>>> computation must be aborted -- is also impossible. He's not written >>>>> it yet >>>> >>>> IT IS IN THE FIRST POST OF THIS THREAD. >>> >>> You have not yet written it (so you said) which it why you have not yet >>> noticed that it won't work. If you have written it, then you need to do >>> more testing, (or ask an expert to tell you why it won't work). >>> >> Here is what Mike said about my way of correctly deciding H_Hat: > > Do you really think the lying about other people's position helps your > case one iota? No, in fact it is shameful behaviour which, sadly, is no > longer unusual for you. I suspect you know you have nothing, so lying > is all you have left. You lied two years about having H and H^ "fully > encoded as actual Turing machines" "exactly and precisely as in Linz" > when you had no such thing, and you have nothing now so you lie about > Mike's position. > >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: >> Here is what Mike said about my way of correctly deciding H_Hat: > > Oh, and you are being childish again, too. Grow up. > >> On 11/20/2020 9:30 PM, Mike Terry wrote: >>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>> described. This is all baby stuff. [So the correct halting decision >>> for the input is non-halting]. > > If anyone with a proper newsreader needs to confirm you mendacity, the > link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk> > > Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from > that post is non-halting -- it calls a function that is not a decider > but one that just simulates the computation of applying the argument to > itself. Mike did not understand that the execution of H_Hat under a simulator and under a halt decider are identical executions. In both cases H_Hat has no way to tell the difference, thus H_Hat cannot change its behavior under the two cases because H_Hat never reaches the point where it would get a different return value from Halts. Mike still does not understand this yet that does not make his misunderstanding correct and my understanding incorrect. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-23 17:07 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <_tudndH2L5L_cSbCnZ2dnUU78W3NnZ2d@brightview.co.uk> |
| In reply to | #25690 |
On 23/11/2020 03:33, olcott wrote: > On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >> Richard Damon <Richard@Damon-Family.org> writes: >> >>> Maybe you have created a system that is a Halter, which will just abort >>> any program that it determines will never halt. That might have some >>> use, but isn't the Halt Decider from Linz. >> >> The irony is that that algorith -- the algorithm that determines if a >> computation must be aborted -- is also impossible. He's not written >> it > yet > > IT IS IN THE FIRST POST OF THIS THREAD. > This is my 2018-12-13 solution. > > We merely scan the complete execution trace after each instruction is > executed and see if there have been any function calls to the same > function from the same address without any intervening conditional > branch instructions. > > Here is what Mike said about correctly deciding H_Hat: > > On 11/20/2020 9:30 PM, Mike Terry wrote: >> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >> described. This is all baby stuff. [So the correct halting decision >> for the input is non-halting]. STOP QUOTING ME OUT OF CONTEXT. THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position to falsely support your own. The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you gave (but have omitted from your misreprestation), in which Halts() was specified to be a pure UTM: no NeedsToBeAborted() calls etc.. OF COURSE that particular H_Hat() never halts, and nobody would say otherwise. Your H_Hat() above contains a call to H() which clearly contains infinite recursion detection logic, making it A COMPLETELY DIFFERENT H_Hat. You must understand that just because you use the same label for two different objects, that does not actually make them the same object! I suggest to you that /deliberately/ misrepresenting someones position on a topic is a form of "bearing false witness" against that person, and so I'll be charitable and assume you are doing it because you have simply misunderstood the thread you are quoting. I expect you to stop this behaviour now you are aware. Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 11:37 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <IvudnSrhmtzCbibCnZ2dnUU7-f_NnZ2d@giganews.com> |
| In reply to | #25712 |
On 11/23/2020 11:07 AM, Mike Terry wrote:
> On 23/11/2020 03:33, olcott wrote:
>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> Maybe you have created a system that is a Halter, which will just abort
>>>> any program that it determines will never halt. That might have some
>>>> use, but isn't the Halt Decider from Linz.
>>>
>>> The irony is that that algorith -- the algorithm that determines if a
>>> computation must be aborted -- is also impossible. He's not written
>>> it > yet
>>
>> IT IS IN THE FIRST POST OF THIS THREAD.
>> This is my 2018-12-13 solution.
>>
>> We merely scan the complete execution trace after each instruction is
>> executed and see if there have been any function calls to the same
>> function from the same address without any intervening conditional
>> branch instructions.
>>
>> Here is what Mike said about correctly deciding H_Hat:
>>
>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>> described. This is all baby stuff. [So the correct halting decision
>>> for the input is non-halting].
>
>
> STOP QUOTING ME OUT OF CONTEXT.
>
> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position to
> falsely support your own.
The two versions of H_Hat are computationally equivalent, thus your
claim that they are *COMPLETELY DIFFERENT* is proved to be false.
Here is the one that you responded to:
On Friday, November 20, 2020 at 8:45:59 PM UTC-6, olcott wrote:
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;
}
https://groups.google.com/g/comp.theory/c/1uKuMgjxJTM/m/c3HEt-UWAAAJ
Here is the one in this thread:
On 11/22/2020 7:24 PM, olcott wrote:
// Defined at the bottom of page 319 of Linz
void Ĥ(u32 P)
{
u32 Input_Halts = H(P, P);
if (!Input_Halts)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)Ĥ;
H(P, P);
HALT;
}
> The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you
> gave (but have omitted from your misreprestation), in which Halts() was
> specified to be a pure UTM: no NeedsToBeAborted() calls etc..
>
> OF COURSE that particular H_Hat() never halts, and nobody would say
> otherwise.
Therefore
On 11/20/2020 9:30 PM, Mike Terry wrote:
> [So the correct halting decision for the input is non-halting].
> Your H_Hat() above contains a call to H() which clearly
> contains infinite recursion detection logic, making it A COMPLETELY
> DIFFERENT H_Hat.
As I have already proven it does not make it a completely different
H_Hat. The execution trace of neither H_Hat ever reaches the point of
the difference.
> You must understand that just because you use the same
> label for two different objects, that does not actually make them the
> same object!
I understand that. The fact that their execution traces are identical
makes them the same execution.
> I suggest to you that /deliberately/ misrepresenting someones position
> on a topic is a form of "bearing false witness" against that person, and
> so I'll be charitable and assume you are doing it because you have
> simply misunderstood the thread you are quoting. I expect you to stop
> this behaviour now you are aware.
>
>
> Mike.
The actual case is that I proved that the difference that you assert
does not actually exist. Also I forgot that you even asserted a difference.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-23 17:42 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <euCdnQOtXNzqaSbCnZ2dnUU78cfNnZ2d@brightview.co.uk> |
| In reply to | #25718 |
On 23/11/2020 17:37, olcott wrote: > On 11/23/2020 11:07 AM, Mike Terry wrote: >> On 23/11/2020 03:33, olcott wrote: >>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>> Richard Damon <Richard@Damon-Family.org> writes: >>>> >>>>> Maybe you have created a system that is a Halter, which will just >>>>> abort >>>>> any program that it determines will never halt. That might have some >>>>> use, but isn't the Halt Decider from Linz. >>>> >>>> The irony is that that algorith -- the algorithm that determines if a >>>> computation must be aborted -- is also impossible. He's not written >>>> it > yet >>> >>> IT IS IN THE FIRST POST OF THIS THREAD. >>> This is my 2018-12-13 solution. >>> >>> We merely scan the complete execution trace after each instruction is >>> executed and see if there have been any function calls to the same >>> function from the same address without any intervening conditional >>> branch instructions. >>> >>> Here is what Mike said about correctly deciding H_Hat: >>> >>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>> described. This is all baby stuff. [So the correct halting decision >>>> for the input is non-halting]. >> >> >> STOP QUOTING ME OUT OF CONTEXT. >> >> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* >> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position >> to falsely support your own. > > The two versions of H_Hat are computationally equivalent, thus your > claim that they are *COMPLETELY DIFFERENT* is proved to be false. I don't care what you /think/ I said or implied. YOU ARE MISREPRESENTING MY POSITION, whether honestly or dishonestly. STOP DOING THAT. I will probably reply in more detail to your other remarks separately. Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 11:53 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <TaadnblrGMqsaibCnZ2dnUU7-YudnZ2d@giganews.com> |
| In reply to | #25720 |
On 11/23/2020 11:42 AM, Mike Terry wrote: > On 23/11/2020 17:37, olcott wrote: >> On 11/23/2020 11:07 AM, Mike Terry wrote: >>> On 23/11/2020 03:33, olcott wrote: >>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>> >>>>>> Maybe you have created a system that is a Halter, which will just >>>>>> abort >>>>>> any program that it determines will never halt. That might have some >>>>>> use, but isn't the Halt Decider from Linz. >>>>> >>>>> The irony is that that algorith -- the algorithm that determines if a >>>>> computation must be aborted -- is also impossible. He's not written >>>>> it > yet >>>> >>>> IT IS IN THE FIRST POST OF THIS THREAD. >>>> This is my 2018-12-13 solution. >>>> >>>> We merely scan the complete execution trace after each instruction is >>>> executed and see if there have been any function calls to the same >>>> function from the same address without any intervening conditional >>>> branch instructions. >>>> >>>> Here is what Mike said about correctly deciding H_Hat: >>>> >>>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>>> described. This is all baby stuff. [So the correct halting decision >>>>> for the input is non-halting]. >>> >>> >>> STOP QUOTING ME OUT OF CONTEXT. >>> >>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* >>> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position >>> to falsely support your own. >> >> The two versions of H_Hat are computationally equivalent, thus your >> claim that they are *COMPLETELY DIFFERENT* is proved to be false. > > I don't care what you /think/ I said or implied. YOU ARE > MISREPRESENTING MY POSITION, whether honestly or dishonestly. > > STOP DOING THAT. > > I will probably reply in more detail to your other remarks separately. > > Mike. > The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is a UTM The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is a Halt decider are identical because neither H_Hat ever reaches the point of the difference: the return value from Halts(). -- 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-23 13:39 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said) |
| Message-ID | <ElTuH.14729$Wi7.8109@fx29.iad> |
| In reply to | #25722 |
On 11/23/20 12:53 PM, olcott wrote: > On 11/23/2020 11:42 AM, Mike Terry wrote: >> On 23/11/2020 17:37, olcott wrote: >>> On 11/23/2020 11:07 AM, Mike Terry wrote: >>>> On 23/11/2020 03:33, olcott wrote: >>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>>> >>>>>>> Maybe you have created a system that is a Halter, which will just >>>>>>> abort >>>>>>> any program that it determines will never halt. That might have some >>>>>>> use, but isn't the Halt Decider from Linz. >>>>>> >>>>>> The irony is that that algorith -- the algorithm that determines if a >>>>>> computation must be aborted -- is also impossible. He's not written >>>>>> it > yet >>>>> >>>>> IT IS IN THE FIRST POST OF THIS THREAD. >>>>> This is my 2018-12-13 solution. >>>>> >>>>> We merely scan the complete execution trace after each instruction is >>>>> executed and see if there have been any function calls to the same >>>>> function from the same address without any intervening conditional >>>>> branch instructions. >>>>> >>>>> Here is what Mike said about correctly deciding H_Hat: >>>>> >>>>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>>>> described. This is all baby stuff. [So the correct halting decision >>>>>> for the input is non-halting]. >>>> >>>> >>>> STOP QUOTING ME OUT OF CONTEXT. >>>> >>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* >>>> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position >>>> to falsely support your own. >>> >>> The two versions of H_Hat are computationally equivalent, thus your >>> claim that they are *COMPLETELY DIFFERENT* is proved to be false. >> >> I don't care what you /think/ I said or implied. YOU ARE >> MISREPRESENTING MY POSITION, whether honestly or dishonestly. >> >> STOP DOING THAT. >> >> I will probably reply in more detail to your other remarks separately. >> >> Mike. >> > > The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is > a UTM > > The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is > a Halt decider > > are identical because neither H_Hat ever reaches the point of the > difference: the return value from Halts(). > If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and Halts is purportedly a Halting Decider, and Halts never get to analyzing the return value of itself in the trace sounds like a real good reason to doubt that it is a proper halting decider. How can it possible claim to do its job if it never gets around to actually looking at the important points of the program. Remember, how Halts works is totally up to its designer, the restrictions on it are what it is to expect as inputs and how it must deliver its answer, so its failure to get the information that it needs, must a a failure in it design. I have shown alternate designs that will happen to handle this particular problem (but makes the Linz contradiction failure painfully obvious, so that may be why you ignore them), so there is no way to claim that it is an inherent part of the problem.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 13:35 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) |
| Message-ID | <zsWdndjhqtR3kyHCnZ2dnUU7-e3NnZ2d@giganews.com> |
| In reply to | #25724 |
On 11/23/2020 12:39 PM, Richard Damon wrote: > On 11/23/20 12:53 PM, olcott wrote: >> On 11/23/2020 11:42 AM, Mike Terry wrote: >>> On 23/11/2020 17:37, olcott wrote: >>>> On 11/23/2020 11:07 AM, Mike Terry wrote: >>>>> On 23/11/2020 03:33, olcott wrote: >>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>>>> >>>>>>>> Maybe you have created a system that is a Halter, which will just >>>>>>>> abort >>>>>>>> any program that it determines will never halt. That might have some >>>>>>>> use, but isn't the Halt Decider from Linz. >>>>>>> >>>>>>> The irony is that that algorith -- the algorithm that determines if a >>>>>>> computation must be aborted -- is also impossible. He's not written >>>>>>> it > yet >>>>>> >>>>>> IT IS IN THE FIRST POST OF THIS THREAD. >>>>>> This is my 2018-12-13 solution. >>>>>> >>>>>> We merely scan the complete execution trace after each instruction is >>>>>> executed and see if there have been any function calls to the same >>>>>> function from the same address without any intervening conditional >>>>>> branch instructions. >>>>>> >>>>>> Here is what Mike said about correctly deciding H_Hat: >>>>>> >>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>>>>> described. This is all baby stuff. [So the correct halting decision >>>>>>> for the input is non-halting]. >>>>> >>>>> >>>>> STOP QUOTING ME OUT OF CONTEXT. >>>>> >>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* >>>>> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position >>>>> to falsely support your own. >>>> >>>> The two versions of H_Hat are computationally equivalent, thus your >>>> claim that they are *COMPLETELY DIFFERENT* is proved to be false. >>> >>> I don't care what you /think/ I said or implied. YOU ARE >>> MISREPRESENTING MY POSITION, whether honestly or dishonestly. >>> >>> STOP DOING THAT. >>> >>> I will probably reply in more detail to your other remarks separately. >>> >>> Mike. >>> >> >> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is >> a UTM >> >> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is >> a Halt decider >> >> are identical because neither H_Hat ever reaches the point of the >> difference: the return value from Halts(). >> > > If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and > Halts is purportedly a Halting Decider, and Halts never get to analyzing > the return value of itself in the trace sounds like a real good reason > to doubt that it is a proper halting decider. How can it possible claim > to do its job if it never gets around to actually looking at the > important points of the program. > You don't have to believe or disbelieve simply look at the actual facts of the provided execution trace itself. -- 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-23 14:58 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) |
| Message-ID | <hvUuH.12605$vo2.4515@fx02.iad> |
| In reply to | #25728 |
On 11/23/20 2:35 PM, olcott wrote: > On 11/23/2020 12:39 PM, Richard Damon wrote: >> On 11/23/20 12:53 PM, olcott wrote: >>> On 11/23/2020 11:42 AM, Mike Terry wrote: >>>> On 23/11/2020 17:37, olcott wrote: >>>>> On 11/23/2020 11:07 AM, Mike Terry wrote: >>>>>> On 23/11/2020 03:33, olcott wrote: >>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>>>>> >>>>>>>>> Maybe you have created a system that is a Halter, which will just >>>>>>>>> abort >>>>>>>>> any program that it determines will never halt. That might have >>>>>>>>> some >>>>>>>>> use, but isn't the Halt Decider from Linz. >>>>>>>> >>>>>>>> The irony is that that algorith -- the algorithm that determines >>>>>>>> if a >>>>>>>> computation must be aborted -- is also impossible. He's not >>>>>>>> written >>>>>>>> it > yet >>>>>>> >>>>>>> IT IS IN THE FIRST POST OF THIS THREAD. >>>>>>> This is my 2018-12-13 solution. >>>>>>> >>>>>>> We merely scan the complete execution trace after each >>>>>>> instruction is >>>>>>> executed and see if there have been any function calls to the same >>>>>>> function from the same address without any intervening conditional >>>>>>> branch instructions. >>>>>>> >>>>>>> Here is what Mike said about correctly deciding H_Hat: >>>>>>> >>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>>>>>> described. This is all baby stuff. [So the correct halting >>>>>>>> decision >>>>>>>> for the input is non-halting]. >>>>>> >>>>>> >>>>>> STOP QUOTING ME OUT OF CONTEXT. >>>>>> >>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* >>>>>> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position >>>>>> to falsely support your own. >>>>> >>>>> The two versions of H_Hat are computationally equivalent, thus your >>>>> claim that they are *COMPLETELY DIFFERENT* is proved to be false. >>>> >>>> I don't care what you /think/ I said or implied. YOU ARE >>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly. >>>> >>>> STOP DOING THAT. >>>> >>>> I will probably reply in more detail to your other remarks separately. >>>> >>>> Mike. >>>> >>> >>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is >>> a UTM >>> >>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is >>> a Halt decider >>> >>> are identical because neither H_Hat ever reaches the point of the >>> difference: the return value from Halts(). >>> >> >> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and >> Halts is purportedly a Halting Decider, and Halts never get to analyzing >> the return value of itself in the trace sounds like a real good reason >> to doubt that it is a proper halting decider. How can it possible claim >> to do its job if it never gets around to actually looking at the >> important points of the program. >> > You don't have to believe or disbelieve simply look at the actual facts > of the provided execution trace itself. > > You mean this trace which is what the requirement require? 1) Enter H_Hat(H_Hat) 2) duplicate H_Hat (this step 'optimized' out in your machine) 3) Enter Halts(H_Hat, H_Hat) 4) Halts does its decision and decides tht H_Hat is non-halting 5) Halts returns false to indicate non-halting 6) H_Hat goes to the else clause 7) H_Hat Halts. Thus, Halts was wrong. Your trace shows a variance, thus there MUST be something wrong in it. Yes, YOUR program says that H_Hat is non-halting. It says it multiple ways. The above trace shows that they are wrong. Do you wish to hire me to debug your code? Rate is $100/Hour, double that if you help. Of course, I will need a detailed statement of work of exactly what is required, and considering you history of bad wording, making sure the definitions are fully agreed on.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-23 14:12 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) |
| Message-ID | <I66dnZUWV7sJiiHCnZ2dnUU7-UfNnZ2d@giganews.com> |
| In reply to | #25731 |
On 11/23/2020 1:58 PM, Richard Damon wrote: > On 11/23/20 2:35 PM, olcott wrote: >> On 11/23/2020 12:39 PM, Richard Damon wrote: >>> On 11/23/20 12:53 PM, olcott wrote: >>>> On 11/23/2020 11:42 AM, Mike Terry wrote: >>>>> On 23/11/2020 17:37, olcott wrote: >>>>>> On 11/23/2020 11:07 AM, Mike Terry wrote: >>>>>>> On 23/11/2020 03:33, olcott wrote: >>>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>>>>>> >>>>>>>>>> Maybe you have created a system that is a Halter, which will just >>>>>>>>>> abort >>>>>>>>>> any program that it determines will never halt. That might have >>>>>>>>>> some >>>>>>>>>> use, but isn't the Halt Decider from Linz. >>>>>>>>> >>>>>>>>> The irony is that that algorith -- the algorithm that determines >>>>>>>>> if a >>>>>>>>> computation must be aborted -- is also impossible. He's not >>>>>>>>> written >>>>>>>>> it > yet >>>>>>>> >>>>>>>> IT IS IN THE FIRST POST OF THIS THREAD. >>>>>>>> This is my 2018-12-13 solution. >>>>>>>> >>>>>>>> We merely scan the complete execution trace after each >>>>>>>> instruction is >>>>>>>> executed and see if there have been any function calls to the same >>>>>>>> function from the same address without any intervening conditional >>>>>>>> branch instructions. >>>>>>>> >>>>>>>> Here is what Mike said about correctly deciding H_Hat: >>>>>>>> >>>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>>>>>>> described. This is all baby stuff. [So the correct halting >>>>>>>>> decision >>>>>>>>> for the input is non-halting]. >>>>>>> >>>>>>> >>>>>>> STOP QUOTING ME OUT OF CONTEXT. >>>>>>> >>>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* >>>>>>> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my position >>>>>>> to falsely support your own. >>>>>> >>>>>> The two versions of H_Hat are computationally equivalent, thus your >>>>>> claim that they are *COMPLETELY DIFFERENT* is proved to be false. >>>>> >>>>> I don't care what you /think/ I said or implied. YOU ARE >>>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly. >>>>> >>>>> STOP DOING THAT. >>>>> >>>>> I will probably reply in more detail to your other remarks separately. >>>>> >>>>> Mike. >>>>> >>>> >>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is >>>> a UTM >>>> >>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is >>>> a Halt decider >>>> >>>> are identical because neither H_Hat ever reaches the point of the >>>> difference: the return value from Halts(). >>>> >>> >>> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and >>> Halts is purportedly a Halting Decider, and Halts never get to analyzing >>> the return value of itself in the trace sounds like a real good reason >>> to doubt that it is a proper halting decider. How can it possible claim >>> to do its job if it never gets around to actually looking at the >>> important points of the program. >>> >> You don't have to believe or disbelieve simply look at the actual facts >> of the provided execution trace itself. >> >> > > You mean this trace which is what the requirement require? > > > 1) Enter H_Hat(H_Hat) > 2) duplicate H_Hat (this step 'optimized' out in your machine) > 3) Enter Halts(H_Hat, H_Hat) > 4) Halts does its decision and decides tht H_Hat is non-halting > 5) Halts returns false to indicate non-halting > 6) H_Hat goes to the else clause > 7) H_Hat Halts. I mean the actual execution trace from fully operational code not any mere misconceptions. Output_Debug_Trace() [00010abc] size(148) capacity(65536) [00000527](01) 55 push ebp [00000528](02) 8bec mov ebp,esp [0000052a](01) 51 push ecx [0000052b](07) c745fcf7040000 mov [ebp-04],000004f7 [00000532](03) 8b45fc mov eax,[ebp-04] [00000535](01) 50 push eax [00000536](03) 8b4dfc mov ecx,[ebp-04] [00000539](01) 51 push ecx [0000053a](05) e838feffff call 00000377 [000004f7](01) 55 push ebp [000004f8](02) 8bec mov ebp,esp [000004fa](01) 51 push ecx [000004fb](03) 8b4508 mov eax,[ebp+08] [000004fe](01) 50 push eax [000004ff](03) 8b4d08 mov ecx,[ebp+08] [00000502](01) 51 push ecx [00000503](05) e86ffeffff call 00000377 [000004f7](01) 55 push ebp [000004f8](02) 8bec mov ebp,esp [000004fa](01) 51 push ecx [000004fb](03) 8b4508 mov eax,[ebp+08] [000004fe](01) 50 push eax [000004ff](03) 8b4d08 mov ecx,[ebp+08] [00000502](01) 51 push ecx [00000503](05) e86ffeffff call 00000377 The last 9 lines of this show the part that infinitely repeats unless aborted. We can tell that it infinitely repeats: (1) By not stopping it and seeing it keep repeating. (2) The fact that there are no conditional branch instructions in this sequence that could possibly exit this infinite recursion. I don't really have time for [fact free people] that are anchored in misconceptions. -- 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-23 15:54 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts) |
| Message-ID | <BkVuH.10295$dN1.5358@fx42.iad> |
| In reply to | #25733 |
On 11/23/20 3:12 PM, olcott wrote: > On 11/23/2020 1:58 PM, Richard Damon wrote: >> On 11/23/20 2:35 PM, olcott wrote: >>> On 11/23/2020 12:39 PM, Richard Damon wrote: >>>> On 11/23/20 12:53 PM, olcott wrote: >>>>> On 11/23/2020 11:42 AM, Mike Terry wrote: >>>>>> On 23/11/2020 17:37, olcott wrote: >>>>>>> On 11/23/2020 11:07 AM, Mike Terry wrote: >>>>>>>> On 23/11/2020 03:33, olcott wrote: >>>>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote: >>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>>>>>>> >>>>>>>>>>> Maybe you have created a system that is a Halter, which will >>>>>>>>>>> just >>>>>>>>>>> abort >>>>>>>>>>> any program that it determines will never halt. That might have >>>>>>>>>>> some >>>>>>>>>>> use, but isn't the Halt Decider from Linz. >>>>>>>>>> >>>>>>>>>> The irony is that that algorith -- the algorithm that determines >>>>>>>>>> if a >>>>>>>>>> computation must be aborted -- is also impossible. He's not >>>>>>>>>> written >>>>>>>>>> it > yet >>>>>>>>> >>>>>>>>> IT IS IN THE FIRST POST OF THIS THREAD. >>>>>>>>> This is my 2018-12-13 solution. >>>>>>>>> >>>>>>>>> We merely scan the complete execution trace after each >>>>>>>>> instruction is >>>>>>>>> executed and see if there have been any function calls to the same >>>>>>>>> function from the same address without any intervening conditional >>>>>>>>> branch instructions. >>>>>>>>> >>>>>>>>> Here is what Mike said about correctly deciding H_Hat: >>>>>>>>> >>>>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote: >>>>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as >>>>>>>>>> described. This is all baby stuff. [So the correct halting >>>>>>>>>> decision >>>>>>>>>> for the input is non-halting]. >>>>>>>> >>>>>>>> >>>>>>>> STOP QUOTING ME OUT OF CONTEXT. >>>>>>>> >>>>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY >>>>>>>> DIFFERENT* >>>>>>>> H_Hat TO THE ONE IN THIS THREAD. You are misrepresenting my >>>>>>>> position >>>>>>>> to falsely support your own. >>>>>>> >>>>>>> The two versions of H_Hat are computationally equivalent, thus your >>>>>>> claim that they are *COMPLETELY DIFFERENT* is proved to be false. >>>>>> >>>>>> I don't care what you /think/ I said or implied. YOU ARE >>>>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly. >>>>>> >>>>>> STOP DOING THAT. >>>>>> >>>>>> I will probably reply in more detail to your other remarks >>>>>> separately. >>>>>> >>>>>> Mike. >>>>>> >>>>> >>>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and >>>>> Halts is >>>>> a UTM >>>>> >>>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and >>>>> Halts is >>>>> a Halt decider >>>>> >>>>> are identical because neither H_Hat ever reaches the point of the >>>>> difference: the return value from Halts(). >>>>> >>>> >>>> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and >>>> Halts is purportedly a Halting Decider, and Halts never get to >>>> analyzing >>>> the return value of itself in the trace sounds like a real good reason >>>> to doubt that it is a proper halting decider. How can it possible claim >>>> to do its job if it never gets around to actually looking at the >>>> important points of the program. >>>> >>> You don't have to believe or disbelieve simply look at the actual facts >>> of the provided execution trace itself. >>> >>> >> >> You mean this trace which is what the requirement require? >> >> >> 1) Enter H_Hat(H_Hat) >> 2) duplicate H_Hat (this step 'optimized' out in your machine) >> 3) Enter Halts(H_Hat, H_Hat) >> 4) Halts does its decision and decides tht H_Hat is non-halting >> 5) Halts returns false to indicate non-halting >> 6) H_Hat goes to the else clause >> 7) H_Hat Halts. > > > I mean the actual execution trace from fully operational code not any > mere misconceptions. > > Output_Debug_Trace() [00010abc] size(148) capacity(65536) > [00000527](01) 55 push ebp > [00000528](02) 8bec mov ebp,esp > [0000052a](01) 51 push ecx > [0000052b](07) c745fcf7040000 mov [ebp-04],000004f7 > [00000532](03) 8b45fc mov eax,[ebp-04] > [00000535](01) 50 push eax > [00000536](03) 8b4dfc mov ecx,[ebp-04] > [00000539](01) 51 push ecx > [0000053a](05) e838feffff call 00000377 > [000004f7](01) 55 push ebp > [000004f8](02) 8bec mov ebp,esp > [000004fa](01) 51 push ecx > [000004fb](03) 8b4508 mov eax,[ebp+08] > [000004fe](01) 50 push eax > [000004ff](03) 8b4d08 mov ecx,[ebp+08] > [00000502](01) 51 push ecx > [00000503](05) e86ffeffff call 00000377 > [000004f7](01) 55 push ebp > [000004f8](02) 8bec mov ebp,esp > [000004fa](01) 51 push ecx > [000004fb](03) 8b4508 mov eax,[ebp+08] > [000004fe](01) 50 push eax > [000004ff](03) 8b4d08 mov ecx,[ebp+08] > [00000502](01) 51 push ecx > [00000503](05) e86ffeffff call 00000377 > > The last 9 lines of this show the part that infinitely repeats unless > aborted. We can tell that it infinitely repeats: > > (1) By not stopping it and seeing it keep repeating. > > (2) The fact that there are no conditional branch instructions in this > sequence that could possibly exit this infinite recursion. > > I don't really have time for [fact free people] that are anchored in > misconceptions. > Right, you have an infinite recursion due to a fault in the design of you Halts function. Your trace is omitting the conditional that the trace inside the trace is providing, thus your trace is defective. This is likely because it appears that you have moved the halting decision to be global and your halts just executes the tape. This breaks you machine as a UTM and makes your halts function inoperative (can the call to halts now ever really return false, or does any call to halts that would return false abort the whole program? You have been putting a lot of effort into breaking you programs ability to run according to the requirements. Your trace does NOT show that H_Hat has non-halting behavior with a working halting decider, because it shows a non-working halt decider. The trace I provided shows that H_Hat WILL be halting if the halt decider meets its decision requirements and says non-halting. As you mentioned elsewhere, your Halts got aborted before it ever got to see what happens after it returns, thus it got into a non-halting loop based on its own bad design. Maybe the problem is that you just can't conceive of any way to tell that a given program will halt or run forever besides just running it, but there are methods that can do a lot better (they of course still can't totally meet the requirements, that is factually proved impossible).
[toc] | [prev] | [next] | [standalone]
Page 1 of 11 [1] 2 3 … 11 Next page →
Back to top | Article view | comp.theory
csiph-web