Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #25683 > unrolled thread

It is known that a correct halt decider must return false (in this case)[V4](Linz)

Started byolcott <NoOne@NoWhere.com>
First post2020-11-22 19:24 -0600
Last post2020-12-02 02:50 +0000
Articles 20 on this page of 210 — 9 participants

Back to article view | Back to comp.theory


Contents

  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 →


#25852 — Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-24 23:37 +0000
SubjectRe: 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]


#25862 — Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 18:03 -0600
SubjectRe: 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]


#25882 — Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-25 01:40 +0000
SubjectRe: 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]


#25884 — Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 20:10 -0600
SubjectRe: 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]


#25889 — Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-25 03:20 +0000
SubjectRe: 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]


#25895 — Re: It is known that a correct halt decider must return false (in this case)[V4](first step)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 21:34 -0600
SubjectRe: 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]


#25832 — Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 14:44 -0600
SubjectRe: 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]


#25883 — Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-25 02:04 +0000
SubjectRe: 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]


#25885 — Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 20:21 -0600
SubjectRe: 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]


#25907 — Re: It is known that a correct halt decider must return false (in this case)[V4](validation of halting criteria)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-24 23:10 -0500
SubjectRe: 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]


#25838 — Re: It is known that a correct halt decider must return false (in this case)[V4](key agreement)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 14:29 -0600
SubjectRe: 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]


#25809 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 10:46 -0600
SubjectRe: 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]


#25811 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-24 17:04 +0000
SubjectRe: 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]


#25812 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-24 17:05 +0000
SubjectRe: 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]


#25814 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 11:19 -0600
SubjectRe: 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]


#25819 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-24 18:08 +0000
SubjectRe: 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]


#25821 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 12:27 -0600
SubjectRe: 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]


#25824 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-24 13:42 -0500
SubjectRe: 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]


#25822 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-24 13:31 -0500
SubjectRe: 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]


#25829 — Re: It is known that a correct halt decider must return false (in this case)[V4](mandatory prerequisite)

From"dklei...@gmail.com" <dkleinecke@gmail.com>
Date2020-11-24 12:31 -0800
SubjectRe: 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