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


Groups > comp.theory > #25604 > unrolled thread

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

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

Back to article view | Back to comp.theory


Contents

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

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


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

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

The H_Hat() that calls DebugTrace() is computationally identical to the 
H_Hat() that calls Halts() because neither one of them ever gets past 
line 03.

You are the only one that I know smart enough to see this. Ben would 
never say it if he did see it. Richard does not understand these things 
well enough to see this.



-- 


Copyright 2020 Pete Olcott

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

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


#26023 — 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-26 09:22 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](no difference)
Message-ID<kSOvH.220802$gR8.143048@fx45.iad>
In reply to#26019
On 11/25/20 11:30 PM, olcott wrote:
>>
> 
> 01 void H_Hat(u32 P)
> 02 {
> 03   u32 Aborted = DebugTrace(P, P);
> 04   if (Aborted)
> 05     HALT
> 06   else
> 07     HERE: goto HERE;
> 08 }
> 
> The H_Hat() that calls DebugTrace() is computationally identical to the
> H_Hat() that calls Halts() because neither one of them ever gets past
> line 03.
> 
> You are the only one that I know smart enough to see this. Ben would
> never say it if he did see it. Richard does not understand these things
> well enough to see this.
> 

The only possible reason to NOT get past line 3 when calling Halts, (if
Halts is supposed to be a proper halt detector), is because Halts is
broken and doesn't meet its requirements.

YOu may complain that that isn't what Halts is supposed to be in this
example, but that is EXACTLY why I said you shouldn't use this naming style.

YOu have already been found 'Guilty' of trying to sneak in the comments
about one version of a function to when it was being used as a different
functions.

The use of obviously misleading names is a good sign that you are
intentionally trying to pull a scam here.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 08:33 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](ridiculous)
Message-ID<IKmdnZkItY0jISLCnZ2dnUU7-RvNnZ2d@giganews.com>
In reply to#26023
On 11/26/2020 8:22 AM, Richard Damon wrote:
> On 11/25/20 11:30 PM, olcott wrote:
>>>
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03   u32 Aborted = DebugTrace(P, P);
>> 04   if (Aborted)
>> 05     HALT
>> 06   else
>> 07     HERE: goto HERE;
>> 08 }
>>
>> The H_Hat() that calls DebugTrace() is computationally identical to the
>> H_Hat() that calls Halts() because neither one of them ever gets past
>> line 03.
>>
>> You are the only one that I know smart enough to see this. Ben would
>> never say it if he did see it. Richard does not understand these things
>> well enough to see this.
>>
> 
> The only possible reason to NOT get past line 3 when calling Halts, (if
> Halts is supposed to be a proper halt detector), is because Halts is
> broken and doesn't meet its requirements.

I am probably going to stop responding to you because you do not have 
enough basic knowledge of things like infinite recursion to ever 
actually understand what I am saying.

It is ridiculous to assume that a function designed to detect Halting 
would be required rewrite the code that it is testing to remove the 
infinite recursion of this code.

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


-- 
Copyright 2020 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 10:43 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](ridiculous)
Message-ID<R2QvH.5642$0h3.1755@fx15.iad>
In reply to#26025
On 11/26/20 9:33 AM, olcott wrote:
> On 11/26/2020 8:22 AM, Richard Damon wrote:
>> On 11/25/20 11:30 PM, olcott wrote:
>>>>
>>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03   u32 Aborted = DebugTrace(P, P);
>>> 04   if (Aborted)
>>> 05     HALT
>>> 06   else
>>> 07     HERE: goto HERE;
>>> 08 }
>>>
>>> The H_Hat() that calls DebugTrace() is computationally identical to the
>>> H_Hat() that calls Halts() because neither one of them ever gets past
>>> line 03.
>>>
>>> You are the only one that I know smart enough to see this. Ben would
>>> never say it if he did see it. Richard does not understand these things
>>> well enough to see this.
>>>
>>
>> The only possible reason to NOT get past line 3 when calling Halts, (if
>> Halts is supposed to be a proper halt detector), is because Halts is
>> broken and doesn't meet its requirements.
> 
> I am probably going to stop responding to you because you do not have
> enough basic knowledge of things like infinite recursion to ever
> actually understand what I am saying.
> 
> It is ridiculous to assume that a function designed to detect Halting
> would be required rewrite the code that it is testing to remove the
> infinite recursion of this code.
> 

WHERE DO I SAY RE-WRITE CODE. Maybe the way you are implementing your
halt detector is SO wrong that it has gotten itself into a jam, but then
that is YOUR problem.

My expectation is that when I execute the call Halts(P, I) that the
Halts function will try to determine if P(I) will complete in finite
time or not.

One way to attempt it would be, as you seem to be doing, is it step
through the code and try to detect non-halting behavior.

The key point that you seem to be missing, perhaps because you are doing
the stepping right, is when THAT halt decider decides that the code that
IT is running has shown non-halting behavior, it can just stop running
it and return to Halts caller, after all, all that simulation was being
done under its control, so it is free to just stop it and return with
the code for this code just won't stop.

One issue you may be running into is that you are just using the virtual
86 mode of the processor, and haven't taken enough care to make that
work recursively. It is harder to write a nested VM system than a
non-nested one, but that is what you will need to implement if that is
your plan (complicated by the fact that your program is probably running
as a protected mode application inside a real OS, that may limit what
you are able to do without loading OS extensions.

Maybe you have done this, we don't know because you seem to assume that
everyone but you is to stupid to comprehend this.

Jumping to the end, ultimately your Halts function, at least when it
claims to be a real halting decider, if you every think you get there,
is going to need to simulate this computation, detect that there is now
an potentially infinite recursion, stop that recursion and then figure
out what that mean the program under test would do. It then needs to
return that answer to its caller.

Since the program under test is the exact same computation as the
caller, we know that the answer, if the halt detecter worked, will match
what the caller ends up doing. Which as been shown, it will alwas=ys be
wrong.

Where you logic goes wrong is that when we look at where that infinite
recursion was detected, it was detected inside another call to Halts,
that if we gave it a bit more time to run, would have broken the
recursion itself, and returned to its caller. You 'logic' about
recursion without a conditional doesn't apply here, because the nested
halt detector provided the needed conditonal to teminate the recursion.

The ultimate problem is that your halt decider has no logic to break up
the trap of infinite recusion except to follow it, which will either
cause your halt decider to fail to make the decision in finite time, or
it will need to make it decision without have been able to see the
actual behavior of the machine to the return values, and thus easily wrong.

This is a fundamental flaw in the base design of you Halt Decider. This
flaw is well known. This might be called the Step 1 to working on a halt
decider. The next step is to look at what cases it doesn't handle,
figure out a method to try to handle them, and then move on to a Step 2
halt decider (which will have its own problems)

I have mentioned several time, one way to go to this Step 2. When you
build such a Halt Decider, there will still be many cases you can't
handle (I don't recall much talk about how you plan to deal with the
more mundane infinite loops, as you focus has been on this Recursion).

One thing that the Step 2 decider  suggested give you, is that it
detects the Linz system, and allows you to define an alternate version
of the Halting Problem that deals with Linz. Because it IS an alternate
version, Linz doesn't claim to apply to it, nor does it impact a lot of
the math that uses the halting problem in it. But it is a reasonable
base for many practical questions.

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


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

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


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

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

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

-- 
Copyright 2020 Pete Olcott

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

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


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

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-26 17:21 +0000
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](ridiculous)
Message-ID<87ft4w5913.fsf@bsb.me.uk>
In reply to#26035
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
<cut>
>> int DebugTrace(u32 P, u32 I) 
>> { 
>> ((int(*)(int))P)(I); 
>> return 1; 
>> } 
>> 
>> void H_Hat(u32 P) 
>> {
>> u32 Aborted = DebugTrace(P, P);
>> if (Aborted) 
>> HALT 
>> else 
>> HERE: goto HERE; 
>> } 
>> 
>> int main() 
>> { 
>> u32 P = (u32)H_Hat; 
>> DebugTrace(P, P); 
>> HALT; 
>> }

(The indentation was lost before I replied, honest, guv.)
 
> That's infinite recusion, right enough.
> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
> then it is no longer infinite recursion.

Which is the key to PO's halting problem 2.0.  A program is non-halting
not because it doesn't halt, but because it wouldn't halt if weren't
halted.  Simples!

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 11:50 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<ELGdnQFzyJJHdyLCnZ2dnUU7-XPNnZ2d@giganews.com>
In reply to#26036
On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
> 
>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
> <cut>
>>> int DebugTrace(u32 P, u32 I)
>>> {
>>> ((int(*)(int))P)(I);
>>> return 1;
>>> }
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = DebugTrace(P, P);
>>> if (Aborted)
>>> HALT
>>> else
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> u32 P = (u32)H_Hat;
>>> DebugTrace(P, P);
>>> HALT;
>>> }
> 
> (The indentation was lost before I replied, honest, guv.)
>   
>> That's infinite recusion, right enough.
>> But if Halts() detects the infinite recursion  and reports "Doesn't halt"
>> then it is no longer infinite recursion.
> 
> Which is the key to PO's halting problem 2.0.  A program is non-halting
> not because it doesn't halt, but because it wouldn't halt if weren't
> halted.  Simples!
> 

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

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

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

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


-- 
Copyright 2020 Pete Olcott

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

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


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

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-11-26 10:29 -0800
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<2c3095b6-3e45-457e-a3a5-eb01142720f3n@googlegroups.com>
In reply to#26038
On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
> On 11/26/2020 11:21 AM, Ben Bacarisse wrote: 
> > Malcolm McLean <malcolm.ar...@gmail.com> writes: 
> > 
> >> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote: 
> > <cut> 
> >>> int DebugTrace(u32 P, u32 I) 
> >>> { 
> >>> ((int(*)(int))P)(I); 
> >>> return 1; 
> >>> } 
> >>> 
> >>> void H_Hat(u32 P) 
> >>> { 
> >>> u32 Aborted = DebugTrace(P, P); 
> >>> if (Aborted) 
> >>> HALT 
> >>> else 
> >>> HERE: goto HERE; 
> >>> } 
> >>> 
> >>> int main() 
> >>> { 
> >>> u32 P = (u32)H_Hat; 
> >>> DebugTrace(P, P); 
> >>> HALT; 
> >>> } 
> > 
> > (The indentation was lost before I replied, honest, guv.) 
> > 
> >> That's infinite recusion, right enough. 
> >> But if Halts() detects the infinite recursion and reports "Doesn't halt" 
> >> then it is no longer infinite recursion. 
> > 
> > Which is the key to PO's halting problem 2.0. A program is non-halting 
> > not because it doesn't halt, but because it wouldn't halt if weren't 
> > halted. Simples! 
> >
> Every program / (TMD being simulated) that does not halt unless it is 
> forced to halt is a non halting program / (TMD being simulated). 
> 
> Every program / (TMD being simulated) that halts without being forced to 
> halt is a halting program / (TMD being simulated). 
>
The point of the H_Hat proof is that "Halts()" is fed to itself. So if Halts() terminates
what would otherwise be an infinite recursion, as it must do if it is to be a
halt detector, the termination is also in the Halts() that is fed to Halts().

There's no way out. But I thought that had been agreed long ago.  
>
> Thus dividing inputs into halting and not halting as the actual Halting 
> Problem itself requires. 
> 
> The Halting problem is a problem in computer science. The problem is 
> looking at a computer program and finding out if the program is going to 
> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
> 
You've been mislead by the term "halting problem". There are plenty  of 
genuinely open problems in computer science, like whether large integers can
be factored other than by exhaustive search, or whether graphs can be laid
out on two dimensional visual representations in polynomial time. The
"halting problem", despite its name, is not one of these problems. 

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 12:41 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<wIudneo02KJXayLCnZ2dnUU7-YXNnZ2d@giganews.com>
In reply to#26041
On 11/26/2020 12:29 PM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>
>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>> <cut>
>>>>> int DebugTrace(u32 P, u32 I)
>>>>> {
>>>>> ((int(*)(int))P)(I);
>>>>> return 1;
>>>>> }
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>> u32 Aborted = DebugTrace(P, P);
>>>>> if (Aborted)
>>>>> HALT
>>>>> else
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> u32 P = (u32)H_Hat;
>>>>> DebugTrace(P, P);
>>>>> HALT;
>>>>> }
>>>
>>> (The indentation was lost before I replied, honest, guv.)
>>>
>>>> That's infinite recusion, right enough.
>>>> But if Halts() detects the infinite recursion and reports "Doesn't halt"
>>>> then it is no longer infinite recursion.
>>>
>>> Which is the key to PO's halting problem 2.0. A program is non-halting
>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>> halted. Simples!
>>>
>> Every program / (TMD being simulated) that does not halt unless it is
>> forced to halt is a non halting program / (TMD being simulated).
>>
>> Every program / (TMD being simulated) that halts without being forced to
>> halt is a halting program / (TMD being simulated).
>>
> The point of the H_Hat proof is that "Halts()" is fed to itself. So if Halts() terminates
> what would otherwise be an infinite recursion, as it must do if it is to be a
> halt detector, the termination is also in the Halts() that is fed to Halts().
> 
> There's no way out. But I thought that had been agreed long ago.

Those words seem incoherent to me.

>>
>> Thus dividing inputs into halting and not halting as the actual Halting
>> Problem itself requires.
>>
>> The Halting problem is a problem in computer science. The problem is
>> looking at a computer program and finding out if the program is going to
>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>
> You've been mislead by the term "halting problem". There are plenty  of
> genuinely open problems in computer science, like whether large integers can
> be factored other than by exhaustive search, or whether graphs can be laid
> out on two dimensional visual representations in polynomial time. The
> "halting problem", despite its name, is not one of these problems.
> 

     The input to H will be the description (encoded in some form)
     of M, say WM, as well as the input w. The requirement is then
     that, given any (WM, w), the Turing machine H will halt with
     either a yes or no answer.

     H.q0 wMw ⊢* H.yes   if M applied to w halts, and
     H.q0 wMw ⊢* H.no    if M applied to w would not halt.
     (Linz 1990:318)



-- 
Copyright 2020 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 13:47 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<bLSvH.42347$1t6.41820@fx40.iad>
In reply to#26042
On 11/26/20 1:41 PM, olcott wrote:
> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>
>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>> <cut>
>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>> {
>>>>>> ((int(*)(int))P)(I);
>>>>>> return 1;
>>>>>> }
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>> if (Aborted)
>>>>>> HALT
>>>>>> else
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 P = (u32)H_Hat;
>>>>>> DebugTrace(P, P);
>>>>>> HALT;
>>>>>> }
>>>>
>>>> (The indentation was lost before I replied, honest, guv.)
>>>>
>>>>> That's infinite recusion, right enough.
>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>> halt"
>>>>> then it is no longer infinite recursion.
>>>>
>>>> Which is the key to PO's halting problem 2.0. A program is non-halting
>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>> halted. Simples!
>>>>
>>> Every program / (TMD being simulated) that does not halt unless it is
>>> forced to halt is a non halting program / (TMD being simulated).
>>>
>>> Every program / (TMD being simulated) that halts without being forced to
>>> halt is a halting program / (TMD being simulated).
>>>
>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>> Halts() terminates
>> what would otherwise be an infinite recursion, as it must do if it is
>> to be a
>> halt detector, the termination is also in the Halts() that is fed to
>> Halts().
>>
>> There's no way out. But I thought that had been agreed long ago.
> 
> Those words seem incoherent to me.

Sounds about right for you
> 
>>>
>>> Thus dividing inputs into halting and not halting as the actual Halting
>>> Problem itself requires.
>>>
>>> The Halting problem is a problem in computer science. The problem is
>>> looking at a computer program and finding out if the program is going to
>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>
>> You've been mislead by the term "halting problem". There are plenty  of
>> genuinely open problems in computer science, like whether large
>> integers can
>> be factored other than by exhaustive search, or whether graphs can be
>> laid
>> out on two dimensional visual representations in polynomial time. The
>> "halting problem", despite its name, is not one of these problems.
>>
> 
>     The input to H will be the description (encoded in some form)
>     of M, say WM, as well as the input w. The requirement is then
>     that, given any (WM, w), the Turing machine H will halt with
>     either a yes or no answer.
> 
>     H.q0 wMw ⊢* H.yes   if M applied to w halts, and
>     H.q0 wMw ⊢* H.no    if M applied to w would not halt.
>     (Linz 1990:318)

Yes, that is the statement of the Halting Problem, but Linz 'solved' it
on one sense by showing that there was NO unversal solutions to the problem.

There can still be work on special cases, which don't need to be
universal, but that is really a different sort of problem.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 13:07 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<ycqdnZ03aq9uYSLCnZ2dnUU7-enNnZ2d@giganews.com>
In reply to#26043
On 11/26/2020 12:47 PM, Richard Damon wrote:
> On 11/26/20 1:41 PM, olcott wrote:
>> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>>
>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>> <cut>
>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>> {
>>>>>>> ((int(*)(int))P)(I);
>>>>>>> return 1;
>>>>>>> }
>>>>>>>
>>>>>>> void H_Hat(u32 P)
>>>>>>> {
>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>> if (Aborted)
>>>>>>> HALT
>>>>>>> else
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> u32 P = (u32)H_Hat;
>>>>>>> DebugTrace(P, P);
>>>>>>> HALT;
>>>>>>> }
>>>>>
>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>
>>>>>> That's infinite recusion, right enough.
>>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>>> halt"
>>>>>> then it is no longer infinite recursion.
>>>>>
>>>>> Which is the key to PO's halting problem 2.0. A program is non-halting
>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>> halted. Simples!
>>>>>
>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>
>>>> Every program / (TMD being simulated) that halts without being forced to
>>>> halt is a halting program / (TMD being simulated).
>>>>
>>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>>> Halts() terminates
>>> what would otherwise be an infinite recursion, as it must do if it is
>>> to be a
>>> halt detector, the termination is also in the Halts() that is fed to
>>> Halts().
>>>
>>> There's no way out. But I thought that had been agreed long ago.
>>
>> Those words seem incoherent to me.
> 
> Sounds about right for you
>>
>>>>
>>>> Thus dividing inputs into halting and not halting as the actual Halting
>>>> Problem itself requires.
>>>>
>>>> The Halting problem is a problem in computer science. The problem is
>>>> looking at a computer program and finding out if the program is going to
>>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>>
>>> You've been mislead by the term "halting problem". There are plenty  of
>>> genuinely open problems in computer science, like whether large
>>> integers can
>>> be factored other than by exhaustive search, or whether graphs can be
>>> laid
>>> out on two dimensional visual representations in polynomial time. The
>>> "halting problem", despite its name, is not one of these problems.
>>>
>>
>>      The input to H will be the description (encoded in some form)
>>      of M, say WM, as well as the input w. The requirement is then
>>      that, given any (WM, w), the Turing machine H will halt with
>>      either a yes or no answer.
>>
>>      H.q0 wMw ⊢* H.yes   if M applied to w halts, and
>>      H.q0 wMw ⊢* H.no    if M applied to w would not halt.
>>      (Linz 1990:318)
> 
> Yes, that is the statement of the Halting Problem, but Linz 'solved' it
> on one sense by showing that there was NO unversal solutions to the problem.
> 
> There can still be work on special cases, which don't need to be
> universal, but that is really a different sort of problem.
> 


(1) The code below is obviously infinitely recursive.

(2) Halts() has identical behavior to DebugStep() until Halts() decides 
to terminate its input.

∴ swapping function calls to Halts() for the two function calls to 
DebugStep() makes the function call to Halts() from H_Hat infinitely 
recursive.

∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a 
correct not halting decision.

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

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

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








-- 
Copyright 2020 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 16:02 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<DJUvH.77496$ql4.4250@fx39.iad>
In reply to#26044
On 11/26/20 2:07 PM, olcott wrote:
> On 11/26/2020 12:47 PM, Richard Damon wrote:
>> On 11/26/20 1:41 PM, olcott wrote:
>>> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>>>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>>>
>>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>>> <cut>
>>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>>> {
>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>> return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>> if (Aborted)
>>>>>>>> HALT
>>>>>>>> else
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>> DebugTrace(P, P);
>>>>>>>> HALT;
>>>>>>>> }
>>>>>>
>>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>>
>>>>>>> That's infinite recusion, right enough.
>>>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>>>> halt"
>>>>>>> then it is no longer infinite recursion.
>>>>>>
>>>>>> Which is the key to PO's halting problem 2.0. A program is
>>>>>> non-halting
>>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>>> halted. Simples!
>>>>>>
>>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>>
>>>>> Every program / (TMD being simulated) that halts without being
>>>>> forced to
>>>>> halt is a halting program / (TMD being simulated).
>>>>>
>>>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>>>> Halts() terminates
>>>> what would otherwise be an infinite recursion, as it must do if it is
>>>> to be a
>>>> halt detector, the termination is also in the Halts() that is fed to
>>>> Halts().
>>>>
>>>> There's no way out. But I thought that had been agreed long ago.
>>>
>>> Those words seem incoherent to me.
>>
>> Sounds about right for you
>>>
>>>>>
>>>>> Thus dividing inputs into halting and not halting as the actual
>>>>> Halting
>>>>> Problem itself requires.
>>>>>
>>>>> The Halting problem is a problem in computer science. The problem is
>>>>> looking at a computer program and finding out if the program is
>>>>> going to
>>>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>>>
>>>> You've been mislead by the term "halting problem". There are plenty  of
>>>> genuinely open problems in computer science, like whether large
>>>> integers can
>>>> be factored other than by exhaustive search, or whether graphs can be
>>>> laid
>>>> out on two dimensional visual representations in polynomial time. The
>>>> "halting problem", despite its name, is not one of these problems.
>>>>
>>>
>>>      The input to H will be the description (encoded in some form)
>>>      of M, say WM, as well as the input w. The requirement is then
>>>      that, given any (WM, w), the Turing machine H will halt with
>>>      either a yes or no answer.
>>>
>>>      H.q0 wMw ⊢* H.yes   if M applied to w halts, and
>>>      H.q0 wMw ⊢* H.no    if M applied to w would not halt.
>>>      (Linz 1990:318)
>>
>> Yes, that is the statement of the Halting Problem, but Linz 'solved' it
>> on one sense by showing that there was NO unversal solutions to the
>> problem.
>>
>> There can still be work on special cases, which don't need to be
>> universal, but that is really a different sort of problem.
>>
> 
> 
> (1) The code below is obviously infinitely recursive.

Yes.

> 
> (2) Halts() has identical behavior to DebugStep() until Halts() decides
> to terminate its input.

Ok. Does it promise to always work in finite time?
> 
> ∴ swapping function calls to Halts() for the two function calls to
> DebugStep() makes the function call to Halts() from H_Hat infinitely
> recursive.>
> ∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
> correct not halting decision.
> 

If its indication is that it found infinite recursion instead of
claiming it has determined non-halting behavior, and it doesn't promise
to always make its decision in fintie time, then depending on exactly
what its indication is supposed to mean, it may be correct.

Halts does NOT meet the requirements of a classical halting detector.

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 15:12 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<bJmdnTaeTNnMh13CnZ2dnUU7-V_NnZ2d@giganews.com>
In reply to#26053
On 11/26/2020 3:02 PM, Richard Damon wrote:
> On 11/26/20 2:07 PM, olcott wrote:
>> On 11/26/2020 12:47 PM, Richard Damon wrote:
>>> On 11/26/20 1:41 PM, olcott wrote:
>>>> On 11/26/2020 12:29 PM, Malcolm McLean wrote:
>>>>> On Thursday, 26 November 2020 at 17:50:26 UTC, olcott wrote:
>>>>>> On 11/26/2020 11:21 AM, Ben Bacarisse wrote:
>>>>>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>>>>>
>>>>>>>> On Thursday, 26 November 2020 at 15:49:31 UTC, olcott wrote:
>>>>>>> <cut>
>>>>>>>>> int DebugTrace(u32 P, u32 I)
>>>>>>>>> {
>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>> return 1;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>> {
>>>>>>>>> u32 Aborted = DebugTrace(P, P);
>>>>>>>>> if (Aborted)
>>>>>>>>> HALT
>>>>>>>>> else
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>>> DebugTrace(P, P);
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>
>>>>>>> (The indentation was lost before I replied, honest, guv.)
>>>>>>>
>>>>>>>> That's infinite recusion, right enough.
>>>>>>>> But if Halts() detects the infinite recursion and reports "Doesn't
>>>>>>>> halt"
>>>>>>>> then it is no longer infinite recursion.
>>>>>>>
>>>>>>> Which is the key to PO's halting problem 2.0. A program is
>>>>>>> non-halting
>>>>>>> not because it doesn't halt, but because it wouldn't halt if weren't
>>>>>>> halted. Simples!
>>>>>>>
>>>>>> Every program / (TMD being simulated) that does not halt unless it is
>>>>>> forced to halt is a non halting program / (TMD being simulated).
>>>>>>
>>>>>> Every program / (TMD being simulated) that halts without being
>>>>>> forced to
>>>>>> halt is a halting program / (TMD being simulated).
>>>>>>
>>>>> The point of the H_Hat proof is that "Halts()" is fed to itself. So if
>>>>> Halts() terminates
>>>>> what would otherwise be an infinite recursion, as it must do if it is
>>>>> to be a
>>>>> halt detector, the termination is also in the Halts() that is fed to
>>>>> Halts().
>>>>>
>>>>> There's no way out. But I thought that had been agreed long ago.
>>>>
>>>> Those words seem incoherent to me.
>>>
>>> Sounds about right for you
>>>>
>>>>>>
>>>>>> Thus dividing inputs into halting and not halting as the actual
>>>>>> Halting
>>>>>> Problem itself requires.
>>>>>>
>>>>>> The Halting problem is a problem in computer science. The problem is
>>>>>> looking at a computer program and finding out if the program is
>>>>>> going to
>>>>>> run forever or not. https://simple.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>> You've been mislead by the term "halting problem". There are plenty  of
>>>>> genuinely open problems in computer science, like whether large
>>>>> integers can
>>>>> be factored other than by exhaustive search, or whether graphs can be
>>>>> laid
>>>>> out on two dimensional visual representations in polynomial time. The
>>>>> "halting problem", despite its name, is not one of these problems.
>>>>>
>>>>
>>>>       The input to H will be the description (encoded in some form)
>>>>       of M, say WM, as well as the input w. The requirement is then
>>>>       that, given any (WM, w), the Turing machine H will halt with
>>>>       either a yes or no answer.
>>>>
>>>>       H.q0 wMw ⊢* H.yes   if M applied to w halts, and
>>>>       H.q0 wMw ⊢* H.no    if M applied to w would not halt.
>>>>       (Linz 1990:318)
>>>
>>> Yes, that is the statement of the Halting Problem, but Linz 'solved' it
>>> on one sense by showing that there was NO unversal solutions to the
>>> problem.
>>>
>>> There can still be work on special cases, which don't need to be
>>> universal, but that is really a different sort of problem.
>>>
>>
>>
>> (1) The code below is obviously infinitely recursive.
> 
> Yes.
> 
>>
>> (2) Halts() has identical behavior to DebugStep() until Halts() decides
>> to terminate its input.
> 
> Ok. Does it promise to always work in finite time?
>>
>> ∴ swapping function calls to Halts() for the two function calls to
>> DebugStep() makes the function call to Halts() from H_Hat infinitely
>> recursive.>
>> ∴ The decision of Halts() to abort H_Hat at its line 03 is necessarily a
>> correct not halting decision.
>>
> 
> If its indication is that it found infinite recursion instead of
> claiming it has determined non-halting behavior, and it doesn't promise
> to always make its decision in fintie time, then depending on exactly
> what its indication is supposed to mean, it may be correct.
> 
> Halts does NOT meet the requirements of a classical halting detector.
Halts() does meet the requirements of a classical partial halt decider 
on input H_Hat.

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



-- 
Copyright 2020 Pete Olcott

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

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


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

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-11-26 13:42 -0800
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<62666bec-e2ed-4f84-8810-034b0f608fb8n@googlegroups.com>
In reply to#26055
On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
> 
> Halts() does meet the requirements of a classical partial halt decider 
> on input H_Hat.
>
No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the
result. There is no way round this. As I thought we agreed long ago.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 15:56 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<C42dnQ5NJ54SuV3CnZ2dnUU7-IHNnZ2d@giganews.com>
In reply to#26060
On 11/26/2020 3:42 PM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>
>> Halts() does meet the requirements of a classical partial halt decider
>> on input H_Hat.
>>
> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the
> result. There is no way round this. As I thought we agreed long ago.
> 

You may have thought you understood it you did not:

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

The invocation of Halts() on line 12 aborts the invocation of Halts() on 
line 03 because it specifies infinite recursion. Line 03 is aborted 
before it ever returns any value to H_Hat.

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

09 int main()
10 {
11   u32 P = (u32)H_Hat;
12   Halts(P, P);
13   HALT;
14 }


-- 
Copyright 2020 Pete Olcott

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

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


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

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-11-26 14:14 -0800
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<2d8960d1-f245-44cd-8b44-5ea355ee5bd9n@googlegroups.com>
In reply to#26062
On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
> On 11/26/2020 3:42 PM, Malcolm McLean wrote: 
> > On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote: 
> >> 
> >> Halts() does meet the requirements of a classical partial halt decider 
> >> on input H_Hat. 
> >> 
> > No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the 
> > result. There is no way round this. As I thought we agreed long ago. 
> >
> You may have thought you understood it you did not: 
> 
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped 
> simulating it expresses behavior that is not halting behavior. 
> 
> The invocation of Halts() on line 12 aborts the invocation of Halts() on 
> line 03 because it specifies infinite recursion. Line 03 is aborted 
> before it ever returns any value to H_Hat.
> 01 void H_Hat(u32 P) 
> 02 {
> 03 u32 Aborted = Halts(P, P); 
> 94 if (Aborted)
> 05 HALT 
> 06 else 
> 07 HERE: goto HERE; 
> 08 }
> 09 int main() 
> 10 { 
> 11 u32 P = (u32)H_Hat; 
> 12 Halts(P, P); 
> 13 HALT; 
> 14 }
> 
H_Hat, as specified by Linz, calls the halt decider itself. So if the halt decider terminates
what would otherwise be infinite recursion, H_Hat does not generate infinite recursion.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 16:20 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<K8CdnQ7DMfK4t13CnZ2dnUU7-XfNnZ2d@giganews.com>
In reply to#26065
On 11/26/2020 4:14 PM, Malcolm McLean wrote:
> On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
>> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
>>> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>>>
>>>> Halts() does meet the requirements of a classical partial halt decider
>>>> on input H_Hat.
>>>>
>>> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat inverts the
>>> result. There is no way round this. As I thought we agreed long ago.
>>>
>> You may have thought you understood it you did not:
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
>>
>> The invocation of Halts() on line 12 aborts the invocation of Halts() on
>> line 03 because it specifies infinite recursion. Line 03 is aborted
>> before it ever returns any value to H_Hat.
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03   u32 Aborted = Halts(P, P);
>> 94   if (Aborted)
>> 05     HALT
>> 06   else
>> 07     HERE: goto HERE;
>> 08 }

>> 09 int main()
>> 10 {
>> 11   u32 P = (u32)H_Hat;
>> 12   Halts(P, P);
>> 13   HALT;
>> 14 }
>>
> H_Hat, as specified by Linz, calls the halt decider itself. So if the halt decider terminates
> what would otherwise be infinite recursion, H_Hat does not generate infinite recursion.
> 

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

When Halts() acts like the UTM specified above then it correctly decides 
not halting on H_Hat using the above criteria.

-- 
Copyright 2020 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-26 19:11 -0500
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<hvXvH.51701$8v5.31186@fx33.iad>
In reply to#26066
On 11/26/20 5:20 PM, olcott wrote:
> On 11/26/2020 4:14 PM, Malcolm McLean wrote:
>> On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
>>> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
>>>> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>>>>
>>>>> Halts() does meet the requirements of a classical partial halt decider
>>>>> on input H_Hat.
>>>>>
>>>> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat
>>>> inverts the
>>>> result. There is no way round this. As I thought we agreed long ago.
>>>>
>>> You may have thought you understood it you did not:
>>>
>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>> simulating it expresses behavior that is not halting behavior.
>>>
>>> The invocation of Halts() on line 12 aborts the invocation of Halts() on
>>> line 03 because it specifies infinite recursion. Line 03 is aborted
>>> before it ever returns any value to H_Hat.
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03   u32 Aborted = Halts(P, P);
>>> 94   if (Aborted)
>>> 05     HALT
>>> 06   else
>>> 07     HERE: goto HERE;
>>> 08 }
> 
>>> 09 int main()
>>> 10 {
>>> 11   u32 P = (u32)H_Hat;
>>> 12   Halts(P, P);
>>> 13   HALT;
>>> 14 }
>>>
>> H_Hat, as specified by Linz, calls the halt decider itself. So if the
>> halt decider terminates
>> what would otherwise be infinite recursion, H_Hat does not generate
>> infinite recursion.
>>
> 
> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
> simulating it expresses behavior that is not halting behavior.
> 
> When Halts() acts like the UTM specified above then it correctly decides
> not halting on H_Hat using the above criteria.
> 

But, when tested H_Hat(H_Hat) will halt under these conditions (or the
Halt decider failed to meet its requirements to deliver the answer in
finite time) so Halts is NOT a correct halting decider.

If you logic said it was, it must be UNSOUND.

The key point here is the 'unless' which you seem to not want to test
properly.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-11-26 18:25 -0600
SubjectRe: It is known that a correct halt decider must return false (in this case)[V2](whole solution)
Message-ID<eMSdnemKcLvl2l3CnZ2dnUU7-K3NnZ2d@giganews.com>
In reply to#26077
On 11/26/2020 6:11 PM, Richard Damon wrote:
> On 11/26/20 5:20 PM, olcott wrote:
>> On 11/26/2020 4:14 PM, Malcolm McLean wrote:
>>> On Thursday, 26 November 2020 at 21:56:38 UTC, olcott wrote:
>>>> On 11/26/2020 3:42 PM, Malcolm McLean wrote:
>>>>> On Thursday, 26 November 2020 at 21:12:56 UTC, olcott wrote:
>>>>>>
>>>>>> Halts() does meet the requirements of a classical partial halt decider
>>>>>> on input H_Hat.
>>>>>>
>>>>> No it doesn't. Because Halts() is fed a copy of itself, then H_Hat
>>>>> inverts the
>>>>> result. There is no way round this. As I thought we agreed long ago.
>>>>>
>>>> You may have thought you understood it you did not:
>>>>
>>>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>>>> simulating it expresses behavior that is not halting behavior.
>>>>
>>>> The invocation of Halts() on line 12 aborts the invocation of Halts() on
>>>> line 03 because it specifies infinite recursion. Line 03 is aborted
>>>> before it ever returns any value to H_Hat.
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03   u32 Aborted = Halts(P, P);
>>>> 94   if (Aborted)
>>>> 05     HALT
>>>> 06   else
>>>> 07     HERE: goto HERE;
>>>> 08 }
>>
>>>> 09 int main()
>>>> 10 {
>>>> 11   u32 P = (u32)H_Hat;
>>>> 12   Halts(P, P);
>>>> 13   HALT;
>>>> 14 }
>>>>
>>> H_Hat, as specified by Linz, calls the halt decider itself. So if the
>>> halt decider terminates
>>> what would otherwise be infinite recursion, H_Hat does not generate
>>> infinite recursion.
>>>
>>
>> Any input (TMD / DATA) that would never halt unless its (UTM) stopped
>> simulating it expresses behavior that is not halting behavior.
>>
>> When Halts() acts like the UTM specified above then it correctly decides
>> not halting on H_Hat using the above criteria.
>>
> 
> But, when tested H_Hat(H_Hat) will halt under these conditions (or the

H_Hat would never halt unless Halts stops simulating it thus perfectly 
matching the required criteria for a "not halting" decision.

> Halt decider failed to meet its requirements to deliver the answer in
> finite time) so Halts is NOT a correct halting decider.
> 
> If you logic said it was, it must be UNSOUND.
> 
> The key point here is the 'unless' which you seem to not want to test
> properly.
> 


-- 
Copyright 2020 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web