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 9 of 11 — ← Prev page 1 … 7 8 [9] 10 11  Next page →


#25806

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 10:27 -0600
Message-ID<Weqdnbjny8LJqSDCnZ2dnUU7-d_NnZ2d@giganews.com>
In reply to#25801
On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> All that I have right now is a DebugTrace() of all the user specified
>>>> code. This provides a very obvious basis for a halt decider's correct
>>>> halting decision of the H_Hat code specified in this execution trace.
>>>
>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or dumb,
>>> dumb or lying?  I can never quite tell.
>>>
>>> Having only the code that loops around the single stepping DebugTrace()
>>> (presumably a simple modification to someone else's emulator) is exactly
>>> the wrong basis for a halt decider.  Its the version that makes the
>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>> computation you are analysing is irrelevant because it's not built on a
>>> finite decider.
>>>
>>> Only when you add the impossible "abort if needed" code would you have
>>> anything that even resembles a decider.  But it's not a halt decider,
>>> because that code has ITS OWN "HAT" computation which it decides
>>> incorrectly.
>>
>> No it does not and you know that it does not.
> 
> If you dare post the code, I'll show you, explicitly (again).

The simplified code that I posted never has been the actual code. The 
actual code is far too complex to use as an example.

Line 14 requires an enormously complex set up to enable x86utm to be a 
multi-tasking operating system. This was the most difficult part of the 
development whole x86utm operating system.

08 bool Halts(u32 P, u32 I)
09 {
10   bool Halted  = false;
11   bool Aborted = false;
12   while (!Halted && !Aborted)
13   {
14     Halted  = DebugStep(P, I);
15     Aborted = Needs_To_Be_Aborted();
16   }
17   return !Aborted;
18 }


>> It neither has its own H_Hat computation and the one H_Hat that exists
>> is decided correctly and you know that it is decided correctly.
> 
> Of course it has it's own -- you don't get to say I can't write one if I
> want.  

There is only one set of machine code in the whole system that comprises 
the intruction of H_Hat. I have very great disrespect for people that 
deny easily verifiable facts.

> Your ruse -- to use one H_Hat and two different called functions
> is simply dishonest.  

It is fricking fully operational code.

> You know about it now, but you keep pushing it
> because you have nothing else.  Twenty years and this is all you have.

Your only rebuttal seems to be based on denying easily verifiable facts.

> Any time you fancy posting what you think is a halt decider (even if it
> refers to impossible-to-write code like your "needs_to_be_aborted"
> function), I will post the confounding example.  

Whataboutism, also known as whataboutery, is a variant of the tu quoque 
logical fallacy that attempts to discredit an opponent's position by 
charging them with hypocrisy without directly refuting or disproving 
their argument.

Whataboutism is particularly associated with Soviet and Russian 
propaganda. https://en.wikipedia.org/wiki/Whataboutism

This is the input to the decider that we are talking about diverting 
away from this is the same kind of dishonest dodge used by Soviet 
propaganda.

01 void H_Hat(u32 P)
02 {
03   if (Halts(P, P))
04     HERE: goto HERE;
05   else
06     HALT
07 }



> You dare not even try
> because you know I'm right.  Need we add intellectual cowardice to your
> character traits?
> 





-- 
Copyright 2020 Pete Olcott

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

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


#25867

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-25 00:16 +0000
Message-ID<87tute8f4h.fsf@bsb.me.uk>
In reply to#25806
olcott <NoOne@NoWhere.com> writes:

> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>
>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or dumb,
>>>> dumb or lying?  I can never quite tell.
>>>>
>>>> Having only the code that loops around the single stepping DebugTrace()
>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>> computation you are analysing is irrelevant because it's not built on a
>>>> finite decider.
>>>>
>>>> Only when you add the impossible "abort if needed" code would you have
>>>> anything that even resembles a decider.  But it's not a halt decider,
>>>> because that code has ITS OWN "HAT" computation which it decides
>>>> incorrectly.
>>>
>>> No it does not and you know that it does not.
>>
>> If you dare post the code, I'll show you, explicitly (again).
>
> The simplified code that I posted never has been the actual code. The
> actual code is far too complex to use as an example.
>
> Line 14 requires an enormously complex set up to enable x86utm to be a
> multi-tasking operating system. This was the most difficult part of
> the development whole x86utm operating system.

(And line 15 is harder still.  It's either impossible or it must get an
infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
happy to assume that it is 100% accurate -- no false positives or
negatives.)

> 08 bool Halts(u32 P, u32 I)
> 09 {
> 10   bool Halted  = false;
> 11   bool Aborted = false;
> 12   while (!Halted && !Aborted)
> 13   {
> 14     Halted  = DebugStep(P, I);
> 15     Aborted = Needs_To_Be_Aborted();
> 16   }
> 17   return !Aborted;
> 18 }

Given

  void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }

The confounding example for Halts is the computation
Confound_Halts(Confound_Halts) whose halting status is not correctly
determined by the function call Halts(Confound_Halts, Confound_Halts).

>>> It neither has its own H_Hat computation and the one H_Hat that exists
>>> is decided correctly and you know that it is decided correctly.
>>
>> Of course it has it's own -- you don't get to say I can't write one if I
>> want.  
>
> There is only one set of machine code in the whole system that
> comprises the intruction of H_Hat. I have very great disrespect for
> people that deny easily verifiable facts.

You have written, at various times, at least half a dozen subtly
different functions called H_Hat.  But that does not matter, because you
don't get to pick the confounding example, I do.

>> Your ruse -- to use one H_Hat and two different called functions
>> is simply dishonest.  
>
> It is fricking fully operational code.

So what?  It's still a ruse, and it's still the case that a sound
Needs_To_Be_Aborted function can't be written.

To be clear: the ruse is to say that the correct answer for the halting
status of a computation is to be determined by the behaviour of a
/different/ computation -- often shown using the same function names (to
add to the smoke and mirrors) -- but a different one none the less.

-- 
Ben.

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


#25871

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 18:30 -0600
Message-ID<2aidnV9e3qQaOCDCnZ2dnUU7-c3NnZ2d@giganews.com>
In reply to#25867
On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>
>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or dumb,
>>>>> dumb or lying?  I can never quite tell.
>>>>>
>>>>> Having only the code that loops around the single stepping DebugTrace()
>>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>> computation you are analysing is irrelevant because it's not built on a
>>>>> finite decider.
>>>>>
>>>>> Only when you add the impossible "abort if needed" code would you have
>>>>> anything that even resembles a decider.  But it's not a halt decider,
>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>> incorrectly.
>>>>
>>>> No it does not and you know that it does not.
>>>
>>> If you dare post the code, I'll show you, explicitly (again).
>>
>> The simplified code that I posted never has been the actual code. The
>> actual code is far too complex to use as an example.
>>
>> Line 14 requires an enormously complex set up to enable x86utm to be a
>> multi-tasking operating system. This was the most difficult part of
>> the development whole x86utm operating system.
> 
> (And line 15 is harder still.  It's either impossible or it must get an
> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
> happy to assume that it is 100% accurate -- no false positives or
> negatives.)
> 
>> 08 bool Halts(u32 P, u32 I)
>> 09 {
>> 10   bool Halted  = false;
>> 11   bool Aborted = false;
>> 12   while (!Halted && !Aborted)
>> 13   {
>> 14     Halted  = DebugStep(P, I);
>> 15     Aborted = Needs_To_Be_Aborted();
>> 16   }
>> 17   return !Aborted;
>> 18 }
> 
> Given
> 
>    void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
> 
> The confounding example for Halts is the computation
> Confound_Halts(Confound_Halts) whose halting status is not correctly
> determined by the function call Halts(Confound_Halts, Confound_Halts).

Halts(Confound_Halts, Confound_Halts) returns false.

Clearly you have not been paying any attention at all.

I have shown the complete execution trace basis for Halts to correctly 
decide any any all instances like your Confound_Halts, quite a few times 
now. The best one is in the original post of this thread.

-- 
Copyright 2020 Pete Olcott

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

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


#25909

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-24 23:17 -0500
Message-ID<wVkvH.8783$OP2.1118@fx18.iad>
In reply to#25871
On 11/24/20 7:30 PM, olcott wrote:
> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>> specified
>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>> correct
>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>> trace.
>>>>>>
>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or
>>>>>> dumb,
>>>>>> dumb or lying?  I can never quite tell.
>>>>>>
>>>>>> Having only the code that loops around the single stepping
>>>>>> DebugTrace()
>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>> exactly
>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>> on a
>>>>>> finite decider.
>>>>>>
>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>> have
>>>>>> anything that even resembles a decider.  But it's not a halt decider,
>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>> incorrectly.
>>>>>
>>>>> No it does not and you know that it does not.
>>>>
>>>> If you dare post the code, I'll show you, explicitly (again).
>>>
>>> The simplified code that I posted never has been the actual code. The
>>> actual code is far too complex to use as an example.
>>>
>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>> multi-tasking operating system. This was the most difficult part of
>>> the development whole x86utm operating system.
>>
>> (And line 15 is harder still.  It's either impossible or it must get an
>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>> happy to assume that it is 100% accurate -- no false positives or
>> negatives.)
>>
>>> 08 bool Halts(u32 P, u32 I)
>>> 09 {
>>> 10   bool Halted  = false;
>>> 11   bool Aborted = false;
>>> 12   while (!Halted && !Aborted)
>>> 13   {
>>> 14     Halted  = DebugStep(P, I);
>>> 15     Aborted = Needs_To_Be_Aborted();
>>> 16   }
>>> 17   return !Aborted;
>>> 18 }
>>
>> Given
>>
>>    void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>
>> The confounding example for Halts is the computation
>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>> determined by the function call Halts(Confound_Halts, Confound_Halts).
> 
> Halts(Confound_Halts, Confound_Halts) returns false.

At which point the if skips the while loop and the machine halts, so the
decider was wrong.

> 
> Clearly you have not been paying any attention at all.

Clearly YOU haven't been.
> 
> I have shown the complete execution trace basis for Halts to correctly
> decide any any all instances like your Confound_Halts, quite a few times
> now. The best one is in the original post of this thread.
> 

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


#25912 — Re: It is known that a correct halt decider must return false (This is the whole thing)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 22:43 -0600
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<n_udnTA2IcmUfCDCnZ2dnUU7-LfNnZ2d@giganews.com>
In reply to#25909
On 11/24/2020 10:17 PM, Richard Damon wrote:
> On 11/24/20 7:30 PM, olcott wrote:
>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>> specified
>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>> correct
>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>> trace.
>>>>>>>
>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or
>>>>>>> dumb,
>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>
>>>>>>> Having only the code that loops around the single stepping
>>>>>>> DebugTrace()
>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>> exactly
>>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>>> on a
>>>>>>> finite decider.
>>>>>>>
>>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>>> have
>>>>>>> anything that even resembles a decider.  But it's not a halt decider,
>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>> incorrectly.
>>>>>>
>>>>>> No it does not and you know that it does not.
>>>>>
>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>
>>>> The simplified code that I posted never has been the actual code. The
>>>> actual code is far too complex to use as an example.
>>>>
>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>> multi-tasking operating system. This was the most difficult part of
>>>> the development whole x86utm operating system.
>>>
>>> (And line 15 is harder still.  It's either impossible or it must get an
>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>> happy to assume that it is 100% accurate -- no false positives or
>>> negatives.)
>>>
>>>> 08 bool Halts(u32 P, u32 I)
>>>> 09 {
>>>> 10   bool Halted  = false;
>>>> 11   bool Aborted = false;
>>>> 12   while (!Halted && !Aborted)
>>>> 13   {
>>>> 14     Halted  = DebugStep(P, I);
>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>> 16   }
>>>> 17   return !Aborted;
>>>> 18 }
>>>
>>> Given
>>>
>>>     void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>
>>> The confounding example for Halts is the computation
>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>
>> Halts(Confound_Halts, Confound_Halts) returns false.
> 
> At which point the if skips the while loop and the machine halts, so the
> decider was wrong.

Only because we change the question from:

Does the input halt on its input?
    to
Must the input be aborted to prevent its otherwise infinite execution?

Are the key counter-examples of the HP proofs made halting decidable.




-- 
Copyright 2020 Pete Olcott

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

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


#25914 — Re: It is known that a correct halt decider must return false (This is the whole thing)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-24 23:53 -0500
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<FrlvH.13948$lo15.12878@fx35.iad>
In reply to#25912
On 11/24/20 11:43 PM, olcott wrote:
> On 11/24/2020 10:17 PM, Richard Damon wrote:
>> On 11/24/20 7:30 PM, olcott wrote:
>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>> specified
>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>> correct
>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>> trace.
>>>>>>>>
>>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or
>>>>>>>> dumb,
>>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>>
>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>> DebugTrace()
>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>> exactly
>>>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>>>> on a
>>>>>>>> finite decider.
>>>>>>>>
>>>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>>>> have
>>>>>>>> anything that even resembles a decider.  But it's not a halt
>>>>>>>> decider,
>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>> incorrectly.
>>>>>>>
>>>>>>> No it does not and you know that it does not.
>>>>>>
>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>
>>>>> The simplified code that I posted never has been the actual code. The
>>>>> actual code is far too complex to use as an example.
>>>>>
>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>> multi-tasking operating system. This was the most difficult part of
>>>>> the development whole x86utm operating system.
>>>>
>>>> (And line 15 is harder still.  It's either impossible or it must get an
>>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>>> happy to assume that it is 100% accurate -- no false positives or
>>>> negatives.)
>>>>
>>>>> 08 bool Halts(u32 P, u32 I)
>>>>> 09 {
>>>>> 10   bool Halted  = false;
>>>>> 11   bool Aborted = false;
>>>>> 12   while (!Halted && !Aborted)
>>>>> 13   {
>>>>> 14     Halted  = DebugStep(P, I);
>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>> 16   }
>>>>> 17   return !Aborted;
>>>>> 18 }
>>>>
>>>> Given
>>>>
>>>>     void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>
>>>> The confounding example for Halts is the computation
>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>
>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>
>> At which point the if skips the while loop and the machine halts, so the
>> decider was wrong.
> 
> Only because we change the question from:
> 
> Does the input halt on its input?
>    to
> Must the input be aborted to prevent its otherwise infinite execution?
> 
> Are the key counter-examples of the HP proofs made halting decidable.
> 

But, as has been shown, this are truly exact opposites, at least if you
want your results to apply to the same thing as the conventional halting
problem. If you agree that you are working on a different question, and
thus your results do not apply to things based on the conventional
halting problem, go ahead and change it, so the the aborting of a
recursively nested version of the code allows you to decide that the
machine is 'need to be aborted'. Just remeber if you do, that you can't
claim any of this applies to the conventional halting problem or things
based on it.

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


#25919 — Re: It is known that a correct halt decider must return false (This is the whole thing)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-24 23:12 -0600
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<sK2dnVNE0sAgeiDCnZ2dnUU7-QXNnZ2d@giganews.com>
In reply to#25914
On 11/24/2020 10:53 PM, Richard Damon wrote:
> On 11/24/20 11:43 PM, olcott wrote:
>> On 11/24/2020 10:17 PM, Richard Damon wrote:
>>> On 11/24/20 7:30 PM, olcott wrote:
>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>> specified
>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>> correct
>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>> trace.
>>>>>>>>>
>>>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or
>>>>>>>>> dumb,
>>>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>>>
>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>> DebugTrace()
>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>> exactly
>>>>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>>>> computation you are analysing is irrelevant because it's not built
>>>>>>>>> on a
>>>>>>>>> finite decider.
>>>>>>>>>
>>>>>>>>> Only when you add the impossible "abort if needed" code would you
>>>>>>>>> have
>>>>>>>>> anything that even resembles a decider.  But it's not a halt
>>>>>>>>> decider,
>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>> incorrectly.
>>>>>>>>
>>>>>>>> No it does not and you know that it does not.
>>>>>>>
>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>
>>>>>> The simplified code that I posted never has been the actual code. The
>>>>>> actual code is far too complex to use as an example.
>>>>>>
>>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>> the development whole x86utm operating system.
>>>>>
>>>>> (And line 15 is harder still.  It's either impossible or it must get an
>>>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>> negatives.)
>>>>>
>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>> 09 {
>>>>>> 10   bool Halted  = false;
>>>>>> 11   bool Aborted = false;
>>>>>> 12   while (!Halted && !Aborted)
>>>>>> 13   {
>>>>>> 14     Halted  = DebugStep(P, I);
>>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>>> 16   }
>>>>>> 17   return !Aborted;
>>>>>> 18 }
>>>>>
>>>>> Given
>>>>>
>>>>>      void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>
>>>>> The confounding example for Halts is the computation
>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>
>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>
>>> At which point the if skips the while loop and the machine halts, so the
>>> decider was wrong.
>>
>> Only because we change the question from:
>>
>> Does the input halt on its input?
>>     to
>> Must the input be aborted to prevent its otherwise infinite execution?
>>
>> Are the key counter-examples of the HP proofs made halting decidable.
>>
> 
> But, as has been shown, this are truly exact opposites,

A program that only halts if it is aborted has opposite halting behavior 
to a program that halts without being aborted.

-- 
Copyright 2020 Pete Olcott

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

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


#25923 — Re: It is known that a correct halt decider must return false (This is the whole thing)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 07:39 -0500
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<IfsvH.106027$1R4.16061@fx44.iad>
In reply to#25919
On 11/25/20 12:12 AM, olcott wrote:
> On 11/24/2020 10:53 PM, Richard Damon wrote:
>> On 11/24/20 11:43 PM, olcott wrote:

>>> Only because we change the question from:
>>>
>>> Does the input halt on its input?
>>>     to
>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>
>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>
>>
>> But, as has been shown, this are truly exact opposites,
> 
> A program that only halts if it is aborted has opposite halting behavior
> to a program that halts without being aborted.

Yes, a program that ONLY halts if it is aborted is the opposite of a
pogrmam that halts without being aborted.

A program that haltes because it was aborted is something very
different. It might have halted anyway if given more time.

The key words here are things like MUST and ONLY. Just because you come
up with some 'logical' justification that make it seems like it needs to
be. The REAL test is to actually run it and see. If the actual program
when run does halt, then the logic has been proved to be unsound.

Yes, proving a given computation is indeed non-halting can be difficult,
even impossible (otherwise we COULD have halting deciders), but very
many cases can be proven with a few simple rules. Things like repeating
state or loops with no way out (absolutely no way out, not even an OS
monetering them with the ability to abort them), so we can answer many
cases, and in particular, if we can find the halting behavior, we can
disprove the non-halting determination.
> 

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


#25928 — Re: It is known that a correct halt decider must return false (This is the whole thing)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 08:17 -0600
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<N6adnVpAzJ_1-iPCnZ2dnUU7-T_NnZ2d@giganews.com>
In reply to#25923
On 11/25/2020 6:39 AM, Richard Damon wrote:
> On 11/25/20 12:12 AM, olcott wrote:
>> On 11/24/2020 10:53 PM, Richard Damon wrote:
>>> On 11/24/20 11:43 PM, olcott wrote:
> 
>>>> Only because we change the question from:
>>>>
>>>> Does the input halt on its input?
>>>>      to
>>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>>
>>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>>
>>>
>>> But, as has been shown, this are truly exact opposites,
>>
>> A program that only halts if it is aborted has opposite halting behavior
>> to a program that halts without being aborted.
> 
> Yes, a program that ONLY halts if it is aborted is the opposite of a
> pogrmam that halts without being aborted.
> 
> A program that haltes because it was aborted is something very
> different. It might have halted anyway if given more time.

There are a set of programs that can be determined in advance to never 
halt. Here is one of them:

int main()
{
   HERE: goto HERE;
}

> The key words here are things like MUST and ONLY. Just because you come
> up with some 'logical' justification that make it seems like it needs to
> be. The REAL test is to actually run it and see. If the actual program
> when run does halt, then the logic has been proved to be unsound.

There are a set of computations that can be determined in advance that 
will never halt and this can be determined with 100% logical certainty.

> Yes, proving a given computation is indeed non-halting can be difficult,
> even impossible (otherwise we COULD have halting deciders), but very

This kind of pure speculation is no sort of counter-example proof of 
undecidability.

> many cases can be proven with a few simple rules. Things like repeating
> state or loops with no way out (absolutely no way out, not even an OS
> monetering them with the ability to abort them), so we can answer many
> cases, and in particular, if we can find the halting behavior, we can
> disprove the non-halting determination.



-- 
Copyright 2020 Pete Olcott

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

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


#25932 — Re: It is known that a correct halt decider must return false (This is the whole thing)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 10:14 -0500
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<3xuvH.199083$oL7.71453@fx06.iad>
In reply to#25928
On 11/25/20 9:17 AM, olcott wrote:
> On 11/25/2020 6:39 AM, Richard Damon wrote:
>> On 11/25/20 12:12 AM, olcott wrote:
>>> On 11/24/2020 10:53 PM, Richard Damon wrote:
>>>> On 11/24/20 11:43 PM, olcott wrote:
>>
>>>>> Only because we change the question from:
>>>>>
>>>>> Does the input halt on its input?
>>>>>      to
>>>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>>>
>>>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>>>
>>>>
>>>> But, as has been shown, this are truly exact opposites,
>>>
>>> A program that only halts if it is aborted has opposite halting behavior
>>> to a program that halts without being aborted.
>>
>> Yes, a program that ONLY halts if it is aborted is the opposite of a
>> pogrmam that halts without being aborted.
>>
>> A program that haltes because it was aborted is something very
>> different. It might have halted anyway if given more time.
> 
> There are a set of programs that can be determined in advance to never
> halt. Here is one of them:
> 
> int main()
> {
>   HERE: goto HERE;
> }
> 

Never denied that.

>> The key words here are things like MUST and ONLY. Just because you come
>> up with some 'logical' justification that make it seems like it needs to
>> be. The REAL test is to actually run it and see. If the actual program
>> when run does halt, then the logic has been proved to be unsound.
> 
> There are a set of computations that can be determined in advance that
> will never halt and this can be determined with 100% logical certainty.
> 

Never denied that, there is a set of computation that can be determined
in adanced that will never halt. That set might not include every
computation that WILL not halt. (in fact, because the halting problem
HAS been proved to be unsolvable, we know that there will be members in
the set of non-halting computations that can not be proven to be
non-halting).

>> Yes, proving a given computation is indeed non-halting can be difficult,
>> even impossible (otherwise we COULD have halting deciders), but very
> 
> This kind of pure speculation is no sort of counter-example proof of
> undecidability.

Until you can PROVE that you can decide EVERY case correctly, you don't
have ground to stand on. I can stand on the grounds of Linz (and
others_, and say the statement is proven.

Since we have a case that your machine still does not decide correctly,
by the criteria of the classical halting problem, which by your
arguments, you seem to be working on, you counter proof is disproved.

The traces you have provided, in part because they are only partial
since you haven't finished, show one of two failures. Either you fail by
failing to proved the answer to the computation asking for it, or you
fail by giving it the wrong answer (you say it will be non-halting when
it actually halts).

As I have said many times before, if you CLEARLY state that you admit to
be working on a different problem, and that therefore your results are
not applicable to the classical halting problem or the theories based on
it, then we can look at your alternate definition.
> 
>> many cases can be proven with a few simple rules. Things like repeating
>> state or loops with no way out (absolutely no way out, not even an OS
>> monetering them with the ability to abort them), so we can answer many
>> cases, and in particular, if we can find the halting behavior, we can
>> disprove the non-halting determination.
> 
> 
> 

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


#25937 — Re: It is known that a correct halt decider must return false (This is the whole thing)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 09:52 -0600
SubjectRe: It is known that a correct halt decider must return false (This is the whole thing)
Message-ID<uO6dnXXxyv1M4CPCnZ2dnUU7-YXNnZ2d@giganews.com>
In reply to#25932
On 11/25/2020 9:14 AM, Richard Damon wrote:
> On 11/25/20 9:17 AM, olcott wrote:
>> On 11/25/2020 6:39 AM, Richard Damon wrote:
>>> On 11/25/20 12:12 AM, olcott wrote:
>>>> On 11/24/2020 10:53 PM, Richard Damon wrote:
>>>>> On 11/24/20 11:43 PM, olcott wrote:
>>>
>>>>>> Only because we change the question from:
>>>>>>
>>>>>> Does the input halt on its input?
>>>>>>       to
>>>>>> Must the input be aborted to prevent its otherwise infinite execution?
>>>>>>
>>>>>> Are the key counter-examples of the HP proofs made halting decidable.
>>>>>>
>>>>>
>>>>> But, as has been shown, this are truly exact opposites,
>>>>
>>>> A program that only halts if it is aborted has opposite halting behavior
>>>> to a program that halts without being aborted.
>>>
>>> Yes, a program that ONLY halts if it is aborted is the opposite of a
>>> pogrmam that halts without being aborted.
>>>
>>> A program that haltes because it was aborted is something very
>>> different. It might have halted anyway if given more time.
>>
>> There are a set of programs that can be determined in advance to never
>> halt. Here is one of them:
>>
>> int main()
>> {
>>    HERE: goto HERE;
>> }
>>
> 
> Never denied that.
> 
>>> The key words here are things like MUST and ONLY. Just because you come
>>> up with some 'logical' justification that make it seems like it needs to
>>> be. The REAL test is to actually run it and see. If the actual program
>>> when run does halt, then the logic has been proved to be unsound.
>>
>> There are a set of computations that can be determined in advance that
>> will never halt and this can be determined with 100% logical certainty.
>>
> 
> Never denied that, there is a set of computation that can be determined
> in adanced that will never halt. That set might not include every
> computation that WILL not halt. (in fact, because the halting problem
> HAS been proved to be unsolvable, we know that there will be members in
> the set of non-halting computations that can not be proven to be
> non-halting).

(1)I did correctly show how to decide halting for the x86utm 
computational equivalent of a simplified form of the Linz Ĥ.

(2) This simplified form of the Linz H_Hat is the basis for all of the 
conventional halting problem proofs.

∴ I have proved that none of these conventional proofs (including Linz) 
have any basis for their conclusion.

void H_Hat(u32 P)
{
   u32 Aborted = DebugTrace(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}

All of the current rebuttals take the form that because Halts() does 
correct decide its input and it is common knowledge that this is 
impossible therefore Halts must be incorrect.


>>> Yes, proving a given computation is indeed non-halting can be difficult,
>>> even impossible (otherwise we COULD have halting deciders), but very
>>
>> This kind of pure speculation is no sort of counter-example proof of
>> undecidability.
> 
> Until you can PROVE that you can decide EVERY case correctly, you don't
> have ground to stand on. I can stand on the grounds of Linz (and
> others_, and say the statement is proven.

Yes if you ignore the verified fact that the above code is decided 
correctly you can bury your head in the sand and say that Linz still 
applies.

> Since we have a case that your machine still does not decide correctly,
> by the criteria of the classical halting problem, which by your
> arguments, you seem to be working on, you counter proof is disproved.

We have no such case. You said that Halts must be wrong BECAUSE it gets 
the correct answer.

> The traces you have provided, in part because they are only partial
> since you haven't finished, show one of two failures. Either you fail by
> failing to proved the answer to the computation asking for it, 

Simply ignoring my rebuttals is not any actual rebuttal at all, you seem 
to thinks that it is. I have asked you this at least three times and and 
you simply ignore my question.


What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?
What return value does H_Hat() receive from DebugTrace() ?

int DebugTrace(u32 N, u32 M)
{
   return ((int(*)(int))N)(M);
   return 1;
}


void H_Hat(u32 P)
{
   u32 Aborted = DebugTrace(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}


int main()
{
   u32 P = (u32)H_Hat;
   DebugTrace(P, P);
   HALT;
}






-- 
Copyright 2020 Pete Olcott

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

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


#25975

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-25 22:16 +0000
Message-ID<87zh355bfu.fsf@bsb.me.uk>
In reply to#25871
olcott <NoOne@NoWhere.com> writes:

> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>>
>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or dumb,
>>>>>> dumb or lying?  I can never quite tell.
>>>>>>
>>>>>> Having only the code that loops around the single stepping DebugTrace()
>>>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>> computation you are analysing is irrelevant because it's not built on a
>>>>>> finite decider.
>>>>>>
>>>>>> Only when you add the impossible "abort if needed" code would you have
>>>>>> anything that even resembles a decider.  But it's not a halt decider,
>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>> incorrectly.
>>>>>
>>>>> No it does not and you know that it does not.
>>>>
>>>> If you dare post the code, I'll show you, explicitly (again).
>>>
>>> The simplified code that I posted never has been the actual code. The
>>> actual code is far too complex to use as an example.
>>>
>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>> multi-tasking operating system. This was the most difficult part of
>>> the development whole x86utm operating system.
>>
>> (And line 15 is harder still.  It's either impossible or it must get an
>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>> happy to assume that it is 100% accurate -- no false positives or
>> negatives.)
>>
>>> 08 bool Halts(u32 P, u32 I)
>>> 09 {
>>> 10   bool Halted  = false;
>>> 11   bool Aborted = false;
>>> 12   while (!Halted && !Aborted)
>>> 13   {
>>> 14     Halted  = DebugStep(P, I);
>>> 15     Aborted = Needs_To_Be_Aborted();
>>> 16   }
>>> 17   return !Aborted;
>>> 18 }
>>
>> Given
>>
>>    void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>
>> The confounding example for Halts is the computation
>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>
> Halts(Confound_Halts, Confound_Halts) returns false.

But Confound_Halts(Confound_Halts) is a finite computation, so that's
the wrong answer (as you know perfectly well).

A halt decider is a function F, such that F(P, I) is true if and only if
P(I) is a finite computation and false otherwise.

> Clearly you have not been paying any attention at all.

Everyone now knows you have your own silly definition of what the right
answer is because you have made the mistake of being clear.

I am not posting this in the hope that you will suddenly accept that you
are wrong, I am posting it just to keep the record straight.
Confound_Halts(Confound_Halts) is one of the problem computations for
the hypothetical halt decider you posted.

Remarkably, this is true even of we assume a perfect implementation of
Needs_To_Be_Aborted.  Think about that for a moment.  The problem that
Needs_To_Be_Aborted has to solve is, more or less, equivalent to the
halting problem itself, yet we can't write a correct halt decider even
when we assume it.  This is of course why the original proof by
contradiction works.

> I have shown the complete execution trace basis for Halts to correctly
> decide any any all instances like your Confound_Halts, quite a few
> times now.

You tell me that Halts(Confound_Halts, Confound_Halts) returns false and
I am happy to take your word for it.  The trace is not needed to confirm
that.  The problem is your insistence that the wrong answer is the right
one.

-- 
Ben.

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


#25977 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 16:25 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<6Y6dnaUGHOdNRCPCnZ2dnUU7-fPNnZ2d@giganews.com>
In reply to#25975
On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> All that I have right now is a DebugTrace() of all the user specified
>>>>>>>> code. This provides a very obvious basis for a halt decider's correct
>>>>>>>> halting decision of the H_Hat code specified in this execution trace.
>>>>>>>
>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying or dumb,
>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>
>>>>>>> Having only the code that loops around the single stepping DebugTrace()
>>>>>>> (presumably a simple modification to someone else's emulator) is exactly
>>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>> computation you are analysing is irrelevant because it's not built on a
>>>>>>> finite decider.
>>>>>>>
>>>>>>> Only when you add the impossible "abort if needed" code would you have
>>>>>>> anything that even resembles a decider.  But it's not a halt decider,
>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>> incorrectly.
>>>>>>
>>>>>> No it does not and you know that it does not.
>>>>>
>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>
>>>> The simplified code that I posted never has been the actual code. The
>>>> actual code is far too complex to use as an example.
>>>>
>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>> multi-tasking operating system. This was the most difficult part of
>>>> the development whole x86utm operating system.
>>>
>>> (And line 15 is harder still.  It's either impossible or it must get an
>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>> happy to assume that it is 100% accurate -- no false positives or
>>> negatives.)
>>>
>>>> 08 bool Halts(u32 P, u32 I)
>>>> 09 {
>>>> 10   bool Halted  = false;
>>>> 11   bool Aborted = false;
>>>> 12   while (!Halted && !Aborted)
>>>> 13   {
>>>> 14     Halted  = DebugStep(P, I);
>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>> 16   }
>>>> 17   return !Aborted;
>>>> 18 }
>>>
>>> Given
>>>
>>>     void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>
>>> The confounding example for Halts is the computation
>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>
>> Halts(Confound_Halts, Confound_Halts) returns false.
> 
> But Confound_Halts(Confound_Halts) is a finite computation, so that's
> the wrong answer (as you know perfectly well).
> 

You start with the assumption: "Pete is wrong".
Based on this assumption you conclude that Pete is wrong".
You make sure to always skip all the steps in-between.

The first step of proof that "Pete is right" is understanding that 
H_Hat() never receives a return value from DebugStep().


int DebugTrace(u32 N, u32 M)
{
   ((int(*)(int))N)(M);
   return 1;
}


void H_Hat(u32 P)
{
   u32 Aborted = DebugTrace(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}


int main()
{
   u32 P = (u32)H_Hat;
   DebugTrace(P, P);
   HALT;
}



-- 
Copyright 2020 Pete Olcott

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

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


#25983 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 18:35 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<0TBvH.159998$gR8.40967@fx45.iad>
In reply to#25977
On 11/25/20 5:25 PM, olcott wrote:
> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>> specified
>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>> correct
>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>> trace.
>>>>>>>>
>>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying
>>>>>>>> or dumb,
>>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>>
>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>> DebugTrace()
>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>> exactly
>>>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>> built on a
>>>>>>>> finite decider.
>>>>>>>>
>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>> you have
>>>>>>>> anything that even resembles a decider.  But it's not a halt
>>>>>>>> decider,
>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>> incorrectly.
>>>>>>>
>>>>>>> No it does not and you know that it does not.
>>>>>>
>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>
>>>>> The simplified code that I posted never has been the actual code. The
>>>>> actual code is far too complex to use as an example.
>>>>>
>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>> multi-tasking operating system. This was the most difficult part of
>>>>> the development whole x86utm operating system.
>>>>
>>>> (And line 15 is harder still.  It's either impossible or it must get an
>>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>>> happy to assume that it is 100% accurate -- no false positives or
>>>> negatives.)
>>>>
>>>>> 08 bool Halts(u32 P, u32 I)
>>>>> 09 {
>>>>> 10   bool Halted  = false;
>>>>> 11   bool Aborted = false;
>>>>> 12   while (!Halted && !Aborted)
>>>>> 13   {
>>>>> 14     Halted  = DebugStep(P, I);
>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>> 16   }
>>>>> 17   return !Aborted;
>>>>> 18 }
>>>>
>>>> Given
>>>>
>>>>     void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>
>>>> The confounding example for Halts is the computation
>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>
>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>
>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>> the wrong answer (as you know perfectly well).
>>
> 
> You start with the assumption: "Pete is wrong".
> Based on this assumption you conclude that Pete is wrong".
> You make sure to always skip all the steps in-between.

The counter does NOT start with the assumption of Pete is wrong, the
counter starts with the knowledge that we have a test we can run to see
what happens, (And happens to know one that this Halts will fail), and
then runs the test and sees the failure.

> 
> The first step of proof that "Pete is right" is understanding that
> H_Hat() never receives a return value from DebugStep().
> 

But it isn't Confounds_Halts problem that Halts never gave its answer in
its emulation to those that needed it for Halts to figure the answer. It
is Halts problem to figure out how to do it, and it did it wrong.

Yes, you 'proof' seems to start with the (baseless) assumption that you
have the right answer, but never establishes that there even is one.

> 
> int DebugTrace(u32 N, u32 M)
> {
>   ((int(*)(int))N)(M);
>   return 1;
> }
> 
> 
> void H_Hat(u32 P)
> {
>   u32 Aborted = DebugTrace(P, P);
>   if (Aborted)
>     HALT
>   else
>     HERE: goto HERE;
> }
> 
> 
> int main()
> {
>   u32 P = (u32)H_Hat;
>   DebugTrace(P, P);
>   HALT;
> }
> 
> 
> 

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


#25986 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 17:59 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<edGdnZFDhqBRciPCnZ2dnUU7-fnNnZ2d@giganews.com>
In reply to#25983
On 11/25/2020 5:35 PM, Richard Damon wrote:
> On 11/25/20 5:25 PM, olcott wrote:
>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>> specified
>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>> correct
>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>> trace.
>>>>>>>>>
>>>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying
>>>>>>>>> or dumb,
>>>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>>>
>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>> DebugTrace()
>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>> exactly
>>>>>>>>> the wrong basis for a halt decider.  Its the version that makes the
>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>>> built on a
>>>>>>>>> finite decider.
>>>>>>>>>
>>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>>> you have
>>>>>>>>> anything that even resembles a decider.  But it's not a halt
>>>>>>>>> decider,
>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>> incorrectly.
>>>>>>>>
>>>>>>>> No it does not and you know that it does not.
>>>>>>>
>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>
>>>>>> The simplified code that I posted never has been the actual code. The
>>>>>> actual code is far too complex to use as an example.
>>>>>>
>>>>>> Line 14 requires an enormously complex set up to enable x86utm to be a
>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>> the development whole x86utm operating system.
>>>>>
>>>>> (And line 15 is harder still.  It's either impossible or it must get an
>>>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>> negatives.)
>>>>>
>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>> 09 {
>>>>>> 10   bool Halted  = false;
>>>>>> 11   bool Aborted = false;
>>>>>> 12   while (!Halted && !Aborted)
>>>>>> 13   {
>>>>>> 14     Halted  = DebugStep(P, I);
>>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>>> 16   }
>>>>>> 17   return !Aborted;
>>>>>> 18 }
>>>>>
>>>>> Given
>>>>>
>>>>>      void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>
>>>>> The confounding example for Halts is the computation
>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>> determined by the function call Halts(Confound_Halts, Confound_Halts).
>>>>
>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>
>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>> the wrong answer (as you know perfectly well).
>>>
>>
>> You start with the assumption: "Pete is wrong".
>> Based on this assumption you conclude that Pete is wrong".
>> You make sure to always skip all the steps in-between.
> 
> The counter does NOT start with the assumption of Pete is wrong, the

Both Ben and Jeff start with the assumption that "Pete is wrong" and 
from this assumption they conclude that "Pete is wrong" making sure to 
avoid any reasoning in-between.

> counter starts with the knowledge that we have a test we can run to see
> what happens, (And happens to know one that this Halts will fail), and
> then runs the test and sees the failure.

In your case my examples were not written clearly enough.

>>
>> The first step of proof that "Pete is right" is understanding that
>> H_Hat() never receives a return value from DebugStep().
>>
> 
> But it isn't Confounds_Halts problem that Halts never gave its answer in

Again I tell you that the relationship between Halts() and H_Hat is the 
same as the relationship between DebugTrace() and H_Hat.

H_Hat never gets any answer from either one of them entirely on the 
basis the a fault of H_Hat.

> its emulation to those that needed it for Halts to figure the answer. It
> is Halts problem to figure out how to do it, and it did it wrong.
> 
> Yes, you 'proof' seems to start with the (baseless) assumption that you
> have the right answer, but never establishes that there even is one.
> 
>>
>> int DebugTrace(u32 N, u32 M)
>> {
>>    ((int(*)(int))N)(M);
>>    return 1;
>> }
>>
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Aborted = DebugTrace(P, P);
>>    if (Aborted)
>>      HALT
>>    else
>>      HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>>    u32 P = (u32)H_Hat;
>>    DebugTrace(P, P);
>>    HALT;
>> }
>>
>>
>>
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25993 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 19:55 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<c2DvH.160002$gR8.79102@fx45.iad>
In reply to#25986
On 11/25/20 6:59 PM, olcott wrote:
> On 11/25/2020 5:35 PM, Richard Damon wrote:
>> On 11/25/20 5:25 PM, olcott wrote:
>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>>> specified
>>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>>> correct
>>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>>> trace.
>>>>>>>>>>
>>>>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying
>>>>>>>>>> or dumb,
>>>>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>>>>
>>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>>> DebugTrace()
>>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>>> exactly
>>>>>>>>>> the wrong basis for a halt decider.  Its the version that
>>>>>>>>>> makes the
>>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>>>> built on a
>>>>>>>>>> finite decider.
>>>>>>>>>>
>>>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>>>> you have
>>>>>>>>>> anything that even resembles a decider.  But it's not a halt
>>>>>>>>>> decider,
>>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>>> incorrectly.
>>>>>>>>>
>>>>>>>>> No it does not and you know that it does not.
>>>>>>>>
>>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>>
>>>>>>> The simplified code that I posted never has been the actual code.
>>>>>>> The
>>>>>>> actual code is far too complex to use as an example.
>>>>>>>
>>>>>>> Line 14 requires an enormously complex set up to enable x86utm to
>>>>>>> be a
>>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>>> the development whole x86utm operating system.
>>>>>>
>>>>>> (And line 15 is harder still.  It's either impossible or it must
>>>>>> get an
>>>>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>>> negatives.)
>>>>>>
>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>> 09 {
>>>>>>> 10   bool Halted  = false;
>>>>>>> 11   bool Aborted = false;
>>>>>>> 12   while (!Halted && !Aborted)
>>>>>>> 13   {
>>>>>>> 14     Halted  = DebugStep(P, I);
>>>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>>>> 16   }
>>>>>>> 17   return !Aborted;
>>>>>>> 18 }
>>>>>>
>>>>>> Given
>>>>>>
>>>>>>      void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>
>>>>>> The confounding example for Halts is the computation
>>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>>> determined by the function call Halts(Confound_Halts,
>>>>>> Confound_Halts).
>>>>>
>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>
>>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>>> the wrong answer (as you know perfectly well).
>>>>
>>>
>>> You start with the assumption: "Pete is wrong".
>>> Based on this assumption you conclude that Pete is wrong".
>>> You make sure to always skip all the steps in-between.
>>
>> The counter does NOT start with the assumption of Pete is wrong, the
> 
> Both Ben and Jeff start with the assumption that "Pete is wrong" and
> from this assumption they conclude that "Pete is wrong" making sure to
> avoid any reasoning in-between.

But I am not they (not sure they really are starting that way either).

We all start KNOWING you are wrong, but the arguements aren't based on
that. Otherwise the response would just be Linz says your wrong.
> 
>> counter starts with the knowledge that we have a test we can run to see
>> what happens, (And happens to know one that this Halts will fail), and
>> then runs the test and sees the failure.
> 
> In your case my examples were not written clearly enough.

Since ultimately, to my understand, you really only have one 'example'
of a Halting Decider you need to present, so all you really need to do
is show it.

A big part of the issue is that you want to try to first reason out with
people so they will accept your arguements before you want to let them
test you decider. The problem is that they don't need to accept your
logic to test it, the just need to know what it actually does.

Now, if you were to change your tack and accept that you are not
thinking of the same halting problem that everyone else uses, make that
clear to everyone, and by doing so accept that you results aren't
applicable to anything that wants the classic halting problem, then you
would need to explain your ideas about why and what and really define
the problem you are trying to solve.

One big piece of that is that if you are no longer working on the
classical halting problem, Linz can just go away if you define your
problem right. This sort of seems what you are trying to do, only you
aren't accepting that you are doing a different problem.

You CAN'T just define yourself around Linz and still be doing the
classical halting problem.

> 
>>>
>>> The first step of proof that "Pete is right" is understanding that
>>> H_Hat() never receives a return value from DebugStep().
>>>
>>
>> But it isn't Confounds_Halts problem that Halts never gave its answer in
> 
> Again I tell you that the relationship between Halts() and H_Hat is the
> same as the relationship between DebugTrace() and H_Hat.
> 
> H_Hat never gets any answer from either one of them entirely on the
> basis the a fault of H_Hat.

Since it is Halts responsibility to give an answer to any and every
quetion posed to it, it gets hard to blame the lowly input that just
came to be tested.

> 
>> its emulation to those that needed it for Halts to figure the answer. It
>> is Halts problem to figure out how to do it, and it did it wrong.
>>
>> Yes, you 'proof' seems to start with the (baseless) assumption that you
>> have the right answer, but never establishes that there even is one.
>>
>>>
>>> int DebugTrace(u32 N, u32 M)
>>> {
>>>    ((int(*)(int))N)(M);
>>>    return 1;
>>> }
>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Aborted = DebugTrace(P, P);
>>>    if (Aborted)
>>>      HALT
>>>    else
>>>      HERE: goto HERE;
>>> }
>>>
>>>
>>> int main()
>>> {
>>>    u32 P = (u32)H_Hat;
>>>    DebugTrace(P, P);
>>>    HALT;
>>> }
>>>
>>>
>>>
>>
> 
> 

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


#25995 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 19:03 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<0NmdnQTOBvJLYyPCnZ2dnUU7-YOdnZ2d@giganews.com>
In reply to#25993
On 11/25/2020 6:55 PM, Richard Damon wrote:
> On 11/25/20 6:59 PM, olcott wrote:
>> On 11/25/2020 5:35 PM, Richard Damon wrote:
>>> On 11/25/20 5:25 PM, olcott wrote:
>>>> On 11/25/2020 4:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/24/2020 6:16 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 11/24/2020 9:53 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 11/23/2020 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> All that I have right now is a DebugTrace() of all the user
>>>>>>>>>>>> specified
>>>>>>>>>>>> code. This provides a very obvious basis for a halt decider's
>>>>>>>>>>>> correct
>>>>>>>>>>>> halting decision of the H_Hat code specified in this execution
>>>>>>>>>>>> trace.
>>>>>>>>>>>
>>>>>>>>>>> Gosh.  Is that a lie, or is that just very, very stupid?  Lying
>>>>>>>>>>> or dumb,
>>>>>>>>>>> dumb or lying?  I can never quite tell.
>>>>>>>>>>>
>>>>>>>>>>> Having only the code that loops around the single stepping
>>>>>>>>>>> DebugTrace()
>>>>>>>>>>> (presumably a simple modification to someone else's emulator) is
>>>>>>>>>>> exactly
>>>>>>>>>>> the wrong basis for a halt decider.  Its the version that
>>>>>>>>>>> makes the
>>>>>>>>>>> "Hat" computation non-finite BY NOT BEING A DECIDER.  The "HAT"
>>>>>>>>>>> computation you are analysing is irrelevant because it's not
>>>>>>>>>>> built on a
>>>>>>>>>>> finite decider.
>>>>>>>>>>>
>>>>>>>>>>> Only when you add the impossible "abort if needed" code would
>>>>>>>>>>> you have
>>>>>>>>>>> anything that even resembles a decider.  But it's not a halt
>>>>>>>>>>> decider,
>>>>>>>>>>> because that code has ITS OWN "HAT" computation which it decides
>>>>>>>>>>> incorrectly.
>>>>>>>>>>
>>>>>>>>>> No it does not and you know that it does not.
>>>>>>>>>
>>>>>>>>> If you dare post the code, I'll show you, explicitly (again).
>>>>>>>>
>>>>>>>> The simplified code that I posted never has been the actual code.
>>>>>>>> The
>>>>>>>> actual code is far too complex to use as an example.
>>>>>>>>
>>>>>>>> Line 14 requires an enormously complex set up to enable x86utm to
>>>>>>>> be a
>>>>>>>> multi-tasking operating system. This was the most difficult part of
>>>>>>>> the development whole x86utm operating system.
>>>>>>>
>>>>>>> (And line 15 is harder still.  It's either impossible or it must
>>>>>>> get an
>>>>>>> infinity of cases wrong.  Curiously, though, it doesn't matter.  I am
>>>>>>> happy to assume that it is 100% accurate -- no false positives or
>>>>>>> negatives.)
>>>>>>>
>>>>>>>> 08 bool Halts(u32 P, u32 I)
>>>>>>>> 09 {
>>>>>>>> 10   bool Halted  = false;
>>>>>>>> 11   bool Aborted = false;
>>>>>>>> 12   while (!Halted && !Aborted)
>>>>>>>> 13   {
>>>>>>>> 14     Halted  = DebugStep(P, I);
>>>>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>>>>> 16   }
>>>>>>>> 17   return !Aborted;
>>>>>>>> 18 }
>>>>>>>
>>>>>>> Given
>>>>>>>
>>>>>>>       void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>>>>>
>>>>>>> The confounding example for Halts is the computation
>>>>>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>>>>>> determined by the function call Halts(Confound_Halts,
>>>>>>> Confound_Halts).
>>>>>>
>>>>>> Halts(Confound_Halts, Confound_Halts) returns false.
>>>>>
>>>>> But Confound_Halts(Confound_Halts) is a finite computation, so that's
>>>>> the wrong answer (as you know perfectly well).
>>>>>
>>>>
>>>> You start with the assumption: "Pete is wrong".
>>>> Based on this assumption you conclude that Pete is wrong".
>>>> You make sure to always skip all the steps in-between.
>>>
>>> The counter does NOT start with the assumption of Pete is wrong, the
>>
>> Both Ben and Jeff start with the assumption that "Pete is wrong" and
>> from this assumption they conclude that "Pete is wrong" making sure to
>> avoid any reasoning in-between.
> 
> But I am not they (not sure they really are starting that way either).
> 
> We all start KNOWING you are wrong, but the arguements aren't based on
> that. Otherwise the response would just be Linz says your wrong.
>>
>>> counter starts with the knowledge that we have a test we can run to see
>>> what happens, (And happens to know one that this Halts will fail), and
>>> then runs the test and sees the failure.
>>
>> In your case my examples were not written clearly enough.
> 
> Since ultimately, to my understand, you really only have one 'example'
> of a Halting Decider you need to present, so all you really need to do
> is show it.
> 
> A big part of the issue is that you want to try to first reason out with
> people so they will accept your arguements before you want to let them
> test you decider. The problem is that they don't need to accept your
> logic to test it, the just need to know what it actually does.
> 
> Now, if you were to change your tack and accept that you are not
> thinking of the same halting problem that everyone else uses, make that
> clear to everyone, and by doing so accept that you results aren't
> applicable to anything that wants the classic halting problem, then you
> would need to explain your ideas about why and what and really define
> the problem you are trying to solve.
> 
> One big piece of that is that if you are no longer working on the
> classical halting problem, Linz can just go away if you define your
> problem right. This sort of seems what you are trying to do, only you
> aren't accepting that you are doing a different problem.
> 
> You CAN'T just define yourself around Linz and still be doing the
> classical halting problem.
> 
>>
>>>>
>>>> The first step of proof that "Pete is right" is understanding that
>>>> H_Hat() never receives a return value from DebugStep().
>>>>
>>>
>>> But it isn't Confounds_Halts problem that Halts never gave its answer in
>>
>> Again I tell you that the relationship between Halts() and H_Hat is the
>> same as the relationship between DebugTrace() and H_Hat.
>>
>> H_Hat never gets any answer from either one of them entirely on the
>> basis the a fault of H_Hat.
> 
> Since it is Halts responsibility to give an answer to any and every
> quetion posed to it, it gets hard to blame the lowly input that just
> came to be tested.
> 

Clearly you have a fundamental lack of understanding of infinite 
recursion.

>>
>>> its emulation to those that needed it for Halts to figure the answer. It
>>> is Halts problem to figure out how to do it, and it did it wrong.
>>>
>>> Yes, you 'proof' seems to start with the (baseless) assumption that you
>>> have the right answer, but never establishes that there even is one.
>>>
>>>>
>>>> int DebugTrace(u32 N, u32 M)
>>>> {
>>>>     ((int(*)(int))N)(M);
>>>>     return 1;
>>>> }
>>>>
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>>     u32 Aborted = DebugTrace(P, P);
>>>>     if (Aborted)
>>>>       HALT
>>>>     else
>>>>       HERE: goto HERE;
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>>     u32 P = (u32)H_Hat;
>>>>     DebugTrace(P, P);
>>>>     HALT;
>>>> }
>>>>
>>>>
>>>>
>>>
>>
>>
> 


-- 
Copyright 2020 Pete Olcott

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

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


#26009 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 21:55 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<TOEvH.65056$J92.17423@fx48.iad>
In reply to#25995
On 11/25/20 8:03 PM, olcott wrote:
> On 11/25/2020 6:55 PM, Richard Damon wrote:

>
>> Since it is Halts responsibility to give an answer to any and every
>> quetion posed to it, it gets hard to blame the lowly input that just
>> came to be tested.
>>
> 
> Clearly you have a fundamental lack of understanding of infinite recursion.

I have no problems understanding infinite recursion, what you seem to
miss is that when the halt decider is in the loop,it can be the need
break of the recursion that keeps H_Hat from being non-halting (and is
relying on the finite execution requirements on the Halt Decider).

It is the Halt Deciders problem with figuring out how to decide this
case that causing the issues.

An 'infinite recursion' that happens inside the 'must be finite' call to
the halt decider does NOT allow a higher level halts decider to call
this H_Hat non-halting.


Lets draw a simple execution nesting tree:

1) A call to Halts(P, I)

2) P(I) exeuctes, and in it

3) calls Halts(P1, I1)

4) P1(I1) executes, which maybe

5) calls Halts(P2, I2)
...


Any non-halting behavior at inside level 3 or 4 can not be used as a
reason to call level 2 non-halting, because each call to Halts is
required to be of finite execution, so it is Halts reponsibility to
resolve any such infinite execution and still return the right answer.


Remember Halts is claimed to be a UNIVERSAL Halt Decider, thus is says
it is willing to take on all comers, even those who in its mind are
cheating.

For the call the Halts at layer 1 to call its input non-halting, it
needs to find the non-halting behavior IN layer 2.

Now if layer 2 calls layer 3 an infinite number of times (not recursive
but iterative) then that iteration loop will be in layer 2 and can be
cause to call P(I) non-halting.

Note it also doesn't matter if P==P1 and I==I1, the execution at layer 4
is distinct, and NO non-halting behavior there can cause P(I) in layer 2
to be non-halting.

One of the problems with your algorithm is that you are detecting the
infinite recursion at layers 3 or 4, and then using that to say that
this is evidence of P(I) at layer 2 is non-halting, when actually either
the Halts at layer 3 will catch the problem and abort the looping, or
the Halts will fail to meet is requirement of making its decision in
finite time

While in the second case, it IS true that P(I) was a non-halting
computation, Halts has still shown itself to fail to meet its requirements.

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


#26012 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 21:06 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<DdOdna35_s86hiLCnZ2dnUU7-ImdnZ2d@giganews.com>
In reply to#26009
On 11/25/2020 8:55 PM, Richard Damon wrote:
> On 11/25/20 8:03 PM, olcott wrote:
>> On 11/25/2020 6:55 PM, Richard Damon wrote:
> 
>>
>>> Since it is Halts responsibility to give an answer to any and every
>>> quetion posed to it, it gets hard to blame the lowly input that just
>>> came to be tested.
>>>
>>
>> Clearly you have a fundamental lack of understanding of infinite recursion.
> 
> I have no problems understanding infinite recursion, what you seem to
> miss is that when the halt decider is in the loop,it can be the need
> break of the recursion that keeps H_Hat from being non-halting (and is
> relying on the finite execution requirements on the Halt Decider).
> 
> It is the Halt Deciders problem with figuring out how to decide this
> case that causing the issues.
> 
> An 'infinite recursion' that happens inside the 'must be finite' call to
> the halt decider does NOT allow a higher level halts decider to call
> this H_Hat non-halting.
> 
> 
> Lets draw a simple execution nesting tree:
> 
> 1) A call to Halts(P, I)
> 
> 2) P(I) exeuctes, and in it
> 
> 3) calls Halts(P1, I1)
> 
> 4) P1(I1) executes, which maybe
> 
> 5) calls Halts(P2, I2)
> ...

void H_Hat(u32 P)
{
   u32 Aborted = Halts(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}

int main()
{
   u32 P = (u32)H_Hat;
   Halts(P, P);
   HALT;
}

There is only one reasonable choice here. The Halts in main() aborts H_Hat.


-- 
Copyright 2020 Pete Olcott

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

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


#26015 — Re: It is known that a correct halt decider must return false (in this case)[V4](Step 1)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 22:34 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V4](Step 1)
Message-ID<0nFvH.65057$J92.9800@fx48.iad>
In reply to#26012
On 11/25/20 10:06 PM, olcott wrote:
> On 11/25/2020 8:55 PM, Richard Damon wrote:
>> On 11/25/20 8:03 PM, olcott wrote:
>>> On 11/25/2020 6:55 PM, Richard Damon wrote:
>>
>>>
>>>> Since it is Halts responsibility to give an answer to any and every
>>>> quetion posed to it, it gets hard to blame the lowly input that just
>>>> came to be tested.
>>>>
>>>
>>> Clearly you have a fundamental lack of understanding of infinite
>>> recursion.
>>
>> I have no problems understanding infinite recursion, what you seem to
>> miss is that when the halt decider is in the loop,it can be the need
>> break of the recursion that keeps H_Hat from being non-halting (and is
>> relying on the finite execution requirements on the Halt Decider).
>>
>> It is the Halt Deciders problem with figuring out how to decide this
>> case that causing the issues.
>>
>> An 'infinite recursion' that happens inside the 'must be finite' call to
>> the halt decider does NOT allow a higher level halts decider to call
>> this H_Hat non-halting.
>>
>>
>> Lets draw a simple execution nesting tree:
>>
>> 1) A call to Halts(P, I)
>>
>> 2) P(I) exeuctes, and in it
>>
>> 3) calls Halts(P1, I1)
>>
>> 4) P1(I1) executes, which maybe
>>
>> 5) calls Halts(P2, I2)
>> ...
> 
> void H_Hat(u32 P)
> {
>   u32 Aborted = Halts(P, P);
>   if (Aborted)
>     HALT
>   else
>     HERE: goto HERE;
> }
> 
> int main()
> {
>   u32 P = (u32)H_Hat;
>   Halts(P, P);
>   HALT;
> }
> 
> There is only one reasonable choice here. The Halts in main() aborts H_Hat.
> 
> 

WHICH H_Hat? and is it saying that H_Hat has non-halting behavior?

If it does so, it is WRONG because when it sees the recursion at level 4
above, that recursion has been 'protected' by an intermedary decider
with a finite limit.

This is seens by the running of H_Hat(H_Hat) which will proceed as follows:

1) Enter H_Hat(H_Hat)
2) Call Halts(H_Hat, H_Hat)
3) Halts run, and per above decides that its input is non-halting
4) returns with aborted set true
5) go to else clause
6) Halts

Thus we see that H_Hat(H_Hat) is a halting behavior, which says that
Halts got the answer wrong.

Again, the error is that your detection system misses that there IS a
conditional between every instruction at level 3 and deeper with respect
to deciding if the level 2 program has non-halting behavior.

Becuase there IS a conditional, the rule of a loop/recusion without a
conditional does not apply.

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


Page 9 of 11 — ← Prev page 1 … 7 8 [9] 10 11  Next page →

Back to top | Article view | comp.theory


csiph-web