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 4 of 11 — ← Prev page 1 2 3 [4] 5 6 … 11 Next page →
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-24 23:37 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) |
| Message-ID | <kLmdnXwIfZTbBCDCnZ2dnUU78IPNnZ2d@brightview.co.uk> |
| In reply to | #25828 |
On 24/11/2020 19:41, olcott wrote: > On 11/24/2020 1:30 PM, Mike Terry wrote: >> On 24/11/2020 17:34, olcott wrote: >>> On 11/24/2020 10:48 AM, Mike Terry wrote: >>>> On 24/11/2020 16:32, olcott wrote: >>>>> On 11/24/2020 10:19 AM, Mike Terry wrote: >>>>>> On 24/11/2020 15:51, olcott wrote: >> <.. snip ..> >>>>>>> >>>>>>> Before we can proceed we need to have agreement on this general >>>>>>> principle: (It is a mandatory prerequisite). >>>>>>> >>>>>>> Any input TMD that would never halt unless a UTM stopped >>>>>>> simulating it >>>>>>> expresses behavior that is not halting behavior. >>>>>> >>>>>> That's a bad wording for lots of reasons. If I agree to it as it >>>>>> stands, I know you will take that quote and post it all over the >>>>>> newsgroup claiming it means something it doesn't. Because that's the >>>>>> kind of guy that you are. >>>>>> >>>>>> However, I'll happily agree to the better worded: >>>>>> >>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM >>>>>> never halts, expresses behaviour that is not halting behaviour. >>>>>> >>>>>> Mike. >>>>>> >>>>> >>>>> I will start quoting it this way: >>>>> Any input (TMD, DATA) which, when run under a (pure) UTM >>>>> never halts, expresses behavior that is not halting behavior. >>>>> (Mike Terry 11/24/2020 10:19 AM) >>>>> >>>>> Yeah !!! Great job !!! >>>>> >>>> >>>> The fact that you would want to quote someone agreeing to such an >>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT, >>>> speaks volumes about your desparation. >>> >>> Both Ben and Richard have made it a habit of denying easily verifiable >>> facts as long as doing this would contrive some rhetorical basis for the >>> denigration of my work that would convince casual observers (that are >>> not paying any attention to the actual reasoning) that I am incorrect. >> >> That's not right. Both Ben and Richard point out perfectly correct >> problems with your arguments. The problem is that you don't >> understand what they point out, so you think they are making it up, >> ignoring your arguments, generally "tricking" readers, and so on. >> >> It's you who are biased here in the way you view those discussions. I >> don't recall any "trickery" on their part - just honest discussion of >> problems with your arguments. >> >>> >>> When I prove my point Ben typically erases this whole point and responds >>> with ad hominem attacks that have nothing to do with the actual point. >> >>> Both Ben and Richard have disagreed that this is an infinitely repeating >>> sequence even though is is an obviously verifiable fact that it is an >>> infinitely repeating sequence: >>> >>> _H_Hat() >>> [000004f7](01) 55 push ebp >>> [000004f8](02) 8bec mov ebp,esp >>> [000004fa](01) 51 push ecx >>> [000004fb](03) 8b4508 mov eax,[ebp+08] >>> [000004fe](01) 50 push eax >>> [000004ff](03) 8b4d08 mov ecx,[ebp+08] >>> [00000502](01) 51 push ecx >>> [00000503](05) e86ffeffff call 00000377 >> >> Well, this is a good example. You think this is an example of your >> "denying easily verifiable facts", but this is just showing your >> biases. You believe there is infinite recursion, so what you have >> provided must "prove" this, because in your mind the "infinite" claim >> is correct. > > Even though it fricking infinitely repeats they deny that it is infinite. Well, you must see that this isn't reasonable behaviour on your part, and you're getting all worked up over it. Let's take a step back and see what we've actually got here... You have published a trace that shows two repeats (or perhaps three, whatever) of a chunk of code and then stops at that point. You did not show the trace repeating infinitely often - of course nobody can do that, and nobody suggests anybody can do that. The point is, though, that you're saying over and over that the trace /proves/ your point, but the trace only proves the point that it repeats twice. I'm not being funny here, just literal, to help you see things from others' perspectives. I could ask how you make a jump from repeating twice to infinite recursion, but the point is /however/ you do it you are not "just seeing it in the trace", right? So there is some reasoning on your part which you are not sharing. Some "proof" even? (Maybe you feel you /are/ sharing it, but I've not seen anything, and you pointedly refuse to expand on this when I ask about it.) So to me it seems quite reasonable for someone else to deny that there is infinite recursion based just on the basis of your trace - because the trace really /doesn't/ show or even "imply" that there is infinite recursion. Maybe you've made the jump somehow from "trace shows two repetitions" to "infinite recursion", but that's /your/ intuition, or perhaps even your proof, if you had a proof (I can't believe that you do...) Do you think it's reasonable that just because you say "Even though it fricking infinitely repeats they deny that it is infinite." that means people should just accept it? Why don't you try to /prove/ it somehow? Or investigate why people are saying it's not true, or whatever. Those approaches would all be reasonable. I see you've started a new thread with a simple example - that's a better response than accusing people of dishonesty/stupidity/whatever. I'll look at the new thread later. (I see you've got two more replies to my same post for me to deal with first!) > >> But those do those trace entries actually prove what you claim? No. >> So your claim isn't "easily verifiable" after all. > > Look at this example. > Validating the halt deciding criteria with a totally concrete example > Yeah, I'll look at that later... >> In a recent post I asked you a key question which I've asked several >> times before - is your "repeated calls to a function with no >> intervening conditional branches" test actually a SOUND test? > > The execution trace that I provided unequivocally prove beyond all > possible doubt that my assessment is correct. I don't see that, but maybe the new thread will help. > > Look at this simpler example: > Validating the halt deciding criteria with a totally concrete example > >> You've never answered > > You ask me is my assessment in my opinion is my reasoning sound after I > have already proven beyond all possible ddunt that my assessment is > necessarily completely correct. I have not seen any proof. Maybe your idea of proof is less exacting than everyone else's... > > That is like asking how sure are you the 2 + 3 = 5? > Are you pretty sure, very sure, really really sure? No it's not, because if someone asked my /why/ I believed 2+3=5 or asked me to prove it, I would go ahead and explain. What you do is just repeat the claim over and over, claiming you've absolutely frickin proved it 100 times already, when you haven't. All you've done is repeat many times that your Halt() is looking for repeated calls to the same address with no intervening conditional branches. (That is at best an observation, not a proof of anything, although perhaps you might like to expand that into a proper proof.) > > Please look at this simpler example. > Validating the halt deciding criteria with a totally concrete example > >> this, so why should anyone take a trace such as the one above as >> indicating infinite recursion? > > It proves that it is infinite recursion. We'll see! Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 18:03 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) |
| Message-ID | <WPKdnUwtIY_EAiDCnZ2dnUU7-Y_NnZ2d@giganews.com> |
| In reply to | #25852 |
On 11/24/2020 5:37 PM, Mike Terry wrote:
> On 24/11/2020 19:41, olcott wrote:
>> On 11/24/2020 1:30 PM, Mike Terry wrote:
>>> On 24/11/2020 17:34, olcott wrote:
>>>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>>>> On 24/11/2020 16:32, olcott wrote:
>>>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>>>> On 24/11/2020 15:51, olcott wrote:
>>> <.. snip ..>
>>>>>>>>
>>>>>>>> Before we can proceed we need to have agreement on this general
>>>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>>>
>>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>>> simulating it
>>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>
>>>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>>>> stands, I know you will take that quote and post it all over the
>>>>>>> newsgroup claiming it means something it doesn't. Because that's
>>>>>>> the
>>>>>>> kind of guy that you are.
>>>>>>>
>>>>>>> However, I'll happily agree to the better worded:
>>>>>>>
>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>>>
>>>>>>> Mike.
>>>>>>>
>>>>>>
>>>>>> I will start quoting it this way:
>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>> never halts, expresses behavior that is not halting behavior.
>>>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>>>
>>>>>> Yeah !!! Great job !!!
>>>>>>
>>>>>
>>>>> The fact that you would want to quote someone agreeing to such an
>>>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>>>> speaks volumes about your desparation.
>>>>
>>>> Both Ben and Richard have made it a habit of denying easily verifiable
>>>> facts as long as doing this would contrive some rhetorical basis for
>>>> the
>>>> denigration of my work that would convince casual observers (that are
>>>> not paying any attention to the actual reasoning) that I am incorrect.
>>>
>>> That's not right. Both Ben and Richard point out perfectly correct
>>> problems with your arguments. The problem is that you don't
>>> understand what they point out, so you think they are making it up,
>>> ignoring your arguments, generally "tricking" readers, and so on.
>>>
>>> It's you who are biased here in the way you view those discussions. I
>>> don't recall any "trickery" on their part - just honest discussion of
>>> problems with your arguments.
>>>
>>>>
>>>> When I prove my point Ben typically erases this whole point and
>>>> responds
>>>> with ad hominem attacks that have nothing to do with the actual point.
>>>
>>>> Both Ben and Richard have disagreed that this is an infinitely
>>>> repeating
>>>> sequence even though is is an obviously verifiable fact that it is an
>>>> infinitely repeating sequence:
>>>>
>>>> _H_Hat()
>>>> [000004f7](01) 55 push ebp
>>>> [000004f8](02) 8bec mov ebp,esp
>>>> [000004fa](01) 51 push ecx
>>>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>>>> [000004fe](01) 50 push eax
>>>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000502](01) 51 push ecx
>>>> [00000503](05) e86ffeffff call 00000377
>>>
>>> Well, this is a good example. You think this is an example of your
>>> "denying easily verifiable facts", but this is just showing your
>>> biases. You believe there is infinite recursion, so what you have
>>> provided must "prove" this, because in your mind the "infinite" claim
>>> is correct.
>>
>> Even though it fricking infinitely repeats they deny that it is infinite.
>
> Well, you must see that this isn't reasonable behaviour on your part,
> and you're getting all worked up over it. Let's take a step back and
> see what we've actually got here...
Although you have sometimes been quite denigrating there has never been
a point where you have been dishonest. I can't say that about the
others. Anyone that denies verifiable facts is a (according to the
bible) damned (going to Hell) liar.
> You have published a trace that shows two repeats (or perhaps three,
> whatever) of a chunk of code and then stops at that point. You did not
> show the trace repeating infinitely often - of course nobody can do
> that, and nobody suggests anybody can do that. The point is, though,
> that you're saying over and over that the trace /proves/ your point, but
> the trace only proves the point that it repeats twice.
They can see the same code that you agreed was infinite recursive and
accept rather than deny that it is infinitely recursive.
I am breaking it down into simpler steps stating here:
Validating the halt deciding criteria with a totally concrete example
--- Step(1)
> I'm not being funny here, just literal, to help you see things from
> others' perspectives. I could ask how you make a jump from repeating
> twice to infinite recursion, but the point is /however/ you do it you
By seeing the infinite recursion in the source code and by seeing the
infinite recursion in the object code.
> are not "just seeing it in the trace", right? So there is some
> reasoning on your part which you are not sharing. Some "proof" even?
> (Maybe you feel you /are/ sharing it, but I've not seen anything, and
> you pointedly refuse to expand on this when I ask about it.)
The exact same thing that you said is "baby stuff" So obvious that
anyone knows it is true, they flat out deny as true.
I am breaking it down into simpler steps stating here:
Validating the halt deciding criteria with a totally concrete example
--- Step(1)
> So to me it seems quite reasonable for someone else to deny that there
> is infinite recursion based just on the basis of your trace - because
> the trace really /doesn't/ show or even "imply" that there is infinite
> recursion.
This one leave zero doubt.
Validating the halt deciding criteria with a totally concrete example
--- Step(1)
I still need to add a few more steps to prove my point, yet I must do
them in micro increments because by reviewers (besides you) have less
than zero interest in understanding me and focus all their attention on
denigration.
> Maybe you've made the jump somehow from "trace shows two
> repetitions" to "infinite recursion", but that's /your/ intuition, or
> perhaps even your proof, if you had a proof (I can't believe that you
> do...)
The source code and the object code prove it. What is "baby stuff" to
you is impossibly difficult for everyone else.
> Do you think it's reasonable that just because you say "Even though it
> fricking infinitely repeats they deny that it is infinite." that means
> people should just accept it? Why don't you try to /prove/ it somehow?
> Or investigate why people are saying it's not true, or whatever. Those
> approaches would all be reasonable.
The source code proves that it is infinitely recursive is "baby stuff".
> I see you've started a new thread with a simple example - that's a
> better response than accusing people of dishonesty/stupidity/whatever.
> I'll look at the new thread later. (I see you've got two more replies
> to my same post for me to deal with first!)
It is too difficult to have any dialogue with people that are entirely
focused on denigration and have no interest in anything besides
denigration.
>>
>>> But those do those trace entries actually prove what you claim? No.
>>> So your claim isn't "easily verifiable" after all.
>>
>> Look at this example.
>> Validating the halt deciding criteria with a totally concrete example
>>
> Yeah, I'll look at that later...
>
>>> In a recent post I asked you a key question which I've asked several
>>> times before - is your "repeated calls to a function with no
>>> intervening conditional branches" test actually a SOUND test?
>>
>> The execution trace that I provided unequivocally prove beyond all
>> possible doubt that my assessment is correct.
>
> I don't see that, but maybe the new thread will help.
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
>>
>> Look at this simpler example:
>> Validating the halt deciding criteria with a totally concrete example
>>
>>> You've never answered
>>
>> You ask me is my assessment in my opinion is my reasoning sound after I
>> have already proven beyond all possible ddunt that my assessment is
>> necessarily completely correct.
>
> I have not seen any proof. Maybe your idea of proof is less exacting
> than everyone else's...
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
>>
>> That is like asking how sure are you the 2 + 3 = 5?
>> Are you pretty sure, very sure, really really sure?
>
> No it's not, because if someone asked my /why/ I believed 2+3=5 or asked
> me to prove it, I would go ahead and explain. What you do is just
> repeat the claim over and over, claiming you've absolutely frickin
> proved it 100 times already, when you haven't. All you've done is
> repeat many times that your Halt() is looking for repeated calls to the
> same address with no intervening conditional branches. (That is at best
> an observation, not a proof of anything, although perhaps you might like
> to expand that into a proper proof.)
>
>>
>> Please look at this simpler example.
>> Validating the halt deciding criteria with a totally concrete example
>>
>>> this, so why should anyone take a trace such as the one above as
>>> indicating infinite recursion?
>>
>> It proves that it is infinite recursion.
>
> We'll see!
>
> Mike.
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-25 01:40 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) |
| Message-ID | <f-CdnZ48HpaXKyDCnZ2dnUU78bXNnZ2d@brightview.co.uk> |
| In reply to | #25862 |
On 25/11/2020 00:03, olcott wrote:
> On 11/24/2020 5:37 PM, Mike Terry wrote:
>> On 24/11/2020 19:41, olcott wrote:
>>> On 11/24/2020 1:30 PM, Mike Terry wrote:
>>>> On 24/11/2020 17:34, olcott wrote:
>>>>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>>>>> On 24/11/2020 16:32, olcott wrote:
>>>>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>>>>> On 24/11/2020 15:51, olcott wrote:
>>>> <.. snip ..>
>>>>>>>>>
>>>>>>>>> Before we can proceed we need to have agreement on this general
>>>>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>>>>
>>>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>>>> simulating it
>>>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>>
>>>>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>>>>> stands, I know you will take that quote and post it all over the
>>>>>>>> newsgroup claiming it means something it doesn't. Because
>>>>>>>> that's the
>>>>>>>> kind of guy that you are.
>>>>>>>>
>>>>>>>> However, I'll happily agree to the better worded:
>>>>>>>>
>>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>>>>
>>>>>>>> Mike.
>>>>>>>>
>>>>>>>
>>>>>>> I will start quoting it this way:
>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>> never halts, expresses behavior that is not halting behavior.
>>>>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>>>>
>>>>>>> Yeah !!! Great job !!!
>>>>>>>
>>>>>>
>>>>>> The fact that you would want to quote someone agreeing to such an
>>>>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>>>>> speaks volumes about your desparation.
>>>>>
>>>>> Both Ben and Richard have made it a habit of denying easily verifiable
>>>>> facts as long as doing this would contrive some rhetorical basis
>>>>> for the
>>>>> denigration of my work that would convince casual observers (that are
>>>>> not paying any attention to the actual reasoning) that I am incorrect.
>>>>
>>>> That's not right. Both Ben and Richard point out perfectly correct
>>>> problems with your arguments. The problem is that you don't
>>>> understand what they point out, so you think they are making it up,
>>>> ignoring your arguments, generally "tricking" readers, and so on.
>>>>
>>>> It's you who are biased here in the way you view those discussions. I
>>>> don't recall any "trickery" on their part - just honest discussion of
>>>> problems with your arguments.
>>>>
>>>>>
>>>>> When I prove my point Ben typically erases this whole point and
>>>>> responds
>>>>> with ad hominem attacks that have nothing to do with the actual point.
>>>>
>>>>> Both Ben and Richard have disagreed that this is an infinitely
>>>>> repeating
>>>>> sequence even though is is an obviously verifiable fact that it is an
>>>>> infinitely repeating sequence:
>>>>>
>>>>> _H_Hat()
>>>>> [000004f7](01) 55 push ebp
>>>>> [000004f8](02) 8bec mov ebp,esp
>>>>> [000004fa](01) 51 push ecx
>>>>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>>>>> [000004fe](01) 50 push eax
>>>>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000502](01) 51 push ecx
>>>>> [00000503](05) e86ffeffff call 00000377
>>>>
>>>> Well, this is a good example. You think this is an example of your
>>>> "denying easily verifiable facts", but this is just showing your
>>>> biases. You believe there is infinite recursion, so what you have
>>>> provided must "prove" this, because in your mind the "infinite" claim
>>>> is correct.
>>>
>>> Even though it fricking infinitely repeats they deny that it is
>>> infinite.
>>
>> Well, you must see that this isn't reasonable behaviour on your part,
>> and you're getting all worked up over it. Let's take a step back and
>> see what we've actually got here...
>
> Although you have sometimes been quite denigrating there has never been
> a point where you have been dishonest. I can't say that about the
> others. Anyone that denies verifiable facts is a (according to the
> bible) damned (going to Hell) liar.
>
>> You have published a trace that shows two repeats (or perhaps three,
>> whatever) of a chunk of code and then stops at that point. You did
>> not show the trace repeating infinitely often - of course nobody can
>> do that, and nobody suggests anybody can do that. The point is,
>> though, that you're saying over and over that the trace /proves/ your
>> point, but the trace only proves the point that it repeats twice.
>
>
> They can see the same code that you agreed was infinite recursive and
> accept rather than deny that it is infinitely recursive.
I rather doubt that. More likely you're confused about what code you're
talking about? Or /they/ are? If they are, the way out is to be
clearer about what you mean [some ideas below]
Hmm, ok I've gone back to the start of this thread, and sure enough
there's code there, and the trace in question. Here it is restored:
// 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;
}
Here H^ calls a function H, which isn't given in the trace. If you want
people to know that H is just a pure UTM, then given the history of all
your Hs, H_Hats, and renames etc. it would be sensible for you to choose
a completely new name like UTM().
Alternatively, if you really want to use H in this thread for a pure
UTM, then you should have GIANT WARNINGS all over the place.
But I don't think the H above is a UTM, because you refer in the same
post to "the halt decider detecting xxx" and in Linz the halt decide is
H. So a perfectly reasonable interpretation here is that this H is NOT
a UTM, and so is not the same as the code I previously commented on.
I also think there's a possibility that you really did intend it to be
just a UTM, but if so you've gone about it in an apalling way (not
intentionally). You have all the talk about halt deciders (which might
just refer to your OS wrapper code?) and Linz and H (the Linz decider)
when you could just have called it UTM. You also could have given a big
CAPS WARNING to make sure that people understood what was being
discussed, given the considerable potential for confusion.
If that is what you intended, I'd have to say I don't feel too sorry for
you, because you've chopped and changed your notations so many times,
and then introduced your overseeing "wrapper" halt decider to confuse
things. People are fatigued by all these changes, and there's often
little consistency across different threads etc...
BTW - I've had an idea for why you made your Halts() "global"! You
realised that it was really quite tricky to get your ABNHBD() to see
what was going on within your /nested/ levels of execution, and rather
than make it all work as it should you just thought you'd make the new
ABNHBD/Halts global, and change your OS interface so that it sees /all/
the emulation levels at once? Just a guess- doesn't really matter. If
that's right, you didn't really need to make it global to achieve that,
although you almost certainly would need to change your OS interface
calls to enable it.
>
> I am breaking it down into simpler steps stating here:
> Validating the halt deciding criteria with a totally concrete example
> --- Step(1)
>
>> I'm not being funny here, just literal, to help you see things from
>> others' perspectives. I could ask how you make a jump from repeating
>> twice to infinite recursion, but the point is /however/ you do it you
>
> By seeing the infinite recursion in the source code and by seeing the
> infinite recursion in the object code.
I don't believe anyone is interpreting your H source code in this thread
as pure UTM source code. I'm not even sure whether /you/ mean it to be
such?
IF YOU DO mean it to be a pure UTM, then the code would be non-halting
as previously agreed, and everybody else would also agree, if they
understood that is what you were saying.
If your H is a proper halt decider with recursion detection logic (which
is how I have interpretted things) then you really /cannot/ see the
infinite recursion in the object code. (Perhaps you think you can?)
Um, ok, now we're back to a recurring problem - I asked you whether you
believe that your INFINITE_RECURSION_TEST in your decider is only
detecting /actual/ infinite recursion in its inputs, and you STILL
haven't properly answered that yet. (You said, look in the new thread,
but there's no explanation there, so far at least.)
You did provide something only by implication in another post which
talked about 3+2=5 : the inference I got from that example is that you
DO believe that your test (checking for calls to the same address with
no intervening conditional branches) is "sound", but why you don't JUST
SAY THAT, and EXPLAIN WHY YOU BELIEVE IT, (or even /prove/ that it is
sound!!) is beyond me. I've been asking about this for weeks now, on
and off.
>
>> are not "just seeing it in the trace", right? So there is some
>> reasoning on your part which you are not sharing. Some "proof" even?
>> (Maybe you feel you /are/ sharing it, but I've not seen anything, and
>> you pointedly refuse to expand on this when I ask about it.)
>
> The exact same thing that you said is "baby stuff" So obvious that
> anyone knows it is true, they flat out deny as true.
>
> I am breaking it down into simpler steps stating here:
> Validating the halt deciding criteria with a totally concrete example
> --- Step(1)
>
If you really do mean your H in this thread to be specifically a pure
UTM, then it is probably best to abandon this thread and start again,
because I don't think it has been interpreted that way throughout the
thread. [And I wouldn't put any blame on this for readers of the thread.]
>> So to me it seems quite reasonable for someone else to deny that there
>> is infinite recursion based just on the basis of your trace - because
>> the trace really /doesn't/ show or even "imply" that there is infinite
>> recursion.
>
> This one leave zero doubt.
> Validating the halt deciding criteria with a totally concrete example
> --- Step(1)
>
> I still need to add a few more steps to prove my point, yet I must do
> them in micro increments because by reviewers (besides you) have less
> than zero interest in understanding me and focus all their attention on
> denigration.
>
The main thing I think is to be clear about what you're doing at each
step. I'd use UTM() [and doubly explain what that means] if you mean a
routine to be exactly a UTM with no added logic, rather than H.
(Probably it's too late for that.)
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 20:10 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) |
| Message-ID | <6bSdnUXzzsdiISDCnZ2dnUU7-IPNnZ2d@giganews.com> |
| In reply to | #25882 |
On 11/24/2020 7:40 PM, Mike Terry wrote:
> On 25/11/2020 00:03, olcott wrote:
>> On 11/24/2020 5:37 PM, Mike Terry wrote:
>>> On 24/11/2020 19:41, olcott wrote:
>>>> On 11/24/2020 1:30 PM, Mike Terry wrote:
>>>>> On 24/11/2020 17:34, olcott wrote:
>>>>>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>>>>>> On 24/11/2020 16:32, olcott wrote:
>>>>>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>>>>>> On 24/11/2020 15:51, olcott wrote:
>>>>> <.. snip ..>
>>>>>>>>>>
>>>>>>>>>> Before we can proceed we need to have agreement on this general
>>>>>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>>>>>
>>>>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>>>>> simulating it
>>>>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>>>
>>>>>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>>>>>> stands, I know you will take that quote and post it all over the
>>>>>>>>> newsgroup claiming it means something it doesn't. Because
>>>>>>>>> that's the
>>>>>>>>> kind of guy that you are.
>>>>>>>>>
>>>>>>>>> However, I'll happily agree to the better worded:
>>>>>>>>>
>>>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>>>>>
>>>>>>>>> Mike.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I will start quoting it this way:
>>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>>> never halts, expresses behavior that is not halting behavior.
>>>>>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>>>>>
>>>>>>>> Yeah !!! Great job !!!
>>>>>>>>
>>>>>>>
>>>>>>> The fact that you would want to quote someone agreeing to such an
>>>>>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>>>>>> speaks volumes about your desparation.
>>>>>>
>>>>>> Both Ben and Richard have made it a habit of denying easily
>>>>>> verifiable
>>>>>> facts as long as doing this would contrive some rhetorical basis
>>>>>> for the
>>>>>> denigration of my work that would convince casual observers (that are
>>>>>> not paying any attention to the actual reasoning) that I am
>>>>>> incorrect.
>>>>>
>>>>> That's not right. Both Ben and Richard point out perfectly correct
>>>>> problems with your arguments. The problem is that you don't
>>>>> understand what they point out, so you think they are making it up,
>>>>> ignoring your arguments, generally "tricking" readers, and so on.
>>>>>
>>>>> It's you who are biased here in the way you view those discussions. I
>>>>> don't recall any "trickery" on their part - just honest discussion of
>>>>> problems with your arguments.
>>>>>
>>>>>>
>>>>>> When I prove my point Ben typically erases this whole point and
>>>>>> responds
>>>>>> with ad hominem attacks that have nothing to do with the actual
>>>>>> point.
>>>>>
>>>>>> Both Ben and Richard have disagreed that this is an infinitely
>>>>>> repeating
>>>>>> sequence even though is is an obviously verifiable fact that it is an
>>>>>> infinitely repeating sequence:
>>>>>>
>>>>>> _H_Hat()
>>>>>> [000004f7](01) 55 push ebp
>>>>>> [000004f8](02) 8bec mov ebp,esp
>>>>>> [000004fa](01) 51 push ecx
>>>>>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>>>>>> [000004fe](01) 50 push eax
>>>>>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00000502](01) 51 push ecx
>>>>>> [00000503](05) e86ffeffff call 00000377
>>>>>
>>>>> Well, this is a good example. You think this is an example of your
>>>>> "denying easily verifiable facts", but this is just showing your
>>>>> biases. You believe there is infinite recursion, so what you have
>>>>> provided must "prove" this, because in your mind the "infinite" claim
>>>>> is correct.
>>>>
>>>> Even though it fricking infinitely repeats they deny that it is
>>>> infinite.
>>>
>>> Well, you must see that this isn't reasonable behaviour on your part,
>>> and you're getting all worked up over it. Let's take a step back and
>>> see what we've actually got here...
>>
>> Although you have sometimes been quite denigrating there has never been
>> a point where you have been dishonest. I can't say that about the
>> others. Anyone that denies verifiable facts is a (according to the
>> bible) damned (going to Hell) liar.
>>
>>> You have published a trace that shows two repeats (or perhaps three,
>>> whatever) of a chunk of code and then stops at that point. You did
>>> not show the trace repeating infinitely often - of course nobody can
>>> do that, and nobody suggests anybody can do that. The point is,
>>> though, that you're saying over and over that the trace /proves/ your
>>> point, but the trace only proves the point that it repeats twice.
>>
>>
>> They can see the same code that you agreed was infinite recursive and
>> accept rather than deny that it is infinitely recursive.
>
> I rather doubt that. More likely you're confused about what code you're
> talking about? Or /they/ are? If they are, the way out is to be
> clearer about what you mean [some ideas below]
>
> Hmm, ok I've gone back to the start of this thread, and sure enough
> there's code there, and the trace in question. Here it is restored:
>
> // 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;
> }
>
> Here H^ calls a function H, which isn't given in the trace. If you want
> people to know that H is just a pure UTM, then given the history of all
> your Hs, H_Hats, and renames etc. it would be sensible for you to choose
> a completely new name like UTM().
>
> Alternatively, if you really want to use H in this thread for a pure
> UTM, then you should have GIANT WARNINGS all over the place.
First I show them this code:
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
Anyone knowing C can tell that the above code is infinitely recursive.
Richard did agree to this yet was so sure of what I was going to say
next that he didn't want to hear it.
Next I tell them about the x86utm operating system version of
DebugTrace() that actually simulates the machine code of the COFF object
file output of the Microsoft C compiler compilation of the above code.
Everything else that you said must back up to this step right here to
this step.
(1) We have code that is obviously infinitely recursive immediately above.
(2) There is another version of DebugTrace() that for all practical
purposes <is> an x86 based UTM. It actually simulates the code of H_Hat
one machine instruction at a time.
The execution trace of the the above user code is identical between the
two vastly different versions of DebugTrace() proving that these two
versions are functionally equivalent.
We cannot proceed to step (3) until after we have perfect agreement with
step (2).
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-25 03:20 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) |
| Message-ID | <87d00286mx.fsf@bsb.me.uk> |
| In reply to | #25882 |
Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
> Hmm, ok I've gone back to the start of this thread, and sure enough
> there's code there, and the trace in question. Here it is restored:
>
> // 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;
> }
>
> Here H^ calls a function H, which isn't given in the trace. If you
> want people to know that H is just a pure UTM, then given the history
> of all your Hs, H_Hats, and renames etc. it would be sensible for you
> to choose a completely new name like UTM().
>
> Alternatively, if you really want to use H in this thread for a pure
> UTM, then you should have GIANT WARNINGS all over the place.
>
> But I don't think the H above is a UTM, because you refer in the same
> post to "the halt decider detecting xxx" and in Linz the halt decide
> is H. So a perfectly reasonable interpretation here is that this H is
> NOT a UTM, and so is not the same as the code I previously commented
> on.
This is, of course, exactly the ruse he is trying to pull off. The H
that is a UTM gives H_Hat the behaviour that the H that is a decider
will "correctly" report. Being clear by giving the two Hs different
names would blow his cover.
I am trying to think that this is just PO being clumsy with notation and
ignorant of what a halting decider is, but I can't shake the feeling he
knows its nonsense. Could he really not know?
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 21:34 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](first step) |
| Message-ID | <jr-dnbhtxfcyTSDCnZ2dnUU7-K3NnZ2d@giganews.com> |
| In reply to | #25889 |
On 11/24/2020 9:20 PM, Ben Bacarisse wrote:
> Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
>
>> Hmm, ok I've gone back to the start of this thread, and sure enough
>> there's code there, and the trace in question. Here it is restored:
>>
>> // 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;
>> }
>>
>> Here H^ calls a function H, which isn't given in the trace. If you
>> want people to know that H is just a pure UTM, then given the history
>> of all your Hs, H_Hats, and renames etc. it would be sensible for you
>> to choose a completely new name like UTM().
>>
>> Alternatively, if you really want to use H in this thread for a pure
>> UTM, then you should have GIANT WARNINGS all over the place.
>>
>> But I don't think the H above is a UTM, because you refer in the same
>> post to "the halt decider detecting xxx" and in Linz the halt decide
>> is H. So a perfectly reasonable interpretation here is that this H is
>> NOT a UTM, and so is not the same as the code I previously commented
>> on.
>
> This is, of course, exactly the ruse he is trying to pull off. The H
> that is a UTM gives H_Hat the behaviour that the H that is a decider
> will "correctly" report. Being clear by giving the two Hs different
> names would blow his cover.
>
> I am trying to think that this is just PO being clumsy with notation and
> ignorant of what a halting decider is, but I can't shake the feeling he
> knows its nonsense. Could he really not know?
>
There is no ruse. I have to break my presentation down into smaller steps.
Here is the new first step:
Does the following code specify infinite recursion?
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 14:44 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) |
| Message-ID | <8sudnS4bA5Ff7SDCnZ2dnUU7-XvNnZ2d@giganews.com> |
| In reply to | #25827 |
On 11/24/2020 1:30 PM, Mike Terry wrote:
> On 24/11/2020 17:34, olcott wrote:
>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>> On 24/11/2020 16:32, olcott wrote:
>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>> On 24/11/2020 15:51, olcott wrote:
> <.. snip ..>
>>>>>>
>>>>>> Before we can proceed we need to have agreement on this general
>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>
>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>> simulating it
>>>>>> expresses behavior that is not halting behavior.
>>>>>
>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>> stands, I know you will take that quote and post it all over the
>>>>> newsgroup claiming it means something it doesn't. Because that's the
>>>>> kind of guy that you are.
>>>>>
>>>>> However, I'll happily agree to the better worded:
>>>>>
>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> I will start quoting it this way:
>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>> never halts, expresses behavior that is not halting behavior.
>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>
>>>> Yeah !!! Great job !!!
>>>>
>>>
>>> The fact that you would want to quote someone agreeing to such an
>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>> speaks volumes about your desparation.
>>
>> Both Ben and Richard have made it a habit of denying easily verifiable
>> facts as long as doing this would contrive some rhetorical basis for the
>> denigration of my work that would convince casual observers (that are
>> not paying any attention to the actual reasoning) that I am incorrect.
>
> That's not right. Both Ben and Richard point out perfectly correct
> problems with your arguments. The problem is that you don't understand
> what they point out, so you think they are making it up, ignoring your
> arguments, generally "tricking" readers, and so on.
>
> It's you who are biased here in the way you view those discussions. I
> don't recall any "trickery" on their part - just honest discussion of
> problems with your arguments.
>
>>
>> When I prove my point Ben typically erases this whole point and responds
>> with ad hominem attacks that have nothing to do with the actual point.
>
>> Both Ben and Richard have disagreed that this is an infinitely repeating
>> sequence even though is is an obviously verifiable fact that it is an
>> infinitely repeating sequence:
>>
>> _H_Hat()
>> [000004f7](01) 55 push ebp
>> [000004f8](02) 8bec mov ebp,esp
>> [000004fa](01) 51 push ecx
>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>> [000004fe](01) 50 push eax
>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>> [00000502](01) 51 push ecx
>> [00000503](05) e86ffeffff call 00000377
>
> Well, this is a good example. You think this is an example of your
> "denying easily verifiable facts", but this is just showing your biases.
> You believe there is infinite recursion, so what you have provided
> must "prove" this, because in your mind the "infinite" claim is correct.
>
> But those do those trace entries actually prove what you claim? No. So
> your claim isn't "easily verifiable" after all.
>
> In a recent post I asked you a key question which I've asked several
> times before - is your "repeated calls to a function with no intervening
> conditional branches" test actually a SOUND test? You've never answered
> this, so why should anyone take a trace such as the one above as
> indicating infinite recursion? And that's before anyone asks whether
> there are hidden trace entries they're not seeing.
>
>
> Mike.
>
The (just now verified) fact that the debug trace produced by executing
the following code is identical to the execution trace produced by the
actual simulator:
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
void H_Hat(u32 P)
{
u32 Aborted = DebugTrace(P, P);
if (Aborted)
HALT
else
HERE: goto HERE;
}
int main()
{
u32 P = (u32)H_Hat;
DebugTrace(P, P);
HALT;
}
This proves the following:
(1) The x86utm simulator does faithfully simulate its input.
(2) H_Hat is infinitely recursive.
(3) The infinite recursion of H_Hat can be analytically be determined in
advance.
(4) If the simulator decides to stop simulating its input and return
false this would be a correct not-halting decision on H_Hat.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-25 02:04 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) |
| Message-ID | <0bSdnR6SX8QwJiDCnZ2dnUU78LfNnZ2d@brightview.co.uk> |
| In reply to | #25832 |
On 24/11/2020 20:44, olcott wrote:
> On 11/24/2020 1:30 PM, Mike Terry wrote:
>> On 24/11/2020 17:34, olcott wrote:
>>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>>> On 24/11/2020 16:32, olcott wrote:
>>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>>> On 24/11/2020 15:51, olcott wrote:
>> <.. snip ..>
>>>>>>>
>>>>>>> Before we can proceed we need to have agreement on this general
>>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>>
>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>> simulating it
>>>>>>> expresses behavior that is not halting behavior.
>>>>>>
>>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>>> stands, I know you will take that quote and post it all over the
>>>>>> newsgroup claiming it means something it doesn't. Because that's the
>>>>>> kind of guy that you are.
>>>>>>
>>>>>> However, I'll happily agree to the better worded:
>>>>>>
>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>>
>>>>>> Mike.
>>>>>>
>>>>>
>>>>> I will start quoting it this way:
>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>> never halts, expresses behavior that is not halting behavior.
>>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>>
>>>>> Yeah !!! Great job !!!
>>>>>
>>>>
>>>> The fact that you would want to quote someone agreeing to such an
>>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>>> speaks volumes about your desparation.
>>>
>>> Both Ben and Richard have made it a habit of denying easily verifiable
>>> facts as long as doing this would contrive some rhetorical basis for the
>>> denigration of my work that would convince casual observers (that are
>>> not paying any attention to the actual reasoning) that I am incorrect.
>>
>> That's not right. Both Ben and Richard point out perfectly correct
>> problems with your arguments. The problem is that you don't
>> understand what they point out, so you think they are making it up,
>> ignoring your arguments, generally "tricking" readers, and so on.
>>
>> It's you who are biased here in the way you view those discussions. I
>> don't recall any "trickery" on their part - just honest discussion of
>> problems with your arguments.
>>
>>>
>>> When I prove my point Ben typically erases this whole point and responds
>>> with ad hominem attacks that have nothing to do with the actual point.
>>
>>> Both Ben and Richard have disagreed that this is an infinitely repeating
>>> sequence even though is is an obviously verifiable fact that it is an
>>> infinitely repeating sequence:
>>>
>>> _H_Hat()
>>> [000004f7](01) 55 push ebp
>>> [000004f8](02) 8bec mov ebp,esp
>>> [000004fa](01) 51 push ecx
>>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>>> [000004fe](01) 50 push eax
>>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000502](01) 51 push ecx
>>> [00000503](05) e86ffeffff call 00000377
>>
>> Well, this is a good example. You think this is an example of your
>> "denying easily verifiable facts", but this is just showing your
>> biases. You believe there is infinite recursion, so what you have
>> provided must "prove" this, because in your mind the "infinite" claim
>> is correct.
>>
>> But those do those trace entries actually prove what you claim? No.
>> So your claim isn't "easily verifiable" after all.
>>
>> In a recent post I asked you a key question which I've asked several
>> times before - is your "repeated calls to a function with no
>> intervening conditional branches" test actually a SOUND test? You've
>> never answered this, so why should anyone take a trace such as the one
>> above as indicating infinite recursion? And that's before anyone asks
>> whether there are hidden trace entries they're not seeing.
>>
>>
>> Mike.
>>
>
> The (just now verified) fact that the debug trace produced by executing
> the following code is identical to the execution trace produced by the
> actual simulator:
>
>
> int DebugTrace(u32 N, u32 M)
> {
> return ((int(*)(int))N)(M);
> }
>
>
> void H_Hat(u32 P)
> {
> u32 Aborted = DebugTrace(P, P);
> if (Aborted)
> HALT
> else
> HERE: goto HERE;
> }
>
>
> int main()
> {
> u32 P = (u32)H_Hat;
> DebugTrace(P, P);
> HALT;
> }
>
>
> This proves the following:
> (1) The x86utm simulator does faithfully simulate its input.
>
People would probably take that on trust, at least initially, up to the
point where some unexplainable problem points to a bug or other
"feature" of x86utm.
BTW, I'm assuming by x86utm, you mean just the UTM "emulation"
functionality, and you're not lumping any "decider" logic into
x86utm.exe itself. If you /are/ then who knows what that hidden decider
logic might be doing? And so there would be no proof (or even
"confidence building") from looking at traces that it is faithfully
simulating its input - because one input might come out ok, but some
other input might be "halt detected" and so interfered with.
> (2) H_Hat is infinitely recursive.
>
I don't think anyone would dispute that... (I don't dispute it, and I'm
"just this guy")
> (3) The infinite recursion of H_Hat can be analytically be determined in
> advance.
No, it *doesn't* prove that! All you have presented is a trace
involving infinite recursion. You need to say (and hopefully *prove*)
whatever it is about that trace that means the recursion can be
(soundly) determined in advance.
Actually, in THIS SPECIFIC EXAMPLE, it should be easy enough to specify
the criterion for analysing the trace! After all, what we have here is
a variation of tight-loop detection, which can be implemented soundly.
Even given this is the case, it does not imply the same for your "real"
halting detector code, which is after all not detecting tight loops due
to the involvement of emulation in the trace output.
>
> (4) If the simulator decides to stop simulating its input and return
> false this would be a correct not-halting decision on H_Hat.
:) For THIS SPECIFIC INPUT (H_Hat,H_Hat) yes.
But you should know by now that if you change DebugTrace() in the code
above, e.g. to return false, it is no longer THIS SPECIFIC INPUT
(H_Hat,H_Hat) any more. It will become SPECIFIC INPUT (H_Hat2,H_Hat2),
and that might or might not be halting, depending on the exact change...
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 20:21 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) |
| Message-ID | <GrudnaIjH_8FIiDCnZ2dnUU7-KvNnZ2d@giganews.com> |
| In reply to | #25883 |
On 11/24/2020 8:04 PM, Mike Terry wrote:
> On 24/11/2020 20:44, olcott wrote:
>> On 11/24/2020 1:30 PM, Mike Terry wrote:
>>> On 24/11/2020 17:34, olcott wrote:
>>>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>>>> On 24/11/2020 16:32, olcott wrote:
>>>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>>>> On 24/11/2020 15:51, olcott wrote:
>>> <.. snip ..>
>>>>>>>>
>>>>>>>> Before we can proceed we need to have agreement on this general
>>>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>>>
>>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>>> simulating it
>>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>
>>>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>>>> stands, I know you will take that quote and post it all over the
>>>>>>> newsgroup claiming it means something it doesn't. Because that's
>>>>>>> the
>>>>>>> kind of guy that you are.
>>>>>>>
>>>>>>> However, I'll happily agree to the better worded:
>>>>>>>
>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>>>
>>>>>>> Mike.
>>>>>>>
>>>>>>
>>>>>> I will start quoting it this way:
>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>> never halts, expresses behavior that is not halting behavior.
>>>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>>>
>>>>>> Yeah !!! Great job !!!
>>>>>>
>>>>>
>>>>> The fact that you would want to quote someone agreeing to such an
>>>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>>>> speaks volumes about your desparation.
>>>>
>>>> Both Ben and Richard have made it a habit of denying easily verifiable
>>>> facts as long as doing this would contrive some rhetorical basis for
>>>> the
>>>> denigration of my work that would convince casual observers (that are
>>>> not paying any attention to the actual reasoning) that I am incorrect.
>>>
>>> That's not right. Both Ben and Richard point out perfectly correct
>>> problems with your arguments. The problem is that you don't
>>> understand what they point out, so you think they are making it up,
>>> ignoring your arguments, generally "tricking" readers, and so on.
>>>
>>> It's you who are biased here in the way you view those discussions. I
>>> don't recall any "trickery" on their part - just honest discussion of
>>> problems with your arguments.
>>>
>>>>
>>>> When I prove my point Ben typically erases this whole point and
>>>> responds
>>>> with ad hominem attacks that have nothing to do with the actual point.
>>>
>>>> Both Ben and Richard have disagreed that this is an infinitely
>>>> repeating
>>>> sequence even though is is an obviously verifiable fact that it is an
>>>> infinitely repeating sequence:
>>>>
>>>> _H_Hat()
>>>> [000004f7](01) 55 push ebp
>>>> [000004f8](02) 8bec mov ebp,esp
>>>> [000004fa](01) 51 push ecx
>>>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>>>> [000004fe](01) 50 push eax
>>>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000502](01) 51 push ecx
>>>> [00000503](05) e86ffeffff call 00000377
>>>
>>> Well, this is a good example. You think this is an example of your
>>> "denying easily verifiable facts", but this is just showing your
>>> biases. You believe there is infinite recursion, so what you have
>>> provided must "prove" this, because in your mind the "infinite" claim
>>> is correct.
>>>
>>> But those do those trace entries actually prove what you claim? No.
>>> So your claim isn't "easily verifiable" after all.
>>>
>>> In a recent post I asked you a key question which I've asked several
>>> times before - is your "repeated calls to a function with no
>>> intervening conditional branches" test actually a SOUND test? You've
>>> never answered this, so why should anyone take a trace such as the one
>>> above as indicating infinite recursion? And that's before anyone asks
>>> whether there are hidden trace entries they're not seeing.
>>>
>>>
>>> Mike.
>>>
>>
>> The (just now verified) fact that the debug trace produced by executing
>> the following code is identical to the execution trace produced by the
>> actual simulator:
>>
>>
>> int DebugTrace(u32 N, u32 M)
>> {
>> return ((int(*)(int))N)(M);
>> }
>>
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> DebugTrace(P, P);
>> HALT;
>> }
>>
>>
>> This proves the following:
>> (1) The x86utm simulator does faithfully simulate its input.
>>
>
> People would probably take that on trust, at least initially, up to the
> point where some unexplainable problem points to a bug or other
> "feature" of x86utm.
>
> BTW, I'm assuming by x86utm, you mean just the UTM "emulation"
> functionality, and you're not lumping any "decider" logic into
> x86utm.exe itself.
I don't have the decider code written yet. DebugTrace() has alway been
the name of this function since the beginning. The above version of
DebugTrace() was the first stub version of the actual code.
The next step is to provide very robust decoding of all of the x86
control flow instructions. Thankfully conditional branch is the easiest.
> If you /are/ then who knows what that hidden decider
> logic might be doing? And so there would be no proof (or even
> "confidence building") from looking at traces that it is faithfully
> simulating its input - because one input might come out ok, but some
> other input might be "halt detected" and so interfered with.
If the execution trace of the user portion of the code executed by the
above white box version of DebugTrace() is identical to the black box
one this proves that the black box one only simulates. I verified this.
>> (2) H_Hat is infinitely recursive.
>>
> I don't think anyone would dispute that... (I don't dispute it, and I'm
> "just this guy")
You are the only one that agreed until I posted the white box version.
>> (3) The infinite recursion of H_Hat can be analytically be determined in
>> advance.
>
> No, it *doesn't* prove that!
So the above code is not infinitely recursive?
No sense proceeding beyond this point.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-24 23:10 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria) |
| Message-ID | <OOkvH.3854$jL.1475@fx13.iad> |
| In reply to | #25885 |
On 11/24/20 9:21 PM, olcott wrote:
> On 11/24/2020 8:04 PM, Mike Terry wrote:
>> On 24/11/2020 20:44, olcott wrote:
>>> On 11/24/2020 1:30 PM, Mike Terry wrote:
>>>> On 24/11/2020 17:34, olcott wrote:
>>>>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>>>>> On 24/11/2020 16:32, olcott wrote:
>>>>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>>>>> On 24/11/2020 15:51, olcott wrote:
>>>> <.. snip ..>
>>>>>>>>>
>>>>>>>>> Before we can proceed we need to have agreement on this general
>>>>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>>>>
>>>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>>>> simulating it
>>>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>>
>>>>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>>>>> stands, I know you will take that quote and post it all over the
>>>>>>>> newsgroup claiming it means something it doesn't. Because
>>>>>>>> that's the
>>>>>>>> kind of guy that you are.
>>>>>>>>
>>>>>>>> However, I'll happily agree to the better worded:
>>>>>>>>
>>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>>>>
>>>>>>>> Mike.
>>>>>>>>
>>>>>>>
>>>>>>> I will start quoting it this way:
>>>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>>>> never halts, expresses behavior that is not halting behavior.
>>>>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>>>>
>>>>>>> Yeah !!! Great job !!!
>>>>>>>
>>>>>>
>>>>>> The fact that you would want to quote someone agreeing to such an
>>>>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>>>>> speaks volumes about your desparation.
>>>>>
>>>>> Both Ben and Richard have made it a habit of denying easily verifiable
>>>>> facts as long as doing this would contrive some rhetorical basis
>>>>> for the
>>>>> denigration of my work that would convince casual observers (that are
>>>>> not paying any attention to the actual reasoning) that I am incorrect.
>>>>
>>>> That's not right. Both Ben and Richard point out perfectly correct
>>>> problems with your arguments. The problem is that you don't
>>>> understand what they point out, so you think they are making it up,
>>>> ignoring your arguments, generally "tricking" readers, and so on.
>>>>
>>>> It's you who are biased here in the way you view those discussions. I
>>>> don't recall any "trickery" on their part - just honest discussion of
>>>> problems with your arguments.
>>>>
>>>>>
>>>>> When I prove my point Ben typically erases this whole point and
>>>>> responds
>>>>> with ad hominem attacks that have nothing to do with the actual point.
>>>>
>>>>> Both Ben and Richard have disagreed that this is an infinitely
>>>>> repeating
>>>>> sequence even though is is an obviously verifiable fact that it is an
>>>>> infinitely repeating sequence:
>>>>>
>>>>> _H_Hat()
>>>>> [000004f7](01) 55 push ebp
>>>>> [000004f8](02) 8bec mov ebp,esp
>>>>> [000004fa](01) 51 push ecx
>>>>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>>>>> [000004fe](01) 50 push eax
>>>>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000502](01) 51 push ecx
>>>>> [00000503](05) e86ffeffff call 00000377
>>>>
>>>> Well, this is a good example. You think this is an example of your
>>>> "denying easily verifiable facts", but this is just showing your
>>>> biases. You believe there is infinite recursion, so what you have
>>>> provided must "prove" this, because in your mind the "infinite" claim
>>>> is correct.
>>>>
>>>> But those do those trace entries actually prove what you claim? No.
>>>> So your claim isn't "easily verifiable" after all.
>>>>
>>>> In a recent post I asked you a key question which I've asked several
>>>> times before - is your "repeated calls to a function with no
>>>> intervening conditional branches" test actually a SOUND test? You've
>>>> never answered this, so why should anyone take a trace such as the one
>>>> above as indicating infinite recursion? And that's before anyone asks
>>>> whether there are hidden trace entries they're not seeing.
>>>>
>>>>
>>>> Mike.
>>>>
>>>
>>> The (just now verified) fact that the debug trace produced by executing
>>> the following code is identical to the execution trace produced by the
>>> actual simulator:
>>>
>>>
>>> int DebugTrace(u32 N, u32 M)
>>> {
>>> return ((int(*)(int))N)(M);
>>> }
>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = DebugTrace(P, P);
>>> if (Aborted)
>>> HALT
>>> else
>>> HERE: goto HERE;
>>> }
>>>
>>>
>>> int main()
>>> {
>>> u32 P = (u32)H_Hat;
>>> DebugTrace(P, P);
>>> HALT;
>>> }
>>>
>>>
>>> This proves the following:
>>> (1) The x86utm simulator does faithfully simulate its input.
>>>
>>
>> People would probably take that on trust, at least initially, up to
>> the point where some unexplainable problem points to a bug or other
>> "feature" of x86utm.
>>
>> BTW, I'm assuming by x86utm, you mean just the UTM "emulation"
>> functionality, and you're not lumping any "decider" logic into
>> x86utm.exe itself.
>
> I don't have the decider code written yet. DebugTrace() has alway been
> the name of this function since the beginning. The above version of
> DebugTrace() was the first stub version of the actual code.
Interesting that you have posted what was claimed to be the results of
this decider that hasn't yet be finished. I guess that explains why its
results have been a bit contradictory.
>
> The next step is to provide very robust decoding of all of the x86
> control flow instructions. Thankfully conditional branch is the easiest.
>
>> If you /are/ then who knows what that hidden decider logic might be
>> doing? And so there would be no proof (or even "confidence building")
>> from looking at traces that it is faithfully simulating its input -
>> because one input might come out ok, but some other input might be
>> "halt detected" and so interfered with.
>
> If the execution trace of the user portion of the code executed by the
> above white box version of DebugTrace() is identical to the black box
> one this proves that the black box one only simulates. I verified this.
Exept that Black Box testing can NEVER prove conclusively the totality
of behavior of the code in the black box. That is the nature of a black box.
>
>>> (2) H_Hat is infinitely recursive.
>>>
>> I don't think anyone would dispute that... (I don't dispute it, and
>> I'm "just this guy")
>
> You are the only one that agreed until I posted the white box version.
>
>>> (3) The infinite recursion of H_Hat can be analytically be determined in
>>> advance.
>>
>> No, it *doesn't* prove that!
>
> So the above code is not infinitely recursive?
> No sense proceeding beyond this point.
>
Here is why the name H_Hat is bad. The name H_Hat has a global standard
meaning in this context, and we KNOW that to try to define a result to
this H_Hat that isn't really H_Hat is going to later be tried to be
imposed on an H_Hat that isn't this H_Hat.
Yes, for THIS particular H_Hat, it is clear that we have an infinte
recursion, based on BOTH the definition of H_Hat and Debug_Step.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 14:29 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement) |
| Message-ID | <grmdnfpuk8yr8CDCnZ2dnUU7-ffNnZ2d@giganews.com> |
| In reply to | #25827 |
On 11/24/2020 1:30 PM, Mike Terry wrote:
> On 24/11/2020 17:34, olcott wrote:
>> On 11/24/2020 10:48 AM, Mike Terry wrote:
>>> On 24/11/2020 16:32, olcott wrote:
>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>> On 24/11/2020 15:51, olcott wrote:
> <.. snip ..>
>>>>>>
>>>>>> Before we can proceed we need to have agreement on this general
>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>
>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>> simulating it
>>>>>> expresses behavior that is not halting behavior.
>>>>>
>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>> stands, I know you will take that quote and post it all over the
>>>>> newsgroup claiming it means something it doesn't. Because that's the
>>>>> kind of guy that you are.
>>>>>
>>>>> However, I'll happily agree to the better worded:
>>>>>
>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> I will start quoting it this way:
>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>> never halts, expresses behavior that is not halting behavior.
>>>> (Mike Terry 11/24/2020 10:19 AM)
>>>>
>>>> Yeah !!! Great job !!!
>>>>
>>>
>>> The fact that you would want to quote someone agreeing to such an
>>> obvious statement, when NOBODY HAS EXPRESSED DISAGREEMENT WITH IT,
>>> speaks volumes about your desparation.
>>
>> Both Ben and Richard have made it a habit of denying easily verifiable
>> facts as long as doing this would contrive some rhetorical basis for the
>> denigration of my work that would convince casual observers (that are
>> not paying any attention to the actual reasoning) that I am incorrect.
>
> That's not right. Both Ben and Richard point out perfectly correct
> problems with your arguments. The problem is that you don't understand
> what they point out, so you think they are making it up, ignoring your
> arguments, generally "tricking" readers, and so on.
>
> It's you who are biased here in the way you view those discussions. I
> don't recall any "trickery" on their part - just honest discussion of
> problems with your arguments.
>
>>
>> When I prove my point Ben typically erases this whole point and responds
>> with ad hominem attacks that have nothing to do with the actual point.
>
>> Both Ben and Richard have disagreed that this is an infinitely repeating
>> sequence even though is is an obviously verifiable fact that it is an
>> infinitely repeating sequence:
>>
>> _H_Hat()
>> [000004f7](01) 55 push ebp
>> [000004f8](02) 8bec mov ebp,esp
>> [000004fa](01) 51 push ecx
>> [000004fb](03) 8b4508 mov eax,[ebp+08]
>> [000004fe](01) 50 push eax
>> [000004ff](03) 8b4d08 mov ecx,[ebp+08]
>> [00000502](01) 51 push ecx
>> [00000503](05) e86ffeffff call 00000377
>
> Well, this is a good example. You think this is an example of your
> "denying easily verifiable facts", but this is just showing your biases.
> You believe there is infinite recursion, so what you have provided
> must "prove" this, because in your mind the "infinite" claim is correct.
>
> But those do those trace entries actually prove what you claim? No. So
> your claim isn't "easily verifiable" after all.
>
> In a recent post I asked you a key question which I've asked several
> times before - is your "repeated calls to a function with no intervening
> conditional branches" test actually a SOUND test? You've never answered
> this, so why should anyone take a trace such as the one above as
> indicating infinite recursion? And that's before anyone asks whether
> there are hidden trace entries they're not seeing.
>
>
> Mike.
>
When we can see that the debug trace produced by the very complex
DebugTrace() that we cannot see produces exactly the same sequences of
instructions as the one that we can see then be have empirical proof
that the hidden DebugTrace() is doing as claimed.
int DebugTrace(u32 N, u32 M)
{
return ((int(*)(int))N)(M);
}
I just verified this. This proves that my x86utm DebugTrace() is a
faithful UTM.
--
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-24 10:46 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <DoqdnefPjehlpSDCnZ2dnUU7-bnNnZ2d@giganews.com> |
| In reply to | #25805 |
On 11/24/2020 10:19 AM, Mike Terry wrote:
> On 24/11/2020 15:51, olcott wrote:
>> On 11/24/2020 9:41 AM, Mike Terry wrote:
>>> On 24/11/2020 04:18, olcott wrote:
>>>> On 11/23/2020 8:53 PM, Mike Terry wrote:
>>>>> On 24/11/2020 00:37, olcott wrote:
>>>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>> On 23/11/2020 21:29, olcott wrote:
>>>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
>>>>>>>>> On 23/11/2020 01:24, 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.
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Hey, you're totally CHEATING here. There ARE conditional branch
>>>>>>>>> intstructions, but you've just silently snipped them from the
>>>>>>>>> trace
>>>>>>>>> output you've shown. There are HUGE gaps in your trace!!
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Mike.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Unless we maintain a line-of-demarcation between the halt decider
>>>>>>>> and
>>>>>>>> its input pathological self-reference(Olcott 2004) makes the
>>>>>>>> halting
>>>>>>>> problem have undecidable inputs in the same way that the Liar
>>>>>>>> Paradox is
>>>>>>>> neither true nor false.
>>>>>>>>
>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>
>>>>>>>>
>>>>>>>> Instead of asking the question: Does the input halt on its input?
>>>>>>>> that is subject to pathological self-reference.
>>>>>>>>
>>>>>>>> We ask the question: Does the execution of the input have to be
>>>>>>>> aborted
>>>>>>>> to prevent its infinite execution?
>>>>>>>>
>>>>>>>> When we ask this latter question then we can ignore all of the
>>>>>>>> conditional branch instructions that are in the halt decider and
>>>>>>>> only
>>>>>>>> pay attention to the ones that are in the input.
>>>>>>>>
>>>>>>>
>>>>>>> We can indeed ignore the halt decider outer-level trace entries, and
>>>>>>> concentrate on just what the halt decider embedded emulator sees its
>>>>>>> input doing.
>>>>>>
>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>>
>>>>>> There will not be an embedded decider because an embedded decider
>>>>>> permits what would seem to causal observers as inconsistent halting
>>>>>> decisions. By not allowing any execution trace data to exist that the
>>>>>> halt decider cannot see then even the apperance of inconsistency
>>>>>> ceases
>>>>>> to exist.
>>>>>
>>>>> There has to be an embedded decider, because that is how the Linz
>>>>> proof specifies H^. When you say "seem to causal [sic] observers as
>>>>> inconsistent halting decisions" that is because the decisions really
>>>>> are inconsistent! You can't magic them to be consistent by making the
>>>>> decider part of the OS. (If that's your plan.)
>>>>
>>>> I do not have to conform to any conventions but this one:
>>>>
>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>>
>>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>>> expresses behavior that is not halting behavior.
>>>>
>>>
>>> Wrong.
>>>
>>> You are talking here about H, whereas I was talking about H^. If you
>>> want to say anything about the Linz proof, you need to talk about H
>>> *and* H^, and H^ must follow the Linz spec for how it relates to H.
>>> Duh.
>>
>> Before we can proceed we need to have agreement on this general
>> principle: (It is a mandatory prerequisite).
>>
>> Any input TMD that would never halt unless a UTM stopped simulating it
>> expresses behavior that is not halting behavior.
>
> That's a bad wording for lots of reasons. If I agree to it as it
> stands, I know you will take that quote and post it all over the
> newsgroup claiming it means something it doesn't. Because that's the
> kind of guy that you are.
>
> However, I'll happily agree to the better worded:
>
> Any input (TMD, DATA) which, when run under a (pure) UTM
> never halts, expresses behaviour that is not halting behaviour.
>
> Mike.
>
That one won't work for me, but it does show that you understand the
principle. It is no good that we say "never halts" because we cannot
wait an eternity to see that it never halts.
Since this statement is to be formulated for a general audience that has
never been a part of these conversations we must remove the word "pure"
because without the context of these conversations the word "pure" would
be quite confusing. When we say UTM to a general audience of computer
scientists "pure" is already understood.
Any input (TMD / DATA) that would never halt unless its (UTM) stopped
simulating it expresses behavior that is not halting behavior.
TMD = Turing Machine Description
UTM = Universal Turing Machine
--
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-24 17:04 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <xYqdndt5fpK8oCDCnZ2dnUU78KOdnZ2d@brightview.co.uk> |
| In reply to | #25809 |
On 24/11/2020 16:46, olcott wrote:
> On 11/24/2020 10:19 AM, Mike Terry wrote:
>> On 24/11/2020 15:51, olcott wrote:
>>> On 11/24/2020 9:41 AM, Mike Terry wrote:
>>>> On 24/11/2020 04:18, olcott wrote:
>>>>> On 11/23/2020 8:53 PM, Mike Terry wrote:
>>>>>> On 24/11/2020 00:37, olcott wrote:
>>>>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>> On 23/11/2020 21:29, olcott wrote:
>>>>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
>>>>>>>>>> On 23/11/2020 01:24, 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.
>>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> Hey, you're totally CHEATING here. There ARE conditional branch
>>>>>>>>>> intstructions, but you've just silently snipped them from the
>>>>>>>>>> trace
>>>>>>>>>> output you've shown. There are HUGE gaps in your trace!!
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Mike.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Unless we maintain a line-of-demarcation between the halt decider
>>>>>>>>> and
>>>>>>>>> its input pathological self-reference(Olcott 2004) makes the
>>>>>>>>> halting
>>>>>>>>> problem have undecidable inputs in the same way that the Liar
>>>>>>>>> Paradox is
>>>>>>>>> neither true nor false.
>>>>>>>>>
>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Instead of asking the question: Does the input halt on its input?
>>>>>>>>> that is subject to pathological self-reference.
>>>>>>>>>
>>>>>>>>> We ask the question: Does the execution of the input have to be
>>>>>>>>> aborted
>>>>>>>>> to prevent its infinite execution?
>>>>>>>>>
>>>>>>>>> When we ask this latter question then we can ignore all of the
>>>>>>>>> conditional branch instructions that are in the halt decider and
>>>>>>>>> only
>>>>>>>>> pay attention to the ones that are in the input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We can indeed ignore the halt decider outer-level trace entries,
>>>>>>>> and
>>>>>>>> concentrate on just what the halt decider embedded emulator sees
>>>>>>>> its
>>>>>>>> input doing.
>>>>>>>
>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>> specified
>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>> correct
>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>> trace.
>>>>>>>
>>>>>>> There will not be an embedded decider because an embedded decider
>>>>>>> permits what would seem to causal observers as inconsistent halting
>>>>>>> decisions. By not allowing any execution trace data to exist that
>>>>>>> the
>>>>>>> halt decider cannot see then even the apperance of inconsistency
>>>>>>> ceases
>>>>>>> to exist.
>>>>>>
>>>>>> There has to be an embedded decider, because that is how the Linz
>>>>>> proof specifies H^. When you say "seem to causal [sic] observers as
>>>>>> inconsistent halting decisions" that is because the decisions really
>>>>>> are inconsistent! You can't magic them to be consistent by making
>>>>>> the
>>>>>> decider part of the OS. (If that's your plan.)
>>>>>
>>>>> I do not have to conform to any conventions but this one:
>>>>>
>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>>>
>>>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>>>> expresses behavior that is not halting behavior.
>>>>>
>>>>
>>>> Wrong.
>>>>
>>>> You are talking here about H, whereas I was talking about H^. If you
>>>> want to say anything about the Linz proof, you need to talk about H
>>>> *and* H^, and H^ must follow the Linz spec for how it relates to H.
>>>> Duh.
>>>
>>> Before we can proceed we need to have agreement on this general
>>> principle: (It is a mandatory prerequisite).
>>>
>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>> expresses behavior that is not halting behavior.
>>
>> That's a bad wording for lots of reasons. If I agree to it as it
>> stands, I know you will take that quote and post it all over the
>> newsgroup claiming it means something it doesn't. Because that's the
>> kind of guy that you are.
>>
>> However, I'll happily agree to the better worded:
>>
>> Any input (TMD, DATA) which, when run under a (pure) UTM
>> never halts, expresses behaviour that is not halting behaviour.
>>
>> Mike.
>>
>
> That one won't work for me, but it does show that you understand the
> principle. It is no good that we say "never halts" because we cannot
> wait an eternity to see that it never halts.
>
> Since this statement is to be formulated for a general audience that has
> never been a part of these conversations we must remove the word "pure"
> because without the context of these conversations the word "pure" would
> be quite confusing. When we say UTM to a general audience of computer
> scientists "pure" is already understood.
>
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.
>
> TMD = Turing Machine Description
> UTM = Universal Turing Machine
>
>
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-24 17:05 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <xYqdndp5fpLJoCDCnZ2dnUU78KMAAAAA@brightview.co.uk> |
| In reply to | #25809 |
On 24/11/2020 16:46, olcott wrote:
> On 11/24/2020 10:19 AM, Mike Terry wrote:
>> On 24/11/2020 15:51, olcott wrote:
>>> On 11/24/2020 9:41 AM, Mike Terry wrote:
>>>> On 24/11/2020 04:18, olcott wrote:
>>>>> On 11/23/2020 8:53 PM, Mike Terry wrote:
>>>>>> On 24/11/2020 00:37, olcott wrote:
>>>>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>> On 23/11/2020 21:29, olcott wrote:
>>>>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
>>>>>>>>>> On 23/11/2020 01:24, 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.
>>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> Hey, you're totally CHEATING here. There ARE conditional branch
>>>>>>>>>> intstructions, but you've just silently snipped them from the
>>>>>>>>>> trace
>>>>>>>>>> output you've shown. There are HUGE gaps in your trace!!
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Mike.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Unless we maintain a line-of-demarcation between the halt decider
>>>>>>>>> and
>>>>>>>>> its input pathological self-reference(Olcott 2004) makes the
>>>>>>>>> halting
>>>>>>>>> problem have undecidable inputs in the same way that the Liar
>>>>>>>>> Paradox is
>>>>>>>>> neither true nor false.
>>>>>>>>>
>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Instead of asking the question: Does the input halt on its input?
>>>>>>>>> that is subject to pathological self-reference.
>>>>>>>>>
>>>>>>>>> We ask the question: Does the execution of the input have to be
>>>>>>>>> aborted
>>>>>>>>> to prevent its infinite execution?
>>>>>>>>>
>>>>>>>>> When we ask this latter question then we can ignore all of the
>>>>>>>>> conditional branch instructions that are in the halt decider and
>>>>>>>>> only
>>>>>>>>> pay attention to the ones that are in the input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We can indeed ignore the halt decider outer-level trace entries,
>>>>>>>> and
>>>>>>>> concentrate on just what the halt decider embedded emulator sees
>>>>>>>> its
>>>>>>>> input doing.
>>>>>>>
>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>> specified
>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>> correct
>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>> trace.
>>>>>>>
>>>>>>> There will not be an embedded decider because an embedded decider
>>>>>>> permits what would seem to causal observers as inconsistent halting
>>>>>>> decisions. By not allowing any execution trace data to exist that
>>>>>>> the
>>>>>>> halt decider cannot see then even the apperance of inconsistency
>>>>>>> ceases
>>>>>>> to exist.
>>>>>>
>>>>>> There has to be an embedded decider, because that is how the Linz
>>>>>> proof specifies H^. When you say "seem to causal [sic] observers as
>>>>>> inconsistent halting decisions" that is because the decisions really
>>>>>> are inconsistent! You can't magic them to be consistent by making
>>>>>> the
>>>>>> decider part of the OS. (If that's your plan.)
>>>>>
>>>>> I do not have to conform to any conventions but this one:
>>>>>
>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>>>
>>>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>>>> expresses behavior that is not halting behavior.
>>>>>
>>>>
>>>> Wrong.
>>>>
>>>> You are talking here about H, whereas I was talking about H^. If you
>>>> want to say anything about the Linz proof, you need to talk about H
>>>> *and* H^, and H^ must follow the Linz spec for how it relates to H.
>>>> Duh.
>>>
>>> Before we can proceed we need to have agreement on this general
>>> principle: (It is a mandatory prerequisite).
>>>
>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>> expresses behavior that is not halting behavior.
>>
>> That's a bad wording for lots of reasons. If I agree to it as it
>> stands, I know you will take that quote and post it all over the
>> newsgroup claiming it means something it doesn't. Because that's the
>> kind of guy that you are.
>>
>> However, I'll happily agree to the better worded:
>>
>> Any input (TMD, DATA) which, when run under a (pure) UTM
>> never halts, expresses behaviour that is not halting behaviour.
>>
>> Mike.
>>
>
> That one won't work for me, but it does show that you understand the
> principle. It is no good that we say "never halts" because we cannot
> wait an eternity to see that it never halts.
>
> Since this statement is to be formulated for a general audience that has
> never been a part of these conversations we must remove the word "pure"
> because without the context of these conversations the word "pure" would
> be quite confusing. When we say UTM to a general audience of computer
> scientists "pure" is already understood.
>
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.
>
Just to be clear - that is your statement, not mine.
Mike.
> TMD = Turing Machine Description
> UTM = Universal Turing Machine
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 11:19 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <S_6dnbK4froW3SDCnZ2dnUU7-ROdnZ2d@giganews.com> |
| In reply to | #25812 |
On 11/24/2020 11:05 AM, Mike Terry wrote:
> On 24/11/2020 16:46, olcott wrote:
>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>> On 24/11/2020 15:51, olcott wrote:
>>>> On 11/24/2020 9:41 AM, Mike Terry wrote:
>>>>> On 24/11/2020 04:18, olcott wrote:
>>>>>> On 11/23/2020 8:53 PM, Mike Terry wrote:
>>>>>>> On 24/11/2020 00:37, olcott wrote:
>>>>>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>> On 23/11/2020 21:29, olcott wrote:
>>>>>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
>>>>>>>>>>> On 23/11/2020 01:24, 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.
>>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> Hey, you're totally CHEATING here. There ARE conditional branch
>>>>>>>>>>> intstructions, but you've just silently snipped them from the
>>>>>>>>>>> trace
>>>>>>>>>>> output you've shown. There are HUGE gaps in your trace!!
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Mike.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Unless we maintain a line-of-demarcation between the halt decider
>>>>>>>>>> and
>>>>>>>>>> its input pathological self-reference(Olcott 2004) makes the
>>>>>>>>>> halting
>>>>>>>>>> problem have undecidable inputs in the same way that the Liar
>>>>>>>>>> Paradox is
>>>>>>>>>> neither true nor false.
>>>>>>>>>>
>>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Instead of asking the question: Does the input halt on its input?
>>>>>>>>>> that is subject to pathological self-reference.
>>>>>>>>>>
>>>>>>>>>> We ask the question: Does the execution of the input have to be
>>>>>>>>>> aborted
>>>>>>>>>> to prevent its infinite execution?
>>>>>>>>>>
>>>>>>>>>> When we ask this latter question then we can ignore all of the
>>>>>>>>>> conditional branch instructions that are in the halt decider and
>>>>>>>>>> only
>>>>>>>>>> pay attention to the ones that are in the input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We can indeed ignore the halt decider outer-level trace entries,
>>>>>>>>> and
>>>>>>>>> concentrate on just what the halt decider embedded emulator sees
>>>>>>>>> its
>>>>>>>>> input doing.
>>>>>>>>
>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>> specified
>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>> correct
>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>> trace.
>>>>>>>>
>>>>>>>> There will not be an embedded decider because an embedded decider
>>>>>>>> permits what would seem to causal observers as inconsistent halting
>>>>>>>> decisions. By not allowing any execution trace data to exist that
>>>>>>>> the
>>>>>>>> halt decider cannot see then even the apperance of inconsistency
>>>>>>>> ceases
>>>>>>>> to exist.
>>>>>>>
>>>>>>> There has to be an embedded decider, because that is how the Linz
>>>>>>> proof specifies H^. When you say "seem to causal [sic] observers as
>>>>>>> inconsistent halting decisions" that is because the decisions really
>>>>>>> are inconsistent! You can't magic them to be consistent by making
>>>>>>> the
>>>>>>> decider part of the OS. (If that's your plan.)
>>>>>>
>>>>>> I do not have to conform to any conventions but this one:
>>>>>>
>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>>>>
>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>> simulating it
>>>>>> expresses behavior that is not halting behavior.
>>>>>>
>>>>>
>>>>> Wrong.
>>>>>
>>>>> You are talking here about H, whereas I was talking about H^. If you
>>>>> want to say anything about the Linz proof, you need to talk about H
>>>>> *and* H^, and H^ must follow the Linz spec for how it relates to H.
>>>>> Duh.
>>>>
>>>> Before we can proceed we need to have agreement on this general
>>>> principle: (It is a mandatory prerequisite).
>>>>
>>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>>> expresses behavior that is not halting behavior.
>>>
>>> That's a bad wording for lots of reasons. If I agree to it as it
>>> stands, I know you will take that quote and post it all over the
>>> newsgroup claiming it means something it doesn't. Because that's the
>>> kind of guy that you are.
>>>
>>> However, I'll happily agree to the better worded:
>>>
>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>> never halts, expresses behaviour that is not halting behaviour.
>>>
>>> Mike.
>>>
>>
>> That one won't work for me, but it does show that you understand the
>> principle. It is no good that we say "never halts" because we cannot
>> wait an eternity to see that it never halts.
>>
>> Since this statement is to be formulated for a general audience that has
>> never been a part of these conversations we must remove the word "pure"
>> because without the context of these conversations the word "pure" would
>> be quite confusing. When we say UTM to a general audience of computer
>> scientists "pure" is already understood.
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
>>
>
> Just to be clear - that is your statement, not mine.
> Mike.
>
>> TMD = Turing Machine Description
>> UTM = Universal Turing Machine
>>
>>
Can you find some flaw in it?
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-24 18:08 +0000 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <4eCdnQG-h8ms0SDCnZ2dnUU78dfNnZ2d@brightview.co.uk> |
| In reply to | #25814 |
On 24/11/2020 17:19, olcott wrote:
> On 11/24/2020 11:05 AM, Mike Terry wrote:
>> On 24/11/2020 16:46, olcott wrote:
>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>> On 24/11/2020 15:51, olcott wrote:
>>>>> On 11/24/2020 9:41 AM, Mike Terry wrote:
>>>>>> On 24/11/2020 04:18, olcott wrote:
>>>>>>> On 11/23/2020 8:53 PM, Mike Terry wrote:
>>>>>>>> On 24/11/2020 00:37, olcott wrote:
>>>>>>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>> On 23/11/2020 21:29, olcott wrote:
>>>>>>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
>>>>>>>>>>>> On 23/11/2020 01:24, 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> Hey, you're totally CHEATING here. There ARE conditional
>>>>>>>>>>>> branch
>>>>>>>>>>>> intstructions, but you've just silently snipped them from the
>>>>>>>>>>>> trace
>>>>>>>>>>>> output you've shown. There are HUGE gaps in your trace!!
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Mike.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Unless we maintain a line-of-demarcation between the halt
>>>>>>>>>>> decider
>>>>>>>>>>> and
>>>>>>>>>>> its input pathological self-reference(Olcott 2004) makes the
>>>>>>>>>>> halting
>>>>>>>>>>> problem have undecidable inputs in the same way that the Liar
>>>>>>>>>>> Paradox is
>>>>>>>>>>> neither true nor false.
>>>>>>>>>>>
>>>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Instead of asking the question: Does the input halt on its
>>>>>>>>>>> input?
>>>>>>>>>>> that is subject to pathological self-reference.
>>>>>>>>>>>
>>>>>>>>>>> We ask the question: Does the execution of the input have to be
>>>>>>>>>>> aborted
>>>>>>>>>>> to prevent its infinite execution?
>>>>>>>>>>>
>>>>>>>>>>> When we ask this latter question then we can ignore all of the
>>>>>>>>>>> conditional branch instructions that are in the halt decider and
>>>>>>>>>>> only
>>>>>>>>>>> pay attention to the ones that are in the input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We can indeed ignore the halt decider outer-level trace entries,
>>>>>>>>>> and
>>>>>>>>>> concentrate on just what the halt decider embedded emulator sees
>>>>>>>>>> its
>>>>>>>>>> input doing.
>>>>>>>>>
>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>> specified
>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>> correct
>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>> trace.
>>>>>>>>>
>>>>>>>>> There will not be an embedded decider because an embedded decider
>>>>>>>>> permits what would seem to causal observers as inconsistent
>>>>>>>>> halting
>>>>>>>>> decisions. By not allowing any execution trace data to exist that
>>>>>>>>> the
>>>>>>>>> halt decider cannot see then even the apperance of inconsistency
>>>>>>>>> ceases
>>>>>>>>> to exist.
>>>>>>>>
>>>>>>>> There has to be an embedded decider, because that is how the Linz
>>>>>>>> proof specifies H^. When you say "seem to causal [sic]
>>>>>>>> observers as
>>>>>>>> inconsistent halting decisions" that is because the decisions
>>>>>>>> really
>>>>>>>> are inconsistent! You can't magic them to be consistent by making
>>>>>>>> the
>>>>>>>> decider part of the OS. (If that's your plan.)
>>>>>>>
>>>>>>> I do not have to conform to any conventions but this one:
>>>>>>>
>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>>>>>
>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>> simulating it
>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>
>>>>>>
>>>>>> Wrong.
>>>>>>
>>>>>> You are talking here about H, whereas I was talking about H^. If you
>>>>>> want to say anything about the Linz proof, you need to talk about H
>>>>>> *and* H^, and H^ must follow the Linz spec for how it relates to H.
>>>>>> Duh.
>>>>>
>>>>> Before we can proceed we need to have agreement on this general
>>>>> principle: (It is a mandatory prerequisite).
>>>>>
>>>>> Any input TMD that would never halt unless a UTM stopped simulating it
>>>>> expresses behavior that is not halting behavior.
>>>>
>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>> stands, I know you will take that quote and post it all over the
>>>> newsgroup claiming it means something it doesn't. Because that's the
>>>> kind of guy that you are.
>>>>
>>>> However, I'll happily agree to the better worded:
>>>>
>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>
>>>> Mike.
>>>>
>>>
>>> That one won't work for me, but it does show that you understand the
>>> principle. It is no good that we say "never halts" because we cannot
>>> wait an eternity to see that it never halts.
>>>
>>> Since this statement is to be formulated for a general audience that has
>>> never been a part of these conversations we must remove the word "pure"
>>> because without the context of these conversations the word "pure" would
>>> be quite confusing. When we say UTM to a general audience of computer
>>> scientists "pure" is already understood.
>>>
>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>> simulating it expresses behavior that is not halting behavior.
>>>
>>
>> Just to be clear - that is your statement, not mine.
>> Mike.
>>
>>> TMD = Turing Machine Description
>>> UTM = Universal Turing Machine
>>>
>>>
>
> Can you find some flaw in it?
Not that it matters, but since you ask...
It's the whole phrasing "..would never XXX unless..". I'll be honest -
that kind of wording is a bit of a red flag for identifying cranks.
Cranks for some reason love to say things like "The ONLY reason xxx is
true is yyy", not appreciating that true statements are typically "just
true" and picking out a single reason why they are true is normally
nonsensical. I guess it's because they've at some time been forced into
accepting something they don't like, and want to say "yeah, ok xxx is
'true' but it's not 'properly true' in some way..."
HP is a mathematical problem, and maths people make clear and concise
definitions of things. In your case what does the phrase "WOULD never
halt UNLESS" mean? (i.e., mathematically?)
Mathematically the definition of halting/non-halting does not involve
anything emulating the calculation, so the whole phrasing is a bit naff
and suggests the author is confused about what halting means. Like, the
author thinks the definition of halting/non-halting is some kind of
experimental result or something, rather than a mathematical definition...
Or... perhaps the author is deliberately choosing a vague wording in
order to later introduce some further confusing irrelevancy.
All the above is just my overall opinion, not really relevant to the
main topic of this thread.
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-24 12:27 -0600 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <cN-dnUaHM-sDzSDCnZ2dnUU7-dWdnZ2d@giganews.com> |
| In reply to | #25819 |
On 11/24/2020 12:08 PM, Mike Terry wrote:
> On 24/11/2020 17:19, olcott wrote:
>> On 11/24/2020 11:05 AM, Mike Terry wrote:
>>> On 24/11/2020 16:46, olcott wrote:
>>>> On 11/24/2020 10:19 AM, Mike Terry wrote:
>>>>> On 24/11/2020 15:51, olcott wrote:
>>>>>> On 11/24/2020 9:41 AM, Mike Terry wrote:
>>>>>>> On 24/11/2020 04:18, olcott wrote:
>>>>>>>> On 11/23/2020 8:53 PM, Mike Terry wrote:
>>>>>>>>> On 24/11/2020 00:37, olcott wrote:
>>>>>>>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
>>>>>>>>>>> On 23/11/2020 21:29, olcott wrote:
>>>>>>>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
>>>>>>>>>>>>> On 23/11/2020 01:24, 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hey, you're totally CHEATING here. There ARE conditional
>>>>>>>>>>>>> branch
>>>>>>>>>>>>> intstructions, but you've just silently snipped them from the
>>>>>>>>>>>>> trace
>>>>>>>>>>>>> output you've shown. There are HUGE gaps in your trace!!
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Mike.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Unless we maintain a line-of-demarcation between the halt
>>>>>>>>>>>> decider
>>>>>>>>>>>> and
>>>>>>>>>>>> its input pathological self-reference(Olcott 2004) makes the
>>>>>>>>>>>> halting
>>>>>>>>>>>> problem have undecidable inputs in the same way that the Liar
>>>>>>>>>>>> Paradox is
>>>>>>>>>>>> neither true nor false.
>>>>>>>>>>>>
>>>>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Instead of asking the question: Does the input halt on its
>>>>>>>>>>>> input?
>>>>>>>>>>>> that is subject to pathological self-reference.
>>>>>>>>>>>>
>>>>>>>>>>>> We ask the question: Does the execution of the input have to be
>>>>>>>>>>>> aborted
>>>>>>>>>>>> to prevent its infinite execution?
>>>>>>>>>>>>
>>>>>>>>>>>> When we ask this latter question then we can ignore all of the
>>>>>>>>>>>> conditional branch instructions that are in the halt decider
>>>>>>>>>>>> and
>>>>>>>>>>>> only
>>>>>>>>>>>> pay attention to the ones that are in the input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We can indeed ignore the halt decider outer-level trace entries,
>>>>>>>>>>> and
>>>>>>>>>>> concentrate on just what the halt decider embedded emulator sees
>>>>>>>>>>> its
>>>>>>>>>>> input doing.
>>>>>>>>>>
>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>> specified
>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>> correct
>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>> trace.
>>>>>>>>>>
>>>>>>>>>> There will not be an embedded decider because an embedded decider
>>>>>>>>>> permits what would seem to causal observers as inconsistent
>>>>>>>>>> halting
>>>>>>>>>> decisions. By not allowing any execution trace data to exist that
>>>>>>>>>> the
>>>>>>>>>> halt decider cannot see then even the apperance of inconsistency
>>>>>>>>>> ceases
>>>>>>>>>> to exist.
>>>>>>>>>
>>>>>>>>> There has to be an embedded decider, because that is how the Linz
>>>>>>>>> proof specifies H^. When you say "seem to causal [sic]
>>>>>>>>> observers as
>>>>>>>>> inconsistent halting decisions" that is because the decisions
>>>>>>>>> really
>>>>>>>>> are inconsistent! You can't magic them to be consistent by making
>>>>>>>>> the
>>>>>>>>> decider part of the OS. (If that's your plan.)
>>>>>>>>
>>>>>>>> I do not have to conform to any conventions but this one:
>>>>>>>>
>>>>>>>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
>>>>>>>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
>>>>>>>>
>>>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>>>> simulating it
>>>>>>>> expresses behavior that is not halting behavior.
>>>>>>>>
>>>>>>>
>>>>>>> Wrong.
>>>>>>>
>>>>>>> You are talking here about H, whereas I was talking about H^. If
>>>>>>> you
>>>>>>> want to say anything about the Linz proof, you need to talk about H
>>>>>>> *and* H^, and H^ must follow the Linz spec for how it relates to H.
>>>>>>> Duh.
>>>>>>
>>>>>> Before we can proceed we need to have agreement on this general
>>>>>> principle: (It is a mandatory prerequisite).
>>>>>>
>>>>>> Any input TMD that would never halt unless a UTM stopped
>>>>>> simulating it
>>>>>> expresses behavior that is not halting behavior.
>>>>>
>>>>> That's a bad wording for lots of reasons. If I agree to it as it
>>>>> stands, I know you will take that quote and post it all over the
>>>>> newsgroup claiming it means something it doesn't. Because that's the
>>>>> kind of guy that you are.
>>>>>
>>>>> However, I'll happily agree to the better worded:
>>>>>
>>>>> Any input (TMD, DATA) which, when run under a (pure) UTM
>>>>> never halts, expresses behaviour that is not halting behaviour.
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> That one won't work for me, but it does show that you understand the
>>>> principle. It is no good that we say "never halts" because we cannot
>>>> wait an eternity to see that it never halts.
>>>>
>>>> Since this statement is to be formulated for a general audience that
>>>> has
>>>> never been a part of these conversations we must remove the word "pure"
>>>> because without the context of these conversations the word "pure"
>>>> would
>>>> be quite confusing. When we say UTM to a general audience of computer
>>>> scientists "pure" is already understood.
>>>>
>>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>>> simulating it expresses behavior that is not halting behavior.
>>>>
>>>
>>> Just to be clear - that is your statement, not mine.
>>> Mike.
>>>
>>>> TMD = Turing Machine Description
>>>> UTM = Universal Turing Machine
>>>>
>>>>
>>
>> Can you find some flaw in it?
>
> Not that it matters, but since you ask...
>
> It's the whole phrasing "..would never XXX unless..". I'll be honest -
> that kind of wording is a bit of a red flag for identifying cranks.
> Cranks for some reason love to say things like "The ONLY reason xxx is
> true is yyy", not appreciating that true statements are typically "just
> true" and picking out a single reason why they are true is normally
> nonsensical. I guess it's because they've at some time been forced into
> accepting something they don't like, and want to say "yeah, ok xxx is
> 'true' but it's not 'properly true' in some way..."
>
> HP is a mathematical problem, and maths people make clear and concise
> definitions of things. In your case what does the phrase "WOULD never
> halt UNLESS" mean? (i.e., mathematically?)
>
> Mathematically the definition of halting/non-halting does not involve
> anything emulating the calculation, so the whole phrasing is a bit naff
> and suggests the author is confused about what halting means. Like, the
> author thinks the definition of halting/non-halting is some kind of
> experimental result or something, rather than a mathematical definition...
>
> Or... perhaps the author is deliberately choosing a vague wording in
> order to later introduce some further confusing irrelevancy.
>
> All the above is just my overall opinion, not really relevant to the
> main topic of this thread.
>
> Mike.
>
So to paraphrase you found no logical error.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-24 13:42 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <BucvH.25440$kf6.10@fx26.iad> |
| In reply to | #25821 |
On 11/24/20 1:27 PM, olcott wrote: > On 11/24/2020 12:08 PM, Mike Terry wrote: >> On 24/11/2020 17:19, olcott wrote: >>> >>> Can you find some flaw in it? >> >> Not that it matters, but since you ask... >> >> It's the whole phrasing "..would never XXX unless..". I'll be honest >> - that kind of wording is a bit of a red flag for identifying cranks. >> Cranks for some reason love to say things like "The ONLY reason xxx is >> true is yyy", not appreciating that true statements are typically >> "just true" and picking out a single reason why they are true is >> normally nonsensical. I guess it's because they've at some time been >> forced into accepting something they don't like, and want to say >> "yeah, ok xxx is 'true' but it's not 'properly true' in some way..." >> >> HP is a mathematical problem, and maths people make clear and concise >> definitions of things. In your case what does the phrase "WOULD never >> halt UNLESS" mean? (i.e., mathematically?) >> >> Mathematically the definition of halting/non-halting does not involve >> anything emulating the calculation, so the whole phrasing is a bit >> naff and suggests the author is confused about what halting means. >> Like, the author thinks the definition of halting/non-halting is some >> kind of experimental result or something, rather than a mathematical >> definition... >> >> Or... perhaps the author is deliberately choosing a vague wording in >> order to later introduce some further confusing irrelevancy. >> >> All the above is just my overall opinion, not really relevant to the >> main topic of this thread. >> >> Mike. >> > > So to paraphrase you found no logical error. > He found too many weasel words that make it too easy to twist to mean something differnt than what was assumed intended.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-24 13:31 -0500 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <okcvH.3850$jL.732@fx13.iad> |
| In reply to | #25809 |
On 11/24/20 11:46 AM, olcott wrote: > > That one won't work for me, but it does show that you understand the > principle. It is no good that we say "never halts" because we cannot > wait an eternity to see that it never halts. > > Since this statement is to be formulated for a general audience that has > never been a part of these conversations we must remove the word "pure" > because without the context of these conversations the word "pure" would > be quite confusing. When we say UTM to a general audience of computer > scientists "pure" is already understood. > > Any input (TMD / DATA) that would never halt unless its (UTM) stopped > simulating it expresses behavior that is not halting behavior. > > TMD = Turing Machine Description > UTM = Universal Turing Machine > My objection to that wording is that would not halt unless ... has a less clear test than will never halt The key here is that unless implies that the current system has done the second clause, and to prove it was right we need to change the system, and whenever people have proposed to make the change in the system, you have objected to how the change was made, insisting that other things need to be changed also. Now, because of the structure of your Halt Decider, running that same program is a 'real' UTM, is exactly the test of the unless the UTM stopped simulating it. The need for the adjective on the UTM is because you seemed to have co-opted the term UTM as your UTM seems to be able to make a stopping decision on its own by your phrasing. You REALLY need to put a distinction between the UTM that is running things from the Halt Detector, and this wrapping of Main in a call to the halt detector. Once you have forced that, you have disqualified your code from running the verification test, since that needs a 'real' or 'pure' UTM, not one that can decide to abort code.
[toc] | [prev] | [next] | [standalone]
| From | "dklei...@gmail.com" <dkleinecke@gmail.com> |
|---|---|
| Date | 2020-11-24 12:31 -0800 |
| Subject | Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite) |
| Message-ID | <85781066-ec75-42d6-aa4e-bf055bfb114cn@googlegroups.com> |
| In reply to | #25805 |
On Tuesday, November 24, 2020 at 8:19:46 AM UTC-8, Mike Terry wrote:
> On 24/11/2020 15:51, olcott wrote:
> > On 11/24/2020 9:41 AM, Mike Terry wrote:
> >> On 24/11/2020 04:18, olcott wrote:
> >>> On 11/23/2020 8:53 PM, Mike Terry wrote:
> >>>> On 24/11/2020 00:37, olcott wrote:
> >>>>> On 11/23/2020 5:51 PM, Mike Terry wrote:
> >>>>>> On 23/11/2020 21:29, olcott wrote:
> >>>>>>> On 11/23/2020 3:02 PM, Mike Terry wrote:
> >>>>>>>> On 23/11/2020 01:24, 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.
> >>>>>>>>>
> >>>>>>>>> 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.
> >>>>>>>>
> >>>>>>>> Hey, you're totally CHEATING here. There ARE conditional branch
> >>>>>>>> intstructions, but you've just silently snipped them from the trace
> >>>>>>>> output you've shown. There are HUGE gaps in your trace!!
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Mike.
> >>>>>>>>
> >>>>>>>
> >>>>>>> Unless we maintain a line-of-demarcation between the halt decider
> >>>>>>> and
> >>>>>>> its input pathological self-reference(Olcott 2004) makes the halting
> >>>>>>> problem have undecidable inputs in the same way that the Liar
> >>>>>>> Paradox is
> >>>>>>> neither true nor false.
> >>>>>>>
> >>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
> >>>>>>>
> >>>>>>> Instead of asking the question: Does the input halt on its input?
> >>>>>>> that is subject to pathological self-reference.
> >>>>>>>
> >>>>>>> We ask the question: Does the execution of the input have to be
> >>>>>>> aborted
> >>>>>>> to prevent its infinite execution?
> >>>>>>>
> >>>>>>> When we ask this latter question then we can ignore all of the
> >>>>>>> conditional branch instructions that are in the halt decider and
> >>>>>>> only
> >>>>>>> pay attention to the ones that are in the input.
> >>>>>>>
> >>>>>>
> >>>>>> We can indeed ignore the halt decider outer-level trace entries, and
> >>>>>> concentrate on just what the halt decider embedded emulator sees its
> >>>>>> input doing.
> >>>>>
> >>>>> All that I have right now is a DebugTrace() of all the user specified
> >>>>> code. This provides a very obvious basis for a halt decider's correct
> >>>>> halting decision of the H_Hat code specified in this execution trace.
> >>>>>
> >>>>> There will not be an embedded decider because an embedded decider
> >>>>> permits what would seem to causal observers as inconsistent halting
> >>>>> decisions. By not allowing any execution trace data to exist that the
> >>>>> halt decider cannot see then even the apperance of inconsistency
> >>>>> ceases
> >>>>> to exist.
> >>>>
> >>>> There has to be an embedded decider, because that is how the Linz
> >>>> proof specifies H^. When you say "seem to causal [sic] observers as
> >>>> inconsistent halting decisions" that is because the decisions really
> >>>> are inconsistent! You can't magic them to be consistent by making the
> >>>> decider part of the OS. (If that's your plan.)
> >>>
> >>> I do not have to conform to any conventions but this one:
> >>>
> >>> H.q0 wMw ⊢* H.yes if M applied to w halts, and
> >>> H.q0 wMw ⊢* H.no if M applied to w would not halt.
> >>>
> >>> Any input TMD that would never halt unless a UTM stopped simulating it
> >>> expresses behavior that is not halting behavior.
> >>>
> >>
> >> Wrong.
> >>
> >> You are talking here about H, whereas I was talking about H^. If you
> >> want to say anything about the Linz proof, you need to talk about H
> >> *and* H^, and H^ must follow the Linz spec for how it relates to H. Duh.
> >
> > Before we can proceed we need to have agreement on this general
> > principle: (It is a mandatory prerequisite).
> >
> > Any input TMD that would never halt unless a UTM stopped simulating it
> > expresses behavior that is not halting behavior.
> That's a bad wording for lots of reasons. If I agree to it as it
> stands, I know you will take that quote and post it all over the
> newsgroup claiming it means something it doesn't. Because that's the
> kind of guy that you are.
>
> However, I'll happily agree to the better worded:
>
> Any input (TMD, DATA) which, when run under a (pure) UTM
> never halts, expresses behaviour that is not halting behaviour.
I wonder - doesn't the "input" to a Turing Machine simulation also
need an initial head position specification? It is trivial to design a
tape that halts for some initial head positions but not for others.
[toc] | [prev] | [next] | [standalone]
Page 4 of 11 — ← Prev page 1 2 3 [4] 5 6 … 11 Next page →
Back to top | Article view | comp.theory
csiph-web