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


Groups > comp.theory > #25604 > unrolled thread

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

Started byolcott <NoOne@NoWhere.com>
First post2020-11-21 13:19 -0600
Last post2020-11-22 13:14 -0600
Articles 20 on this page of 137 — 8 participants

Back to article view | Back to comp.theory


Contents

  It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 13:19 -0600
    Re: It is known that a correct halt decider must return false (in this case)[V2] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-21 13:06 -0800
      Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 15:35 -0600
    Re: It is known that a correct halt decider must return false (in this case)[V2] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-21 23:46 +0000
      Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-21 18:07 -0600
        Re: It is known that a correct halt decider must return false (in this case)[V2] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-22 01:14 +0000
    Re: It is known that a correct halt decider must return false (in this case)[V2] André G. Isaak <agisaak@gm.invalid> - 2020-11-22 03:48 -0700
      Re: It is known that a correct halt decider must return false (in this case)[V2] olcott <NoOne@NoWhere.com> - 2020-11-22 08:17 -0600
        Re: It is known that a correct halt decider must return false (in this case)[V2] André G. Isaak <agisaak@gm.invalid> - 2020-11-22 07:58 -0700
          Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) olcott <NoOne@NoWhere.com> - 2020-11-22 10:16 -0600
            Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 10:10 -0700
              Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) olcott <NoOne@NoWhere.com> - 2020-11-22 11:47 -0600
                Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 13:14 -0500
                  Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 12:28 -0600
                    Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 13:44 -0500
                      Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 12:56 -0600
                        Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 14:23 -0500
                          Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 13:28 -0600
                            Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 16:21 -0500
                              Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 16:25 -0600
                                Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 18:09 -0500
                                  Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-22 17:35 -0600
                                    Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Richard Damon <Richard@Damon-Family.org> - 2020-11-22 20:03 -0500
                                      Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Alan Mackenzie <acm@muc.de> - 2020-11-23 12:54 +0000
                                        Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-23 07:09 -0600
                                          Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 08:38 -0500
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 07:55 -0600
                                              Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 10:19 -0500
                                                Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 09:52 -0600
                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-23 12:46 -0500
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 08:50 -0600
                                              Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:33 +0000
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:31 +0000
                                          Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:14 +0000
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](actual execution trace) olcott <NoOne@NoWhere.com> - 2020-11-23 12:08 -0600
                    Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 11:50 -0700
                      Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-22 13:04 -0600
                        Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 04:00 -0700
                          Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) olcott <NoOne@NoWhere.com> - 2020-11-23 07:08 -0600
                            Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 08:19 -0700
                              Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 09:49 -0600
                                Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-23 09:44 -0700
                                Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 02:26 +0000
                                  Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-23 21:30 -0600
                                    Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-24 15:22 +0000
                                      Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 09:47 -0600
                                        Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 11:08 -0500
                                          Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 10:33 -0600
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 13:07 -0500
                                        Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 02:49 +0000
                                          Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-24 21:06 -0600
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 22:45 -0500
                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-24 21:58 -0600
                                                Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-24 23:46 -0500
                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-24 23:05 -0600
                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 07:17 -0500
                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 08:02 -0600
                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:01 -0500
                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 09:19 -0600
                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 10:55 -0500
                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 11:37 -0600
                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 13:03 -0500
                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 12:13 -0600
                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 14:27 -0500
                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 13:33 -0600
                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 14:46 -0500
                                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 14:16 -0600
                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 21:05 +0000
                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 15:24 -0600
                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 17:32 -0500
                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 17:18 -0600
                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:19 -0500
                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 20:55 +0000
                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 18:26 -0500
                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 00:26 +0000
                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 18:49 -0600
                                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 20:30 -0500
                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 20:43 -0600
                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:18 -0500
                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 04:12 +0000
                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 22:30 -0600
                                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 09:22 -0500
                                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) olcott <NoOne@NoWhere.com> - 2020-11-26 08:33 -0600
                                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 10:43 -0500
                                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) olcott <NoOne@NoWhere.com> - 2020-11-26 09:49 -0600
                                                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 09:09 -0800
                                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 17:21 +0000
                                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 11:50 -0600
                                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 10:29 -0800
                                                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 12:41 -0600
                                                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 13:47 -0500
                                                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 13:07 -0600
                                                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 16:02 -0500
                                                                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 15:12 -0600
                                                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 13:42 -0800
                                                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 15:56 -0600
                                                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-26 14:14 -0800
                                                                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 16:20 -0600
                                                                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 19:11 -0500
                                                                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 18:25 -0600
                                                                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 20:17 -0500
                                                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 17:22 -0500
                                                                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 16:34 -0600
                                                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 18:09 -0500
                                                                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 17:16 -0600
                                                                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 19:06 -0500
                                                                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 18:10 -0600
                                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 23:11 +0000
                                                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 17:41 -0600
                                                                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 01:34 +0000
                                                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself) olcott <NoOne@NoWhere.com> - 2020-11-26 20:45 -0600
                                                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:09 +0000
                                                                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself [verified]) olcott <NoOne@NoWhere.com> - 2020-11-27 12:14 -0600
                                                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution) olcott <NoOne@NoWhere.com> - 2020-11-26 11:58 -0600
                                                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 13:21 -0500
                                                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](ridiculous) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-26 16:35 +0000
                                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood) olcott <NoOne@NoWhere.com> - 2020-11-26 08:26 -0600
                                                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood) Richard Damon <Richard@Damon-Family.org> - 2020-11-26 10:51 -0500
                                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 19:10 -0600
                                                Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 16:16 +0000
                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 10:44 -0600
                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 18:55 +0000
                                                      Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 13:24 -0600
                                                        Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-25 19:43 +0000
                                                          Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 14:09 -0600
                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Jeff Barnett <jbb@notatt.com> - 2020-11-25 14:30 -0700
                                                            Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 21:24 -0500
                                                              Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) olcott <NoOne@NoWhere.com> - 2020-11-25 21:03 -0600
                                                                Re: It is known that a correct halt decider must return false (in this case)[V2](no difference) Richard Damon <Richard@Damon-Family.org> - 2020-11-25 22:52 -0500
                                            Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-25 21:53 +0000
                                              Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-25 16:07 -0600
                                                Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-26 02:21 +0000
                                                  Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) olcott <NoOne@NoWhere.com> - 2020-11-25 20:50 -0600
                                                    Re: It is known that a correct halt decider must return false (in this case)[V2](obvious facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-27 17:02 +0000
                            Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-23 17:34 +0000
                Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back) André G. Isaak <agisaak@gm.invalid> - 2020-11-22 12:03 -0700
                  Re: It is known that a correct halt decider must return false (in this case)[V2](black cats are black) olcott <NoOne@NoWhere.com> - 2020-11-22 13:14 -0600

Page 1 of 7  [1] 2 3 4 5 6 7  Next page →


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-21 13:19 -0600
SubjectIt is known that a correct halt decider must return false (in this case)[V2]
Message-ID<uoGdnQXanKOz9STCnZ2dnUU7-XnNnZ2d@giganews.com>
(1) It is known that the UTM simulation of a machine's Turing machine 
description is equivalent to directly executing it.


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


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 }


19 int main()
20  {
21    u32 P = (u32)H_Hat;
22    Halts(P, P);
23    HALT;
24  }


(2) It is known that the above code is infinitely recursive if Halts() 
acts like a UTM (by having its line 15 disabled) and simulates its input 
returning true if and only if its input halts.

(3) On the basis of (1) and (2) It is known that a correct halt decider 
(without line 15 disabled) must return false.

-- 
Copyright 2020 Pete Olcott

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

[toc] | [next] | [standalone]


#25611

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-11-21 13:06 -0800
Message-ID<266fc6d3-8e9e-4482-a927-a623ae0abe05n@googlegroups.com>
In reply to#25604
On Saturday, 21 November 2020 at 19:19:18 UTC, olcott wrote:
> (1) It is known that the UTM simulation of a machine's Turing machine 
> description is equivalent to directly executing it. 
> 
> 
> 01 void H_Hat(u32 P) 
> 02 { 
> 03 if (H(P, P)) 
> 04 HERE: goto HERE; 
> 05 else 
> 06 HALT 
> 07 } 
> 
> 
> 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 } 
> 
> 
> 19 int main() 
> 20 { 
> 21 u32 P = (u32)H_Hat; 
> 22 Halts(P, P); 
> 23 HALT; 
> 24 } 
> 
> 
> (2) It is known that the above code is infinitely recursive if Halts() 
> acts like a UTM (by having its line 15 disabled) and simulates its input 
> returning true if and only if its input halts. 
> 
> (3) On the basis of (1) and (2) It is known that a correct halt decider 
> (without line 15 disabled) must return false. 
> 
You need to disable the line when H_Hat() is run directly, but not when
Halt() is called directly.
THen you get consistent results.

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


#25613

Fromolcott <NoOne@NoWhere.com>
Date2020-11-21 15:35 -0600
Message-ID<xPadnRHFgriwFSTCnZ2dnUU7-cPNnZ2d@giganews.com>
In reply to#25611
On 11/21/2020 3:06 PM, Malcolm McLean wrote:
> On Saturday, 21 November 2020 at 19:19:18 UTC, olcott wrote:
>> (1) It is known that the UTM simulation of a machine's Turing machine
>> description is equivalent to directly executing it.
>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 if (H(P, P))
>> 04 HERE: goto HERE;
>> 05 else
>> 06 HALT
>> 07 }
>>
>>
>> 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 }
>>
>>
>> 19 int main()
>> 20 {
>> 21 u32 P = (u32)H_Hat;
>> 22 Halts(P, P);
>> 23 HALT;
>> 24 }
>>
>>
>> (2) It is known that the above code is infinitely recursive if Halts()
>> acts like a UTM (by having its line 15 disabled) and simulates its input
>> returning true if and only if its input halts.
>>
>> (3) On the basis of (1) and (2) It is known that a correct halt decider
>> (without line 15 disabled) must return false.
>>
> You need to disable the line when H_Hat() is run directly, but not when
> Halt() is called directly.
> THen you get consistent results.
> 

Bullshit on that. All that does is force the halt decider to give the 
wrong answer some of the time.

It is just like you are saying to see how well your car really runs we 
cannot simply just run the car we have to take out one of the spark 
plugs first.

The Turing machine description of H_Hat() is either simulated by the 
halt decider or simulated by a machine that is not a halt decider.

That the second case never halts proves by definition that the not 
halting decision of the first case was necessary correct.




-- 
Copyright 2020 Pete Olcott

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

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


#25619

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-21 23:46 +0000
Message-ID<87k0ueuvcb.fsf@bsb.me.uk>
In reply to#25604
olcott <NoOne@NoWhere.com> writes:

> (1) It is known that the UTM simulation of a machine's Turing machine description is equivalent to directly executing it.
>
>
> 01 void H_Hat(u32 P)
> 02 {
> 03   if (H(P, P))
> 04     HERE: goto HERE;
> 05   else
> 06     HALT
> 07 }

You've got this the right way round now.  When I told you you'd got it
wrong before you basically accused me of lying.  And the name at least
makes sense this time.  But it references an unknown function.  Is that
a deliberate sleight of hand or just the fact that you don't do details?

> 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 }
>
>
> 19 int main()
> 20  {
> 21    u32 P = (u32)H_Hat;
> 22    Halts(P, P);
> 23    HALT;
> 24  }

The program is incomplete as there is no H.  (We know, in outline, what
the other two missing functions are supposed to do.)  Is that just a
random cutting and pasting error, or was it deliberate?

> (2) It is known that the above code is infinitely recursive if Halts()
> acts like a UTM (by having its line 15 disabled) and simulates its
> input returning true if and only if its input halts.

If H always returns false, line 22 should behave the same regardless of
whether line 15 is there or not.

> (3) On the basis of (1) and (2) It is known that a correct halt
> decider (without line 15 disabled) must return false.

How can you claim to know what the right answer is since you don't show
us what H is.

Bottom line: is "Halts" your claimed halt decider?  If so, why post it
again since you've been shown, over and over, one of the infinity of
cases it gets wrong?

-- 
Ben.

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


#25623

Fromolcott <NoOne@NoWhere.com>
Date2020-11-21 18:07 -0600
Message-ID<kYidnRJqBY1YNiTCnZ2dnUU7-VHNnZ2d@giganews.com>
In reply to#25619
On 11/21/2020 5:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> (1) It is known that the UTM simulation of a machine's Turing machine description is equivalent to directly executing it.
>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {

fixed typo
>> 03   if (Halts(P, P))
>> 04     HERE: goto HERE;
>> 05   else
>> 06     HALT
>> 07 }
> 
> You've got this the right way round now.  When I told you you'd got it
> wrong before you basically accused me of lying. 

If people saw their typos they wouldn't make them.

> And the name at least
> makes sense this time.  But it references an unknown function.  Is that
> a deliberate sleight of hand or just the fact that you don't do details?

typo corrected above and in V3.

>> 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 }
>>
>>
>> 19 int main()
>> 20  {
>> 21    u32 P = (u32)H_Hat;
>> 22    Halts(P, P);
>> 23    HALT;
>> 24  }
> 
> The program is incomplete as there is no H.  (We know, in outline, what
> the other two missing functions are supposed to do.)  Is that just a
> random cutting and pasting error, or was it deliberate?

It was a typo that is now corrected here and in V3.

>> (2) It is known that the above code is infinitely recursive if Halts()
>> acts like a UTM (by having its line 15 disabled) and simulates its
>> input returning true if and only if its input halts.
> 
> If H always returns false, line 22 should behave the same regardless of
> whether line 15 is there or not.

H does not exist it was only a typo.

>> (3) On the basis of (1) and (2) It is known that a correct halt
>> decider (without line 15 disabled) must return false.
> 
> How can you claim to know what the right answer is since you don't show
> us what H is.
> 
> Bottom line: is "Halts" your claimed halt decider?  If so, why post it
> again since you've been shown, over and over, one of the infinity of
> cases it gets wrong?
> 

Swicth to V3 it has this typo corrected.

-- 
Copyright 2020 Pete Olcott

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

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


#25630

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-22 01:14 +0000
Message-ID<875z5yur90.fsf@bsb.me.uk>
In reply to#25623
olcott <NoOne@NoWhere.com> writes:

> On 11/21/2020 5:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> (1) It is known that the UTM simulation of a machine's Turing machine description is equivalent to directly executing it.
>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>
> fixed typo
>>> 03   if (Halts(P, P))
>>> 04     HERE: goto HERE;
>>> 05   else
>>> 06     HALT
>>> 07 }
>>
>> You've got this the right way round now.  When I told you you'd got it
>> wrong before you basically accused me of lying. 
>
> If people saw their typos they wouldn't make them.

Next time you think I am lying, mad or playing head games, just remember
how many times you've had to admit I was right.

-- 
Ben.

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


#25651

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-22 03:48 -0700
Message-ID<rpdflh$g15$1@dont-email.me>
In reply to#25604
On 2020-11-21 12:19, olcott wrote:
> (1) It is known that the UTM simulation of a machine's Turing machine 
> description is equivalent to directly executing it.
> 
> 
> 01 void H_Hat(u32 P)
> 02 {
> 03   if (H(P, P))
> 04     HERE: goto HERE;
> 05   else
> 06     HALT
> 07 }
> 
> 
> 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 }
> 
> 
> 19 int main()
> 20  {
> 21    u32 P = (u32)H_Hat;
> 22    Halts(P, P);
> 23    HALT;
> 24  }
> 
> 
> (2) It is known that the above code is infinitely recursive if Halts() 
> acts like a UTM (by having its line 15 disabled) and simulates its input 
> returning true if and only if its input halts.
> 
> (3) On the basis of (1) and (2) It is known that a correct halt decider 
> (without line 15 disabled) must return false.

You need to stop conflating two different functions and calling both of 
them Halt().

You have your Halt decider:

bool Halts(u32 P, u32 I) {
     bool Halted  = false;
     bool Aborted = false;
     while (!Halted && !Aborted) {
         Halted  = DebugStep(P, I);
         Aborted = Needs_To_Be_Aborted();
     }
     return !Aborted;
}

And then you have your Simulator derived from Halt() by removing line 15:

bool Simulate(u32 P, u32 I) {
     bool Halted  = false;
     bool Aborted = false;
     while (!Halted && !Aborted) {
         Halted  = DebugStep(P, I);
     }
     return !Aborted;
}

Though of course your simulator doesn't really need the return.

These are entirely different functions. Calling both of them Halts() is 
misleading. They do different things, and thus should exist as separate 
functions, either of which could be called by some other routine.

H_Hat in the Linz proof (and other comparable proofs) is defined as a 
function which (in your implementation) invokes a *halt decider*, not a 
*simulator*, so if you insist for arcane reasons that we test the 
behaviour of H_Hat(H_Hat) inside a simulator rather than simply running 
it directly, we would call:

Simulate(H_Hat, H_Hat);

but H_Hat still needs to call Halts(), not Simulate(), because that's 
the computation which H_Hat is defined to perform by Linz.

If you do things your way, by changing from 'halt detection mode' to 
'simulator mode' by removing line 15 from the Halts() function which 
H_Hat also calls, then you are not just altering which 'mode' you are 
in; you are also fundamentally altering the computation performed by 
H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that 
your Halt detector using as input when Halts(H_Hat, H_Hat) is called, 
effectively rendering your test of the behaviour of H_Hat(H_Hat) worthless.

The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe is 
the behaviour of H_Hat(H_Hat) when it is run directly. Not when it is 
run inside a halting detector; not when it is run in a simulator; and 
definitely not when one of the 'Operating System' calls that it relies 
on has been altered to do something else.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#25653

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 08:17 -0600
Message-ID<TfidnQqBC9iS7ifCnZ2dnUU7-SHNnZ2d@giganews.com>
In reply to#25651
On 11/22/2020 4:48 AM, André G. Isaak wrote:
> On 2020-11-21 12:19, olcott wrote:
>> (1) It is known that the UTM simulation of a machine's Turing machine 
>> description is equivalent to directly executing it.
>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03   if (Halts(P, P))
>> 04     HERE: goto HERE;
>> 05   else
>> 06     HALT
>> 07 }
>>
>>
>> 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 }
>>
>>
>> 19 int main()
>> 20  {
>> 21    u32 P = (u32)H_Hat;
>> 22    Halts(P, P);
>> 23    HALT;
>> 24  }
>>
>>
>> (2) It is known that the above code is infinitely recursive if Halts() 
>> acts like a UTM (by having its line 15 disabled) and simulates its 
>> input returning true if and only if its input halts.
>>
>> (3) On the basis of (1) and (2) It is known that a correct halt 
>> decider (without line 15 disabled) must return false.
> 
> You need to stop conflating two different functions and calling both of 
> them Halt().
> 
> You have your Halt decider:
> 
> bool Halts(u32 P, u32 I) {
>      bool Halted  = false;
>      bool Aborted = false;
>      while (!Halted && !Aborted) {
>          Halted  = DebugStep(P, I);
>          Aborted = Needs_To_Be_Aborted();
>      }
>      return !Aborted;
> }
> 
> And then you have your Simulator derived from Halt() by removing line 15:
> 
> bool Simulate(u32 P, u32 I) {
>      bool Halted  = false;
>      bool Aborted = false;
>      while (!Halted && !Aborted) {
>          Halted  = DebugStep(P, I);
>      }
>      return !Aborted;
> }
> 
> Though of course your simulator doesn't really need the return.
> 
> These are entirely different functions. Calling both of them Halts() is 
> misleading. They do different things, and thus should exist as separate 
> functions, either of which could be called by some other routine.

OK, good idea.

> H_Hat in the Linz proof (and other comparable proofs) is defined as a 
> function which (in your implementation) invokes a *halt decider*, not a 
> *simulator*, so if you insist for arcane reasons that we test the 
> behaviour of H_Hat(H_Hat) inside a simulator rather than simply running 
> it directly, we would call:
> 
> Simulate(H_Hat, H_Hat);
> 
> but H_Hat still needs to call Halts(), not Simulate(), because that's 
> the computation which H_Hat is defined to perform by Linz.

The ONLY purpose of the two different functions is to prove that when 
Halts(main, NULL) invokes H_Hat(H_Hat) that it aborts H_Hat at its line 
03 and decides not halting.

When Halts(H_Hat, H_Hat) is called it aborts the first H_Hat at its line 
03. Yet when the Halt deciding ability is removed from Halts both of the 
function calls are now infinitely recursive.

> If you do things your way, by changing from 'halt detection mode' to 
> 'simulator mode' by removing line 15 from the Halts() function which 
> H_Hat also calls, then you are not just altering which 'mode' you are 
> in; you are also fundamentally altering the computation performed by 
> H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that 

It turns out that this is not the case because none of the H_Hat 
computations ever receive any return value from Halts. None of them 
every complete their execution of line 03.

All of the H_Hat(H_Hat) computations are state transition by state 
transition identical. None of them ever complete their line 03.
Those aborted by the decider never repeat, those not aborted by the 
decider infinitely repeat.

> your Halt detector using as input when Halts(H_Hat, H_Hat) is called, 
> effectively rendering your test of the behaviour of H_Hat(H_Hat) worthless.
> 
> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe is 
> the behaviour of H_Hat(H_Hat) when it is run directly. Not when it is 
> run inside a halting detector; not when it is run in a simulator; and 

So you do not understand the computer science that guarantees that the 
direct execution of a TM is equivalent to simulating the TMD of this 
machine by a UTM?

The only equivalent way to specify a recursive function call using 
Turing machines is to define H_Hat to be a UTM that executes its own TMD.

This is a mandatory aspect of the problem otherwise the equivalence 
between the x86utm computation and the Turing machine computation is 
broken.

> definitely not when one of the 'Operating System' calls that it relies 
> on has been altered to do something else.
> 
> André
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25658

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-22 07:58 -0700
Message-ID<rpduaa$k0r$1@dont-email.me>
In reply to#25653
On 2020-11-22 07:17, olcott wrote:
> On 11/22/2020 4:48 AM, André G. Isaak wrote:
>> On 2020-11-21 12:19, olcott wrote:
>>> (1) It is known that the UTM simulation of a machine's Turing machine 
>>> description is equivalent to directly executing it.
>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03   if (Halts(P, P))
>>> 04     HERE: goto HERE;
>>> 05   else
>>> 06     HALT
>>> 07 }
>>>
>>>
>>> 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 }
>>>
>>>
>>> 19 int main()
>>> 20  {
>>> 21    u32 P = (u32)H_Hat;
>>> 22    Halts(P, P);
>>> 23    HALT;
>>> 24  }
>>>
>>>
>>> (2) It is known that the above code is infinitely recursive if 
>>> Halts() acts like a UTM (by having its line 15 disabled) and 
>>> simulates its input returning true if and only if its input halts.
>>>
>>> (3) On the basis of (1) and (2) It is known that a correct halt 
>>> decider (without line 15 disabled) must return false.
>>
>> You need to stop conflating two different functions and calling both 
>> of them Halt().
>>
>> You have your Halt decider:
>>
>> bool Halts(u32 P, u32 I) {
>>      bool Halted  = false;
>>      bool Aborted = false;
>>      while (!Halted && !Aborted) {
>>          Halted  = DebugStep(P, I);
>>          Aborted = Needs_To_Be_Aborted();
>>      }
>>      return !Aborted;
>> }
>>
>> And then you have your Simulator derived from Halt() by removing line 15:
>>
>> bool Simulate(u32 P, u32 I) {
>>      bool Halted  = false;
>>      bool Aborted = false;
>>      while (!Halted && !Aborted) {
>>          Halted  = DebugStep(P, I);
>>      }
>>      return !Aborted;
>> }
>>
>> Though of course your simulator doesn't really need the return.
>>
>> These are entirely different functions. Calling both of them Halts() 
>> is misleading. They do different things, and thus should exist as 
>> separate functions, either of which could be called by some other 
>> routine.
> 
> OK, good idea.
> 
>> H_Hat in the Linz proof (and other comparable proofs) is defined as a 
>> function which (in your implementation) invokes a *halt decider*, not 
>> a *simulator*, so if you insist for arcane reasons that we test the 
>> behaviour of H_Hat(H_Hat) inside a simulator rather than simply 
>> running it directly, we would call:
>>
>> Simulate(H_Hat, H_Hat);
>>
>> but H_Hat still needs to call Halts(), not Simulate(), because that's 
>> the computation which H_Hat is defined to perform by Linz.
> 
> The ONLY purpose of the two different functions is to prove that when 
> Halts(main, NULL) invokes H_Hat(H_Hat) that it aborts H_Hat at its line 
> 03 and decides not halting.
> 
> When Halts(H_Hat, H_Hat) is called it aborts the first H_Hat at its line 
> 03. Yet when the Halt deciding ability is removed from Halts both of the 
> function calls are now infinitely recursive.
> 
>> If you do things your way, by changing from 'halt detection mode' to 
>> 'simulator mode' by removing line 15 from the Halts() function which 
>> H_Hat also calls, then you are not just altering which 'mode' you are 
>> in; you are also fundamentally altering the computation performed by 
>> H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that 
> 
> It turns out that this is not the case because none of the H_Hat 
> computations ever receive any return value from Halts. None of them 
> every complete their execution of line 03.

H_Hat doesn't make use of the return value, but its behaviour still 
depends on the presence of the abort code. Remove that, and you are 
*changing* the definition of H_Hat.

A proper simulator running H_Hat doesn't do that. H_Hat should behave 
identically when run in a simulator as when run natively.

> All of the H_Hat(H_Hat) computations are state transition by state 
> transition identical. None of them ever complete their line 03.
> Those aborted by the decider never repeat, those not aborted by the 
> decider infinitely repeat.
> 
>> your Halt detector using as input when Halts(H_Hat, H_Hat) is called, 
>> effectively rendering your test of the behaviour of H_Hat(H_Hat) 
>> worthless.
>>
>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe 
>> is the behaviour of H_Hat(H_Hat) when it is run directly. Not when it 
>> is run inside a halting detector; not when it is run in a simulator; and 
> 
> So you do not understand the computer science that guarantees that the 
> direct execution of a TM is equivalent to simulating the TMD of this 
> machine by a UTM?

That's only true if your simulator is actually a reliable simulator.

If your simulator were a true simulator, one should be able to run 
Halts(H_Hat, H_Hat) *within* the simulator and have it return a value of 
true or false exactly as when it wasn't run inside the simulator. That's 
not the case in your proposal. Similarly, one should be able to run 
Simulate(H_Hat, H_Hat) *within* the simulator and one expects this to 
behave differently from Halts(H_Hat, H_Hat) run *within* the simulator. 
Again, this is not the case. That's because your simulator changes the 
behaviour of an "operating system call" that other programs rely on.

This is no different from having a 'simulator' in which, e.g. a function 
SUM(x, y) which is called by some of the programs it simulates is 
replaced by a different function MULTIPLY(x, y) in the simulator. 
Obviously, programs running in the 'simulator' which make use of SUM() 
are not going to behave the same way in the 'simulator' as they do when 
run directly because your 'simulator' doesn't actually provide a 
faithful simulation.

André


-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#25662 — Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 10:16 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](behind its back)
Message-ID<MbydnW5VOJVUEyfCnZ2dnUU7-TnNnZ2d@giganews.com>
In reply to#25658
On 11/22/2020 8:58 AM, André G. Isaak wrote:
> On 2020-11-22 07:17, olcott wrote:
>> On 11/22/2020 4:48 AM, André G. Isaak wrote:
>>> On 2020-11-21 12:19, olcott wrote:
>>>> (1) It is known that the UTM simulation of a machine's Turing 
>>>> machine description is equivalent to directly executing it.
>>>>
>>>>
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03   if (Halts(P, P))
>>>> 04     HERE: goto HERE;
>>>> 05   else
>>>> 06     HALT
>>>> 07 }
>>>>
>>>>
>>>> 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 }
>>>>
>>>>
>>>> 19 int main()
>>>> 20  {
>>>> 21    u32 P = (u32)H_Hat;
>>>> 22    Halts(P, P);
>>>> 23    HALT;
>>>> 24  }
>>>>
>>>>
>>>> (2) It is known that the above code is infinitely recursive if 
>>>> Halts() acts like a UTM (by having its line 15 disabled) and 
>>>> simulates its input returning true if and only if its input halts.
>>>>
>>>> (3) On the basis of (1) and (2) It is known that a correct halt 
>>>> decider (without line 15 disabled) must return false.
>>>
>>> You need to stop conflating two different functions and calling both 
>>> of them Halt().
>>>
>>> You have your Halt decider:
>>>
>>> bool Halts(u32 P, u32 I) {
>>>      bool Halted  = false;
>>>      bool Aborted = false;
>>>      while (!Halted && !Aborted) {
>>>          Halted  = DebugStep(P, I);
>>>          Aborted = Needs_To_Be_Aborted();
>>>      }
>>>      return !Aborted;
>>> }
>>>
>>> And then you have your Simulator derived from Halt() by removing line 
>>> 15:
>>>
>>> bool Simulate(u32 P, u32 I) {
>>>      bool Halted  = false;
>>>      bool Aborted = false;
>>>      while (!Halted && !Aborted) {
>>>          Halted  = DebugStep(P, I);
>>>      }
>>>      return !Aborted;
>>> }
>>>
>>> Though of course your simulator doesn't really need the return.
>>>
>>> These are entirely different functions. Calling both of them Halts() 
>>> is misleading. They do different things, and thus should exist as 
>>> separate functions, either of which could be called by some other 
>>> routine.
>>
>> OK, good idea.
>>
>>> H_Hat in the Linz proof (and other comparable proofs) is defined as a 
>>> function which (in your implementation) invokes a *halt decider*, not 
>>> a *simulator*, so if you insist for arcane reasons that we test the 
>>> behaviour of H_Hat(H_Hat) inside a simulator rather than simply 
>>> running it directly, we would call:
>>>
>>> Simulate(H_Hat, H_Hat);
>>>
>>> but H_Hat still needs to call Halts(), not Simulate(), because that's 
>>> the computation which H_Hat is defined to perform by Linz.
>>
>> The ONLY purpose of the two different functions is to prove that when 
>> Halts(main, NULL) invokes H_Hat(H_Hat) that it aborts H_Hat at its 
>> line 03 and decides not halting.
>>
>> When Halts(H_Hat, H_Hat) is called it aborts the first H_Hat at its 
>> line 03. Yet when the Halt deciding ability is removed from Halts both 
>> of the function calls are now infinitely recursive.
>>
>>> If you do things your way, by changing from 'halt detection mode' to 
>>> 'simulator mode' by removing line 15 from the Halts() function which 
>>> H_Hat also calls, then you are not just altering which 'mode' you are 
>>> in; you are also fundamentally altering the computation performed by 
>>> H_Hat, so you are not actually simulating the same H_Hat(H_Hat) that 
>>
>> It turns out that this is not the case because none of the H_Hat 
>> computations ever receive any return value from Halts. None of them 
>> every complete their execution of line 03.
> 
> H_Hat doesn't make use of the return value, but its behaviour still 
> depends on the presence of the abort code. Remove that, and you are 
> *changing* the definition of H_Hat.
> 
> A proper simulator running H_Hat doesn't do that. H_Hat should behave 
> identically when run in a simulator as when run natively.

So in other words because Halts does gets the right answer and you have 
been conditioned to believe that Halts cannot get the right answer you 
conclude that Halts must be cheating.

>> All of the H_Hat(H_Hat) computations are state transition by state 
>> transition identical. None of them ever complete their line 03.
>> Those aborted by the decider never repeat, those not aborted by the 
>> decider infinitely repeat.
>>
>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is called, 
>>> effectively rendering your test of the behaviour of H_Hat(H_Hat) 
>>> worthless.
>>>
>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe 
>>> is the behaviour of H_Hat(H_Hat) when it is run directly. Not when it 
>>> is run inside a halting detector; not when it is run in a simulator; and 
>>
>> So you do not understand the computer science that guarantees that the 
>> direct execution of a TM is equivalent to simulating the TMD of this 
>> machine by a UTM?
> 
> That's only true if your simulator is actually a reliable simulator.
> If your simulator were a true simulator, one should be able to run 
> Halts(H_Hat, H_Hat) *within* the simulator and have it return a value of 
> true or false exactly as when it wasn't run inside the simulator. That's 

In this case we can do that and it would get a correct answer.

When we simulate H_Hat(H_Hat) in this simulator we are doing things 
behind the back of the halt decider so its answer is misleading.

It is for this reason that the simulator must act as if it was the UTM 
for all code that is simulated. In this case the halt decider aborts the 
above invocation at its line 3.

When the simulator acts as a UTM and simulates all of its input then 
nothing can be done behind the back of the halt decider to make it seem 
like the halt decider is making inconsistent halting decisions.

> not the case in your proposal. Similarly, one should be able to run 
> Simulate(H_Hat, H_Hat) *within* the simulator and one expects this to 
> behave differently from Halts(H_Hat, H_Hat) run *within* the simulator. 
> Again, this is not the case. That's because your simulator changes the 
> behaviour of an "operating system call" that other programs rely on.
> 
> This is no different from having a 'simulator' in which, e.g. a function 
> SUM(x, y) which is called by some of the programs it simulates is 
> replaced by a different function MULTIPLY(x, y) in the simulator. 
> Obviously, programs running in the 'simulator' which make use of SUM() 
> are not going to behave the same way in the 'simulator' as they do when 
> run directly because your 'simulator' doesn't actually provide a 
> faithful simulation.
> 
> André
> 
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25663 — Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-22 10:10 -0700
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](behind its back)
Message-ID<rpe62b$dk9$1@dont-email.me>
In reply to#25662
On 2020-11-22 09:16, olcott wrote:
> On 11/22/2020 8:58 AM, André G. Isaak wrote:
>> On 2020-11-22 07:17, olcott wrote:
>>> On 11/22/2020 4:48 AM, André G. Isaak wrote:

<snip>

>> H_Hat doesn't make use of the return value, but its behaviour still 
>> depends on the presence of the abort code. Remove that, and you are 
>> *changing* the definition of H_Hat.
>>
>> A proper simulator running H_Hat doesn't do that. H_Hat should behave 
>> identically when run in a simulator as when run natively.
> 
> So in other words because Halts does gets the right answer and you have 
> been conditioned to believe that Halts cannot get the right answer you 
> conclude that Halts must be cheating.

Halts doesn't get the right answer. You claim it does because its result 
matches the behaviour of H_Hat(H_Hat) *only when* it is run inside your 
simulator which has the effect of changing the behaviour of the Halts() 
call *inside* H_Hat. If you ran it without the simulator such that it 
calls the normal Halts() you get the wrong answer.

It's not Halts that is cheating. It's your Simulator with the one line 
of halts disabled that is cheating.

>>> All of the H_Hat(H_Hat) computations are state transition by state 
>>> transition identical. None of them ever complete their line 03.
>>> Those aborted by the decider never repeat, those not aborted by the 
>>> decider infinitely repeat.
>>>
>>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is 
>>>> called, effectively rendering your test of the behaviour of 
>>>> H_Hat(H_Hat) worthless.
>>>>
>>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately describe 
>>>> is the behaviour of H_Hat(H_Hat) when it is run directly. Not when 
>>>> it is run inside a halting detector; not when it is run in a 
>>>> simulator; and 
>>>
>>> So you do not understand the computer science that guarantees that 
>>> the direct execution of a TM is equivalent to simulating the TMD of 
>>> this machine by a UTM?
>>
>> That's only true if your simulator is actually a reliable simulator.
>> If your simulator were a true simulator, one should be able to run 
>> Halts(H_Hat, H_Hat) *within* the simulator and have it return a value 
>> of true or false exactly as when it wasn't run inside the simulator. 
>> That's 
> 
> In this case we can do that and it would get a correct answer.

Not as far as I can tell.

If you run Halts(H_Hat, H_Hat), it reports (erroneously), that 
H_Hat(H_Hat) doesn't halt.

If you run Halts(H_Hat, H_Hat) *inside the simulator*, it won't report 
anything. It will simply hang.

If something behaves differently inside the simulator than when run 
without the simulator, then the simulator is not a faithful simulator.

> When we simulate H_Hat(H_Hat) in this simulator we are doing things 
> behind the back of the halt decider so its answer is misleading.

I have no idea what it means to 'do something behind the back of the 
halt decider', but you seem to be acknowledging that how something 
behaves inside the simulator is misleading. Therefore how can you assess 
the predictions of your decider based on how things behave when run 
inside your simulator

> It is for this reason that the simulator must act as if it was the UTM 
> for all code that is simulated. In this case the halt decider aborts the 
> above invocation at its line 3.

How is line 3 supposed to get aborted in the simulator given that your 
simulator omits the line Aborted = Needs_To_Be_Aborted()?

> When the simulator acts as a UTM and simulates all of its input then 
> nothing can be done behind the back of the halt decider to make it seem 
> like the halt decider is making inconsistent halting decisions.

I can make no sense of the that paragraphs.

André


-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#25664 — Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 11:47 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](behind its back)
Message-ID<s5udnVTv7MHYOSfCnZ2dnUU7-QnNnZ2d@giganews.com>
In reply to#25663
On 11/22/2020 11:10 AM, André G. Isaak wrote:
> On 2020-11-22 09:16, olcott wrote:
>> On 11/22/2020 8:58 AM, André G. Isaak wrote:
>>> On 2020-11-22 07:17, olcott wrote:
>>>> On 11/22/2020 4:48 AM, André G. Isaak wrote:
> 
> <snip>
> 
>>> H_Hat doesn't make use of the return value, but its behaviour still 
>>> depends on the presence of the abort code. Remove that, and you are 
>>> *changing* the definition of H_Hat.
>>>
>>> A proper simulator running H_Hat doesn't do that. H_Hat should behave 
>>> identically when run in a simulator as when run natively.
>>
>> So in other words because Halts does gets the right answer and you 
>> have been conditioned to believe that Halts cannot get the right 
>> answer you conclude that Halts must be cheating.
> 
> Halts doesn't get the right answer. You claim it does because its result 
> matches the behaviour of H_Hat(H_Hat) *only when* it is run inside your 
> simulator which has the effect of changing the behaviour of the Halts() 
> call *inside* H_Hat. If you ran it without the simulator such that it 
> calls the normal Halts() you get the wrong answer.
> 
> It's not Halts that is cheating. It's your Simulator with the one line 
> of halts disabled that is cheating.
> 
>>>> All of the H_Hat(H_Hat) computations are state transition by state 
>>>> transition identical. None of them ever complete their line 03.
>>>> Those aborted by the decider never repeat, those not aborted by the 
>>>> decider infinitely repeat.
>>>>
>>>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is 
>>>>> called, effectively rendering your test of the behaviour of 
>>>>> H_Hat(H_Hat) worthless.
>>>>>
>>>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately 
>>>>> describe is the behaviour of H_Hat(H_Hat) when it is run directly. 
>>>>> Not when it is run inside a halting detector; not when it is run in 
>>>>> a simulator; and 
>>>>
>>>> So you do not understand the computer science that guarantees that 
>>>> the direct execution of a TM is equivalent to simulating the TMD of 
>>>> this machine by a UTM?
>>>
>>> That's only true if your simulator is actually a reliable simulator.
>>> If your simulator were a true simulator, one should be able to run 
>>> Halts(H_Hat, H_Hat) *within* the simulator and have it return a value 
>>> of true or false exactly as when it wasn't run inside the simulator. 
>>> That's 
>>
>> In this case we can do that and it would get a correct answer.
> 
> Not as far as I can tell.
> 
> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that 
> H_Hat(H_Hat) doesn't halt.

I keep repeating this criterion measure as a challenge to everyone to 
find any input that it decides incorrectly.

It seems that everyone continues to ignore this challenge because they 
understand that this criterion measure is necessarily correct.

When-so-ever decider Halts() (adapted from a UTM) decides that:
(a) its input (<P>,I) would never halt unless it stopped simulating it
and it is the case that
(b) its input (<P>,I) would never halt unless it stopped simulating it
then Halts() has made a correct not-halting decision on this input.

> If you run Halts(H_Hat, H_Hat) *inside the simulator*, it won't report 
> anything. It will simply hang.

I see now that what you are referring to as the simulator its Halts() 
with its line 15 removed. I thought that you were referring to an actual 
UTM that would also simulate Halts();

> If something behaves differently inside the simulator than when run 
> without the simulator, then the simulator is not a faithful simulator.
> 

In other words when-so-ever the halt decider decides its input correctly 
and aborts this input so that it remains a decider, it must be cheating 
because everyone knows that there is no such thing as a halt decider 
that decides this key input correctly.

>> When we simulate H_Hat(H_Hat) in this simulator we are doing things 
>> behind the back of the halt decider so its answer is misleading.
> 
> I have no idea what it means to 'do something behind the back of the 
> halt decider', 

We are simulating the execution of inputs such that the halt decider is 
not provided with the full execution trace of these inputs that are 
being simulated.

Whatever execution of H_Hat(H_Hat) that it can see the halt decider 
aborts. When we execute H_Hat(H_Hat) in a simulator that is not a halt 
decider then the halt decider cannot see the execution trace of the 
first H_Hat.

> but you seem to be acknowledging that how something 
> behaves inside the simulator is misleading. Therefore how can you assess 
> the predictions of your decider based on how things behave when run 
> inside your simulator

If I decide that by turning on the ignition of my car that it will start 
running and I turn on the ignition to my car and it starts running then 
I have necessarily made a correct car starting decision.

For this same (true by definition) reason the following is also true:
When-so-ever decider Halts() (adapted from a UTM) decides that:
(a) its input (<P>,I) would never halt unless it stopped simulating it
and it is the case that
(b) its input (<P>,I) would never halt unless it stopped simulating it
then Halts() has made a correct not-halting decision on this input.

>> It is for this reason that the simulator must act as if it was the UTM 
>> for all code that is simulated. In this case the halt decider aborts 
>> the above invocation at its line 3.
> 
> How is line 3 supposed to get aborted in the simulator given that your 
> simulator omits the line Aborted = Needs_To_Be_Aborted()?

We keep switching back and forth wheter a simulator is an actual UTM or 
merely Halts with line 15 removed.

> 
>> When the simulator acts as a UTM and simulates all of its input then 
>> nothing can be done behind the back of the halt decider to make it 
>> seem like the halt decider is making inconsistent halting decisions.
> 
> I can make no sense of the that paragraphs.
> 
> André
> 
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25665 — Re: It is known that a correct halt decider must return false (in this case)[V2](behind its back)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-22 13:14 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](behind its back)
Message-ID<NTxuH.2673$Gw2.1572@fx24.iad>
In reply to#25664
On 11/22/20 12:47 PM, olcott wrote:
> On 11/22/2020 11:10 AM, André G. Isaak wrote:
>>
>> Not as far as I can tell.
>>
>> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that
>> H_Hat(H_Hat) doesn't halt.
> 
> I keep repeating this criterion measure as a challenge to everyone to
> find any input that it decides incorrectly.
> 
> It seems that everyone continues to ignore this challenge because they
> understand that this criterion measure is necessarily correct.
> 
> When-so-ever decider Halts() (adapted from a UTM) decides that:
> (a) its input (<P>,I) would never halt unless it stopped simulating it
> and it is the case that
> (b) its input (<P>,I) would never halt unless it stopped simulating it
> then Halts() has made a correct not-halting decision on this input.
> 

First, I will point out that your are changing the criteria of the
halting problem, so you either need to accept the RIGHT definition or
state that you are working on a different problem (and thus acknowledge
that any result you get to apply to the classic problem without further
proof to show they are). The proper statement of the halting problem is
to make a program that correctly predicts in finite time whether a given
program with given input will halt in finite time or run forever. ALWAYS
the ultimate test of success is does the deciders answer match the
actual machines performance. It also must ALWAY give the right answer in
finite time for ANY program.

The counter example for your decider is Linz H_Hat. The following is a
program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as
the input to a working UTM. This is the only possible trace for this
case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
your stated answer, and Halts meets the requirements of a Halt Decider:

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

Thus, Halts was wrong.

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


#25666 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 12:28 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<I56dnUuP5fJWMCfCnZ2dnUU7-RfNnZ2d@giganews.com>
In reply to#25665
On 11/22/2020 12:14 PM, Richard Damon wrote:
> On 11/22/20 12:47 PM, olcott wrote:
>> On 11/22/2020 11:10 AM, André G. Isaak wrote:
>>>
>>> Not as far as I can tell.
>>>
>>> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that
>>> H_Hat(H_Hat) doesn't halt.
>>
>> I keep repeating this criterion measure as a challenge to everyone to
>> find any input that it decides incorrectly.
>>
>> It seems that everyone continues to ignore this challenge because they
>> understand that this criterion measure is necessarily correct.
>>
>> When-so-ever decider Halts() (adapted from a UTM) decides that:
>> (a) its input (<P>,I) would never halt unless it stopped simulating it
>> and it is the case that
>> (b) its input (<P>,I) would never halt unless it stopped simulating it
>> then Halts() has made a correct not-halting decision on this input.
>>
> 
> First, I will point out that your are changing the criteria of the
> halting problem, so you either need to accept the RIGHT definition or
> state that you are working on a different problem (and thus acknowledge
> that any result you get to apply to the classic problem without further
> proof to show they are). The proper statement of the halting problem is
> to make a program that correctly predicts in finite time whether a given
> program with given input will halt in finite time or run forever. ALWAYS
> the ultimate test of success is does the deciders answer match the
> actual machines performance. It also must ALWAY give the right answer in
> finite time for ANY program.
> 
> The counter example for your decider is Linz H_Hat. The following is a
> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as
> the input to a working UTM. This is the only possible trace for this
> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
> your stated answer, and Halts meets the requirements of a Halt Decider:
> 
> 1) Enter H_Hat(H_Hat)
> 2) duplicate H_Hat (this step 'optimized' out in your machine)
> 3) Enter Halts(H_Hat, H_Hat)
> 4) Halts does its decision and decides tht H_Hat is non-halting
> 5) Halts returns false to indicate non-halting
> 6) H_Hat goes to the else clause
> 7) H_Hat Halts.
> 
> Thus, Halts was wrong.
> 

Your false assumptions have never been any sort of rebuttal.

When the halt decider has been defined on the basis of transforming a 
UTM into a decider:

1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
2) Halts does its decision and decides that H_Hat is non-halting and 
aborts H_Hat at its line 03.
3) Halts returns false to indicate non-halting.

Thus Halts was right.


-- 
Copyright 2020 Pete Olcott

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

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


#25667 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-22 13:44 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<QjyuH.13166$ZbR7.2118@fx01.iad>
In reply to#25666
On 11/22/20 1:28 PM, olcott wrote:
> On 11/22/2020 12:14 PM, Richard Damon wrote:

>> First, I will point out that your are changing the criteria of the
>> halting problem, so you either need to accept the RIGHT definition or
>> state that you are working on a different problem (and thus acknowledge
>> that any result you get to apply to the classic problem without further
>> proof to show they are). The proper statement of the halting problem is
>> to make a program that correctly predicts in finite time whether a given
>> program with given input will halt in finite time or run forever. ALWAYS
>> the ultimate test of success is does the deciders answer match the
>> actual machines performance. It also must ALWAY give the right answer in
>> finite time for ANY program.
>>
>> The counter example for your decider is Linz H_Hat. The following is a
>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as
>> the input to a working UTM. This is the only possible trace for this
>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>> your stated answer, and Halts meets the requirements of a Halt Decider:
>>
>> 1) Enter H_Hat(H_Hat)
>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>> 3) Enter Halts(H_Hat, H_Hat)
>> 4) Halts does its decision and decides tht H_Hat is non-halting
>> 5) Halts returns false to indicate non-halting
>> 6) H_Hat goes to the else clause
>> 7) H_Hat Halts.
>>
>> Thus, Halts was wrong.
>>
> 
> Your false assumptions have never been any sort of rebuttal.
> 
> When the halt decider has been defined on the basis of transforming a
> UTM into a decider:
> 
> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
> 2) Halts does its decision and decides that H_Hat is non-halting and
> aborts H_Hat at its line 03.
> 3) Halts returns false to indicate non-halting.
> 
> Thus Halts was right.
> 
> 

First, YOU don't get to say what are the definition of a halt decider if
you which to use the term properly, based on classical theory.

If you wish to go off on you own, you need to be clear about this and
SAY that you are working in an alternate definition framework, and thus
your results are not applicable to the classical theory or problems.

You have started with a bad definition, and thus you get bad answers.

If Halts 'aborted' this run in line 3, then Halts is NOT a decider, as
it fails to meet the definition of a decider, as the decider need to
return its answer to the context it was put in, that is H_Hat.

Now, it could also be that you have improperly translated the problem
from the Turing Machine Space that the Linz definition was in, so again,
your system fails to meet its requirements.

Basic fact, if you fail to meet the stipulations of a problem, your
answer fails to be an answer, and you can't just change the
stipulation/requirements of a problem without making it a fact that you
are now working on a DIFFERENT problem.

As I have stated multiple times, you need to make you choice and make it
clear. Either you are working on the classical Halting Problem and thus
working under the definitions and stipulations of that problem, or you
are working on some other problem, which you need to clearly indicate
and then also realize that your results are not applicable to the
original problem statement.

Your insistance on using the classical language and referring to classic
proofs indicate to me, that you intend you work to be on the classical
problem, thus you are under the classical requirements and you don't get
to change them.

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


#25669 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 12:56 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<aZOdnSMqDbXRKSfCnZ2dnUU7-R3NnZ2d@giganews.com>
In reply to#25667
On 11/22/2020 12:44 PM, Richard Damon wrote:
> On 11/22/20 1:28 PM, olcott wrote:
>> On 11/22/2020 12:14 PM, Richard Damon wrote:
> 
>>> First, I will point out that your are changing the criteria of the
>>> halting problem, so you either need to accept the RIGHT definition or
>>> state that you are working on a different problem (and thus acknowledge
>>> that any result you get to apply to the classic problem without further
>>> proof to show they are). The proper statement of the halting problem is
>>> to make a program that correctly predicts in finite time whether a given
>>> program with given input will halt in finite time or run forever. ALWAYS
>>> the ultimate test of success is does the deciders answer match the
>>> actual machines performance. It also must ALWAY give the right answer in
>>> finite time for ANY program.
>>>
>>> The counter example for your decider is Linz H_Hat. The following is a
>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as
>>> the input to a working UTM. This is the only possible trace for this
>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>>> your stated answer, and Halts meets the requirements of a Halt Decider:
>>>
>>> 1) Enter H_Hat(H_Hat)
>>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>>> 3) Enter Halts(H_Hat, H_Hat)
>>> 4) Halts does its decision and decides tht H_Hat is non-halting
>>> 5) Halts returns false to indicate non-halting
>>> 6) H_Hat goes to the else clause
>>> 7) H_Hat Halts.
>>>
>>> Thus, Halts was wrong.
>>>
>>
>> Your false assumptions have never been any sort of rebuttal.
>>
>> When the halt decider has been defined on the basis of transforming a
>> UTM into a decider:
>>
>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
>> 2) Halts does its decision and decides that H_Hat is non-halting and
>> aborts H_Hat at its line 03.
>> 3) Halts returns false to indicate non-halting.
>>
>> Thus Halts was right.
>>
>>
> 
> First, YOU don't get to say what are the definition of a halt decider if
> you which to use the term properly, based on classical theory.

The term "definition" has two distinctly different contexts.
(1) What does the term of the sort "halt decider" mean in computer science.

(2) Exactly which state transitions can be plugged into the ⊢*  wildcard 
state transitions such that Halts would correctly transition to its 
final state of Halts.yes if its input would halt on its input and 
Halts.no if is input would not halt on its input.

Halts.q0  wMw  ⊢*  Halts.yes
Halts.q0  wMw  ⊢*  Halts.no

(1)(2)(3) are this second type of definition.

If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when 
you say no you are wrong steps (4)(5)(6) do not correctly decide halting 
on H_Halt you have merely used the dishonest dodge known as the 
straw-man fallacy: "an intentionally misrepresented proposition that is 
set up because it is easier to defeat than an opponent's real argument."


> If you wish to go off on you own, you need to be clear about this and
> SAY that you are working in an alternate definition framework, and thus
> your results are not applicable to the classical theory or problems.
> 
> You have started with a bad definition, and thus you get bad answers.
> 
> If Halts 'aborted' this run in line 3, then Halts is NOT a decider, as
> it fails to meet the definition of a decider, as the decider need to
> return its answer to the context it was put in, that is H_Hat.
> 
> Now, it could also be that you have improperly translated the problem
> from the Turing Machine Space that the Linz definition was in, so again,
> your system fails to meet its requirements.
> 
> Basic fact, if you fail to meet the stipulations of a problem, your
> answer fails to be an answer, and you can't just change the
> stipulation/requirements of a problem without making it a fact that you
> are now working on a DIFFERENT problem.
> 
> As I have stated multiple times, you need to make you choice and make it
> clear. Either you are working on the classical Halting Problem and thus
> working under the definitions and stipulations of that problem, or you
> are working on some other problem, which you need to clearly indicate
> and then also realize that your results are not applicable to the
> original problem statement.
> 
> Your insistance on using the classical language and referring to classic
> proofs indicate to me, that you intend you work to be on the classical
> problem, thus you are under the classical requirements and you don't get
> to change them.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25673 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-22 14:23 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<5VyuH.12594$vo2.10615@fx02.iad>
In reply to#25669
On 11/22/20 1:56 PM, olcott wrote:
> On 11/22/2020 12:44 PM, Richard Damon wrote:
>> On 11/22/20 1:28 PM, olcott wrote:
>>> On 11/22/2020 12:14 PM, Richard Damon wrote:
>>
>>>> First, I will point out that your are changing the criteria of the
>>>> halting problem, so you either need to accept the RIGHT definition or
>>>> state that you are working on a different problem (and thus acknowledge
>>>> that any result you get to apply to the classic problem without further
>>>> proof to show they are). The proper statement of the halting problem is
>>>> to make a program that correctly predicts in finite time whether a
>>>> given
>>>> program with given input will halt in finite time or run forever.
>>>> ALWAYS
>>>> the ultimate test of success is does the deciders answer match the
>>>> actual machines performance. It also must ALWAY give the right
>>>> answer in
>>>> finite time for ANY program.
>>>>
>>>> The counter example for your decider is Linz H_Hat. The following is a
>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as
>>>> the input to a working UTM. This is the only possible trace for this
>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>>>> your stated answer, and Halts meets the requirements of a Halt Decider:
>>>>
>>>> 1) Enter H_Hat(H_Hat)
>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>>>> 3) Enter Halts(H_Hat, H_Hat)
>>>> 4) Halts does its decision and decides tht H_Hat is non-halting
>>>> 5) Halts returns false to indicate non-halting
>>>> 6) H_Hat goes to the else clause
>>>> 7) H_Hat Halts.
>>>>
>>>> Thus, Halts was wrong.
>>>>
>>>
>>> Your false assumptions have never been any sort of rebuttal.
>>>
>>> When the halt decider has been defined on the basis of transforming a
>>> UTM into a decider:
>>>
>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
>>> 2) Halts does its decision and decides that H_Hat is non-halting and
>>> aborts H_Hat at its line 03.
>>> 3) Halts returns false to indicate non-halting.
>>>
>>> Thus Halts was right.
>>>
>>>
>>
>> First, YOU don't get to say what are the definition of a halt decider if
>> you which to use the term properly, based on classical theory.
> 
> The term "definition" has two distinctly different contexts.
> (1) What does the term of the sort "halt decider" mean in computer science.
> 
> (2) Exactly which state transitions can be plugged into the ⊢*  wildcard
> state transitions such that Halts would correctly transition to its
> final state of Halts.yes if its input would halt on its input and
> Halts.no if is input would not halt on its input.
> 
> Halts.q0  wMw  ⊢*  Halts.yes
> Halts.q0  wMw  ⊢*  Halts.no
> 
> (1)(2)(3) are this second type of definition.
> 
> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when
> you say no you are wrong steps (4)(5)(6) do not correctly decide halting
> on H_Halt you have merely used the dishonest dodge known as the
> straw-man fallacy: "an intentionally misrepresented proposition that is
> set up because it is easier to defeat than an opponent's real argument."

Yes, you get to 'define' the factors that implement your Halts. You
don't get to define that they are 'Correct', you can presume them right
and then test. The TEST for your Halts is still what the ACTUAL machine
does, which shows Halts to be wrong.

The above trace shows that Halts is wrong. Now, if Halts didn't end up
in either of Halts.yes or Halts.no, then it failed to meet the
requirements on it. That ending up at Halt.no is what puts you at step
4, and then by the definition of H_Hat, it moves 5, 6, and then 7.

By your logic, I can 'define' that the states transition in Halts proves
correctly that Peter Oslcott is a buffoon and any argument to the
contray is just a strawman.


> 

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


#25674 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 13:28 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<MsudnZCpVMZHJifCnZ2dnUU7-I-dnZ2d@giganews.com>
In reply to#25673
On 11/22/2020 1:23 PM, Richard Damon wrote:
> On 11/22/20 1:56 PM, olcott wrote:
>> On 11/22/2020 12:44 PM, Richard Damon wrote:
>>> On 11/22/20 1:28 PM, olcott wrote:
>>>> On 11/22/2020 12:14 PM, Richard Damon wrote:
>>>
>>>>> First, I will point out that your are changing the criteria of the
>>>>> halting problem, so you either need to accept the RIGHT definition or
>>>>> state that you are working on a different problem (and thus acknowledge
>>>>> that any result you get to apply to the classic problem without further
>>>>> proof to show they are). The proper statement of the halting problem is
>>>>> to make a program that correctly predicts in finite time whether a
>>>>> given
>>>>> program with given input will halt in finite time or run forever.
>>>>> ALWAYS
>>>>> the ultimate test of success is does the deciders answer match the
>>>>> actual machines performance. It also must ALWAY give the right
>>>>> answer in
>>>>> finite time for ANY program.
>>>>>
>>>>> The counter example for your decider is Linz H_Hat. The following is a
>>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine or as
>>>>> the input to a working UTM. This is the only possible trace for this
>>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>>>>> your stated answer, and Halts meets the requirements of a Halt Decider:
>>>>>
>>>>> 1) Enter H_Hat(H_Hat)
>>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>>>>> 3) Enter Halts(H_Hat, H_Hat)
>>>>> 4) Halts does its decision and decides tht H_Hat is non-halting
>>>>> 5) Halts returns false to indicate non-halting
>>>>> 6) H_Hat goes to the else clause
>>>>> 7) H_Hat Halts.
>>>>>
>>>>> Thus, Halts was wrong.
>>>>>
>>>>
>>>> Your false assumptions have never been any sort of rebuttal.
>>>>
>>>> When the halt decider has been defined on the basis of transforming a
>>>> UTM into a decider:
>>>>
>>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
>>>> 2) Halts does its decision and decides that H_Hat is non-halting and
>>>> aborts H_Hat at its line 03.
>>>> 3) Halts returns false to indicate non-halting.
>>>>
>>>> Thus Halts was right.
>>>>
>>>>
>>>
>>> First, YOU don't get to say what are the definition of a halt decider if
>>> you which to use the term properly, based on classical theory.
>>
>> The term "definition" has two distinctly different contexts.
>> (1) What does the term of the sort "halt decider" mean in computer science.
>>
>> (2) Exactly which state transitions can be plugged into the ⊢*  wildcard
>> state transitions such that Halts would correctly transition to its
>> final state of Halts.yes if its input would halt on its input and
>> Halts.no if is input would not halt on its input.
>>
>> Halts.q0  wMw  ⊢*  Halts.yes
>> Halts.q0  wMw  ⊢*  Halts.no
>>
>> (1)(2)(3) are this second type of definition.
>>
>> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when
>> you say no you are wrong steps (4)(5)(6) do not correctly decide halting
>> on H_Halt you have merely used the dishonest dodge known as the
>> straw-man fallacy: "an intentionally misrepresented proposition that is
>> set up because it is easier to defeat than an opponent's real argument."
> 
> Yes, you get to 'define' the factors that implement your Halts. You
> don't get to define that they are 'Correct', you can presume them right
> and then test. The TEST for your Halts is still what the ACTUAL machine
> does, which shows Halts to be wrong.

Forget about the (apparently overwhelming details of Halts and 
Simulates) and just focus on this:

If the code that it does not abort is always infinitely recursive unless 
it aborts this code then the decision to abort this code is impossibly 
incorrect.

This is the same thing as saying if a cat is black then we know it is a 
black cat.

> The above trace shows that Halts is wrong. Now, if Halts didn't end up
> in either of Halts.yes or Halts.no, then it failed to meet the
> requirements on it. That ending up at Halt.no is what puts you at step
> 4, and then by the definition of H_Hat, it moves 5, 6, and then 7.
> 
> By your logic, I can 'define' that the states transition in Halts proves
> correctly that Peter Oslcott is a buffoon and any argument to the
> contray is just a strawman.
> 
> 
>>


-- 
Copyright 2020 Pete Olcott

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

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


#25675 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-22 16:21 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<4DAuH.21599$oL7.5244@fx06.iad>
In reply to#25674
On 11/22/20 2:28 PM, olcott wrote:
> On 11/22/2020 1:23 PM, Richard Damon wrote:
>> On 11/22/20 1:56 PM, olcott wrote:
>>> On 11/22/2020 12:44 PM, Richard Damon wrote:
>>>> On 11/22/20 1:28 PM, olcott wrote:
>>>>> On 11/22/2020 12:14 PM, Richard Damon wrote:
>>>>
>>>>>> First, I will point out that your are changing the criteria of the
>>>>>> halting problem, so you either need to accept the RIGHT definition or
>>>>>> state that you are working on a different problem (and thus
>>>>>> acknowledge
>>>>>> that any result you get to apply to the classic problem without
>>>>>> further
>>>>>> proof to show they are). The proper statement of the halting
>>>>>> problem is
>>>>>> to make a program that correctly predicts in finite time whether a
>>>>>> given
>>>>>> program with given input will halt in finite time or run forever.
>>>>>> ALWAYS
>>>>>> the ultimate test of success is does the deciders answer match the
>>>>>> actual machines performance. It also must ALWAY give the right
>>>>>> answer in
>>>>>> finite time for ANY program.
>>>>>>
>>>>>> The counter example for your decider is Linz H_Hat. The following
>>>>>> is a
>>>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine
>>>>>> or as
>>>>>> the input to a working UTM. This is the only possible trace for this
>>>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>>>>>> your stated answer, and Halts meets the requirements of a Halt
>>>>>> Decider:
>>>>>>
>>>>>> 1) Enter H_Hat(H_Hat)
>>>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>>>>>> 3) Enter Halts(H_Hat, H_Hat)
>>>>>> 4) Halts does its decision and decides tht H_Hat is non-halting
>>>>>> 5) Halts returns false to indicate non-halting
>>>>>> 6) H_Hat goes to the else clause
>>>>>> 7) H_Hat Halts.
>>>>>>
>>>>>> Thus, Halts was wrong.
>>>>>>
>>>>>
>>>>> Your false assumptions have never been any sort of rebuttal.
>>>>>
>>>>> When the halt decider has been defined on the basis of transforming a
>>>>> UTM into a decider:
>>>>>
>>>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
>>>>> 2) Halts does its decision and decides that H_Hat is non-halting and
>>>>> aborts H_Hat at its line 03.
>>>>> 3) Halts returns false to indicate non-halting.
>>>>>
>>>>> Thus Halts was right.
>>>>>
>>>>>
>>>>
>>>> First, YOU don't get to say what are the definition of a halt
>>>> decider if
>>>> you which to use the term properly, based on classical theory.
>>>
>>> The term "definition" has two distinctly different contexts.
>>> (1) What does the term of the sort "halt decider" mean in computer
>>> science.
>>>
>>> (2) Exactly which state transitions can be plugged into the ⊢*  wildcard
>>> state transitions such that Halts would correctly transition to its
>>> final state of Halts.yes if its input would halt on its input and
>>> Halts.no if is input would not halt on its input.
>>>
>>> Halts.q0  wMw  ⊢*  Halts.yes
>>> Halts.q0  wMw  ⊢*  Halts.no
>>>
>>> (1)(2)(3) are this second type of definition.
>>>
>>> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when
>>> you say no you are wrong steps (4)(5)(6) do not correctly decide halting
>>> on H_Halt you have merely used the dishonest dodge known as the
>>> straw-man fallacy: "an intentionally misrepresented proposition that is
>>> set up because it is easier to defeat than an opponent's real argument."
>>
>> Yes, you get to 'define' the factors that implement your Halts. You
>> don't get to define that they are 'Correct', you can presume them right
>> and then test. The TEST for your Halts is still what the ACTUAL machine
>> does, which shows Halts to be wrong.
> 
> Forget about the (apparently overwhelming details of Halts and
> Simulates) and just focus on this:
> 
> If the code that it does not abort is always infinitely recursive unless
> it aborts this code then the decision to abort this code is impossibly
> incorrect.

Yes, infinitely recurseive code does not halt. The issue is that in your
H_Hat/Halts combo, it is the Halts that creates the infinite recursion,
when it as a prerequisite to be finite in execution. The thing that you
don't seem to understand is that the definition of a halt decider does
not imply that the halt detector must just blindly simulate the provided
code until it can determine that something it know as non-halting
behavvior is detected.

The fact that the recursion in NOT inevitably recursive can be seen
because it IS possible to define a different halt decider that using a
similar detection of recursion, rather that just giving up and saying
the recursion is infinite, first asks itself if it assumed halting, does
the system halt, in which case it can decide halting, else if it decides
non-halting, does the system become non-halting, in which case it can
return non-halting. This still has to decide which wrong answer to give
to Linz (or you modify the problem to allow the decider to report that
the machine is acting contradictory). You also still need to solve the
problem of detecting non-recursive non-halting detection.

Of course that fact that your logic has a flaw in it becomes obvious
when we look at the actual results of running the code under proper
conditions, as if and when Halts returns a non-halting result, the
system almost immediately comes to a halt.

The fact that your logic says that H_Hat(H_Hat) must not halt and we
also have the proof that if Halts meets the requirements of a Halt
Decider that H_Hat(H_Hat) does halt, shows that either Halts does not
meet the requirements of a Halt Detector, there is some other logic
error we are not seeing, or something has been done in the axioms of the
system that make the logic system inconsistent. The one thing we can be
sure of is that Halts is NOT a correcct Halting Decider for the
classical Halting Problem.

> 
> This is the same thing as saying if a cat is black then we know it is a
> black cat.
>

Yes, if a cat is black, it is a black cat, but that doesn't prove that
there ARE black cats. Also, your statement is actually more of like, I
will define this cat as black, so it is a black cat, even though the cat
is white, or maybe even a dog.

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


#25676 — Re: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 16:25 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<xb2dnQr6lZjteCfCnZ2dnUU7-R3NnZ2d@giganews.com>
In reply to#25675
On 11/22/2020 3:21 PM, Richard Damon wrote:
> On 11/22/20 2:28 PM, olcott wrote:
>> On 11/22/2020 1:23 PM, Richard Damon wrote:
>>> On 11/22/20 1:56 PM, olcott wrote:
>>>> On 11/22/2020 12:44 PM, Richard Damon wrote:
>>>>> On 11/22/20 1:28 PM, olcott wrote:
>>>>>> On 11/22/2020 12:14 PM, Richard Damon wrote:
>>>>>
>>>>>>> First, I will point out that your are changing the criteria of the
>>>>>>> halting problem, so you either need to accept the RIGHT definition or
>>>>>>> state that you are working on a different problem (and thus
>>>>>>> acknowledge
>>>>>>> that any result you get to apply to the classic problem without
>>>>>>> further
>>>>>>> proof to show they are). The proper statement of the halting
>>>>>>> problem is
>>>>>>> to make a program that correctly predicts in finite time whether a
>>>>>>> given
>>>>>>> program with given input will halt in finite time or run forever.
>>>>>>> ALWAYS
>>>>>>> the ultimate test of success is does the deciders answer match the
>>>>>>> actual machines performance. It also must ALWAY give the right
>>>>>>> answer in
>>>>>>> finite time for ANY program.
>>>>>>>
>>>>>>> The counter example for your decider is Linz H_Hat. The following
>>>>>>> is a
>>>>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine
>>>>>>> or as
>>>>>>> the input to a working UTM. This is the only possible trace for this
>>>>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>>>>>>> your stated answer, and Halts meets the requirements of a Halt
>>>>>>> Decider:
>>>>>>>
>>>>>>> 1) Enter H_Hat(H_Hat)
>>>>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>>>>>>> 3) Enter Halts(H_Hat, H_Hat)
>>>>>>> 4) Halts does its decision and decides tht H_Hat is non-halting
>>>>>>> 5) Halts returns false to indicate non-halting
>>>>>>> 6) H_Hat goes to the else clause
>>>>>>> 7) H_Hat Halts.
>>>>>>>
>>>>>>> Thus, Halts was wrong.
>>>>>>>
>>>>>>
>>>>>> Your false assumptions have never been any sort of rebuttal.
>>>>>>
>>>>>> When the halt decider has been defined on the basis of transforming a
>>>>>> UTM into a decider:
>>>>>>
>>>>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
>>>>>> 2) Halts does its decision and decides that H_Hat is non-halting and
>>>>>> aborts H_Hat at its line 03.
>>>>>> 3) Halts returns false to indicate non-halting.
>>>>>>
>>>>>> Thus Halts was right.
>>>>>>
>>>>>>
>>>>>
>>>>> First, YOU don't get to say what are the definition of a halt
>>>>> decider if
>>>>> you which to use the term properly, based on classical theory.
>>>>
>>>> The term "definition" has two distinctly different contexts.
>>>> (1) What does the term of the sort "halt decider" mean in computer
>>>> science.
>>>>
>>>> (2) Exactly which state transitions can be plugged into the ⊢*  wildcard
>>>> state transitions such that Halts would correctly transition to its
>>>> final state of Halts.yes if its input would halt on its input and
>>>> Halts.no if is input would not halt on its input.
>>>>
>>>> Halts.q0  wMw  ⊢*  Halts.yes
>>>> Halts.q0  wMw  ⊢*  Halts.no
>>>>
>>>> (1)(2)(3) are this second type of definition.
>>>>
>>>> If I say that steps (1)(2)(3) correctly decide halting on H_Hat, when
>>>> you say no you are wrong steps (4)(5)(6) do not correctly decide halting
>>>> on H_Halt you have merely used the dishonest dodge known as the
>>>> straw-man fallacy: "an intentionally misrepresented proposition that is
>>>> set up because it is easier to defeat than an opponent's real argument."
>>>
>>> Yes, you get to 'define' the factors that implement your Halts. You
>>> don't get to define that they are 'Correct', you can presume them right
>>> and then test. The TEST for your Halts is still what the ACTUAL machine
>>> does, which shows Halts to be wrong.
>>
>> Forget about the (apparently overwhelming details of Halts and
>> Simulates) and just focus on this:
>>
>> If the code that it does not abort is always infinitely recursive unless
>> it aborts this code then the decision to abort this code is impossibly
>> incorrect.
> 
> Yes, infinitely recurseive code does not halt. The issue is that in your
> H_Hat/Halts combo, it is the Halts that creates the infinite recursion,
> when it as a prerequisite to be finite in execution. The thing that you
> don't seem to understand is that the definition of a halt decider does
> not imply that the halt detector must just blindly simulate the provided
> code until it can determine that something it know as non-halting
> behavvior is detected.

This definition of a halt decider allows utterly free reign in 
specifying the state transitions from H.0 to H.yes or H.no as long as 
H.yes indicates that wM is the Turing machine description that would 
halt on its input w and H.no indicates that wM is the Turing machine 
description that would not halt on its input w.
H.q0  wMw  ⊢*  H.yes
H.q0  wMw  ⊢*  H.no

Thus when I specify these state transitions such that the invocation of 
Ĥ(Ĥ) would be infinitely recursive I am free to do so. I am allowed by 
the above defintion of a halt decider to specify the ⊢* wildcard state 
transitions such that the invocation of Ĥ(Ĥ) would be infinitely recursive.

> The fact that the recursion in NOT inevitably recursive can be seen
> because it IS possible to define a different halt decider that using a
> similar detection of recursion, rather that just giving up and saying
> the recursion is infinite, first asks itself if it assumed halting, does
> the system halt, in which case it can decide halting, else if it decides
> non-halting, does the system become non-halting, in which case it can
> return non-halting. This still has to decide which wrong answer to give
> to Linz (or you modify the problem to allow the decider to report that
> the machine is acting contradictory). You also still need to solve the
> problem of detecting non-recursive non-halting detection.
> 
> Of course that fact that your logic has a flaw in it becomes obvious
> when we look at the actual results of running the code under proper
> conditions, as if and when Halts returns a non-halting result, the
> system almost immediately comes to a halt.

You construe proper conditions incorrectly. You cannot correctly justify 
why your "proper conditions" are required.

> The fact that your logic says that H_Hat(H_Hat) must not halt and we
> also have the proof that if Halts meets the requirements of a Halt
> Decider that H_Hat(H_Hat) does halt, shows that either Halts does not
> meet the requirements of a Halt Detector,

A halt decider that simulates its input TMD until it detects that this 
simulation would never end <is> a valid halt decider architecture. It is 
foolish to argue otherwise.

>  there is some other logic
> error we are not seeing, or something has been done in the axioms of the
> system that make the logic system inconsistent. The one thing we can be
> sure of is that Halts is NOT a correcct Halting Decider for the
> classical Halting Problem.
> 
>>
>> This is the same thing as saying if a cat is black then we know it is a
>> black cat.
>>
> 
> Yes, if a cat is black, it is a black cat, but that doesn't prove that
> there ARE black cats. Also, your statement is actually more of like, I
> will define this cat as black, so it is a black cat, even though the cat
> is white, or maybe even a dog.
> 
> 


-- 
Copyright 2020 Pete Olcott

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

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


Page 1 of 7  [1] 2 3 4 5 6 7  Next page →

Back to top | Article view | comp.theory


csiph-web