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


#25944 — 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 10:44 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<7I6dnW3mdvVPFCPCnZ2dnUU7-a_NnZ2d@giganews.com>
In reply to#25942
On 11/25/2020 10:16 AM, Mike Terry wrote:
> 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!)

No one else gets this besides you and I.

> 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.


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


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

This is the x86utm equivalent TMD for H_Hat:

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


The machine language and execution trace of H_Hat is identical** between:
(1) The above code.
(2) The x86utm based UTM equivalent DebugTrace().
(3) The x86utm based UTM equivalent DebugTrace() that has been adapted 
to become a halt decider.

Up to the point where the decider terminates the infinite recursion of 
H_Hat().

** The address of the called DebugTrace() varies between them.

-- 
Copyright 2020 Pete Olcott

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

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


#25955 — 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 18:55 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<6NidnXhGvKA2NSPCnZ2dnUU78W3NnZ2d@brightview.co.uk>
In reply to#25944
On 25/11/2020 16:44, olcott wrote:
> On 11/25/2020 10:16 AM, Mike Terry wrote:
>> 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!)
>
> No one else gets this besides you and I.
>

Nonsense.

>> 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.

<.. snip claims nothing to do with my remark ..>
(if you want to introduce tangental material, start a new thread)

Mike.

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


#25956 — 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 13:24 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<VuidnVnyUvzlMiPCnZ2dnUU7-evNnZ2d@giganews.com>
In reply to#25955
On 11/25/2020 12:55 PM, Mike Terry wrote:
> On 25/11/2020 16:44, olcott wrote:
>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>> 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!)
>>
>> No one else gets this besides you and I.
>>
> 
> Nonsense.
> 

On 11/25/2020 10:16 AM, Mike Terry wrote:
 >   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.

On 11/25/2020 12:03 PM, Richard Damon wrote:
 > 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,





-- 
Copyright 2020 Pete Olcott

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

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


#25960 — 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 19:43 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<csadnWNv-b9_LiPCnZ2dnUU78SnNnZ2d@brightview.co.uk>
In reply to#25956
On 25/11/2020 19:24, olcott wrote:
> On 11/25/2020 12:55 PM, Mike Terry wrote:
>> On 25/11/2020 16:44, olcott wrote:
>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>> 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!)
>>>
>>> No one else gets this besides you and I.
>>>
>>
>> Nonsense.
>>
>
> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>   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.
>
> On 11/25/2020 12:03 PM, Richard Damon wrote:
>> 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,

This is an example of you being too stupid to understand what people are 
actually saying, and too lazy to be bothered to actually find out.


Mike.

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


#25963 — 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 14:09 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<EJqdnWcy8YSNJyPCnZ2dnUU7-LPNnZ2d@giganews.com>
In reply to#25960
On 11/25/2020 1:43 PM, Mike Terry wrote:
> On 25/11/2020 19:24, olcott wrote:
>> On 11/25/2020 12:55 PM, Mike Terry wrote:
>>> On 25/11/2020 16:44, olcott wrote:
>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>> 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!)
>>>>
>>>> No one else gets this besides you and I.
>>>>
>>>
>>> Nonsense.
>>>
>>
>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>   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.
>>
>> On 11/25/2020 12:03 PM, Richard Damon wrote:
>>> 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,
> 
> This is an example of you being too stupid to understand what people are 
> actually saying, and too lazy to be bothered to actually find out.
> 
> 
> Mike.
> 

You can be free to misinterpret that way.
Many many times Richard was saying the the execution of H_Hat was 
incorrect because I did not show the return value that H_Hat received.

I had to simplify this for him and go over this code again and again 
before he realized that H_Hat() does not receive a return value from 
DebugTrace() because H_Hat() is stuck in infinite recursion.

I am still not sure that he gets this key point yet.

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


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




-- 
Copyright 2020 Pete Olcott

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

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


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

FromJeff Barnett <jbb@notatt.com>
Date2020-11-25 14:30 -0700
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<rpmiei$9f6$1@dont-email.me>
In reply to#25963
On 11/25/2020 1:09 PM, olcott wrote:
> On 11/25/2020 1:43 PM, Mike Terry wrote:
>> On 25/11/2020 19:24, olcott wrote:
>>> On 11/25/2020 12:55 PM, Mike Terry wrote:
>>>> On 25/11/2020 16:44, olcott wrote:
>>>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>>> 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!)
>>>>>
>>>>> No one else gets this besides you and I.
>>>>>
>>>>
>>>> Nonsense.
>>>>
>>>
>>> On 11/25/2020 10:16 AM, Mike Terry wrote:
>>>>   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.
>>>
>>> On 11/25/2020 12:03 PM, Richard Damon wrote:
>>>> 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,
>>
>> This is an example of you being too stupid to understand what people 
>> are actually saying, and too lazy to be bothered to actually find out.
>>
>>
>> Mike.
>>
> 
> You can be free to misinterpret that way.
> Many many times Richard was saying the the execution of H_Hat was 
> incorrect because I did not show the return value that H_Hat received.
> 
> I had to simplify this for him and go over this code again and again 
> before he realized that H_Hat() does not receive a return value from 
> DebugTrace() because H_Hat() is stuck in infinite recursion.
> 
> I am still not sure that he gets this key point yet.
> 
> int DebugTrace(u32 N, u32 M)
> {
>    return ((int(*)(int))N)(M);
> }
> 
> 
> void H_Hat(u32 P)
> {
>    u32 Aborted = DebugTrace(P, P);
>    if (Aborted)
>      HALT
>    else
>      HERE: goto HERE;
> }

You were given two choices above: you are 1) stupid or 2) lazy.

We all note that you jumped on stupid like a wild dog on a pork chop. 
Chew carefully, you might choke.
-- 
Jeff Barnett

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 21:24 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<AlEvH.30103$Uz.5082@fx46.iad>
In reply to#25963
On 11/25/20 3:09 PM, olcott wrote:

> You can be free to misinterpret that way.
> Many many times Richard was saying the the execution of H_Hat was
> incorrect because I did not show the return value that H_Hat received.
> 
> I had to simplify this for him and go over this code again and again
> before he realized that H_Hat() does not receive a return value from
> DebugTrace() because H_Hat() is stuck in infinite recursion.
> 
> I am still not sure that he gets this key point yet.
> 
> int DebugTrace(u32 N, u32 M)
> {
>   return ((int(*)(int))N)(M);
> }
> 
> 
> void H_Hat(u32 P)
> {
>   u32 Aborted = DebugTrace(P, P);
>   if (Aborted)
>     HALT
>   else
>     HERE: goto HERE;
> }
> 
>

Actually, If you are refering the the Linz equivalent H_Hat (I think you
are, but you misuse terms so much that it hard to be sure). At least
once near the begining, when I presented my trace of how H_Hat(H_Hat)
would execute as a Real Turing Machine, you sepcifically objected to the
trace because you said, but we don't get to the else because Halts (That
was its name at the time) aborted the execution, so H_Hat didn't get a
chance to halt and show itself to be halting.

I will note that the above example has no halt decider in it, and
experiences Critical Underfined Behavior in the expression
((int(*)(int))N)(M); before we get into the recursion.

I never said that this program doesn't get stuck in a recursive loop.

I will also continue to put forward that when DebugTrace is supposed to
be a halt detector, any detected 'infinite recursion' isn't the 'fault'
of H_Hat, but is a sign that DebugTrace isn't meeting its requirements
to be a proper Halt Detector.

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


#26011 — 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 21:03 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<DdOdnbL5_s-fhiLCnZ2dnUU7-InNnZ2d@giganews.com>
In reply to#26004
On 11/25/2020 8:24 PM, Richard Damon wrote:
> On 11/25/20 3:09 PM, olcott wrote:
> 
>> You can be free to misinterpret that way.
>> Many many times Richard was saying the the execution of H_Hat was
>> incorrect because I did not show the return value that H_Hat received.
>>
>> I had to simplify this for him and go over this code again and again
>> before he realized that H_Hat() does not receive a return value from
>> DebugTrace() because H_Hat() is stuck in infinite recursion.
>>
>> I am still not sure that he gets this key point yet.
>>
>> int DebugTrace(u32 N, u32 M)
>> {
>>    return ((int(*)(int))N)(M);
>> }
>>
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Aborted = DebugTrace(P, P);
>>    if (Aborted)
>>      HALT
>>    else
>>      HERE: goto HERE;
>> }
>>
>>
> 
> Actually, If you are refering the the Linz equivalent H_Hat (I think you
> are, but you misuse terms so much that it hard to be sure). At least
> once near the begining, when I presented my trace of how H_Hat(H_Hat)
> would execute as a Real Turing Machine, you sepcifically objected to the
> trace because you said, but we don't get to the else because Halts (That
> was its name at the time) aborted the execution, so H_Hat didn't get a
> chance to halt and show itself to be halting.
> 
> I will note that the above example has no halt decider in it, and
> experiences Critical Underfined Behavior in the expression
> ((int(*)(int))N)(M); before we get into the recursion.
> 

I rewrote it, my first rewrite had a bug that both you and Mike caught.

int DebugTrace(u32 P, u32 I)
{
   ((int(*)(int))P)(I);
   return 1;
}

> I never said that this program doesn't get stuck in a recursive loop.

If we rename DebugTrace() to Halts() it still gets stuck in infinite 
recursion.

If Halts is smart enough to detect infinite recursion then the simplest 
thing for it to do is to abort this infinite recursion.

If it simply aborts this infinite recursion then H_Hat does receive a 
return value. If it does not abort the infinite recursion then H_Hat 
does receive a return value. H_Hat does receive a return value either way.

Do you get this or do you think that Halts should also automatically 
repair code that incorrectly specifies infinite recursion?


-- 
Copyright 2020 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-25 22:52 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<IDFvH.65359$J92.36085@fx48.iad>
In reply to#26011
On 11/25/20 10:03 PM, olcott wrote:
> On 11/25/2020 8:24 PM, Richard Damon wrote:
>> On 11/25/20 3:09 PM, olcott wrote:
>>
>>> You can be free to misinterpret that way.
>>> Many many times Richard was saying the the execution of H_Hat was
>>> incorrect because I did not show the return value that H_Hat received.
>>>
>>> I had to simplify this for him and go over this code again and again
>>> before he realized that H_Hat() does not receive a return value from
>>> DebugTrace() because H_Hat() is stuck in infinite recursion.
>>>
>>> I am still not sure that he gets this key point yet.
>>>
>>> int DebugTrace(u32 N, u32 M)
>>> {
>>>    return ((int(*)(int))N)(M);
>>> }
>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Aborted = DebugTrace(P, P);
>>>    if (Aborted)
>>>      HALT
>>>    else
>>>      HERE: goto HERE;
>>> }
>>>
>>>
>>
>> Actually, If you are refering the the Linz equivalent H_Hat (I think you
>> are, but you misuse terms so much that it hard to be sure). At least
>> once near the begining, when I presented my trace of how H_Hat(H_Hat)
>> would execute as a Real Turing Machine, you sepcifically objected to the
>> trace because you said, but we don't get to the else because Halts (That
>> was its name at the time) aborted the execution, so H_Hat didn't get a
>> chance to halt and show itself to be halting.
>>
>> I will note that the above example has no halt decider in it, and
>> experiences Critical Underfined Behavior in the expression
>> ((int(*)(int))N)(M); before we get into the recursion.
>>
> 
> I rewrote it, my first rewrite had a bug that both you and Mike caught.
> 
> int DebugTrace(u32 P, u32 I)
> {
>   ((int(*)(int))P)(I);
>   return 1;
> }
> 
>> I never said that this program doesn't get stuck in a recursive loop.
> 
> If we rename DebugTrace() to Halts() it still gets stuck in infinite
> recursion.
> 
> If Halts is smart enough to detect infinite recursion then the simplest
> thing for it to do is to abort this infinite recursion.
> 
> If it simply aborts this infinite recursion then H_Hat does receive a
> return value. If it does not abort the infinite recursion then H_Hat
> does receive a return value. H_Hat does receive a return value either way.
> 
> Do you get this or do you think that Halts should also automatically
> repair code that incorrectly specifies infinite recursion?
> 

So is this what you are proposing:

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

We now have a function called Halts(u32 P, u32 I), that works by
stepping through and emulating the program. (But we no longer have code
for it, so going by specs)

It will stop that emulation if it detect infintite recursion.

You next paragraph seems garbled, I am not sure what you ACTUALLY mean.
You talk about abort or not, but either way H_hat gets a return value.
If you abort the WHOLE program it won't so that isn't what you mean, but
then what does not aborting mean which will still give an answer to
H_Hat? Not sure where 'repair code' comes from.

I will assume that you mean that it will terminate the emulation on
deteciton of the infinite recursion, and return a 1 to its caller, and
return a 0 if the emulation completes to a halt.

The big question is you have added some halt detection code but it is
very incomplete, I presume you are not yet calling this a halt detector
(even though it is called Halts) so it is not yet under the constraint
of answering in finite time (since there may be other causes of infinite
execution than just infinite recursion).

Note, that is the answer to H_Hat with infinite recursion detection only.

In this case, since Halts is not providing assurances of finite
execution time, and is not promising that its answer matches that actual
halting status of the program, it is fine for it to detect the infinite
recursion, at which point H_Hat will halt.


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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-25 21:53 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](obvious facts)
Message-ID<875z5t6r32.fsf@bsb.me.uk>
In reply to#25887
olcott <NoOne@NoWhere.com> writes:

> 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)

H_Hat is not Ĥ.  You said "Ĥ does not copy its input" after a direct
reference to Linz who says "This new machine takes its input wM and
copies it".  You made a silly mistake.  Please just admit it and move
on.

Ideally, you would also address the consequences of the TM traces I
wrote out that shows what happens after Ĥ copies its input.

>> 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.

Ĥ copies it's input.  You were wrong to say that it does not.  Admitting
that one mistake would go along way to persuading people you are an
honest interlocutor.

> You have already agreed that computational equivalence is good enough
> and now you try to back out of this agreement (as I always expected).

Oh dear.  Another staggeringly silly remark.  Computational equivalence
is "black box" equivalence.  One function/algorithm/machine might work
by copying it's input, and another might go about the same task in an
entirely different way.  The are computationally equivalent based on the
results (for given inputs) not on the actions they take to get there.

(I am happy to go deeper, and explain how it is that "computational
equivalence" can be used inside functions to show why it is that your
code also "copies its input", but I won't while you continue to dig
yourself into the "Ĥ does not copy its input" hole.)

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 16:07 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](obvious facts)
Message-ID<JNWdnaMeNcwPSCPCnZ2dnUU7-fPNnZ2d@giganews.com>
In reply to#25972
On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> 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)
> 
> H_Hat is not Ĥ.  You said "Ĥ does not copy its input" after a direct
> reference to Linz who says "This new machine takes its input wM and
> copies it".  You made a silly mistake.  Please just admit it and move
> on.


What I said in the post that you are responding to is this:

On 11/24/2020 9:06 PM, olcott wrote:
 > 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;
 > }

Thus your comment above is objectively verified as counter-factual.

> Ideally, you would also address the consequences of the TM traces I
> wrote out that shows what happens after Ĥ copies its input.
> 
>>> 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.
> 
> Ĥ copies it's input.  You were wrong to say that it does not.  Admitting
> that one mistake would go along way to persuading people you are an
> honest interlocutor.
> 
>> You have already agreed that computational equivalence is good enough
>> and now you try to back out of this agreement (as I always expected).
> 
> Oh dear.  Another staggeringly silly remark.  Computational equivalence
> is "black box" equivalence.  One function/algorithm/machine might work
> by copying it's input, and another might go about the same task in an
> entirely different way.  The are computationally equivalent based on the
> results (for given inputs) not on the actions they take to get there.
> 
> (I am happy to go deeper, and explain how it is that "computational
> equivalence" can be used inside functions to 


> show why it is that your
> code also "copies its input", but I won't while you continue to dig
> yourself into the "Ĥ does not copy its input" hole.)
> 

By "copies its input" I mean copying all the bytes of the machine 
language at the address specified by P. The following code very 
obviously does not do that.

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


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



-- 
Copyright 2020 Pete Olcott

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

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


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

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

> On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> 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)
>>
>> H_Hat is not Ĥ.  You said "Ĥ does not copy its input" after a direct
>> reference to Linz who says "This new machine takes its input wM and
>> copies it".  You made a silly mistake.  Please just admit it and move
>> on.
>
>
> What I said in the post that you are responding to is this:
>
> On 11/24/2020 9:06 PM, olcott wrote:
>> 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;
>> }
>
> Thus your comment above is objectively verified as counter-factual.

As usual, I can't tell if you are dumb or dishonest.

You were wrong to say "Ĥ does not copy its input" but you won't admit
it.  Your attempts to get me to talk about H_Hat is a diversion from
your very simple and obvious error: Ĥ /does/ copy its input.

As I said, I /will/ explain why you are wrong about H_Hat as well, but
not while you refuse to admit your mistake about Ĥ.

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-25 20:50 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](obvious facts)
Message-ID<I42dnS9L4IVviiLCnZ2dnUU7-aXNnZ2d@giganews.com>
In reply to#26006
On 11/25/2020 8:21 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> 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)
>>>
>>> H_Hat is not Ĥ.  You said "Ĥ does not copy its input" after a direct
>>> reference to Linz who says "This new machine takes its input wM and
>>> copies it".  You made a silly mistake.  Please just admit it and move
>>> on.
>>
>>
>> What I said in the post that you are responding to is this:
>>
>> On 11/24/2020 9:06 PM, olcott wrote:
>>> 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;
>>> }
>>
>> Thus your comment above is objectively verified as counter-factual.
> 
> As usual, I can't tell if you are dumb or dishonest.
> 

When I say something and your reply ignores what I just said and refers 
to some other conversation as if it was responding to what I just said 
this is very deceipitful.


-- 
Copyright 2020 Pete Olcott

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

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


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

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

> On 11/25/2020 8:21 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/25/2020 3:53 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> 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)
>>>>
>>>> H_Hat is not Ĥ.  You said "Ĥ does not copy its input" after a direct
>>>> reference to Linz who says "This new machine takes its input wM and
>>>> copies it".  You made a silly mistake.  Please just admit it and move
>>>> on.
>>>
>>>
>>> What I said in the post that you are responding to is this:
>>>
>>> On 11/24/2020 9:06 PM, olcott wrote:
>>>> 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;
>>>> }
>>>
>>> Thus your comment above is objectively verified as counter-factual.
>>
>> As usual, I can't tell if you are dumb or dishonest.
>
> When I say something and your reply ignores what I just said and
> refers to some other conversation as if it was responding to what I
> just said this is very deceipitful.

No, it means it is either a non-answer or a diversion.  But suit
yourself.  I am very happy that the record will show you cited Linz's H
and then said "Ĥ does not copy its input".  That you refused to admit
that this was wrong is just fine by me.  The more silly errors, childish
repetition, and outright lies linked to your name the better.

-- 
Ben.

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


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

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-11-23 17:34 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](false assumptions are not a rebuttal)
Message-ID<cJ6dnWAZMckAbybCnZ2dnUU78R8AAAAA@brightview.co.uk>
In reply to#25698
On 23/11/2020 13:08, olcott wrote:
> On 11/23/2020 5:00 AM, André G. Isaak wrote:
>> On 2020-11-22 12:04, olcott wrote:
>>> On 11/22/2020 12:50 PM, André G. Isaak wrote:
>>>> On 2020-11-22 11:28, olcott wrote:
>>>>> On 11/22/2020 12:14 PM, Richard Damon wrote:
>>>>>> On 11/22/20 12:47 PM, olcott wrote:
>>>>>>> On 11/22/2020 11:10 AM, André G. Isaak wrote:
>>>>>>>>
>>>>>>>> Not as far as I can tell.
>>>>>>>>
>>>>>>>> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that
>>>>>>>> H_Hat(H_Hat) doesn't halt.
>>>>>>>
>>>>>>> I keep repeating this criterion measure as a challenge to
>>>>>>> everyone to
>>>>>>> find any input that it decides incorrectly.
>>>>>>>
>>>>>>> It seems that everyone continues to ignore this challenge because
>>>>>>> they
>>>>>>> understand that this criterion measure is necessarily correct.
>>>>>>>
>>>>>>> When-so-ever decider Halts() (adapted from a UTM) decides that:
>>>>>>> (a) its input (<P>,I) would never halt unless it stopped
>>>>>>> simulating it
>>>>>>> and it is the case that
>>>>>>> (b) its input (<P>,I) would never halt unless it stopped
>>>>>>> simulating it
>>>>>>> then Halts() has made a correct not-halting decision on this input.
>>>>>>>
>>>>>>
>>>>>> First, I will point out that your are changing the criteria of the
>>>>>> halting problem, so you either need to accept the RIGHT definition or
>>>>>> state that you are working on a different problem (and thus
>>>>>> acknowledge
>>>>>> that any result you get to apply to the classic problem without
>>>>>> further
>>>>>> proof to show they are). The proper statement of the halting
>>>>>> problem is
>>>>>> to make a program that correctly predicts in finite time whether a
>>>>>> given
>>>>>> program with given input will halt in finite time or run forever.
>>>>>> ALWAYS
>>>>>> the ultimate test of success is does the deciders answer match the
>>>>>> actual machines performance. It also must ALWAY give the right
>>>>>> answer in
>>>>>> finite time for ANY program.
>>>>>>
>>>>>> The counter example for your decider is Linz H_Hat. The following
>>>>>> is a
>>>>>> program trace when H_Hat(H_Hat) is run as a proper Turing Machine
>>>>>> or as
>>>>>> the input to a working UTM. This is the only possible trace for this
>>>>>> case, if the decider decides that H_Hat(H_Hat) is non-halt, which is
>>>>>> your stated answer, and Halts meets the requirements of a Halt
>>>>>> Decider:
>>>>>>
>>>>>> 1) Enter H_Hat(H_Hat)
>>>>>> 2) duplicate H_Hat (this step 'optimized' out in your machine)
>>>>>> 3) Enter Halts(H_Hat, H_Hat)
>>>>>> 4) Halts does its decision and decides tht H_Hat is non-halting
>>>>>> 5) Halts returns false to indicate non-halting
>>>>>> 6) H_Hat goes to the else clause
>>>>>> 7) H_Hat Halts.
>>>>>>
>>>>>> Thus, Halts was wrong.
>>>>>>
>>>>>
>>>>> Your false assumptions have never been any sort of rebuttal.
>>>>>
>>>>> When the halt decider has been defined on the basis of transforming
>>>>> a UTM into a decider:
>>>>>
>>>>> 1) Enter H_Hat(H_Hat) actually specifies: Halts(H_Hat, H_Hat).
>>>>
>>>> H_Hat(H_Hat) and Halts(H_Hat, H_Hat) are entirely different
>>>> computations. How exactly does entering H_Hat(H_Hat) "actually
>>>> specify" Halts(H_Hat, H_Hat)?
>>>
>>> When the halt decider is the whole emulation system then no code can
>>> do anything that the halt decider cannot see. This aspect of the
>>> x86utm operating system is already fully operational.
>>
>> This seems to go back to your claim that somehow your system
>> automatically invokes Halts(main, NULL).
>>
>> This is an entirely nonsensical position. If you invoke Halts(main,
>> NULL), then your Halt decider is not being asked about H_Hat(H_Hat).
>> It is being asked about main(). Any functions in main() are simply
>> part of the description that Halts() is being asked to evaluate rather
>> than functions actually being executed.
>>
>> The fact that you need to invoke Halts(main, NULL) to get the correct
>> behaviour for H_Hat(H_Hat) inside of main simply demonstrates that
>> your simulator is not an accurate simulator. If it were, the behaviour
>> of H_Hat(H_Hat) within main where main is *not* an input to Halts()
>> would be identical to the behaviour of H_Hat(H_Hat) when it is
>> emulated inside Halts().
>>
>> André
>>
>>
>
> The bottom line is that I did show to H_Hat() would be decided correctly
>
> On 11/20/2020 9:30 PM, Mike Terry wrote:
>> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
>> described.  This is all baby stuff.  [So the correct halting decision
>> for the input is non-halting].
>
> https://groups.google.com/g/comp.theory/c/1uKuMgjxJTM/m/c3HEt-UWAAAJ

STOP QUOTING ME OUT OF CONTEXT.

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

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

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

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


Mike.

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


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

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-22 12:03 -0700
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](behind its back)
Message-ID<rpecmj$tf7$1@dont-email.me>
In reply to#25664
On 2020-11-22 10:47, olcott wrote:
> On 11/22/2020 11:10 AM, André G. Isaak wrote:
>> On 2020-11-22 09:16, olcott wrote:
>>> On 11/22/2020 8:58 AM, André G. Isaak wrote:
>>>> On 2020-11-22 07:17, olcott wrote:
>>>>> On 11/22/2020 4:48 AM, André G. Isaak wrote:
>>
>> <snip>
>>
>>>> H_Hat doesn't make use of the return value, but its behaviour still 
>>>> depends on the presence of the abort code. Remove that, and you are 
>>>> *changing* the definition of H_Hat.
>>>>
>>>> A proper simulator running H_Hat doesn't do that. H_Hat should 
>>>> behave identically when run in a simulator as when run natively.
>>>
>>> So in other words because Halts does gets the right answer and you 
>>> have been conditioned to believe that Halts cannot get the right 
>>> answer you conclude that Halts must be cheating.
>>
>> Halts doesn't get the right answer. You claim it does because its 
>> result matches the behaviour of H_Hat(H_Hat) *only when* it is run 
>> inside your simulator which has the effect of changing the behaviour 
>> of the Halts() call *inside* H_Hat. If you ran it without the 
>> simulator such that it calls the normal Halts() you get the wrong answer.
>>
>> It's not Halts that is cheating. It's your Simulator with the one line 
>> of halts disabled that is cheating.
>>
>>>>> All of the H_Hat(H_Hat) computations are state transition by state 
>>>>> transition identical. None of them ever complete their line 03.
>>>>> Those aborted by the decider never repeat, those not aborted by the 
>>>>> decider infinitely repeat.
>>>>>
>>>>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is 
>>>>>> called, effectively rendering your test of the behaviour of 
>>>>>> H_Hat(H_Hat) worthless.
>>>>>>
>>>>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately 
>>>>>> describe is the behaviour of H_Hat(H_Hat) when it is run directly. 
>>>>>> Not when it is run inside a halting detector; not when it is run 
>>>>>> in a simulator; and 
>>>>>
>>>>> So you do not understand the computer science that guarantees that 
>>>>> the direct execution of a TM is equivalent to simulating the TMD of 
>>>>> this machine by a UTM?
>>>>
>>>> That's only true if your simulator is actually a reliable simulator.
>>>> If your simulator were a true simulator, one should be able to run 
>>>> Halts(H_Hat, H_Hat) *within* the simulator and have it return a 
>>>> value of true or false exactly as when it wasn't run inside the 
>>>> simulator. That's 
>>>
>>> In this case we can do that and it would get a correct answer.
>>
>> Not as far as I can tell.
>>
>> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that 
>> H_Hat(H_Hat) doesn't halt.
> 
> I keep repeating this criterion measure as a challenge to everyone to 
> find any input that it decides incorrectly.
> 
> It seems that everyone continues to ignore this challenge because they 
> understand that this criterion measure is necessarily correct.
> 
> When-so-ever decider Halts() (adapted from a UTM) decides that:
> (a) its input (<P>,I) would never halt unless it stopped simulating it
> and it is the case that
> (b) its input (<P>,I) would never halt unless it stopped simulating it
> then Halts() has made a correct not-halting decision on this input.
> 
>> If you run Halts(H_Hat, H_Hat) *inside the simulator*, it won't report 
>> anything. It will simply hang.
> 
> I see now that what you are referring to as the simulator its Halts() 
> with its line 15 removed. I thought that you were referring to an actual 
> UTM that would also simulate Halts();

Yes, that's because that's what *YOU* seem to be insisting upon. You 
reject the idea that we can simulate (as opposed to running the halt 
decider) the behaviour of H_Hat(H_Hat) such that line 15 *is* present in 
the call to Halts() within H_Hat.

You insist that when we simulate this, line 15 is somehow turned off 
"globally" and that you must either run *everything* inside Halts() with 
line 15 globally present, or run everything inside Simulate() with line 
15 globally absent.

But if Halts() and Simulates() are different functions, then H_Hat() can 
be defined such that it always calls Halts() and never calls 
Simulates(), which is what the H ~ H_Hat relationship requires.

So when we Simulate(H_Hat, H_Hat), Simulates() calls H_Hat(H_Hat) which 
calls Halts(H_Hat, H_Hat).

You seem to want it to be the case that if (H_Hat, H_Hat) is used as the 
input to Simulate() that H_Hat suddenly starts calling Simulate(H_Hat, 
H_Hat) instead of Halts(H_Hat, H_Hat)

André

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

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


#25672 — Re: It is known that a correct halt decider must return false (in this case)[V2](black cats are black)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-22 13:14 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](black cats are black)
Message-ID<vsOdncsIWN8EJSfCnZ2dnUU7-dnNnZ2d@giganews.com>
In reply to#25670
On 11/22/2020 1:03 PM, André G. Isaak wrote:
> On 2020-11-22 10:47, olcott wrote:
>> On 11/22/2020 11:10 AM, André G. Isaak wrote:
>>> On 2020-11-22 09:16, olcott wrote:
>>>> On 11/22/2020 8:58 AM, André G. Isaak wrote:
>>>>> On 2020-11-22 07:17, olcott wrote:
>>>>>> On 11/22/2020 4:48 AM, André G. Isaak wrote:
>>>
>>> <snip>
>>>
>>>>> H_Hat doesn't make use of the return value, but its behaviour still 
>>>>> depends on the presence of the abort code. Remove that, and you are 
>>>>> *changing* the definition of H_Hat.
>>>>>
>>>>> A proper simulator running H_Hat doesn't do that. H_Hat should 
>>>>> behave identically when run in a simulator as when run natively.
>>>>
>>>> So in other words because Halts does gets the right answer and you 
>>>> have been conditioned to believe that Halts cannot get the right 
>>>> answer you conclude that Halts must be cheating.
>>>
>>> Halts doesn't get the right answer. You claim it does because its 
>>> result matches the behaviour of H_Hat(H_Hat) *only when* it is run 
>>> inside your simulator which has the effect of changing the behaviour 
>>> of the Halts() call *inside* H_Hat. If you ran it without the 
>>> simulator such that it calls the normal Halts() you get the wrong 
>>> answer.
>>>
>>> It's not Halts that is cheating. It's your Simulator with the one 
>>> line of halts disabled that is cheating.
>>>
>>>>>> All of the H_Hat(H_Hat) computations are state transition by state 
>>>>>> transition identical. None of them ever complete their line 03.
>>>>>> Those aborted by the decider never repeat, those not aborted by 
>>>>>> the decider infinitely repeat.
>>>>>>
>>>>>>> your Halt detector using as input when Halts(H_Hat, H_Hat) is 
>>>>>>> called, effectively rendering your test of the behaviour of 
>>>>>>> H_Hat(H_Hat) worthless.
>>>>>>>
>>>>>>> The behaviour which Halts(H_Hat, H_Hat) needs to accurately 
>>>>>>> describe is the behaviour of H_Hat(H_Hat) when it is run 
>>>>>>> directly. Not when it is run inside a halting detector; not when 
>>>>>>> it is run in a simulator; and 
>>>>>>
>>>>>> So you do not understand the computer science that guarantees that 
>>>>>> the direct execution of a TM is equivalent to simulating the TMD 
>>>>>> of this machine by a UTM?
>>>>>
>>>>> That's only true if your simulator is actually a reliable simulator.
>>>>> If your simulator were a true simulator, one should be able to run 
>>>>> Halts(H_Hat, H_Hat) *within* the simulator and have it return a 
>>>>> value of true or false exactly as when it wasn't run inside the 
>>>>> simulator. That's 
>>>>
>>>> In this case we can do that and it would get a correct answer.
>>>
>>> Not as far as I can tell.
>>>
>>> If you run Halts(H_Hat, H_Hat), it reports (erroneously), that 
>>> H_Hat(H_Hat) doesn't halt.
>>
>> I keep repeating this criterion measure as a challenge to everyone to 
>> find any input that it decides incorrectly.
>>
>> It seems that everyone continues to ignore this challenge because they 
>> understand that this criterion measure is necessarily correct.
>>
>> When-so-ever decider Halts() (adapted from a UTM) decides that:
>> (a) its input (<P>,I) would never halt unless it stopped simulating it
>> and it is the case that
>> (b) its input (<P>,I) would never halt unless it stopped simulating it
>> then Halts() has made a correct not-halting decision on this input.
>>
>>> If you run Halts(H_Hat, H_Hat) *inside the simulator*, it won't 
>>> report anything. It will simply hang.
>>
>> I see now that what you are referring to as the simulator its Halts() 
>> with its line 15 removed. I thought that you were referring to an 
>> actual UTM that would also simulate Halts();
> 
> Yes, that's because that's what *YOU* seem to be insisting upon. You 
> reject the idea that we can simulate (as opposed to running the halt 
> decider) the behaviour of H_Hat(H_Hat) such that line 15 *is* present in 
> the call to Halts() within H_Hat.

I reject the idea that making changes the state transitions that I 
specified is any rebuttal to the state transtions that I specified.

The fact that you can screw up an otherwise correct halt decider is not 
the slightest trace of evidence that the original halt dedcider was not 
correct.

> You insist that when we simulate this, line 15 is somehow turned off 
> "globally" and that you must either run *everything* inside Halts() with 
> line 15 globally present, or run everything inside Simulate() with line 
> 15 globally absent.

Yes this is the only conclusive way to prove that the halt decider is 
correct. If the code that it does not abort is always infinitely 
recursive unless it aborts this code then the decision to abort this 
code is impossibly incorrect.

No amount of convoluted nonsence counts as any sort of rebuttal to this.

> But if Halts() and Simulates() are different functions, then H_Hat() can 
> be defined such that it always calls Halts() and never calls 
> Simulates(), which is what the H ~ H_Hat relationship requires.
> 
> So when we Simulate(H_Hat, H_Hat), Simulates() calls H_Hat(H_Hat) which 
> calls Halts(H_Hat, H_Hat).
> 
> You seem to want it to be the case that if (H_Hat, H_Hat) is used as the 
> input to Simulate() that H_Hat suddenly starts calling Simulate(H_Hat, 
> H_Hat) instead of Halts(H_Hat, H_Hat)
> 
> André
> 

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

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

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

-- 
Copyright 2020 Pete Olcott

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

[toc] | [prev] | [standalone]


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

Back to top | Article view | comp.theory


csiph-web