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 6 of 7 — ← Prev page 1 2 3 4 5 [6] 7  Next page →


#26080 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 20:17 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<xsYvH.213551$1R4.111919@fx44.iad>
In reply to#26078
On 11/26/20 7:25 PM, olcott wrote:
> On 11/26/2020 6:11 PM, Richard Damon wrote:

>>
>> But, when tested H_Hat(H_Hat) will halt under these conditions (or the
> 
> H_Hat would never halt unless Halts stops simulating it thus perfectly
> matching the required criteria for a "not halting" decision.

But then Halts failed to meet its requirements, and thus still isn't a
proper halting decider.

Ultimately, the actual behave IS the test, not the prediction.

Note, a device using the Halt Decider is allowed to trust that the Halt
Decider will fulfill its requirements.

Also, as I have pointed out, your method of just blindly simulating
until you get enough evidence to declare non-halting is a particularly
bad method, and it is that choice of method that introduces the infinite
recursion.

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


#26067 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 17:22 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<iUVvH.9038$Cc5.4040@fx36.iad>
In reply to#26055
On 11/26/20 4:12 PM, olcott wrote:
> On 11/26/2020 3:02 PM, Richard Damon wrote:
>> On 11/26/20 2:07 PM, olcott wrote:
>>
>>>
>>> (1) The code below is obviously infinitely recursive.
>>
>> Yes.
>>
>>>
>>> (2) Halts() has identical behavior to DebugStep() until Halts() decides
>>> to terminate its input.
>>
>> Ok. Does it promise to always work in finite time?
>>>
>>> ∴ swapping function calls to Halts() for the two function calls to
>>> DebugStep() makes the function call to Halts() from H_Hat infinitely
>>> recursive.>
>>> ∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
>>> correct not halting decision.
>>>
>>
>> If its indication is that it found infinite recursion instead of
>> claiming it has determined non-halting behavior, and it doesn't promise
>> to always make its decision in fintie time, then depending on exactly
>> what its indication is supposed to mean, it may be correct.
>>
>> Halts does NOT meet the requirements of a classical halting detector.
> Halts() does meet the requirements of a classical partial halt decider
> on input H_Hat.
> 

Then its answer is incorrect if it is interpreted to mean that H_Hat is
a non-halting computation. This is because by taking on the requirements
of a decider, then the apparent infinite recursion, all of which happen
inside an invocation of Halt, is required to be terminated by the
definition of Halts.

As to just being infinite recursion, that might get a bit into what
exact definition you want to use. The infinite recursion can not
actually happen, due to the specification of Halts, which is in control
of that recursion. You might be able to argue that it is infinite
recursion that Halts had to abort, because it was required by
specification to abort, and if it failed to do so it wouldn't meet its
own requirement.

>>
>>> int DebugTrace(u32 P, u32 I)
>>> {
>>>    ((int(*)(int))P)(I);
>>>    return 1;
>>> }
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03   u32 Aborted = DebugTrace(P, P);
>>> 04   if (Aborted)
>>> 05     HALT
>>> 06   else
>>> 07     HERE: goto HERE;
>>> 08 }
>>>
>>> int main()
>>> {
>>>    u32 P = (u32)H_Hat;
>>>    DebugTrace(P, P);
>>>    HALT;
>>> }
> 
> 
> 

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


#26068 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 16:34 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<CpWdnXldTOH4sF3CnZ2dnUU7-T3NnZ2d@giganews.com>
In reply to#26067
On 11/26/2020 4:22 PM, Richard Damon wrote:
> On 11/26/20 4:12 PM, olcott wrote:
>> On 11/26/2020 3:02 PM, Richard Damon wrote:
>>> On 11/26/20 2:07 PM, olcott wrote:
>>>
>>>>
>>>> (1) The code below is obviously infinitely recursive.
>>>
>>> Yes.
>>>
>>>>
>>>> (2) Halts() has identical behavior to DebugStep() until Halts() decides
>>>> to terminate its input.
>>>
>>> Ok. Does it promise to always work in finite time?
>>>>
>>>> ∴ swapping function calls to Halts() for the two function calls to
>>>> DebugStep() makes the function call to Halts() from H_Hat infinitely
>>>> recursive.>
>>>> ∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
>>>> correct not halting decision.
>>>>
>>>
>>> If its indication is that it found infinite recursion instead of
>>> claiming it has determined non-halting behavior, and it doesn't promise
>>> to always make its decision in fintie time, then depending on exactly
>>> what its indication is supposed to mean, it may be correct.
>>>
>>> Halts does NOT meet the requirements of a classical halting detector.
>> Halts() does meet the requirements of a classical partial halt decider
>> on input H_Hat.
>>
> 
> Then its answer is incorrect if it is interpreted to mean that H_Hat is
> a non-halting computation. 

Any input (TMD / DATA) that would never halt unless its (UTM) stopped 
simulating it expresses behavior that is not halting behavior.

When Halts() simulates its input (playing the exact same role as the 
above UTM) then any "not halting" decision that it makes according to 
the above criteria would be necessarily correct.

Halts(H_Hat, H_Hat) is such a "not halting" decision.


> This is because by taking on the requirements
> of a decider, then the apparent infinite recursion, all of which happen
> inside an invocation of Halt, is required to be terminated by the
> definition of Halts.
> 
> As to just being infinite recursion, that might get a bit into what
> exact definition you want to use. The infinite recursion can not
> actually happen, due to the specification of Halts, which is in control
> of that recursion. You might be able to argue that it is infinite
> recursion that Halts had to abort, because it was required by
> specification to abort, and if it failed to do so it wouldn't meet its
> own requirement.
> 
>>>
>>>> int DebugTrace(u32 P, u32 I)
>>>> {
>>>>     ((int(*)(int))P)(I);
>>>>     return 1;
>>>> }
>>>>
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03   u32 Aborted = DebugTrace(P, P);
>>>> 04   if (Aborted)
>>>> 05     HALT
>>>> 06   else
>>>> 07     HERE: goto HERE;
>>>> 08 }
>>>>
>>>> int main()
>>>> {
>>>>     u32 P = (u32)H_Hat;
>>>>     DebugTrace(P, P);
>>>>     HALT;
>>>> }
>>
>>
>>
> 


-- 
Copyright 2020 Pete Olcott

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

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


#26071 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 18:09 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<bBWvH.66897$J92.572@fx48.iad>
In reply to#26068
On 11/26/20 5:34 PM, olcott wrote:
> 
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.
> 
> When Halts() simulates its input (playing the exact same role as the
> above UTM) then any "not halting" decision that it makes according to
> the above criteria would be necessarily correct.
> 
> Halts(H_Hat, H_Hat) is such a "not halting" decision.

The key word here is "unless."


As has been shown several times before, and you keep inventing more
convoluted ways to prevent actually doing this, that unless is FALSE in
this case, as if we convert that first (and only the first) halt decider
into a UTM, we see that the infinite recursion is broken by the next
decider down, and then the system completes and comes to a halt.

Note, your 'dodge' of moving the decider into a global does not save you
here. This necessity test is not 'change the function' but change that
PARTICULAR halting decision, so must only affect that particular level
of operation.

This has been shown multiple times how to do this, either by spliting
the functions into two copies, the top one using the UTM and the rest of
the recursion using the Halt decider, or giving the decider a parameter
to tell it that this invocation is a unless test, and disable the halt
test just here.

Another important thing to note, this whole proof is being done on you
x86 under the guise of a Turing Equivalent computation, which says we
need to look back to haw this would be done on an actual Turing Machine.
When we do this, the 'global' nature of thr halt decider goes away, as
it WILL be incoded into an actual Turing Machine, and then there will be
a copy of it in the representation that will get duplicated, and so on.
This says that it is actually quite possible to change just the top
level description, and any inability on your part to do so is a flaw in
your equivalence.

I note, that in your original description of what you were going to do,
the input was going to be a COFF file, but it seems that somehow  it
became just a program loaded into memory.

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


#26072 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 17:16 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<pKmdnT_XYfXLql3CnZ2dnUU7-aOdnZ2d@giganews.com>
In reply to#26071
On 11/26/2020 5:09 PM, Richard Damon wrote:
> On 11/26/20 5:34 PM, olcott wrote:
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
>>
>> When Halts() simulates its input (playing the exact same role as the
>> above UTM) then any "not halting" decision that it makes according to
>> the above criteria would be necessarily correct.
>>
>> Halts(H_Hat, H_Hat) is such a "not halting" decision.
> 
> The key word here is "unless."
> 
> 
> As has been shown several times before, and you keep inventing more
> convoluted ways to prevent actually doing this, that unless is FALSE in
> this case, as if we convert that first (and only the first) halt decider

You must have brain damage. There is only one global halt decider.
I have told you this way too many times.

-- 
Copyright 2020 Pete Olcott

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

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


#26075 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 19:06 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<kqXvH.14738$Wi7.11318@fx29.iad>
In reply to#26072
On 11/26/20 6:16 PM, olcott wrote:
> On 11/26/2020 5:09 PM, Richard Damon wrote:
>> On 11/26/20 5:34 PM, olcott wrote:
>>>
>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>> simulating it expresses behavior that is not halting behavior.
>>>
>>> When Halts() simulates its input (playing the exact same role as the
>>> above UTM) then any "not halting" decision that it makes according to
>>> the above criteria would be necessarily correct.
>>>
>>> Halts(H_Hat, H_Hat) is such a "not halting" decision.
>>
>> The key word here is "unless."
>>
>>
>> As has been shown several times before, and you keep inventing more
>> convoluted ways to prevent actually doing this, that unless is FALSE in
>> this case, as if we convert that first (and only the first) halt decider
> 
> You must have brain damage. There is only one global halt decider.
> I have told you this way too many times.
> 

You have IMPLEMENTED one global halt detector, but when the system is
convert back in a Turing Machine, it wont be, as that structure doesn't
match the problem statement.

In fact, depending on how you have actually implement this, you may have
broken you Turing Equivalence, which would invalidate you whole proof.

Note, that in the Linz proof, there exists two very distinct copies of
H, there is one as part of the actual Turing Machine H^, and a second
copy contained within the representation of H^ put on the input tape.

If you pull too many shenanigans with your structure, you will be asked
to PROVE that you system is an equivalent, which I don't know if you
know how to do that.

Note that Turing Equivalence thesis says there is one, but just quoting
it won't show that your particular program is the equivalent of the
specified machine from the Linz proof.

One thing to remember, By definition, you program, including the Halt
Decider, is the equivalent of some Turing Machine, so that Turing
Machine can be legally converted back and used as an input to your
program, so you can't use that ruse to get around having a second copy
of the halt decider in the system. (Hope you were good in your design of
your VM design so it can emulate a VM.)

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


#26076 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 18:10 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<zPGdnaSewZp23l3CnZ2dnUU7-f-dnZ2d@giganews.com>
In reply to#26075
On 11/26/2020 6:06 PM, Richard Damon wrote:
> On 11/26/20 6:16 PM, olcott wrote:
>> On 11/26/2020 5:09 PM, Richard Damon wrote:
>>> On 11/26/20 5:34 PM, olcott wrote:
>>>>
>>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>>> simulating it expresses behavior that is not halting behavior.
>>>>
>>>> When Halts() simulates its input (playing the exact same role as the
>>>> above UTM) then any "not halting" decision that it makes according to
>>>> the above criteria would be necessarily correct.
>>>>
>>>> Halts(H_Hat, H_Hat) is such a "not halting" decision.
>>>
>>> The key word here is "unless."
>>>
>>>
>>> As has been shown several times before, and you keep inventing more
>>> convoluted ways to prevent actually doing this, that unless is FALSE in
>>> this case, as if we convert that first (and only the first) halt decider
>>
>> You must have brain damage. There is only one global halt decider.
>> I have told you this way too many times.
>>
> 
> You have IMPLEMENTED one global halt detector, but when the system is
> convert back in a Turing Machine, it wont be, as that structure doesn't
> match the problem statement.
> 

Any input (TMD / DATA) that would never halt unless its (UTM) stopped 
simulating it expresses behavior that is not halting behavior.

When Halts() simulates its input (playing the exact same role as the 
above UTM) then any "not halting" decision that it makes according to 
the above criteria would be necessarily correct.

Halts(H_Hat, H_Hat) is such a "not halting" decision.


-- 
Copyright 2020 Pete Olcott

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

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


#26073 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-26 23:11 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<87a6v367cz.fsf@bsb.me.uk>
In reply to#26038
olcott <NoOne@NoWhere.com> writes:

> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>> <cut>
>>>> int DebugTrace(u32 P, u32 I)
>>>> {
>>>> ((int(*)(int))P)(I);
>>>> return 1;
>>>> }
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Aborted = DebugTrace(P, P);
>>>> if (Aborted)
>>>> HALT
>>>> else
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> u32 P = (u32)H_Hat;
>>>> DebugTrace(P, P);
>>>> HALT;
>>>> }
>>
>> (The indentation was lost before I replied, honest, guv.)
>>   
>>> That's infinite recusion, right enough.
>>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>>> then it is no longer infinite recursion.
>>
>> Which is the key to PO's halting problem 2.0.  A program is non-halting
>> not because it doesn't halt, but because it wouldn't halt if weren't
>> halted.  Simples!
>>
>
> Every program / (TMD being simulated) that does not halt unless it is
> forced to halt is a non halting program / (TMD being simulated).

There are simpler ways to put it, but yes.  I don't think there is any
dispute (even from you) about what is a finite computation and what isn't.

> Every program / (TMD being simulated) that halts without being forced
> to halt is a halting program / (TMD being simulated).

Again, there are much simpler ways to put this, but it's not wrong, just
devious.

> Thus dividing inputs into halting and not halting as the actual
> Halting Problem itself requires.

Yes.  Your confusing wording is not helping you, but I think it's
deliberate -- it's laying the ground work for your ruse.

> The Halting problem is a problem in computer science. The problem is
> looking at a computer program and finding out if the program is going
> to run forever or not.
> https://simple.wikipedia.org/wiki/Halting_problem

See?  There are simpler ways to put it.  (Mind you, as one might expect,
WP has gone a bit too far the other way and is slightly oversimplifying
the issue.)

Anytime you fancy having another go at posting a function F such that
F(P, I) is true if and only if P(I) is a finite computation and false
otherwise, let me know.  I'll post values for P and I that show that F is
not a halt decider.

-- 
Ben.

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


#26074 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 17:41 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<Feadnbm6R6KgoF3CnZ2dnUU7-fOdnZ2d@giganews.com>
In reply to#26073
On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>
>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>> <cut>
>>>>> int DebugTrace(u32 P, u32 I)
>>>>> {
>>>>> ((int(*)(int))P)(I);
>>>>> return 1;
>>>>> }
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>> u32 Aborted = DebugTrace(P, P);
>>>>> if (Aborted)
>>>>> HALT
>>>>> else
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> u32 P = (u32)H_Hat;
>>>>> DebugTrace(P, P);
>>>>> HALT;
>>>>> }
>>>
>>> (The indentation was lost before I replied, honest, guv.)
>>>    
>>>> That's infinite recusion, right enough.
>>>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>>>> then it is no longer infinite recursion.
>>>
>>> Which is the key to PO's halting problem 2.0.  A program is non-halting
>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>> halted.  Simples!
>>>
>>
>> Every program / (TMD being simulated) that does not halt unless it is
>> forced to halt is a non halting program / (TMD being simulated).
> 
> There are simpler ways to put it, but yes.  I don't think there is any
> dispute (even from you) about what is a finite computation and what isn't.
> 
>> Every program / (TMD being simulated) that halts without being forced
>> to halt is a halting program / (TMD being simulated).
> 
> Again, there are much simpler ways to put this, but it's not wrong, just
> devious.
> 
>> Thus dividing inputs into halting and not halting as the actual
>> Halting Problem itself requires.
> 
> Yes.  Your confusing wording is not helping you, but I think it's
> deliberate -- it's laying the ground work for your ruse.
> 
>> The Halting problem is a problem in computer science. The problem is
>> looking at a computer program and finding out if the program is going
>> to run forever or not.
>> https://simple.wikipedia.org/wiki/Halting_problem
> 
> See?  There are simpler ways to put it.  (Mind you, as one might expect,
> WP has gone a bit too far the other way and is slightly oversimplifying
> the issue.)
> 
> Anytime you fancy having another go at posting a function F such that
> F(P, I) is true if and only if P(I) is a finite computation and false
> otherwise, let me know.  I'll post values for P and I that show that F is
> not a halt decider.
> 

Any input (TMD / DATA) that would never halt unless its (UTM) stopped 
simulating it expresses behavior that is not halting behavior.

When Halts() simulates its input (playing the exact same role as the 
above UTM) then any "not halting" decision that it makes according to 
the above criteria would be necessarily correct.

Halts(H_Hat, H_Hat) is such a "not halting" decision.
Halts(H_Hat, H_Hat) is such a "not halting" decision.
Halts(H_Hat, H_Hat) is such a "not halting" decision.



-- 
Copyright 2020 Pete Olcott

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

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


#26081 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-27 01:34 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<874klb60r9.fsf@bsb.me.uk>
In reply to#26074
olcott <NoOne@NoWhere.com> writes:

> On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>
>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>> <cut>
>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>> {
>>>>>> ((int(*)(int))P)(I);
>>>>>> return 1;
>>>>>> }
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>> if (Aborted)
>>>>>> HALT
>>>>>> else
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 P = (u32)H_Hat;
>>>>>> DebugTrace(P, P);
>>>>>> HALT;
>>>>>> }
>>>>
>>>> (The indentation was lost before I replied, honest, guv.)
>>>>    
>>>>> That's infinite recusion, right enough.
>>>>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>>>>> then it is no longer infinite recursion.
>>>>
>>>> Which is the key to PO's halting problem 2.0.  A program is non-halting
>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>> halted.  Simples!
>>>>
>>>
>>> Every program / (TMD being simulated) that does not halt unless it is
>>> forced to halt is a non halting program / (TMD being simulated).
>>
>> There are simpler ways to put it, but yes.  I don't think there is any
>> dispute (even from you) about what is a finite computation and what isn't.
>>
>>> Every program / (TMD being simulated) that halts without being forced
>>> to halt is a halting program / (TMD being simulated).
>>
>> Again, there are much simpler ways to put this, but it's not wrong, just
>> devious.
>>
>>> Thus dividing inputs into halting and not halting as the actual
>>> Halting Problem itself requires.
>>
>> Yes.  Your confusing wording is not helping you, but I think it's
>> deliberate -- it's laying the ground work for your ruse.
>>
>>> The Halting problem is a problem in computer science. The problem is
>>> looking at a computer program and finding out if the program is going
>>> to run forever or not.
>>> https://simple.wikipedia.org/wiki/Halting_problem
>>
>> See?  There are simpler ways to put it.  (Mind you, as one might expect,
>> WP has gone a bit too far the other way and is slightly oversimplifying
>> the issue.)
>>
>> Anytime you fancy having another go at posting a function F such that
>> F(P, I) is true if and only if P(I) is a finite computation and false
>> otherwise, let me know.  I'll post values for P and I that show that F is
>> not a halt decider.
>
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.

Too much waffle.  We care about actual halting/non-halting not what
would happen.  But you need the waffle to be able to declare the wrong
halting decision the right one.

The proper definition if non-halting is much simpler and refers to what
the code means as written.  Pretty much any sentence from you with
"would" in it sets off the *WHOOP*, *WHOOP*, *WHOOP* of the ruse alarm.

> When Halts() simulates its input (playing the exact same role as the
> above UTM) then any "not halting" decision that it makes according to
> the above criteria would be necessarily correct.

... and necessarily incorrect according to the halting criterion.  You
can declare the wrong answer to be the right one according to your
criteria until you are blue in the face, but you don't get to define
what a halting (or non-halting) computation is.

> Halts(H_Hat, H_Hat) is such a "not halting" decision.

Who cares?  H_Hat (as shown) makes no reference to Halts.  That function
is not a problem case for Halts.

Anytime you fancy having another go at posting a function F such that
F(P, I) is true if and only if P(I) is a finite computation and false
otherwise, let me know.  I'll post values for P and I that show that F
is not a halt decider.

> Halts(H_Hat, H_Hat) is such a "not halting" decision.
> Halts(H_Hat, H_Hat) is such a "not halting" decision.

Still no one cares.  Post Halts, even in outline and I will show you
(yet again) a case it gets wrong.

-- 
Ben.

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


#26083 — Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 20:45 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself)
Message-ID<PZedncKZbL_P9V3CnZ2dnUU7-ePNnZ2d@giganews.com>
In reply to#26081
On 11/26/2020 7:34 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>>
>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>> <cut>
>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>> {
>>>>>>> ((int(*)(int))P)(I);
>>>>>>> return 1;
>>>>>>> }
>>>>>>>
>>>>>>> void H_Hat(u32 P)
>>>>>>> {
>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>> if (Aborted)
>>>>>>> HALT
>>>>>>> else
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> u32 P = (u32)H_Hat;
>>>>>>> DebugTrace(P, P);
>>>>>>> HALT;
>>>>>>> }
>>>>>
>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>     
>>>>>> That's infinite recusion, right enough.
>>>>>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>>>>>> then it is no longer infinite recursion.
>>>>>
>>>>> Which is the key to PO's halting problem 2.0.  A program is non-halting
>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>> halted.  Simples!
>>>>>
>>>>
>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>> forced to halt is a non halting program / (TMD being simulated).
>>>
>>> There are simpler ways to put it, but yes.  I don't think there is any
>>> dispute (even from you) about what is a finite computation and what isn't.
>>>
>>>> Every program / (TMD being simulated) that halts without being forced
>>>> to halt is a halting program / (TMD being simulated).
>>>
>>> Again, there are much simpler ways to put this, but it's not wrong, just
>>> devious.
>>>
>>>> Thus dividing inputs into halting and not halting as the actual
>>>> Halting Problem itself requires.
>>>
>>> Yes.  Your confusing wording is not helping you, but I think it's
>>> deliberate -- it's laying the ground work for your ruse.
>>>
>>>> The Halting problem is a problem in computer science. The problem is
>>>> looking at a computer program and finding out if the program is going
>>>> to run forever or not.
>>>> https://simple.wikipedia.org/wiki/Halting_problem
>>>
>>> See?  There are simpler ways to put it.  (Mind you, as one might expect,
>>> WP has gone a bit too far the other way and is slightly oversimplifying
>>> the issue.)
>>>
>>> Anytime you fancy having another go at posting a function F such that
>>> F(P, I) is true if and only if P(I) is a finite computation and false
>>> otherwise, let me know.  I'll post values for P and I that show that F is
>>> not a halt decider.
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
> 
> Too much waffle.  We care about actual halting/non-halting not what
> would happen.  But you need the waffle to be able to declare the wrong
> halting decision the right one.
On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
 > olcott <NoOne@NoWhere.com> writes:
 >> Every program / (TMD being simulated) that does not halt unless it is
 >> forced to halt is a non halting program / (TMD being simulated).
 >
 > There are simpler ways to put it, but yes.  I don't think there
 > is any dispute (even from you) about what is a finite computation
 > and what isn't.


-- 
Copyright 2020 Pete Olcott

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

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


#26095 — Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-27 17:09 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself)
Message-ID<87mtz24thr.fsf@bsb.me.uk>
In reply to#26083
olcott <NoOne@NoWhere.com> writes:

> On 11/26/2020 7:34 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>>>
>>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>>> <cut>
>>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>>> {
>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>> return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>> if (Aborted)
>>>>>>>> HALT
>>>>>>>> else
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>> DebugTrace(P, P);
>>>>>>>> HALT;
>>>>>>>> }
>>>>>>
>>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>>     
>>>>>>> That's infinite recusion, right enough.
>>>>>>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>>>>>>> then it is no longer infinite recursion.
>>>>>>
>>>>>> Which is the key to PO's halting problem 2.0.  A program is non-halting
>>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>>> halted.  Simples!
>>>>>>
>>>>>
>>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>
>>>> There are simpler ways to put it, but yes.  I don't think there is any
>>>> dispute (even from you) about what is a finite computation and what isn't.
>>>>
>>>>> Every program / (TMD being simulated) that halts without being forced
>>>>> to halt is a halting program / (TMD being simulated).
>>>>
>>>> Again, there are much simpler ways to put this, but it's not wrong, just
>>>> devious.
>>>>
>>>>> Thus dividing inputs into halting and not halting as the actual
>>>>> Halting Problem itself requires.
>>>>
>>>> Yes.  Your confusing wording is not helping you, but I think it's
>>>> deliberate -- it's laying the ground work for your ruse.
>>>>
>>>>> The Halting problem is a problem in computer science. The problem is
>>>>> looking at a computer program and finding out if the program is going
>>>>> to run forever or not.
>>>>> https://simple.wikipedia.org/wiki/Halting_problem
>>>>
>>>> See?  There are simpler ways to put it.  (Mind you, as one might expect,
>>>> WP has gone a bit too far the other way and is slightly oversimplifying
>>>> the issue.)
>>>>
>>>> Anytime you fancy having another go at posting a function F such that
>>>> F(P, I) is true if and only if P(I) is a finite computation and false
>>>> otherwise, let me know.  I'll post values for P and I that show that F is
>>>> not a halt decider.
>>>
>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>> simulating it expresses behavior that is not halting behavior.
>>
>> Too much waffle.  We care about actual halting/non-halting not what
>> would happen.  But you need the waffle to be able to declare the wrong
>> halting decision the right one.
> On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> Every program / (TMD being simulated) that does not halt unless it is
>>> forced to halt is a non halting program / (TMD being simulated).
>>
>> There are simpler ways to put it, but yes.  I don't think there
>> is any dispute (even from you) about what is a finite computation
>> and what isn't.

Why are you quoting something that is already in the quoted text?  If
you have something to say about, the usual method is write your remarks
below where it appears in context.

Are you pretending that you change from "would" to "does" is
insignificant, and you think I've changed my mind?

-- 
Ben.

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


#26102 — Re: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself [verified])

Fromolcott <NoOne@NoWhere.com>
Date2020-11-27 12:14 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](Ben disagrees with himself [verified])
Message-ID<BuKdnRYkYfSL31zCnZ2dnUU7-dHNnZ2d@giganews.com>
In reply to#26095
On 11/27/2020 11:09 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/26/2020 7:34 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>>>>
>>>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>>>> <cut>
>>>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>>>> {
>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>> return 1;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>> {
>>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>>> if (Aborted)
>>>>>>>>> HALT
>>>>>>>>> else
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>>> DebugTrace(P, P);
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>
>>>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>>>      
>>>>>>>> That's infinite recusion, right enough.
>>>>>>>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>>>>>>>> then it is no longer infinite recursion.
>>>>>>>
>>>>>>> Which is the key to PO's halting problem 2.0.  A program is non-halting
>>>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>>>> halted.  Simples!
>>>>>>>
>>>>>>
>>>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>>
>>>>> There are simpler ways to put it, but yes.  I don't think there is any
>>>>> dispute (even from you) about what is a finite computation and what isn't.
>>>>>
>>>>>> Every program / (TMD being simulated) that halts without being forced
>>>>>> to halt is a halting program / (TMD being simulated).
>>>>>
>>>>> Again, there are much simpler ways to put this, but it's not wrong, just
>>>>> devious.
>>>>>
>>>>>> Thus dividing inputs into halting and not halting as the actual
>>>>>> Halting Problem itself requires.
>>>>>
>>>>> Yes.  Your confusing wording is not helping you, but I think it's
>>>>> deliberate -- it's laying the ground work for your ruse.
>>>>>
>>>>>> The Halting problem is a problem in computer science. The problem is
>>>>>> looking at a computer program and finding out if the program is going
>>>>>> to run forever or not.
>>>>>> https://simple.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> See?  There are simpler ways to put it.  (Mind you, as one might expect,
>>>>> WP has gone a bit too far the other way and is slightly oversimplifying
>>>>> the issue.)
>>>>>
>>>>> Anytime you fancy having another go at posting a function F such that
>>>>> F(P, I) is true if and only if P(I) is a finite computation and false
>>>>> otherwise, let me know.  I'll post values for P and I that show that F is
>>>>> not a halt decider.
>>>>
>>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>>> simulating it expresses behavior that is not halting behavior.
>>>
>>> Too much waffle.  We care about actual halting/non-halting not what
>>> would happen.  But you need the waffle to be able to declare the wrong
>>> halting decision the right one.
>> On 11/26/2020 5:11 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>> forced to halt is a non halting program / (TMD being simulated).
>>>
>>> There are simpler ways to put it, but yes.  I don't think there
>>> is any dispute (even from you) about what is a finite computation
>>> and what isn't.
> 
> Why are you quoting something that is already in the quoted text?  If

To focus attention more sharply some of the repondents seem to have 
attenition deficit disorder.

> you have something to say about, the usual method is write your remarks
> below where it appears in context.
> 
> Are you pretending that you change from "would" to "does" is
> insignificant, and you think I've changed my mind?
> 

CASE I
(a) Any input (TMD / DATA) that would never halt
(b) unless its (UTM) stopped simulating it
(c) expresses behavior that is not halting behavior.

CASE II
(a) Every program / (TMD being simulated) that does not halt
(b) unless it is forced to halt
(c) is a non halting program / (TMD being simulated).

I(a) ≡ II(a)  PREMISE part (a)
I(b) ≡ II(b)  PREMISE part (b)
I(c) ≡ II(c)  CONCLUSION

Ben did not understand that he disagreed with himself.

-- 
Copyright 2020 Pete Olcott

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

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


#26039 — Re: It is known that a correct halt decider must return false (in this case)[V2](whole solution)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 11:58 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<ELGdnQBzyJJTcSLCnZ2dnUU7-XOdnZ2d@giganews.com>
In reply to#26035
On 11/26/2020 11:09 AM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>> On 11/26/2020 9:43 AM, Richard Damon wrote:
>>> On 11/26/20 9:33 AM, olcott wrote:
>>>> On 11/26/2020 8:22 AM, Richard Damon wrote:
>>>>> On 11/25/20 11:30 PM, olcott wrote:
>>>>>>>
>>>>>>
>>>>>> 01 void H_Hat(u32 P)
>>>>>> 02 {
>>>>>> 03 u32 Aborted = DebugTrace(P, P);
>>>>>> 04 if (Aborted)
>>>>>> 05 HALT
>>>>>> 06 else
>>>>>> 07 HERE: goto HERE;
>>>>>> 08 }
>>>>>>
>>>>>> The H_Hat() that calls DebugTrace() is computationally identical to the
>>>>>> H_Hat() that calls Halts() because neither one of them ever gets past
>>>>>> line 03.
>>>>>>
>>>>>> You are the only one that I know smart enough to see this. Ben would
>>>>>> never say it if he did see it. Richard does not understand these things
>>>>>> well enough to see this.
>>>>>>
>>>>>
>>>>> The only possible reason to NOT get past line 3 when calling Halts, (if
>>>>> Halts is supposed to be a proper halt detector), is because Halts is
>>>>> broken and doesn't meet its requirements.
>>>>
>>>> I am probably going to stop responding to you because you do not have
>>>> enough basic knowledge of things like infinite recursion to ever
>>>> actually understand what I am saying.
>>>>
>>>> It is ridiculous to assume that a function designed to detect Halting
>>>> would be required rewrite the code that it is testing to remove the
>>>> infinite recursion of this code.
>>>>
>>>
>>> WHERE DO I SAY RE-WRITE CODE. Maybe the way you are implementing your
>>> halt detector is SO wrong that it has gotten itself into a jam, but then
>>> that is YOUR problem.
>>>
>> When you expect Halts() to return a value to H_Hat() that is exactly the
>> same as expecting DebugTrace() to return a value to H_Hat(), thus
>> proving that you must be clueless about how infinite recursion works.
>>
>>
>> int DebugTrace(u32 P, u32 I)
>> {
>> ((int(*)(int))P)(I);
>> return 1;
>> }
>>
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> DebugTrace(P, P);
>> HALT;
>> }
>>
> That's infinite recusion, right enough.
> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
> then it is no longer infinite recursion.
> 

Every program / (TMD being simulated) that does not halt unless it is 
forced to halt is a non halting program / (TMD being simulated).

Every program / (TMD being simulated) that halts without being forced to 
halt is a halting program / (TMD being simulated).

Thus dividing inputs into halting and not halting as the actual Halting 
Problem itself requires:

The Halting problem is a problem in computer science. The problem is 
looking at a computer program and finding out if the program is going to 
run forever or not.  https://simple.wikipedia.org/wiki/Halting_problem

-- 
Copyright 2020 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 13:21 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](ridiculous)
Message-ID<lmSvH.9324$sB6.9256@fx34.iad>
In reply to#26028
On 11/26/20 10:49 AM, olcott wrote:
> On 11/26/2020 9:43 AM, Richard Damon wrote:
>> On 11/26/20 9:33 AM, olcott wrote:
>>> On 11/26/2020 8:22 AM, Richard Damon wrote:
>>>> On 11/25/20 11:30 PM, olcott wrote:
>>>>>>
>>>>>
>>>>> 01 void H_Hat(u32 P)
>>>>> 02 {
>>>>> 03   u32 Aborted = DebugTrace(P, P);
>>>>> 04   if (Aborted)
>>>>> 05     HALT
>>>>> 06   else
>>>>> 07     HERE: goto HERE;
>>>>> 08 }
>>>>>
>>>>> The H_Hat() that calls DebugTrace() is computationally identical to
>>>>> the
>>>>> H_Hat() that calls Halts() because neither one of them ever gets past
>>>>> line 03.
>>>>>
>>>>> You are the only one that I know smart enough to see this. Ben would
>>>>> never say it if he did see it. Richard does not understand these
>>>>> things
>>>>> well enough to see this.
>>>>>
>>>>
>>>> The only possible reason to NOT get past line 3 when calling Halts, (if
>>>> Halts is supposed to be a proper halt detector), is because Halts is
>>>> broken and doesn't meet its requirements.
>>>
>>> I am probably going to stop responding to you because you do not have
>>> enough basic knowledge of things like infinite recursion to ever
>>> actually understand what I am saying.
>>>
>>> It is ridiculous to assume that a function designed to detect Halting
>>> would be required rewrite the code that it is testing to remove the
>>> infinite recursion of this code.
>>>
>>
>> WHERE DO I SAY RE-WRITE CODE. Maybe the way you are implementing your
>> halt detector is SO wrong that it has gotten itself into a jam, but then
>> that is YOUR problem.
>>
> When you expect Halts() to return a value to H_Hat() that is exactly the
> same as expecting DebugTrace() to return a value to H_Hat(), thus
> proving that you must be clueless about how infinite recursion works.
> 

If DebugTrace is suppose to be/defkned as a 'Halt Decider' then Yes, I
would expect it, If DebugTrace is not supposed to be/defined as a 'Halt
Decider' but just an emulator, no, I don't expect it.

Note, I am talking about the TEST execution, where we are directly
running H_Hat

THAT is part of the definition of a Halt Decider, it gives its answer to
its caller.


Given: (Magical code for Halts not shown)

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

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

The Execution trace/call stack that I expect is something like:

1) enter main
2) Call H_Hat (#1)
3) Call Halts (#2)
4) in emulation: Call H_Hat (#3)
5) in emulation: Call Halts (#4)
5) in double emulation Call H_Hat (#5)
6) Recursion detected byt Halts (#2), stops emulation
7) Halts (#2) return Aborted to H_Hat (#1)
8) H_Hat #1 Halts.

H_Hat #1 Halting shows that the computation H_Hat(H_Hat) using this
Halts definition is halting.

But this Halts definition decided that H_Hat(H_Hat) was non-halting.

Remember, normally the ONLY trace I really care about is the running of
the actual machine. I don't really care what the halt decider did to
come up with the answer (but need to know the answer it gives)

Now, if we do look into the trace, the fact that at no part in the trace
within Halts has an answer been given and responded to is a good hint
that there is a problem with the design of Halts, it has set up an
inconclusive test for the problem it was designed to do. This is NOT the
'fault' of H_Hat, but the responsibility of Halts to figure out.

Thus, the fact that within the simulation, H_Hat never return to its
caller is a sign that some code needs to be fixed, not code in H_Hat,
but code in Halts.

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

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


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

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-26 16:35 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](ridiculous)
Message-ID<X4adnRnx8YmhRCLCnZ2dnUU78SvNnZ2d@brightview.co.uk>
In reply to#26025
On 26/11/2020 14:33, olcott wrote:
> On 11/26/2020 8:22 AM, Richard Damon wrote:
>> On 11/25/20 11:30 PM, olcott wrote:
>>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03   u32 Aborted = DebugTrace(P, P);
>>> 04   if (Aborted)
>>> 05     HALT
>>> 06   else
>>> 07     HERE: goto HERE;
>>> 08 }
>>>
>>> The H_Hat() that calls DebugTrace() is computationally identical to the
>>> H_Hat() that calls Halts() because neither one of them ever gets past
>>> line 03.
>>>
>>> You are the only one that I know smart enough to see this. Ben would
>>> never say it if he did see it. Richard does not understand these things
>>> well enough to see this.
>>>
>>
>> The only possible reason to NOT get past line 3 when calling Halts, (if
>> Halts is supposed to be a proper halt detector), is because Halts is
>> broken and doesn't meet its requirements.
>
> I am probably going to stop responding to you because you do not have
> enough basic knowledge of things like infinite recursion to ever
> actually understand what I am saying.

You are quick to accuse other people of lacking competence to understand 
things - in this case recursion.  Haven't you learned by now that every 
time you do this it back-fires and turns out that YOU are the one who 
doesn't understand?

In our current discussion around detecting infinite recursion, you are 
showing clear signs of not understanding the basics again....
Mike.

>
> It is ridiculous to assume that a function designed to detect Halting
> would be required rewrite the code that it is testing to remove the
> infinite recursion of this code.
>
>> YOu may complain that that isn't what Halts is supposed to be in this
>> example, but that is EXACTLY why I said you shouldn't use this naming
>> style.
>>
>> YOu have already been found 'Guilty' of trying to sneak in the comments
>> about one version of a function to when it was being used as a different
>> functions.
>>
>> The use of obviously misleading names is a good sign that you are
>> intentionally trying to pull a scam here.
>>
>
>

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


#26024 — Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 08:26 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood)
Message-ID<9vmdnf2idIqHJiLCnZ2dnUU7-RHNnZ2d@giganews.com>
In reply to#26017
On 11/25/2020 10:12 PM, Mike Terry wrote:
> On 26/11/2020 02:43, olcott wrote:
>> On 11/25/2020 7:30 PM, Richard Damon wrote:
>>> On 11/25/20 7:49 PM, olcott wrote:
>>>
>>>> I am sure that Richard still does not get this:
>>>>
>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>> 1)  There is the possibility that a halt decider
>>>>> might choose to quit enumerating the calculation
>>>>> steps earlier than the UTM
>>>>
>>>>> ...any perceived "change of behaviour" as a
>>>>> result of the halt decider aborting its emulation
>>>>> is not actually behaviour of H_Hat, it's different
>>>>> emulator behaviour.
>>>>
>>>>
>>>>
>>>
>>> I fully understand it, and as Mike said, it is not applicable to this
>>> problem.
>>>
>>> The key is he was talking about the steps taken INSIDE the emulation,
>>> which yes, there is no diference base on what is outside it.
>>>
>>> There IS a difference to what happens OUTSIDE the emulation, to the
>>> machine that is CALLING the UTM/Halt Decider.
>>>
>>> Now, because of the recursion that is happening, many of the machines
>>> are actually in both situations.
>>>
>>> Thus
>>>
>>> int H_UTM(P)
>>> {
>>>     if(UTM(P, P))
>>>         while(1) ;
>>>     else
>>>        HALT;
>>> }
>>>
>>> is a different computation from
>>>
>>> int H_Halt(P)
>>> {
>>>    if(Halt_Detector(P,P))
>>>        while(1);
>>>    else
>>>        HALT;
>>> }
>>>
>>> (irrespective of what P is so we are talking the recursive stuff yet)
>>
>>
>> That is an incorrect way of specifying it.
>> Here is the correct way.
> 
> Richard does not specify the input data P for the calculation, so I 
> would have said H_UTM(H_UTM) is a different computation from 
> H_Halt(H_Halt).  (Or that H_UTM is a different machine from H_Halt, or 
> maybe supplied the main() setup/call to make the input clear.  We all 
> understand what was meant though...)
> 
>>
>> void H_Hat(u32 P)
>> {
>>   u32 Aborted = DebugTrace(P, P);
>>   if (Aborted)
>>     HALT
>>   else
>>     HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>   u32 P = (u32)H_Hat;
>>   DebugTrace(P, P);
>>   HALT;
>> }
>>
>>
>> void H_Hat(u32 P)
>> {
>>   u32 Aborted = Halts(P, P);
>>   if (Aborted)
>>     HALT
>>   else
>>     HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>   u32 P = (u32)H_Hat;
>>   Halts(P, P);
>>   HALT;
>> }
>>
> That's just asking for confusion, using H_Hat for two quite different 
> machines.
> 
> But... the two machines you show above DO have different calculations as 
> Richard was saying.  (I'm not sure if that's what you were trying to say.)
> 
> 
>>
>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>> ...any perceived "change of behaviour" as a
>>>>> result of the halt decider aborting its emulation
>>>>> is not actually behaviour of H_Hat, it's different
>>>>> emulator behaviour.
>>
>> Thus when Halts() decides to abort H_Hat it is the same H_Hat as the
>> H_Hat that DebugTrace(P, P) is merely emulating.
>>
> That's ridiculous - the emulations are not even looking at the same 
> machine, let alone the same calculation.  I don't think you understand 
> what I said at all.  (No wonder you sounded so uncharacteristically 
> happy when I said it!  Mystery explained...  :) )

When we execute the following code and compare its execution trace to 
the same code that calls DebugTrace() with halt deciding enabled we find 
that these two execution traces have the exact same machine code bytes 
up to the point where the halt decider aborts the execution of H_Hat.

This would remain true even if we showed the internal computations of 
DebugTrace()

This proves as a matter of verified fact that that these two 
computations are identical.

If you disagree that they are identical you are disagreeing with 
verifiable facts thus unequivocally proving that your disagreement is 
counter-factual.

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

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




-- 
Copyright 2020 Pete Olcott

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

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


#26029 — Re: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 10:51 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](facts v falsehood)
Message-ID<7aQvH.16438$ZbR7.7768@fx01.iad>
In reply to#26024
On 11/26/20 9:26 AM, olcott wrote:
> On 11/25/2020 10:12 PM, Mike Terry wrote:
>> On 26/11/2020 02:43, olcott wrote:
>>> On 11/25/2020 7:30 PM, Richard Damon wrote:
>>>> On 11/25/20 7:49 PM, olcott wrote:
>>>>
>>>>> I am sure that Richard still does not get this:
>>>>>
>>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>>> 1)  There is the possibility that a halt decider
>>>>>> might choose to quit enumerating the calculation
>>>>>> steps earlier than the UTM
>>>>>
>>>>>> ...any perceived "change of behaviour" as a
>>>>>> result of the halt decider aborting its emulation
>>>>>> is not actually behaviour of H_Hat, it's different
>>>>>> emulator behaviour.
>>>>>
>>>>>
>>>>>
>>>>
>>>> I fully understand it, and as Mike said, it is not applicable to this
>>>> problem.
>>>>
>>>> The key is he was talking about the steps taken INSIDE the emulation,
>>>> which yes, there is no diference base on what is outside it.
>>>>
>>>> There IS a difference to what happens OUTSIDE the emulation, to the
>>>> machine that is CALLING the UTM/Halt Decider.
>>>>
>>>> Now, because of the recursion that is happening, many of the machines
>>>> are actually in both situations.
>>>>
>>>> Thus
>>>>
>>>> int H_UTM(P)
>>>> {
>>>>     if(UTM(P, P))
>>>>         while(1) ;
>>>>     else
>>>>        HALT;
>>>> }
>>>>
>>>> is a different computation from
>>>>
>>>> int H_Halt(P)
>>>> {
>>>>    if(Halt_Detector(P,P))
>>>>        while(1);
>>>>    else
>>>>        HALT;
>>>> }
>>>>
>>>> (irrespective of what P is so we are talking the recursive stuff yet)
>>>
>>>
>>> That is an incorrect way of specifying it.
>>> Here is the correct way.
>>
>> Richard does not specify the input data P for the calculation, so I
>> would have said H_UTM(H_UTM) is a different computation from
>> H_Halt(H_Halt).  (Or that H_UTM is a different machine from H_Halt, or
>> maybe supplied the main() setup/call to make the input clear.  We all
>> understand what was meant though...)
>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>>   u32 Aborted = DebugTrace(P, P);
>>>   if (Aborted)
>>>     HALT
>>>   else
>>>     HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>   u32 P = (u32)H_Hat;
>>>   DebugTrace(P, P);
>>>   HALT;
>>> }
>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>>   u32 Aborted = Halts(P, P);
>>>   if (Aborted)
>>>     HALT
>>>   else
>>>     HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>   u32 P = (u32)H_Hat;
>>>   Halts(P, P);
>>>   HALT;
>>> }
>>>
>> That's just asking for confusion, using H_Hat for two quite different
>> machines.
>>
>> But... the two machines you show above DO have different calculations
>> as Richard was saying.  (I'm not sure if that's what you were trying
>> to say.)
>>
>>
>>>
>>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>>> ...any perceived "change of behaviour" as a
>>>>>> result of the halt decider aborting its emulation
>>>>>> is not actually behaviour of H_Hat, it's different
>>>>>> emulator behaviour.
>>>
>>> Thus when Halts() decides to abort H_Hat it is the same H_Hat as the
>>> H_Hat that DebugTrace(P, P) is merely emulating.
>>>
>> That's ridiculous - the emulations are not even looking at the same
>> machine, let alone the same calculation.  I don't think you understand
>> what I said at all.  (No wonder you sounded so uncharacteristically
>> happy when I said it!  Mystery explained...  :) )
> 
> When we execute the following code and compare its execution trace to
> the same code that calls DebugTrace() with halt deciding enabled we find
> that these two execution traces have the exact same machine code bytes
> up to the point where the halt decider aborts the execution of H_Hat.
> 
> This would remain true even if we showed the internal computations of
> DebugTrace()
> 
> This proves as a matter of verified fact that that these two
> computations are identical.

No it doesn't. For the computations to be identical, they need to be
shown to be identical for ALL time. The fact that they then diverges
show that they are different.

What the key thing you need to do is look at the execution trace of the
TOP level machine, as THAT is the computation of intersest, not the
computation being traces inside DebugTrace.

You have always mentioned that we are running all this code inside a
ttop level UTM. Make THAT UTM record a full execution trace of main and
all that happens below it.

You will see the difference between the trace when using just a UTM like
function and using a halt deciding function. This difference shows that
they are diffeent computations.

> 
> If you disagree that they are identical you are disagreeing with
> verifiable facts thus unequivocally proving that your disagreement is
> counter-factual.
> 
> void H_Hat(u32 P)
> {
>   u32 Aborted = DebugTrace(P, P, 0);
>   if (Aborted)
>     HALT
>   else
>     HERE: goto HERE;
> }
> 
> int main()
> {
>   u32 P = (u32)H_Hat;
>   DebugTrace(P, P, 0);
>   HALT;
> }
> 
> 
> 
> 

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


#25997 — Re: It is known that a correct halt decider must return false (in this case)[V2](no difference)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 19:10 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<e7ydnUpRe8j6nSLCnZ2dnUU7-fednZ2d@giganews.com>
In reply to#25988
On 11/25/2020 6:26 PM, Mike Terry wrote:
> On 25/11/2020 23:26, Richard Damon wrote:
>> On 11/25/20 3:55 PM, Mike Terry wrote:
>>> On 25/11/2020 18:03, Richard Damon wrote:
>>>> On 11/25/20 12:37 PM, olcott wrote:
>>>>> On 11/25/2020 9:55 AM, Richard Damon wrote:
>>>>>>
>>>>>> The code may not be present in the code of the caller. The 
>>>>>> behavior of
>>>>>> the called function IS in the behavior of the context of the caller.
>>>>>
>>>>> Not at all:
>>>>>
>>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>>> 1)  There is the possibility that a halt decider might choose to quit
>>>>>> enumerating the calculation steps earlier than the UTM - but of 
>>>>>> course
>>>>>> the calculation itself is nothing to do with either of those
>>>>>> emulations.
>>>>>>    And any perceived "change of behaviour" as a result of the halt
>>>>>> decider aborting its emulation is not actually behaviour of H_Hat,
>>>>>> it's different emulator behaviour.  Aside from this, the behaviour
>>>>>> OF THE SAME CALCULATION under different emulators will of course
>>>>>> be the same up to the point where the emulators decide to
>>>>>> stop enumerating the steps.
>>>>>> (Duh!)
>>>>>>
>>>>
>>>> First, If Mike was actually stating that there is no behavior change in
>>>> H_Hat between it having a UTM or a Halt Decider as the operation it is
>>>> use, I will disagree with it, and your argument just becomes a case of
>>>> Appealing to Authority. It is clear that there IS a change of behavior.
>>>
>>> I thought my "the behaviour OF THE SAME CALCULATION under different
>>> emulators will of course be the same up to the point where the emulators
>>> decide to stop enumerating the steps." was 100% clear.  I even put OF
>>> THE SAME CALCULATION in caps. :)
>>>
>>> I'll say it differently:
>>>
>>> HMM, after getting to the end of this post I realise perhaps the key
>>> here is my technical use of the word "calculation":
>>>
>>> Def.  Given a TM P, and input data I, the *calculation* P(I) is the
>>> sequence of calculation steps (p0,p1,p2,...) as usually defined
>>> (recursively) in the theory of TMs.  (Note: nothing to do with 
>>> emulation!)
>>>
>>> Ok...
>>> Suppose we have a calculation P(I), with steps (p0,p1,p2,...),
>>> Suppose we have two emulators E1 and E2 which enumerate the steps of
>>> P(I). E1 enumerates steps as far as n1 and then stops, for whatever
>>> reason, while E2 enumerates steps as far as n2 and then stops.
>>>
>>> Then:
>>>    The steps enumerated by E1 will be (p0,p1,...p_n1)
>>>    The steps enumerated by E2 will be (p0,p1,...p_n2)
>>>    The enumerations of E1 and E2 will agree, as far as the
>>>    enumerations both go.
>>>
>>> That is because both E1 and E2 are just enumerating the same
>>> "calculation" P(I) = (p0,p1,p2,...).
>>>
>>> The sequence (p0,p1,p2,...) has a mathematical definition, which depends
>>> only on P and I, not any emulator which enumerates the steps.
>>>
>>> Do you agree with all the above?  (You may use a slightly different word
>>> for "calculation" perhaps - please adjust accordingly!)
>>
>> The key feature here is that the sequence of steps done by going into
>> the UTM are different then the sequence of steps going into the Halt
>> Decicer, because presumably at some point the halt decider is going to
>> make its decision and return that answer, while the UTM will just keep
>> on executiong.
> 
> Agreed.
> 
> But nothing I said above involved halting machines or UTMs, it was just 
> discussing "emulation" generally:  E1, E2 being two emulators.  What you 
> describe as the halt-decider giving up earlier than the UTM is just what 
> I was saying with my n1, n2 which can be different.  (Maybe P(I) is 
> non-halting, and Decider looks at 20000 steps then stops, whereas UTM 
> will never stop.)  We can say at least that the 20000 steps as examined 
> by the two emulators will be the same! Er, that's it :)
> 
>>
>> One KEY point here is that the machines should have a different external
>> structure. The UTM will have a start state, and one terminal state to
>> indicate the machine being run finished. The Halt decider has two
>> terminal states, one for the machine WILL halt (might get there before
>> it actually did if it can tell, might not even have done an emulation),
>> and a seconde to say that the machine WILL never halt if it was run.
>>
>> If the machine given to them is halting, then the ultimate results might
>> be the same.
>>
>> Now, which is RUNNING H_Hat doesn't matter, except that the halt decider
>> isn't required to actually try to run the machine, but a halt decider
>> making the vain attempt to make the decison by simple emulation would
>> step through the same steps.
> 
> Agreed.  (As expected - despite PO's suggestion you don't understand this.)
> 
>>>
>>> Now on to specifics:
>>>
>>> Do you (Richard) take the following two machines H_Hat1 and H_Hat2 to be
>>> THE SAME machine:   (to have and to hold... :))
>>>
>>>    H_Hat1:   H_Hat as above, "having a UTM as the
>>>              operation it is use [sic]"
>>>    H_Hat2:   H_Hat as above, "having a halt decider as the
>>>              operation it is use [sic]"
>>
>> H_Hat1 (or I would call H_HAT_UT) is a different machine than H_Hat2
>> (which is Linz's machine)
>>>
>>> (Sorry, I don't understand the phrase "operation it is use(ing?)"  I
>>> suspect this relates to two completely different machines, each using
>>> its own unique Halts()/ABNHBD()/whatever, but it might relate to one
>>> FIXED H_Hat whose calculation is being emulated (possibly to different
>>> depths) under two different emulators, E1=UTM and E2=haltdecider.)
>>
>> Peter is talking about changing the behavior of Debug_Step from first
>> being simply a UTM to being the halt decider. When he does this, this
>> will change the computation that H_Hat is doing.
> 
> Exactly - 100% agreement.  So these are DIFFERENT CALCULATIONS, and so 
> there's no reason to think they must have the same steps if emulated. 
> Since what I said only applied to THE SAME calculation, but run under 
> different emulators, my comments which PO quoted don't apply.
> 
>>>
>>> If your answer is "no, H_Hat1 and H_Hat2 are different", then the
>>> calculation H_Hat1(H_Hat1) and H_Hat2(H_Hat2) are DIFFERENT
>>> CALCULATIONS, so I didn't say they had the same behaviour.
>>>
>>> If your answer is "yes, we're talking about enumerating the same
>>> calculation under two different emulators", then what I said applies:
>>> the emulators are enumerating the same calculation, and so the
>>> enumerations will agree up to the point where one of the emulators gives
>>> up.
>>>
>>> For example, one enumerator may see (p0,p1,p2,p3) and then give up,
>>> whereas the second sees (p0,p1,p2,p3,p4) then gives up.  The first four
>>> steps are the same.  Regardless of this, the actual "calculation"
>>> (p0,p1,p2...) either halts or doesn't halt.
>>
>> Note that H_Hat2 actual uses the results of the decision to decide what
>> to do. So it isn't that maybe it went farther in executing the tape then
>> the other, but that after making that decision, it decides on a path of
>> execution to perform from there. Thus we have some ADDED functionality
>> on the non-halting behavior path the the halt decider has that the UTM
>> did not have.
> 
> Agreed.  Put more simply, the calculations are different, and so the 
> fact that one is non-halting doesn't mean the other is non-halting.
> 
>>>
>>> In my wording I said that the "behaviour of the *calculation*" (e.g.
>>> halting/non-halting) is not changed by either emulator "giving up" after
>>> 3 or 4 steps.  If you want to use a different interpretation for
>>> "behaviour" which says that the behaviour of calculation (p_i) is
>>> different under the two emulators, that would be a different word usage
>>> to mine.  [I say there is one calculation (p_i) which "behaves" in one
>>> way, and the two emulators just enumerate this one calculation to
>>> different depths.  Under my interpretation, the "difference" is not in
>>> the one calculation (p_i), but in the behaviour of the /emulators/ in so
>>> far as the emulators make different decisions on how far to enumerate
>>> the calculation.]
>>>
>> I think you are looking at a different level of processing than I am, I
>> see the primary calcualtion at the top level, H_Hat is trying to decide
>> what to do, so it asked the Halt Decider a question. In a real sense,
>> H_Hat doesn't care diddly how the Halt Decider works, whether it runs
>> the machine provided or does some magical hashing function to make a
>> decision, so any difference in how the program it was given ran is
>> meaningless to it, it just wants to know would it complete.  THAT
>> computation works very differently between asking a UTM that question an
>> a Halting Decider. The Halting Decider has the ability to say, this
>> computation will not complete, to which H_Hat can say great, I will just
>> halt then. Or the Halting Decider can say that this computation will
>> complete, at which point H_Hat desides to just sit there idleing its
>> engines forever and not halt.
>>
>> When H_Hat_UTM asks the UTM to run the input, the UTM has just one
>> answer it can give, it can say that the input came to a halt, and then
>> H_Hat will just idle again. A second behavior is the UTM can just run
>> forever because the input program was non-halting. This give a very
>> different result than that same operation with the Halt Decicder.
>>
> 
> OK, I agree with all that, no problem.
> 
> The text of mine that PO quoted is indeed at a different (simpler) level 
> of detail.  It did not involve H_Hat, halt deciders or UTMs except 
> perhaps as illustrative examples.
> 
> All I (originally) said was that if we have ONE FIXED (P,I) input, and 
> two correctly written emulators which examine that input, then the two 
> emulators will agree on the calculation steps up to the point one of 
> them gives up.  PO claims I'm the only person (apart from him!) who 
> understands that, but of course I know everybody would agree once 
> terminology is sorted.
> 
> In my "simple" level it is enough to simply say that H_Hat_Decider is 
> different from H_Hat_UTM, and so PO can't use my words to imply that 
> H_Hat_Decider(H_Hat_Decider) has the same behaviour as 
> H_Hat_UTM(H_Hat_UTM).
> 
> Going back to your original words:
> 
>  >>> First, If Mike was actually stating that there is no behavior 
> change in
>  >>> H_Hat between it having a UTM or a Halt Decider as the operation it is
>  >>> use, I will disagree with it, and your argument just becomes a case of
>  >>> Appealing to Authority. It is clear that there IS a change of 
> behavior.
> 
> then the resolution for this mini-thread is that I wouldn't claim those 
> two hats were the same, so I wouldn't apply remarks about how THE SAME 
> calculation behaves under different emulators - it's just not 
> applicable.  (So, no I don't say there's no behaviour change - it's just 
> PO being PO.)
> 
> Phew! Glad that's cleared up :)
> 
>>> I accept that others may use terms slightly differently, but the main
>>> thing is the facts don't change.  (PO doesn't understand complications
>>> like this, so whereas some may say he exploits this to confuse people, I
>>> would say he's just too stupid to appreciate what's actually going on.)
>>>
>>>>
>>>> I also think he is refering to a different topic. Yes, H_Hat makes no
>>>> decision to change its behavior because of the change, but its behavior
>>>> IS changed, and Mike even mentions this. That AFTER the point of the
>>>> trace when the abort occurs, the trace for the caller to the operation
>>>> is now different, so it is doing a different computation.
>>>>
>>>
>>> Aha, that sounds like a mere difference in use of the word
>>> "calculation".  I use it to mean the complete mathematically defined
>>> sequence (p_i).  You seem to use it to mean "the results of emulation
>>> activity" (not the HP concept used to define halting/non-halting).
>>> That's OK I guess, since we could say that what an emulator does is
>>> "calculate the steps", but then what word do you use for what I call the
>>> calculation?  Is there a standard terminology here?  (I try to be
>>> consistant in my own usage...)
>>>
>>>
>>> Mike.
>>>
>>
>> I think the big difference is you seem to be looking at the computation
>> being done BY the UTM/Decider, while I am looking at the computation
>> being done WITH the results of the UTM/Decider, since THAT is the
>> machine the question is being asked of when we start at H_Hat.
>>

I am sure that Richard still does not get this:

On 11/25/2020 10:16 AM, Mike Terry wrote:
 > 1)  There is the possibility that a halt decider
 > might choose to quit enumerating the calculation
 > steps earlier than the UTM

 > ...any perceived "change of behaviour" as a
 > result of the halt decider aborting its emulation
 > is not actually behaviour of H_Hat, it's different
 > emulator behaviour.


-- 
Copyright 2020 Pete Olcott

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

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


#25942 — Re: It is known that a correct halt decider must return false (in this case)[V2](no difference)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-25 16:16 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<2IOdnXCqUZnmHiPCnZ2dnUU78QGdnZ2d@brightview.co.uk>
In reply to#25905
On 25/11/2020 03:58, olcott wrote:
> On 11/24/2020 9:45 PM, Richard Damon wrote:
>> On 11/24/20 10:06 PM, olcott wrote:
>>> On 11/24/2020 8:49 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/24/2020 9:22 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/23/2020 8:26 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> The point is that H(Ĥ, Ĥ) ⊢* H.no is correct.
>>>>>>>>>
>>>>>>>>>         H.q0 wMw ⊢* H.yes   if M applied to w halts, and
>>>>>>>>>         H.q0 wMw ⊢* H.no    if M applied to w does not halt.
>>>>>>>>>         (Linz 1990:318)
>>>>>>>>
>>>>>>>> Good grief, you are using the notation almost correctly!  But you
>>>>>>>> open
>>>>>>>> with a falsehood.  H.q0 wĤ wĤ ⊢* H.no is /not/ correct as Linz
>>>>>>>> explains.
>>>>>>>> Basically, Ĥ is constructed so that
>>>>>>>>
>>>>>>>>       Ĥ.q0 wĤ ⊢* H.q0 wĤ wĤ ⊢* H.no
>>>>>>>
>>>>>>> Ĥ does not copy its input.
>>>>>>
>>>>>> Yes it does.  You cited the book that tell you it does.  If you don't
>>>>>> accept the "hat" construction from Linz, you have nothing more to say
>>>>>> about the proof.
>>>>>
>>>>> As I have told you hundreds of times I simplify the counter-example to
>>>>> make it conform to the general counter-example that does not copy its
>>>>> input.
>>>>
>>>> You cited Linz and gave the desired behaviour of H exactly as Linz
>>>> does.
>>>> Linz says of Ĥ "This new machine takes its input wM and copies it".  I
>>>> wrote exactly what Linz writes using the slightly different notation
>>>> you
>>>> have adopted:
>>>>
>>>>     Ĥ.q0 wM ⊢* H.q0 wM wM ⊢* H.no
>>>>
>>>> To keep denying that Ĥ copies its input is just silly.  Just admit it
>>>> and move.  We can then talk about your x86 code, and why that's wrong.
>>>
>>> To say that this code copies itself is dishonest:
>>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Aborted = DebugTrace(P, P);
>>>    if (Aborted)
>>>      HALT
>>>    else
>>>      HERE: goto HERE;
>>> }
>>>
>>
>> I see 1 P becoming 2 Ps, and a violation of the design if DebugTrace,
>> via the program P it is emulating, happens to change its tape. Note that
>> at this level of defintion, P does NOT yet need to be a representation
>> of H_Hat, so it is possible to come up with a machine that this will
>> process in a none equivalent matter to the Turing Machine Version, thus
>> it is NOT the equivalent calculation.
>>
>>>
>>>>>> Does this, in fact, mean you accept the proof as
>>>>>> presented by Linz about actual Turing machines -- the one where Ĥ
>>>>>> /does/
>>>>>> copy its input?
>>>>>
>>>>> No it does not.  It is quite crazy that you say this
>>>>
>>>> Take a deep breath.  What is the usual end result when you have had to
>>>> resort to thinking I'm saying crazy things?  I am usually right, aren't
>>>> I?
>>>
>>> I have already shown how the Linz equivalent code above has been
>>> correctly decided.
>>
>> Only in your own mind.
>>>
>>>>> when I have shown you the actual execution trace of a concrete example
>>>>> of an equivalent H_Hat...
>>>>
>>>> H_Hat is not Ĥ.  Ĥ is a Turing machine which can be run with a tape
>>>> containing the encoding of Ĥ.  What matters for this post is the
>>>> execution trace of the Turing machine Ĥ, not the execution trace of
>>>> your
>>>> x86 code.  The TM execution trace is written like this:
>>>
>>> No that does not matter. What does matter is that my H_Hat is
>>> computationally equivalent to the Linz Ĥ. It has the exact same relation
>>> between Halts and H_Hat as H has to Ĥ. That was the only required
>>> element.
>>
>> As pointed above, it isn't, if Program P changes its tape, the execution
>> equivalence is broken.
>>
>>>
>>> You have already agreed that computational equivalence is good enough
>>> and now you try to back out of this agreement (as I always expected).
>>>
>>
>> I don't think anyone has complained about this optimization. What they
>> HAVE complained about is that in if we want to make a change to the top
>> level code to test a 'needed' clause, you won't allow the tape to remain
>> per the original definition, even if at the top level we have a
>> different H_Hat or Halt Decider, but that is a DIFFERENT issue.
>>
>
> Only Mike has the capacity to understand this key aspect

(LOL)

> and he has not
> yet provided me any feedback of my rebuttal of this.
>
> At least he explained why this sort of change is thought to be required.
> Everyone else was incapable of providing any reasoning for their
> requirement merely dogmatic assertions entirely bereft of any reasoning.
>
> It is an actual verifiable fact that the execution of H_Hat under a
> simulator and the execution of H_Hat under a halt decider is perfectly
> identical from H_Hat's point of view, thus not at all two different
> computations as Mike has indicated.
>
> H_Hat does not decide to change its behavior between its simulation
> under a UTM and its simulation under a halt decider because H_Hat is
> utterly unaware of any difference.

You know, I can't work out what you're actually claiming I've said so 
I'll just state two obvious points that aren't in any way controversial, 
and should cover anything I might have said previously:

1)  There is the possibility that a halt decider might choose to quit 
enumerating the calculation steps earlier than the UTM - but of course 
the calculation itself is nothing to do with either of those emulations. 
  And any perceived "change of behaviour" as a result of the halt 
decider aborting its emulation is not actually behaviour of H_Hat, it's 
different emulator behaviour.  Aside from this, the behaviour OF THE 
SAME CALCULATION under different emulators will of course be the same up 
to the point where the emulators decide to stop enumerating the steps. 
(Duh!)

2)  Where a problem might come in is that if you change the TMDesc for 
H_Hat it becomes a different TMDesc H_Hat2.  The computations 
H_Hat(H_Hat) and H_Hat2(H_Hat2) are two different computations, and may 
have different halting statuses.  This includes changing H_Hat when 
making some change to the H machine in order to settle some what-if 
question concerning the behaviour of the specific input (H_Hat,H_Hat).


Mike.

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


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

Back to top | Article view | comp.theory


csiph-web