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 1 of 11  [1] 2 3 … 11  Next page →


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 19:24 -0600
SubjectIt is known that a correct halt decider must return false (in this case)[V4](Linz)
Message-ID<TqWdnXCuh8jFkibCnZ2dnUU7-QfNnZ2d@giganews.com>
The following shows exactly how the Peter Linz H would correctly decide 
halting on the Peter Linz Ĥ. This is fully operational code that has 
been executed in the x86utm operating system that I wrote.

To make the Linz counter-example conform to the standard halting problem 
counter-examples the input is not copied as it is in Linz.

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

Linz, Peter 1990. An Introduction to Formal Languages and Automata. 
Lexington/Toronto: D. C. Heath and Company.

x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
The x86 language is computationally equivalent to a UTM for all 
computations that do not require more memory than is available.

Recursion can be directly simulated by a UTM that simulates its own 
Turing machine Description. Infinite recursion would repeat the same 
state transitions every time the UTM simulates its own Turing machine 
Description.

// Defined at the bottom of page 319 of Linz
void Ĥ(u32 P)
{
   u32 Input_Halts = H(P, P);
   if (!Input_Halts)
     HALT
   else
     HERE: goto HERE;
}


int main()
{
   u32 P = (u32)Ĥ;
   H(P, P);
   HALT;
}


Disassembled x86 machine language of the above pair of C functions.

Ĥ()
[000004f7](01)  55                  push ebp
[000004f8](02)  8bec                mov ebp,esp
[000004fa](01)  51                  push ecx
[000004fb](03)  8b4508              mov eax,[ebp+08]
[000004fe](01)  50                  push eax
[000004ff](03)  8b4d08              mov ecx,[ebp+08]
[00000502](01)  51                  push ecx
[00000503](05)  e86ffeffff          call 00000377
[00000508](03)  83c408              add esp,+08
[0000050b](03)  8945fc              mov [ebp-04],eax
[0000050e](04)  837dfc00            cmp dword [ebp-04],+00
[00000512](02)  7403                jz 00000517
[00000514](01)  f4                  hlt
[00000515](02)  eb02                jmp 00000519
[00000517](02)  ebfe                jmp 00000517
[00000519](02)  8be5                mov esp,ebp
[0000051b](01)  5d                  pop ebp
[0000051c](01)  c3                  ret

_main()
[00000527](01)  55                  push ebp
[00000528](02)  8bec                mov ebp,esp
[0000052a](01)  51                  push ecx
[0000052b](07)  c745fcf7040000      mov [ebp-04],000004f7
[00000532](03)  8b45fc              mov eax,[ebp-04]
[00000535](01)  50                  push eax
[00000536](03)  8b4dfc              mov ecx,[ebp-04]
[00000539](01)  51                  push ecx
[0000053a](05)  e838feffff          call 00000377
[0000053f](03)  83c408              add esp,+08
[00000542](01)  f4                  hlt
[00000543](02)  8be5                mov esp,ebp
[00000545](01)  5d                  pop ebp
[00000546](01)  c3                  ret



Output_Debug_Trace() [00010abc]  size(148)  capacity(65536)
[00000527](01)  55                  push ebp
[00000528](02)  8bec                mov ebp,esp
[0000052a](01)  51                  push ecx
[0000052b](07)  c745fcf7040000      mov [ebp-04],000004f7
[00000532](03)  8b45fc              mov eax,[ebp-04]
[00000535](01)  50                  push eax
[00000536](03)  8b4dfc              mov ecx,[ebp-04]
[00000539](01)  51                  push ecx
[0000053a](05)  e838feffff          call 00000377
[000004f7](01)  55                  push ebp
[000004f8](02)  8bec                mov ebp,esp
[000004fa](01)  51                  push ecx
[000004fb](03)  8b4508              mov eax,[ebp+08]
[000004fe](01)  50                  push eax
[000004ff](03)  8b4d08              mov ecx,[ebp+08]
[00000502](01)  51                  push ecx
[00000503](05)  e86ffeffff          call 00000377
[000004f7](01)  55                  push ebp
[000004f8](02)  8bec                mov ebp,esp
[000004fa](01)  51                  push ecx
[000004fb](03)  8b4508              mov eax,[ebp+08]
[000004fe](01)  50                  push eax
[000004ff](03)  8b4d08              mov ecx,[ebp+08]
[00000502](01)  51                  push ecx
[00000503](05)  e86ffeffff          call 00000377
25 instructions

The above is where the halt decider aborts the whole Ĥ(Ĥ) invocation 
sequence because the halt decider detects infinite recursion.

In this case infinite recursion is a function call to the same function 
from the same machine address without any conditional branch 
instructions that would terminate this recursion.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [next] | [standalone]


#25685

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-22 20:56 -0500
Message-ID<CFEuH.1740$se1.1735@fx27.iad>
In reply to#25683
On 11/22/20 8:24 PM, olcott wrote:
> The following shows exactly how the Peter Linz H would correctly decide
> halting on the Peter Linz Ĥ. This is fully operational code that has
> been executed in the x86utm operating system that I wrote.

What Peter Linz H? The paper does NOT present any indication of how H is
supposed to do it job. It shows a simple outline of a start state that
moves in some unspecified manner to one of two output states.

It is only something in YOUR mind that somehow says this must be
something based on a UTM.

> 
> To make the Linz counter-example conform to the standard halting problem
> counter-examples the input is not copied as it is in Linz.

Omitting the copy says this can NOT possible be a Turing Machine as in
the definition of Linz. What other 'standard Halting Problem' are you
refering to.

All the verison I know you pass to the Halt Decider, a representation of
the program and a representation of the input, that is Two Things.

The Linz counter example, and the similer ones, you have a program that
is passed a representation of itself. Since the Halting Decider needs
two representations, you need to in some way dupicate the counter
example input to provide these two seperate input.
> 
> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
> 
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company.
> 
> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> The x86 language is computationally equivalent to a UTM for all
> computations that do not require more memory than is available.

Again, a von Neumann machine can't be a UTM since it is not even a
Turing Machine.

There also isn't anything that would be called the x86 'language'. Yes,
the x86 processor is computationally equivalent to a Turing Machine,
within resource limits. We can use a number of languages on an x86
processor. Maybe you mean by x86 language the x86 assembly language, ok,
but you do understand that there really isn't *A* x86 assembly language
that is actually used on anything. It is a short hand for a wide family
of processors and assembly languages.

> Recursion can be directly simulated by a UTM that simulates its own
> Turing machine Description. Infinite recursion would repeat the same
> state transitions every time the UTM simulates its own Turing machine
> Description.

Yes, you can write broken code in many forms.
> 
> // Defined at the bottom of page 319 of Linz
> void Ĥ(u32 P)
> {
>   u32 Input_Halts = H(P, P);
>   if (!Input_Halts)
>     HALT
>   else
>     HERE: goto HERE;
> }
> 
> 
> int main()
> {
>   u32 P = (u32)Ĥ;
>   H(P, P);
>   HALT;
> }
> 
> 
> Disassembled x86 machine language of the above pair of C functions.
> 
> Ĥ()
> [000004f7](01)  55                  push ebp
> [000004f8](02)  8bec                mov ebp,esp
> [000004fa](01)  51                  push ecx
> [000004fb](03)  8b4508              mov eax,[ebp+08]
> [000004fe](01)  50                  push eax
> [000004ff](03)  8b4d08              mov ecx,[ebp+08]
> [00000502](01)  51                  push ecx
> [00000503](05)  e86ffeffff          call 00000377
> [00000508](03)  83c408              add esp,+08
> [0000050b](03)  8945fc              mov [ebp-04],eax
> [0000050e](04)  837dfc00            cmp dword [ebp-04],+00
> [00000512](02)  7403                jz 00000517
> [00000514](01)  f4                  hlt
> [00000515](02)  eb02                jmp 00000519
> [00000517](02)  ebfe                jmp 00000517
> [00000519](02)  8be5                mov esp,ebp
> [0000051b](01)  5d                  pop ebp
> [0000051c](01)  c3                  ret
> 
> _main()
> [00000527](01)  55                  push ebp
> [00000528](02)  8bec                mov ebp,esp
> [0000052a](01)  51                  push ecx
> [0000052b](07)  c745fcf7040000      mov [ebp-04],000004f7
> [00000532](03)  8b45fc              mov eax,[ebp-04]
> [00000535](01)  50                  push eax
> [00000536](03)  8b4dfc              mov ecx,[ebp-04]
> [00000539](01)  51                  push ecx
> [0000053a](05)  e838feffff          call 00000377
> [0000053f](03)  83c408              add esp,+08
> [00000542](01)  f4                  hlt
> [00000543](02)  8be5                mov esp,ebp
> [00000545](01)  5d                  pop ebp
> [00000546](01)  c3                  ret
> 
> 
> 
> Output_Debug_Trace() [00010abc]  size(148)  capacity(65536)
> [00000527](01)  55                  push ebp
> [00000528](02)  8bec                mov ebp,esp
> [0000052a](01)  51                  push ecx
> [0000052b](07)  c745fcf7040000      mov [ebp-04],000004f7
> [00000532](03)  8b45fc              mov eax,[ebp-04]
> [00000535](01)  50                  push eax
> [00000536](03)  8b4dfc              mov ecx,[ebp-04]
> [00000539](01)  51                  push ecx
> [0000053a](05)  e838feffff          call 00000377
> [000004f7](01)  55                  push ebp
> [000004f8](02)  8bec                mov ebp,esp
> [000004fa](01)  51                  push ecx
> [000004fb](03)  8b4508              mov eax,[ebp+08]
> [000004fe](01)  50                  push eax
> [000004ff](03)  8b4d08              mov ecx,[ebp+08]
> [00000502](01)  51                  push ecx
> [00000503](05)  e86ffeffff          call 00000377
> [000004f7](01)  55                  push ebp
> [000004f8](02)  8bec                mov ebp,esp
> [000004fa](01)  51                  push ecx
> [000004fb](03)  8b4508              mov eax,[ebp+08]
> [000004fe](01)  50                  push eax
> [000004ff](03)  8b4d08              mov ecx,[ebp+08]
> [00000502](01)  51                  push ecx
> [00000503](05)  e86ffeffff          call 00000377
> 25 instructions
> 
> The above is where the halt decider aborts the whole Ĥ(Ĥ) invocation
> sequence because the halt decider detects infinite recursion.
> 
> In this case infinite recursion is a function call to the same function
> from the same machine address without any conditional branch
> instructions that would terminate this recursion.
> 
> 

Yes, your trace shows that YOUR H has a flaw of infinite recursion when
evaluation a machine that has a copy of itself in it.

By the trace, there appears to be no code in H to detect this situation
so it just keep running, and then some magic force not shown anywhere
aborts the computation, so H actually never returned an answer, thus H
has FAILED at its job to be a Halt Decider.

Maybe you have created a system that is a Halter, which will just abort
any program that it determines will never halt. That might have some
use, but isn't the Halt Decider from Linz.

[toc] | [prev] | [next] | [standalone]


#25688

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-23 03:14 +0000
Message-ID<87v9dwsr1m.fsf@bsb.me.uk>
In reply to#25685
Richard Damon <Richard@Damon-Family.org> writes:

> Maybe you have created a system that is a Halter, which will just abort
> any program that it determines will never halt. That might have some
> use, but isn't the Halt Decider from Linz.

The irony is that that algorith -- the algorithm that determines if a
computation must be aborted -- is also impossible.  He's not written it
yet so we are focusing on the wrapper function that he's call variously
H and Halts, but as I told PO some time ago, that code must end up
"aborting" an infinity to computations that are, in fact, finite.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#25690 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 21:33 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<vNCdnT2ISMM4sCbCnZ2dnUU7-LPNnZ2d@giganews.com>
In reply to#25688
On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> Maybe you have created a system that is a Halter, which will just abort
>> any program that it determines will never halt. That might have some
>> use, but isn't the Halt Decider from Linz.
> 
> The irony is that that algorith -- the algorithm that determines if a
> computation must be aborted -- is also impossible.  He's not written it > yet

IT IS IN THE FIRST POST OF THIS THREAD.
This is my 2018-12-13 solution.

We merely scan the complete execution trace after each instruction is 
executed and see if there have been any function calls to the same 
function from the same address without any intervening conditional 
branch instructions.

Here is what Mike said about correctly deciding H_Hat:

On 11/20/2020 9:30 PM, Mike Terry wrote:
 > input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
 > described.  This is all baby stuff.  [So the correct halting decision
 > for the input is non-halting].

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25693 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-23 04:03 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<878sassos3.fsf@bsb.me.uk>
In reply to#25690
olcott <NoOne@NoWhere.com> writes:

> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> Maybe you have created a system that is a Halter, which will just abort
>>> any program that it determines will never halt. That might have some
>>> use, but isn't the Halt Decider from Linz.
>>
>> The irony is that that algorith -- the algorithm that determines if a
>> computation must be aborted -- is also impossible.  He's not written
>> it yet
>
> IT IS IN THE FIRST POST OF THIS THREAD.

You have not yet written it (so you said) which it why you have not yet
noticed that it won't work.  If you have written it, then you need to do
more testing, (or ask an expert to tell you why it won't work).

> This is my 2018-12-13 solution.

(You have no solution.)

> We merely scan the complete execution trace after each instruction is
> executed and see if there have been any function calls to the same
> function from the same address without any intervening conditional
> branch instructions.

Yes, it's true you can be wrong the other way as well -- your test could
simply fail to spot many non-finite computations, so the H (or Halts)
built from it would not always return.  But being wrong in another way
to the one I pointed does not make you right.

If you want H/Halts to be a decider it must always return.  That means
your decision to abort must not miss any non-halting cases.  To do that,
it must also incorrectly abort an infinity of halting cases.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#25694 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 22:07 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<n76dnQpEpLL-qCbCnZ2dnUU7-IPNnZ2d@giganews.com>
In reply to#25693
On 11/22/2020 10:03 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> Maybe you have created a system that is a Halter, which will just abort
>>>> any program that it determines will never halt. That might have some
>>>> use, but isn't the Halt Decider from Linz.
>>>
>>> The irony is that that algorith -- the algorithm that determines if a
>>> computation must be aborted -- is also impossible.  He's not written
>>> it yet
>>
>> IT IS IN THE FIRST POST OF THIS THREAD.
> 
> You have not yet written it (so you said) which it why you have not yet
> noticed that it won't work.  If you have written it, then you need to do
> more testing, (or ask an expert to tell you why it won't work).
> 
Here is what Mike said about my way of correctly deciding H_Hat:
Here is what Mike said about my way of correctly deciding H_Hat:
Here is what Mike said about my way of correctly deciding H_Hat:
Here is what Mike said about my way of correctly deciding H_Hat:
Here is what Mike said about my way of correctly deciding H_Hat:

On 11/20/2020 9:30 PM, Mike Terry wrote:
 > input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
 > described.  This is all baby stuff.  [So the correct halting decision
 > for the input is non-halting].



-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25713 — Re: It is known that a correct halt decider must return false (in this case)[V4](Misrepresentation of MTs position)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-23 17:09 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Misrepresentation of MTs position)
Message-ID<_tudndD2L5JBcSbCnZ2dnUU78W1QAAAA@brightview.co.uk>
In reply to#25694
On 23/11/2020 04:07, olcott wrote:
> On 11/22/2020 10:03 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> Maybe you have created a system that is a Halter, which will just
>>>>> abort
>>>>> any program that it determines will never halt. That might have some
>>>>> use, but isn't the Halt Decider from Linz.
>>>>
>>>> The irony is that that algorith -- the algorithm that determines if a
>>>> computation must be aborted -- is also impossible.  He's not written
>>>> it yet
>>>
>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>
>> You have not yet written it (so you said) which it why you have not yet
>> noticed that it won't work.  If you have written it, then you need to do
>> more testing, (or ask an expert to tell you why it won't work).
>>
> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:
>
> On 11/20/2020 9:30 PM, Mike Terry wrote:
>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>> described.  This is all baby stuff.  [So the correct halting decision
>> for the input is non-halting].


STOP QUOTING ME OUT OF CONTEXT.

THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* 
H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position to 
falsely support your own.

The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you 
gave (but have omitted from your misreprestation), in which Halts() was 
specified to be a pure UTM: no NeedsToBeAborted() calls etc..

OF COURSE that particular H_Hat() never halts, and nobody would say 
otherwise.  Your H_Hat() above contains a Needs_To_Be_Aborted() call, 
making it A COMPLETELY DIFFERENT H_Hat.  You must understand that just 
because you use the same label for two different objects, that does not 
actually make them the same object!

I suggest to you that /deliberately/ misrepresenting someones position 
on a topic is a form of "bearing false witness" against that person, and 
so I'll be charitable and assume you are doing it because you have 
simply misunderstood the thread you are quoting.  I expect you to stop 
this behaviour now you are aware.


Mike.

[toc] | [prev] | [next] | [standalone]


#25779 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-24 03:39 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<87o8jnpgnf.fsf@bsb.me.uk>
In reply to#25694
olcott <NoOne@NoWhere.com> writes:

> On 11/22/2020 10:03 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> Maybe you have created a system that is a Halter, which will just abort
>>>>> any program that it determines will never halt. That might have some
>>>>> use, but isn't the Halt Decider from Linz.
>>>>
>>>> The irony is that that algorith -- the algorithm that determines if a
>>>> computation must be aborted -- is also impossible.  He's not written
>>>> it yet
>>>
>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>
>> You have not yet written it (so you said) which it why you have not yet
>> noticed that it won't work.  If you have written it, then you need to do
>> more testing, (or ask an expert to tell you why it won't work).
>>
> Here is what Mike said about my way of correctly deciding H_Hat:

Do you really think the lying about other people's position helps your
case one iota?  No, in fact it is shameful behaviour which, sadly, is no
longer unusual for you.  I suspect you know you have nothing, so lying
is all you have left.  You lied two years about having H and H^ "fully
encoded as actual Turing machines" "exactly and precisely as in Linz"
when you had no such thing, and you have nothing now so you lie about
Mike's position.

> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:
> Here is what Mike said about my way of correctly deciding H_Hat:

Oh, and you are being childish again, too.  Grow up.

> On 11/20/2020 9:30 PM, Mike Terry wrote:
>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>> described.  This is all baby stuff.  [So the correct halting decision
>> for the input is non-halting].

If anyone with a proper newsreader needs to confirm you mendacity, the
link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk>

Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from
that post is non-halting -- it calls a function that is not a decider
but one that just simulates the computation of applying the argument to
itself.

Tellingly, that post did not include any code you could reasonably call
a halt decider because you now know that as soon as you show that code,
I (or indeed anyone else but you) will produce the confounding example
for it.  The H_Hat you show is in fact irrelevant since it calls a
function that is not even a decider (let alone a halt decider), but you
hope naive readers will be fooled by the silly name you gave it: Halts.

You didn't show the function you actually claim (erroneously, of course)
to be a halt decider in that post.  That function, also called Halts in
a deliberate attempt to muddy the waters, gets the right answer for the
H_Hat(H_Hat) case written with the other Halts.  But it gets the wrong
answer for a similar computation built from it.  Why?  Because anytime
you dare to post any code the claims to be a halt decider, someone will
instantly post the confounding example, AND IT WILL USE YOUR HALT
DECIDER, AND NOT ANOTHER FUNCTION WITH THE SAME NAME.

Of course you did not respond to the points I made about the
impossibility of the code you have not yet shown anyone -- the code that
decides a computation must be aborted.  That code is as impossible as a
halt decider, unless it gets an infinity of cases wrong.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#25784 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 22:55 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<A4KdnTD-OPS7DyHCnZ2dnUU7-V_NnZ2d@giganews.com>
In reply to#25779
On 11/23/2020 9:39 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/22/2020 10:03 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> Maybe you have created a system that is a Halter, which will just abort
>>>>>> any program that it determines will never halt. That might have some
>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>
>>>>> The irony is that that algorith -- the algorithm that determines if a
>>>>> computation must be aborted -- is also impossible.  He's not written
>>>>> it yet
>>>>
>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>
>>> You have not yet written it (so you said) which it why you have not yet
>>> noticed that it won't work.  If you have written it, then you need to do
>>> more testing, (or ask an expert to tell you why it won't work).
>>>
>> Here is what Mike said about my way of correctly deciding H_Hat:
> 
> Do you really think the lying about other people's position helps your
> case one iota?  No, in fact it is shameful behaviour which, sadly, is no
> longer unusual for you.  I suspect you know you have nothing, so lying
> is all you have left.  You lied two years about having H and H^ "fully
> encoded as actual Turing machines" "exactly and precisely as in Linz"
> when you had no such thing, and you have nothing now so you lie about
> Mike's position.
> 
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
> 
> Oh, and you are being childish again, too.  Grow up.
> 
>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>> described.  This is all baby stuff.  [So the correct halting decision
>>> for the input is non-halting].
> 
> If anyone with a proper newsreader needs to confirm you mendacity, the
> link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk>
> 
> Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from
> that post is non-halting -- it calls a function that is not a decider
> but one that just simulates the computation of applying the argument to
> itself.
Mike did not understand that the execution of H_Hat under a simulator 
and under a halt decider are identical executions.

In both cases H_Hat has no way to tell the difference, thus H_Hat cannot 
change its behavior under the two cases because H_Hat never reaches the 
point where it would get a different return value from Halts.

Mike still does not understand this yet that does not make his 
misunderstanding correct and my understanding incorrect.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25787 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 23:22 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<HqednfLNjZQ4BSHCnZ2dnUU7-TudnZ2d@giganews.com>
In reply to#25779
On 11/23/2020 9:39 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/22/2020 10:03 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> Maybe you have created a system that is a Halter, which will just abort
>>>>>> any program that it determines will never halt. That might have some
>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>
>>>>> The irony is that that algorith -- the algorithm that determines if a
>>>>> computation must be aborted -- is also impossible.  He's not written
>>>>> it yet
>>>>
>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>
>>> You have not yet written it (so you said) which it why you have not yet
>>> noticed that it won't work.  If you have written it, then you need to do
>>> more testing, (or ask an expert to tell you why it won't work).
>>>
>> Here is what Mike said about my way of correctly deciding H_Hat:
> 
> Do you really think the lying about other people's position helps your
> case one iota?  No, in fact it is shameful behaviour which, sadly, is no
> longer unusual for you.  I suspect you know you have nothing, so lying
> is all you have left.  You lied two years about having H and H^ "fully
> encoded as actual Turing machines" "exactly and precisely as in Linz"
> when you had no such thing, and you have nothing now so you lie about
> Mike's position.
> 
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
> 
> Oh, and you are being childish again, too.  Grow up.
> 
>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>> described.  This is all baby stuff.  [So the correct halting decision
>>> for the input is non-halting].
> 
> If anyone with a proper newsreader needs to confirm you mendacity, the
> link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk>
> 
> Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from
> that post is non-halting -- it calls a function that is not a decider
> but one that just simulates the computation of applying the argument to
> itself.

Mike did not understand that the execution of H_Hat under a simulator 
and under a halt decider are identical executions.

In both cases H_Hat has no way to tell the difference, thus H_Hat cannot 
change its behavior under the two cases because H_Hat never reaches the 
point where it would get a different return value from Halts.

Mike still does not understand this yet that does not make his 
misunderstanding correct and my understanding incorrect.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25788 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 23:23 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<Hqedne3NjZRUBSHCnZ2dnUU7-TsAAAAA@giganews.com>
In reply to#25779
On 11/23/2020 9:39 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/22/2020 10:03 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> Maybe you have created a system that is a Halter, which will just abort
>>>>>> any program that it determines will never halt. That might have some
>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>
>>>>> The irony is that that algorith -- the algorithm that determines if a
>>>>> computation must be aborted -- is also impossible.  He's not written
>>>>> it yet
>>>>
>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>
>>> You have not yet written it (so you said) which it why you have not yet
>>> noticed that it won't work.  If you have written it, then you need to do
>>> more testing, (or ask an expert to tell you why it won't work).
>>>
>> Here is what Mike said about my way of correctly deciding H_Hat:
> 
> Do you really think the lying about other people's position helps your
> case one iota?  No, in fact it is shameful behaviour which, sadly, is no
> longer unusual for you.  I suspect you know you have nothing, so lying
> is all you have left.  You lied two years about having H and H^ "fully
> encoded as actual Turing machines" "exactly and precisely as in Linz"
> when you had no such thing, and you have nothing now so you lie about
> Mike's position.
> 
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
>> Here is what Mike said about my way of correctly deciding H_Hat:
> 
> Oh, and you are being childish again, too.  Grow up.
> 
>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>> described.  This is all baby stuff.  [So the correct halting decision
>>> for the input is non-halting].
> 
> If anyone with a proper newsreader needs to confirm you mendacity, the
> link is Message-ID: <pP-dnWFAVJ0hFCXCnZ2dnUU78RvNnZ2d@brightview.co.uk>
> 
> Mike is confirming what everyone knows: of course the H_Hat(H_Hat) from
> that post is non-halting -- it calls a function that is not a decider
> but one that just simulates the computation of applying the argument to
> itself.

Mike did not understand that the execution of H_Hat under a simulator 
and under a halt decider are identical executions.

In both cases H_Hat has no way to tell the difference, thus H_Hat cannot 
change its behavior under the two cases because H_Hat never reaches the 
point where it would get a different return value from Halts.

Mike still does not understand this yet that does not make his 
misunderstanding correct and my understanding incorrect.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25712 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-23 17:07 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<_tudndH2L5L_cSbCnZ2dnUU78W3NnZ2d@brightview.co.uk>
In reply to#25690
On 23/11/2020 03:33, olcott wrote:
> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> Maybe you have created a system that is a Halter, which will just abort
>>> any program that it determines will never halt. That might have some
>>> use, but isn't the Halt Decider from Linz.
>>
>> The irony is that that algorith -- the algorithm that determines if a
>> computation must be aborted -- is also impossible.  He's not written
>> it > yet
>
> IT IS IN THE FIRST POST OF THIS THREAD.
> This is my 2018-12-13 solution.
>
> We merely scan the complete execution trace after each instruction is
> executed and see if there have been any function calls to the same
> function from the same address without any intervening conditional
> branch instructions.
>
> Here is what Mike said about correctly deciding H_Hat:
>
> On 11/20/2020 9:30 PM, Mike Terry wrote:
>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>> described.  This is all baby stuff.  [So the correct halting decision
>> for the input is non-halting].


STOP QUOTING ME OUT OF CONTEXT.

THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* 
H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position to 
falsely support your own.

The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you 
gave (but have omitted from your misreprestation), in which Halts() was 
specified to be a pure UTM: no NeedsToBeAborted() calls etc..

OF COURSE that particular H_Hat() never halts, and nobody would say 
otherwise.  Your H_Hat() above contains a call to H() which clearly 
contains infinite recursion detection logic, making it A COMPLETELY 
DIFFERENT H_Hat.  You must understand that just because you use the same 
label for two different objects, that does not actually make them the 
same object!

I suggest to you that /deliberately/ misrepresenting someones position 
on a topic is a form of "bearing false witness" against that person, and 
so I'll be charitable and assume you are doing it because you have 
simply misunderstood the thread you are quoting.  I expect you to stop 
this behaviour now you are aware.


Mike.

[toc] | [prev] | [next] | [standalone]


#25718 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 11:37 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<IvudnSrhmtzCbibCnZ2dnUU7-f_NnZ2d@giganews.com>
In reply to#25712
On 11/23/2020 11:07 AM, Mike Terry wrote:
> On 23/11/2020 03:33, olcott wrote:
>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> Maybe you have created a system that is a Halter, which will just abort
>>>> any program that it determines will never halt. That might have some
>>>> use, but isn't the Halt Decider from Linz.
>>>
>>> The irony is that that algorith -- the algorithm that determines if a
>>> computation must be aborted -- is also impossible.  He's not written
>>> it > yet
>>
>> IT IS IN THE FIRST POST OF THIS THREAD.
>> This is my 2018-12-13 solution.
>>
>> We merely scan the complete execution trace after each instruction is
>> executed and see if there have been any function calls to the same
>> function from the same address without any intervening conditional
>> branch instructions.
>>
>> Here is what Mike said about correctly deciding H_Hat:
>>
>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>> described.  This is all baby stuff.  [So the correct halting decision
>>> for the input is non-halting].
> 
> 
> STOP QUOTING ME OUT OF CONTEXT.
> 
> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT* 
> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position to 
> falsely support your own.

The two versions of H_Hat are computationally equivalent, thus your 
claim that they are *COMPLETELY DIFFERENT*  is proved to be false.

Here is the one that you responded to:
On Friday, November 20, 2020 at 8:45:59 PM UTC-6, olcott wrote:
void H_Hat(u32 P)
{
   u32 Aborted = Halts(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}


int main()
{
   u32 P = (u32)H_Hat;
   Halts(P, P);
   HALT;
}
https://groups.google.com/g/comp.theory/c/1uKuMgjxJTM/m/c3HEt-UWAAAJ


Here is the one in this thread:
On 11/22/2020 7:24 PM, olcott wrote:
// Defined at the bottom of page 319 of Linz
void Ĥ(u32 P)
{
   u32 Input_Halts = H(P, P);
   if (!Input_Halts)
     HALT
   else
     HERE: goto HERE;
}


int main()
{
   u32 P = (u32)Ĥ;
   H(P, P);
   HALT;
}


> The H_Hat that I said was non-halting was A SPECIFIC CODE SAMPLE you 
> gave (but have omitted from your misreprestation), in which Halts() was 
> specified to be a pure UTM: no NeedsToBeAborted() calls etc..
> 
> OF COURSE that particular H_Hat() never halts, and nobody would say 
> otherwise.  

Therefore
On 11/20/2020 9:30 PM, Mike Terry wrote:
 > [So the correct halting decision for the input is non-halting].

> Your H_Hat() above contains a call to H() which clearly 
> contains infinite recursion detection logic, making it A COMPLETELY 
> DIFFERENT H_Hat.  

As I have already proven it does not make it a completely different 
H_Hat. The execution trace of neither H_Hat ever reaches the point of 
the difference.

> You must understand that just because you use the same 
> label for two different objects, that does not actually make them the 
> same object!

I understand that. The fact that their execution traces are identical 
makes them the same execution.

> I suggest to you that /deliberately/ misrepresenting someones position 
> on a topic is a form of "bearing false witness" against that person, and 
> so I'll be charitable and assume you are doing it because you have 
> simply misunderstood the thread you are quoting.  I expect you to stop 
> this behaviour now you are aware.
> 
> 
> Mike.

The actual case is that I proved that the difference that you assert 
does not actually exist. Also I forgot that you even asserted a difference.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25720 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-23 17:42 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<euCdnQOtXNzqaSbCnZ2dnUU78cfNnZ2d@brightview.co.uk>
In reply to#25718
On 23/11/2020 17:37, olcott wrote:
> On 11/23/2020 11:07 AM, Mike Terry wrote:
>> On 23/11/2020 03:33, olcott wrote:
>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> Maybe you have created a system that is a Halter, which will just
>>>>> abort
>>>>> any program that it determines will never halt. That might have some
>>>>> use, but isn't the Halt Decider from Linz.
>>>>
>>>> The irony is that that algorith -- the algorithm that determines if a
>>>> computation must be aborted -- is also impossible.  He's not written
>>>> it > yet
>>>
>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>> This is my 2018-12-13 solution.
>>>
>>> We merely scan the complete execution trace after each instruction is
>>> executed and see if there have been any function calls to the same
>>> function from the same address without any intervening conditional
>>> branch instructions.
>>>
>>> Here is what Mike said about correctly deciding H_Hat:
>>>
>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>> described.  This is all baby stuff.  [So the correct halting decision
>>>> for the input is non-halting].
>>
>>
>> STOP QUOTING ME OUT OF CONTEXT.
>>
>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position
>> to falsely support your own.
>
> The two versions of H_Hat are computationally equivalent, thus your
> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.

I don't care what you /think/ I said or implied.  YOU ARE 
MISREPRESENTING MY POSITION, whether honestly or dishonestly.

STOP DOING THAT.

I will probably reply in more detail to your other remarks separately.

Mike.

[toc] | [prev] | [next] | [standalone]


#25722 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 11:53 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<TaadnblrGMqsaibCnZ2dnUU7-YudnZ2d@giganews.com>
In reply to#25720
On 11/23/2020 11:42 AM, Mike Terry wrote:
> On 23/11/2020 17:37, olcott wrote:
>> On 11/23/2020 11:07 AM, Mike Terry wrote:
>>> On 23/11/2020 03:33, olcott wrote:
>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> Maybe you have created a system that is a Halter, which will just
>>>>>> abort
>>>>>> any program that it determines will never halt. That might have some
>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>
>>>>> The irony is that that algorith -- the algorithm that determines if a
>>>>> computation must be aborted -- is also impossible.  He's not written
>>>>> it > yet
>>>>
>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>> This is my 2018-12-13 solution.
>>>>
>>>> We merely scan the complete execution trace after each instruction is
>>>> executed and see if there have been any function calls to the same
>>>> function from the same address without any intervening conditional
>>>> branch instructions.
>>>>
>>>> Here is what Mike said about correctly deciding H_Hat:
>>>>
>>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>>> described.  This is all baby stuff.  [So the correct halting decision
>>>>> for the input is non-halting].
>>>
>>>
>>> STOP QUOTING ME OUT OF CONTEXT.
>>>
>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
>>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position
>>> to falsely support your own.
>>
>> The two versions of H_Hat are computationally equivalent, thus your
>> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.
> 
> I don't care what you /think/ I said or implied.  YOU ARE 
> MISREPRESENTING MY POSITION, whether honestly or dishonestly.
> 
> STOP DOING THAT.
> 
> I will probably reply in more detail to your other remarks separately.
> 
> Mike.
> 

The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is 
a UTM

The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is 
a Halt decider

are identical because neither H_Hat ever reaches the point of the 
difference: the return value from Halts().



-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25724 — Re: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-23 13:39 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Mike Terry said)
Message-ID<ElTuH.14729$Wi7.8109@fx29.iad>
In reply to#25722
On 11/23/20 12:53 PM, olcott wrote:
> On 11/23/2020 11:42 AM, Mike Terry wrote:
>> On 23/11/2020 17:37, olcott wrote:
>>> On 11/23/2020 11:07 AM, Mike Terry wrote:
>>>> On 23/11/2020 03:33, olcott wrote:
>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> Maybe you have created a system that is a Halter, which will just
>>>>>>> abort
>>>>>>> any program that it determines will never halt. That might have some
>>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>>
>>>>>> The irony is that that algorith -- the algorithm that determines if a
>>>>>> computation must be aborted -- is also impossible.  He's not written
>>>>>> it > yet
>>>>>
>>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>>> This is my 2018-12-13 solution.
>>>>>
>>>>> We merely scan the complete execution trace after each instruction is
>>>>> executed and see if there have been any function calls to the same
>>>>> function from the same address without any intervening conditional
>>>>> branch instructions.
>>>>>
>>>>> Here is what Mike said about correctly deciding H_Hat:
>>>>>
>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>>>> described.  This is all baby stuff.  [So the correct halting decision
>>>>>> for the input is non-halting].
>>>>
>>>>
>>>> STOP QUOTING ME OUT OF CONTEXT.
>>>>
>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
>>>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position
>>>> to falsely support your own.
>>>
>>> The two versions of H_Hat are computationally equivalent, thus your
>>> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.
>>
>> I don't care what you /think/ I said or implied.  YOU ARE
>> MISREPRESENTING MY POSITION, whether honestly or dishonestly.
>>
>> STOP DOING THAT.
>>
>> I will probably reply in more detail to your other remarks separately.
>>
>> Mike.
>>
> 
> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
> a UTM
> 
> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
> a Halt decider
> 
> are identical because neither H_Hat ever reaches the point of the
> difference: the return value from Halts().
> 

If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and
Halts is purportedly a Halting Decider, and Halts never get to analyzing
the return value of itself in the trace sounds like a real good reason
to doubt that it is a proper halting decider. How can it possible claim
to do its job if it never gets around to actually looking at the
important points of the program.

Remember, how Halts works is totally up to its designer, the
restrictions on it are what it is to expect as inputs and how it must
deliver its answer, so its failure to get the information that it needs,
must a a failure in it design.

I have shown alternate designs that will happen to handle this
particular problem (but makes the Linz contradiction failure painfully
obvious, so that may be why you ignore them), so there is no way to
claim that it is an inherent part of the problem.

[toc] | [prev] | [next] | [standalone]


#25728 — Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 13:35 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](actual facts)
Message-ID<zsWdndjhqtR3kyHCnZ2dnUU7-e3NnZ2d@giganews.com>
In reply to#25724
On 11/23/2020 12:39 PM, Richard Damon wrote:
> On 11/23/20 12:53 PM, olcott wrote:
>> On 11/23/2020 11:42 AM, Mike Terry wrote:
>>> On 23/11/2020 17:37, olcott wrote:
>>>> On 11/23/2020 11:07 AM, Mike Terry wrote:
>>>>> On 23/11/2020 03:33, olcott wrote:
>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>
>>>>>>>> Maybe you have created a system that is a Halter, which will just
>>>>>>>> abort
>>>>>>>> any program that it determines will never halt. That might have some
>>>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>>>
>>>>>>> The irony is that that algorith -- the algorithm that determines if a
>>>>>>> computation must be aborted -- is also impossible.  He's not written
>>>>>>> it > yet
>>>>>>
>>>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>>>> This is my 2018-12-13 solution.
>>>>>>
>>>>>> We merely scan the complete execution trace after each instruction is
>>>>>> executed and see if there have been any function calls to the same
>>>>>> function from the same address without any intervening conditional
>>>>>> branch instructions.
>>>>>>
>>>>>> Here is what Mike said about correctly deciding H_Hat:
>>>>>>
>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>>>>> described.  This is all baby stuff.  [So the correct halting decision
>>>>>>> for the input is non-halting].
>>>>>
>>>>>
>>>>> STOP QUOTING ME OUT OF CONTEXT.
>>>>>
>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
>>>>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position
>>>>> to falsely support your own.
>>>>
>>>> The two versions of H_Hat are computationally equivalent, thus your
>>>> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.
>>>
>>> I don't care what you /think/ I said or implied.  YOU ARE
>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly.
>>>
>>> STOP DOING THAT.
>>>
>>> I will probably reply in more detail to your other remarks separately.
>>>
>>> Mike.
>>>
>>
>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
>> a UTM
>>
>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
>> a Halt decider
>>
>> are identical because neither H_Hat ever reaches the point of the
>> difference: the return value from Halts().
>>
> 
> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and
> Halts is purportedly a Halting Decider, and Halts never get to analyzing
> the return value of itself in the trace sounds like a real good reason
> to doubt that it is a proper halting decider. How can it possible claim
> to do its job if it never gets around to actually looking at the
> important points of the program.
> 
You don't have to believe or disbelieve simply look at the actual facts 
of the provided execution trace itself.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25731 — Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-23 14:58 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](actual facts)
Message-ID<hvUuH.12605$vo2.4515@fx02.iad>
In reply to#25728
On 11/23/20 2:35 PM, olcott wrote:
> On 11/23/2020 12:39 PM, Richard Damon wrote:
>> On 11/23/20 12:53 PM, olcott wrote:
>>> On 11/23/2020 11:42 AM, Mike Terry wrote:
>>>> On 23/11/2020 17:37, olcott wrote:
>>>>> On 11/23/2020 11:07 AM, Mike Terry wrote:
>>>>>> On 23/11/2020 03:33, olcott wrote:
>>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>
>>>>>>>>> Maybe you have created a system that is a Halter, which will just
>>>>>>>>> abort
>>>>>>>>> any program that it determines will never halt. That might have
>>>>>>>>> some
>>>>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>>>>
>>>>>>>> The irony is that that algorith -- the algorithm that determines
>>>>>>>> if a
>>>>>>>> computation must be aborted -- is also impossible.  He's not
>>>>>>>> written
>>>>>>>> it > yet
>>>>>>>
>>>>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>>>>> This is my 2018-12-13 solution.
>>>>>>>
>>>>>>> We merely scan the complete execution trace after each
>>>>>>> instruction is
>>>>>>> executed and see if there have been any function calls to the same
>>>>>>> function from the same address without any intervening conditional
>>>>>>> branch instructions.
>>>>>>>
>>>>>>> Here is what Mike said about correctly deciding H_Hat:
>>>>>>>
>>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>>>>>> described.  This is all baby stuff.  [So the correct halting
>>>>>>>> decision
>>>>>>>> for the input is non-halting].
>>>>>>
>>>>>>
>>>>>> STOP QUOTING ME OUT OF CONTEXT.
>>>>>>
>>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
>>>>>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position
>>>>>> to falsely support your own.
>>>>>
>>>>> The two versions of H_Hat are computationally equivalent, thus your
>>>>> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.
>>>>
>>>> I don't care what you /think/ I said or implied.  YOU ARE
>>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly.
>>>>
>>>> STOP DOING THAT.
>>>>
>>>> I will probably reply in more detail to your other remarks separately.
>>>>
>>>> Mike.
>>>>
>>>
>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
>>> a UTM
>>>
>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
>>> a Halt decider
>>>
>>> are identical because neither H_Hat ever reaches the point of the
>>> difference: the return value from Halts().
>>>
>>
>> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and
>> Halts is purportedly a Halting Decider, and Halts never get to analyzing
>> the return value of itself in the trace sounds like a real good reason
>> to doubt that it is a proper halting decider. How can it possible claim
>> to do its job if it never gets around to actually looking at the
>> important points of the program.
>>
> You don't have to believe or disbelieve simply look at the actual facts
> of the provided execution trace itself.
> 
> 

You mean this trace which is what the requirement require?


1) Enter H_Hat(H_Hat)
2) duplicate H_Hat (this step 'optimized' out in your machine)
3) Enter Halts(H_Hat, H_Hat)
4) Halts does its decision and decides tht H_Hat is non-halting
5) Halts returns false to indicate non-halting
6) H_Hat goes to the else clause
7) H_Hat Halts.

Thus, Halts was wrong.


Your trace shows a variance, thus there MUST be something wrong in it.

Yes, YOUR program says that H_Hat is non-halting. It says it multiple
ways. The above trace shows that they are wrong.

Do you wish to hire me to debug your code? Rate is $100/Hour, double
that if you help.

Of course, I will need a detailed statement of work of exactly what is
required, and considering you history of bad wording, making sure the
definitions are fully agreed on.

[toc] | [prev] | [next] | [standalone]


#25733 — Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-23 14:12 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](actual facts)
Message-ID<I66dnZUWV7sJiiHCnZ2dnUU7-UfNnZ2d@giganews.com>
In reply to#25731
On 11/23/2020 1:58 PM, Richard Damon wrote:
> On 11/23/20 2:35 PM, olcott wrote:
>> On 11/23/2020 12:39 PM, Richard Damon wrote:
>>> On 11/23/20 12:53 PM, olcott wrote:
>>>> On 11/23/2020 11:42 AM, Mike Terry wrote:
>>>>> On 23/11/2020 17:37, olcott wrote:
>>>>>> On 11/23/2020 11:07 AM, Mike Terry wrote:
>>>>>>> On 23/11/2020 03:33, olcott wrote:
>>>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> Maybe you have created a system that is a Halter, which will just
>>>>>>>>>> abort
>>>>>>>>>> any program that it determines will never halt. That might have
>>>>>>>>>> some
>>>>>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>>>>>
>>>>>>>>> The irony is that that algorith -- the algorithm that determines
>>>>>>>>> if a
>>>>>>>>> computation must be aborted -- is also impossible.  He's not
>>>>>>>>> written
>>>>>>>>> it > yet
>>>>>>>>
>>>>>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>>>>>> This is my 2018-12-13 solution.
>>>>>>>>
>>>>>>>> We merely scan the complete execution trace after each
>>>>>>>> instruction is
>>>>>>>> executed and see if there have been any function calls to the same
>>>>>>>> function from the same address without any intervening conditional
>>>>>>>> branch instructions.
>>>>>>>>
>>>>>>>> Here is what Mike said about correctly deciding H_Hat:
>>>>>>>>
>>>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>>>>>>> described.  This is all baby stuff.  [So the correct halting
>>>>>>>>> decision
>>>>>>>>> for the input is non-halting].
>>>>>>>
>>>>>>>
>>>>>>> STOP QUOTING ME OUT OF CONTEXT.
>>>>>>>
>>>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY DIFFERENT*
>>>>>>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my position
>>>>>>> to falsely support your own.
>>>>>>
>>>>>> The two versions of H_Hat are computationally equivalent, thus your
>>>>>> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.
>>>>>
>>>>> I don't care what you /think/ I said or implied.  YOU ARE
>>>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly.
>>>>>
>>>>> STOP DOING THAT.
>>>>>
>>>>> I will probably reply in more detail to your other remarks separately.
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
>>>> a UTM
>>>>
>>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and Halts is
>>>> a Halt decider
>>>>
>>>> are identical because neither H_Hat ever reaches the point of the
>>>> difference: the return value from Halts().
>>>>
>>>
>>> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and
>>> Halts is purportedly a Halting Decider, and Halts never get to analyzing
>>> the return value of itself in the trace sounds like a real good reason
>>> to doubt that it is a proper halting decider. How can it possible claim
>>> to do its job if it never gets around to actually looking at the
>>> important points of the program.
>>>
>> You don't have to believe or disbelieve simply look at the actual facts
>> of the provided execution trace itself.
>>
>>
> 
> You mean this trace which is what the requirement require?
> 
> 
> 1) Enter H_Hat(H_Hat)
> 2) duplicate H_Hat (this step 'optimized' out in your machine)
> 3) Enter Halts(H_Hat, H_Hat)
> 4) Halts does its decision and decides tht H_Hat is non-halting
> 5) Halts returns false to indicate non-halting
> 6) H_Hat goes to the else clause
> 7) H_Hat Halts.


I mean the actual execution trace from fully operational code not any 
mere misconceptions.

Output_Debug_Trace() [00010abc]  size(148)  capacity(65536)
[00000527](01)  55                  push ebp
[00000528](02)  8bec                mov ebp,esp
[0000052a](01)  51                  push ecx
[0000052b](07)  c745fcf7040000      mov [ebp-04],000004f7
[00000532](03)  8b45fc              mov eax,[ebp-04]
[00000535](01)  50                  push eax
[00000536](03)  8b4dfc              mov ecx,[ebp-04]
[00000539](01)  51                  push ecx
[0000053a](05)  e838feffff          call 00000377
[000004f7](01)  55                  push ebp
[000004f8](02)  8bec                mov ebp,esp
[000004fa](01)  51                  push ecx
[000004fb](03)  8b4508              mov eax,[ebp+08]
[000004fe](01)  50                  push eax
[000004ff](03)  8b4d08              mov ecx,[ebp+08]
[00000502](01)  51                  push ecx
[00000503](05)  e86ffeffff          call 00000377
[000004f7](01)  55                  push ebp
[000004f8](02)  8bec                mov ebp,esp
[000004fa](01)  51                  push ecx
[000004fb](03)  8b4508              mov eax,[ebp+08]
[000004fe](01)  50                  push eax
[000004ff](03)  8b4d08              mov ecx,[ebp+08]
[00000502](01)  51                  push ecx
[00000503](05)  e86ffeffff          call 00000377

The last 9 lines of this show the part that infinitely repeats unless 
aborted. We can tell that it infinitely repeats:

(1) By not stopping it and seeing it keep repeating.

(2) The fact that there are no conditional branch instructions in this 
sequence that could possibly exit this infinite recursion.

I don't really have time for [fact free people] that are anchored in 
misconceptions.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#25734 — Re: It is known that a correct halt decider must return false (in this case)[V4](actual facts)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-23 15:54 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](actual facts)
Message-ID<BkVuH.10295$dN1.5358@fx42.iad>
In reply to#25733
On 11/23/20 3:12 PM, olcott wrote:
> On 11/23/2020 1:58 PM, Richard Damon wrote:
>> On 11/23/20 2:35 PM, olcott wrote:
>>> On 11/23/2020 12:39 PM, Richard Damon wrote:
>>>> On 11/23/20 12:53 PM, olcott wrote:
>>>>> On 11/23/2020 11:42 AM, Mike Terry wrote:
>>>>>> On 23/11/2020 17:37, olcott wrote:
>>>>>>> On 11/23/2020 11:07 AM, Mike Terry wrote:
>>>>>>>> On 23/11/2020 03:33, olcott wrote:
>>>>>>>>> On 11/22/2020 9:14 PM, Ben Bacarisse wrote:
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>
>>>>>>>>>>> Maybe you have created a system that is a Halter, which will
>>>>>>>>>>> just
>>>>>>>>>>> abort
>>>>>>>>>>> any program that it determines will never halt. That might have
>>>>>>>>>>> some
>>>>>>>>>>> use, but isn't the Halt Decider from Linz.
>>>>>>>>>>
>>>>>>>>>> The irony is that that algorith -- the algorithm that determines
>>>>>>>>>> if a
>>>>>>>>>> computation must be aborted -- is also impossible.  He's not
>>>>>>>>>> written
>>>>>>>>>> it > yet
>>>>>>>>>
>>>>>>>>> IT IS IN THE FIRST POST OF THIS THREAD.
>>>>>>>>> This is my 2018-12-13 solution.
>>>>>>>>>
>>>>>>>>> We merely scan the complete execution trace after each
>>>>>>>>> instruction is
>>>>>>>>> executed and see if there have been any function calls to the same
>>>>>>>>> function from the same address without any intervening conditional
>>>>>>>>> branch instructions.
>>>>>>>>>
>>>>>>>>> Here is what Mike said about correctly deciding H_Hat:
>>>>>>>>>
>>>>>>>>> On 11/20/2020 9:30 PM, Mike Terry wrote:
>>>>>>>>>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>>>>>>>>>> described.  This is all baby stuff.  [So the correct halting
>>>>>>>>>> decision
>>>>>>>>>> for the input is non-halting].
>>>>>>>>
>>>>>>>>
>>>>>>>> STOP QUOTING ME OUT OF CONTEXT.
>>>>>>>>
>>>>>>>> THE H_Hat OF THE POST TO WHICH YOU REFER IS A *COMPLETELY
>>>>>>>> DIFFERENT*
>>>>>>>> H_Hat TO THE ONE IN THIS THREAD.  You are misrepresenting my
>>>>>>>> position
>>>>>>>> to falsely support your own.
>>>>>>>
>>>>>>> The two versions of H_Hat are computationally equivalent, thus your
>>>>>>> claim that they are *COMPLETELY DIFFERENT*  is proved to be false.
>>>>>>
>>>>>> I don't care what you /think/ I said or implied.  YOU ARE
>>>>>> MISREPRESENTING MY POSITION, whether honestly or dishonestly.
>>>>>>
>>>>>> STOP DOING THAT.
>>>>>>
>>>>>> I will probably reply in more detail to your other remarks
>>>>>> separately.
>>>>>>
>>>>>> Mike.
>>>>>>
>>>>>
>>>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and
>>>>> Halts is
>>>>> a UTM
>>>>>
>>>>> The execution trace where H_Hat calls Halts(H_Hat, _H_Hat) and
>>>>> Halts is
>>>>> a Halt decider
>>>>>
>>>>> are identical because neither H_Hat ever reaches the point of the
>>>>> difference: the return value from Halts().
>>>>>
>>>>
>>>> If the execution trace of H_Hat(H_Hat) where H_Hat calls Halts, and
>>>> Halts is purportedly a Halting Decider, and Halts never get to
>>>> analyzing
>>>> the return value of itself in the trace sounds like a real good reason
>>>> to doubt that it is a proper halting decider. How can it possible claim
>>>> to do its job if it never gets around to actually looking at the
>>>> important points of the program.
>>>>
>>> You don't have to believe or disbelieve simply look at the actual facts
>>> of the provided execution trace itself.
>>>
>>>
>>
>> You mean this trace which is what the requirement require?
>>
>>
>> 1) Enter H_Hat(H_Hat)
>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>> 3) Enter Halts(H_Hat, H_Hat)
>> 4) Halts does its decision and decides tht H_Hat is non-halting
>> 5) Halts returns false to indicate non-halting
>> 6) H_Hat goes to the else clause
>> 7) H_Hat Halts.
> 
> 
> I mean the actual execution trace from fully operational code not any
> mere misconceptions.
> 
> Output_Debug_Trace() [00010abc]  size(148)  capacity(65536)
> [00000527](01)  55                  push ebp
> [00000528](02)  8bec                mov ebp,esp
> [0000052a](01)  51                  push ecx
> [0000052b](07)  c745fcf7040000      mov [ebp-04],000004f7
> [00000532](03)  8b45fc              mov eax,[ebp-04]
> [00000535](01)  50                  push eax
> [00000536](03)  8b4dfc              mov ecx,[ebp-04]
> [00000539](01)  51                  push ecx
> [0000053a](05)  e838feffff          call 00000377
> [000004f7](01)  55                  push ebp
> [000004f8](02)  8bec                mov ebp,esp
> [000004fa](01)  51                  push ecx
> [000004fb](03)  8b4508              mov eax,[ebp+08]
> [000004fe](01)  50                  push eax
> [000004ff](03)  8b4d08              mov ecx,[ebp+08]
> [00000502](01)  51                  push ecx
> [00000503](05)  e86ffeffff          call 00000377
> [000004f7](01)  55                  push ebp
> [000004f8](02)  8bec                mov ebp,esp
> [000004fa](01)  51                  push ecx
> [000004fb](03)  8b4508              mov eax,[ebp+08]
> [000004fe](01)  50                  push eax
> [000004ff](03)  8b4d08              mov ecx,[ebp+08]
> [00000502](01)  51                  push ecx
> [00000503](05)  e86ffeffff          call 00000377
> 
> The last 9 lines of this show the part that infinitely repeats unless
> aborted. We can tell that it infinitely repeats:
> 
> (1) By not stopping it and seeing it keep repeating.
> 
> (2) The fact that there are no conditional branch instructions in this
> sequence that could possibly exit this infinite recursion.
> 
> I don't really have time for [fact free people] that are anchored in
> misconceptions.
> 

Right, you have an infinite recursion due to a fault in the design of
you Halts function.

Your trace is omitting the conditional that the trace inside the trace
is providing, thus your trace is defective. This is likely because it
appears that you have moved the halting decision to be global and your
halts just executes the tape. This breaks you machine as a UTM and makes
your halts function inoperative (can the call to halts now ever really
return false, or does any call to halts that would return false abort
the whole program?

You have been putting a lot of effort into breaking you programs ability
to run according to the requirements.

Your trace does NOT show that H_Hat has non-halting behavior with a
working halting decider, because it shows a non-working halt decider.

The trace I provided shows that H_Hat WILL be halting if the halt
decider meets its decision requirements and says non-halting.

As you mentioned elsewhere, your Halts got aborted before it ever got to
see what happens after it returns, thus it got into a non-halting loop
based on its own bad design.

Maybe the problem is that you just can't conceive of any way to tell
that a given program will halt or run forever besides just running it,
but there are methods that can do a lot better (they of course still
can't totally meet the requirements, that is factually proved impossible).

[toc] | [prev] | [next] | [standalone]


Page 1 of 11  [1] 2 3 … 11  Next page →

Back to top | Article view | comp.theory


csiph-web