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


Groups > comp.theory > #28957 > unrolled thread

Refuting the halting problem proofs with fully operational code

Started byolcott <NoOne@NoWhere.com>
First post2021-03-09 16:56 -0600
Last post2021-03-15 02:37 +0000
Articles 20 on this page of 452 — 20 participants

Back to article view | Back to comp.theory


Contents

  Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 16:56 -0600
    Re: Refuting the halting problem proofs with fully operational code Siri Cruise <chine.bleu@yahoo.com> - 2021-03-09 15:39 -0800
      Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 18:49 -0500
      Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 18:02 -0600
        Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:35 +0000
          Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:49 -0600
        Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:10 -0500
          Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 21:12 -0600
      Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:27 +0000
    Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-10 00:29 +0000
      Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 18:42 -0600
        Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-10 00:57 +0000
          Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 19:05 -0600
            Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-10 01:49 +0000
              Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:39 -0600
                Re: Refuting the halting problem proofs with fully operational code Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 18:48 -0800
                Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:18 -0500
                Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:39 +0000
                Re: Refuting the halting problem proofs with fully operational code Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 03:59 +0000
                  Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-09 22:04 -0600
                    Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-09 22:20 -0600
                      Re: Refuting the halting problem proofs with fully operational code (truth) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 20:36 -0800
                    Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 05:06 +0000
                      Re: Refuting the halting problem proofs with fully operational code (truth) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-10 00:12 -0800
                      Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:23 -0600
                        Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:27 -0600
                          Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 15:41 +0000
                            Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 09:55 -0600
                          Re: Refuting the halting problem proofs with fully operational code (truth) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 08:46 -0700
                            Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 10:12 -0600
                              Re: Refuting the halting problem proofs with fully operational code (truth) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 09:55 -0700
                          Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 16:03 +0000
                            Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 10:23 -0600
                              Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 17:16 +0000
                                Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 12:01 -0600
                                  Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 12:11 -0600
                                  Re: Refuting the halting problem proofs with fully operational code (Curry:1977) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 12:14 -0700
                                    Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 14:05 -0600
                                      Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-10 22:02 +0000
                                      Re: Refuting the halting problem proofs with fully operational code (Curry:1977) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 15:08 -0700
                                        Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 16:38 -0600
                                          Re: Refuting the halting problem proofs with fully operational code (Curry:1977) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 15:53 -0700
                                            Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 17:07 -0600
                                              Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-10 23:40 +0000
                                            Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 17:10 -0600
                                              Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:16 -0500
                                                Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-13 15:37 -0600
                                                  Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 15:18 -0400
                                  Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 14:16 -0500
                            Re: Refuting the halting problem proofs with fully operational code (truth) Jeff Barnett <jbb@notatt.com> - 2021-03-10 11:49 -0700
                              Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 14:20 -0500
                                Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 20:18 +0000
                                  Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 23:51 +0000
                                    Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-11 00:38 +0000
                                Re: Refuting the halting problem proofs with fully operational code (truth) Jeff Barnett <jbb@notatt.com> - 2021-03-10 15:39 -0700
                            Re: Refuting the halting problem proofs with fully operational code (truth) Peter <peterxpercival@hotmail.com> - 2021-03-12 18:25 +0000
                              Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 19:05 +0000
                        Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 15:29 +0000
                          Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:40 -0600
                            Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 19:26 -0500
                              Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 19:04 -0600
                                Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 23:23 -0500
                                  Re: Refuting the halting problem proofs with fully operational code [truth bearer defined] olcott <NoOne@NoWhere.com> - 2021-03-10 22:35 -0600
                          Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 16:06 +0000
                        Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 14:46 -0400
                    Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 15:25 +0000
                      Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:38 -0600
                        Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 15:42 +0000
                          Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:56 -0600
                        Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 11:33 -0500
                  Re: Refuting the halting problem proofs with fully operational code Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 20:11 -0800
                Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-11 01:45 +0000
                  Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-10 20:10 -0600
                    Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:03 +0000
                      Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 18:08 -0600
                    Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-14 15:20 -0400
                  Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 08:15 -0600
                    Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 08:31 -0600
                      Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:15 +0000
                        Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 18:22 -0600
                          Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 01:02 +0000
                            Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 20:35 -0600
                          Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-11 19:36 -0700
                            Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 20:48 -0600
                              Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-11 20:13 -0700
                                Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 21:22 -0600
                                  Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-11 21:16 -0700
                                    Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 22:24 -0600
                                      Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-11 22:20 -0700
                                        Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 23:36 -0600
                                          Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:38 -0500
                                      Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 05:40 +0000
                                        Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 08:27 -0600
                                          Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 15:28 +0000
                              Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-11 22:38 -0500
                      Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:35 -0500
                    Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:06 +0000
                      Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 18:14 -0600
                        Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 01:06 +0000
                          Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 20:43 -0600
                            Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 03:29 +0000
                              Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 21:37 -0600
                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 05:38 +0000
                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 08:20 -0600
                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 15:20 +0000
                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 09:36 -0600
                                        Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 16:03 +0000
                                          Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 10:55 -0600
                                            Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 17:50 +0000
                                              Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 12:02 -0600
                                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 18:13 +0000
                                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 12:21 -0600
                                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-12 11:20 -0700
                                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 12:23 -0600
                                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 19:03 +0000
                                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 13:10 -0600
                                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-12 12:42 -0700
                                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 13:45 -0600
                                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 16:17 -0600
                                                        Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-12 15:31 -0700
                                                          Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 16:42 -0600
                                                            Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 09:00 -0700
                                                              Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 10:29 -0600
                                                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-13 08:45 -0800
                                                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 10:58 -0600
                                                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 10:28 -0700
                                                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 11:55 -0600
                                                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 11:25 -0700
                                                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 12:38 -0600
                                                                        Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 12:51 -0700
                                                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-14 16:00 -0400
                                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-12 16:39 -0800
                                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-12 23:20 -0500
                            Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-13 00:34 +0000
                              Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-12 20:10 -0600
                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-13 04:08 +0000
                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-12 22:51 -0600
                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-13 23:53 +0000
                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <polcott2@gmail.com> - 2021-03-13 18:20 -0600
                                        Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:54 -0500
                                        Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 16:34 +0000
                                          Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <polcott2@gmail.com> - 2021-03-14 13:17 -0500
                                            Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 13:27 -0500
                                              Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-03-14 11:35 -0700
                                                Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 13:43 -0500
                                                  Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 17:43 -0400
                                              Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 18:43 +0000
                                                Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 14:05 -0500
                                                  Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 19:22 +0000
                                                    Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 14:47 -0500
                                                      Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 21:22 +0000
                                                        Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 16:46 -0500
                                                          Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 00:00 +0000
                                                            Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 19:43 -0500
                                                              Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 01:12 +0000
                                                                Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 20:24 -0500
                                                                  Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 21:50 -0400
                                                                    Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) R Kym Horsell <kym@kymhorsell.com> - 2021-03-15 01:53 +0000
                                                                      Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 21:20 -0500
                                                                        Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-14 19:29 -0700
                                                                          Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) R Kym Horsell <kym@kymhorsell.com> - 2021-03-15 03:30 +0000
                                                                            Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Jeff Barnett <jbb@notatt.com> - 2021-03-15 10:48 -0600
                                                                        Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-14 19:30 -0700
                                                                          Re: Refuting the halting problem proofs [...]. Andy Walker <anw@cuboid.co.uk> - 2021-03-15 13:38 +0000
                                                                            Re: Refuting the halting problem proofs [...]. olcott <NoOne@NoWhere.com> - 2021-03-15 09:03 -0500
                                                                              Re: Refuting the halting problem proofs [...]. Alan Mackenzie <acm@muc.de> - 2021-03-15 14:22 +0000
                                                                                Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 09:44 -0500
                                                                              Re: Refuting the halting problem proofs [...]. Richard Damon <Richard@Damon-Family.org> - 2021-03-16 07:33 -0400
                                                                                Re: Refuting the halting problem proofs [...]. olcott <NoOne@NoWhere.com> - 2021-03-16 08:32 -0500
                                                                                  Re: Refuting the halting problem proofs [...]. Richard Damon <Richard@Damon-Family.org> - 2021-03-18 23:11 -0400
                                                                                    Re: Refuting the halting problem proofs [...]. olcott <NoOne@NoWhere.com> - 2021-03-18 22:15 -0500
                                                                                      Re: Refuting the halting problem proofs [...]. Richard Damon <Richard@Damon-Family.org> - 2021-03-18 23:50 -0400
                                                                            Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 09:09 -0500
                                                                              Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-15 15:55 +0100
                                                                                Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 10:11 -0500
                                                                                  Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-15 16:38 +0100
                                                                                    Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 12:01 -0500
                                                                                      Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-15 18:53 +0100
                                                                                        Re: Refuting the halting problem proofs [...]. (rebuttal has no basis) olcott <NoOne@NoWhere.com> - 2021-03-15 13:04 -0500
                                                                                Re: Refuting the halting problem proofs [...]. (I dare you to find the error) Jeff Barnett <jbb@notatt.com> - 2021-03-15 15:15 -0600
                                                                                  Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-16 09:35 +0100
                                                                                    Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-16 08:10 -0500
                                                                  Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 02:30 +0000
                                                                    Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 22:00 -0500
                                                                      Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 03:13 +0000
                                                                        Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 22:22 -0500
                                                                          Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 20:18 +0000
                                                                            Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) olcott <NoOne@NoWhere.com> - 2021-03-15 15:41 -0500
                                                                              Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 13:45 +0000
                                                                                Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) olcott <NoOne@NoWhere.com> - 2021-03-16 09:59 -0500
                                                                                  Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 17:26 +0000
                                                                                    Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 13:09 -0500
                                                                                      Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 18:38 +0000
                                                                                        Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:14 -0500
                                                                                          Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 19:46 +0000
                                                                                            Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:55 -0500
                                                                                              Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:11 +0000
                                                                                                Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:21 -0500
                                                                                                  Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:27 +0000
                                                                                                    Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 16:19 -0500
                                                                                                      Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:12 +0000
                                                                                      Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 13:40 -0500
                                                                                        Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 19:12 +0000
                                                                                          Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:18 -0500
                                                                                            Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-16 19:21 +0000
                                                                                            Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 12:33 -0700
                                                                                              Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:49 -0500
                                                                                                Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:04 +0000
                                                                                                  Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:14 -0500
                                                                                                    Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:24 +0000
                                                                                            Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 19:52 +0000
                                                                                              Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:56 -0500
                                                                                              Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:03 -0500
                                                                                                Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:20 +0000
                                                                                                  Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:27 -0500
                                                                                                    Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:31 +0000
                                                                                                      Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 16:21 -0500
                                                                                                        Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:10 +0000
                                                                                                          Re: Refuting the halting problem proofs with fully operational code (subordinate computation) olcott <NoOne@NoWhere.com> - 2021-03-17 09:11 -0500
                                                                                        Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 12:17 -0700
                                                                                          Re: Refuting the halting problem proofs with fully operational code (simpler example) olcott <NoOne@NoWhere.com> - 2021-03-16 14:46 -0500
                                                                                            Re: Refuting the halting problem proofs with fully operational code (simpler example) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:10 +0000
                                                                                              Re: Refuting the halting problem proofs with fully operational code (simpler example) olcott <NoOne@NoWhere.com> - 2021-03-16 15:17 -0500
                                                                                                Re: Refuting the halting problem proofs with fully operational code (simpler example) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:22 +0000
                                                                                                  Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 16:16 -0500
                                                                                                    Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 14:38 -0700
                                                                                                      Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 16:52 -0500
                                                                                                        Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 15:25 -0700
                                                                                                          Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 17:38 -0500
                                                                                                            Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 16:03 -0700
                                                                                                              Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 18:34 -0500
                                                                                                                Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 18:35 -0500
                                                                                                                  Re: Refuting the halting problem proofs with fully operational code (Turing computable) Jeff Barnett <jbb@notatt.com> - 2021-03-16 18:01 -0600
                                                                                                                    Re: Refuting the halting problem proofs with fully operational code (Turing computable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:18 +0000
                                                                                                                    Re: Refuting the halting problem proofs with fully operational code (Turing computable) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-16 23:42 -0700
                                                                                                                  Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 17:06 -0700
                                                                                                              Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 19:22 -0500
                                                                                                                Halt Decider "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-03-16 18:29 -0700
                                                                                                                  Re: Halt Decider olcott <NoOne@NoWhere.com> - 2021-03-16 20:41 -0500
                                                                                                        Re: Refuting the halting problem proofs with fully operational code (Turing computable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:17 +0000
                                                                                                    Re: Refuting the halting problem proofs with fully operational code (Turing computable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:16 +0000
                                                                                                      Re: Refuting the halting problem proofs with fully operational code (Turing computable)[unconventional part] olcott <NoOne@NoWhere.com> - 2021-03-17 09:27 -0500
                                                              Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 21:47 -0400
                                                          Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 20:14 -0400
                                                      Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 20:09 -0400
                                Re: Refuting the halting problem proofs [...] Andy Walker <anw@cuboid.co.uk> - 2021-03-13 12:18 +0000
                                  Re: Refuting the halting problem proofs [...](contradictory questions) olcott <NoOne@NoWhere.com> - 2021-03-13 08:18 -0600
                                  Re: Refuting the halting problem proofs [...] (contradictory questions) olcott <NoOne@NoWhere.com> - 2021-03-13 08:23 -0600
                                Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 02:10 +0000
                                  Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-13 20:21 -0600
                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:59 -0500
                                    Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 02:30 +0000
                                      Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-14 22:15 -0500
                                        Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:33 +0000
                                          Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-14 22:40 -0500
                                            Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Richard Damon <Richard@Damon-Family.org> - 2021-03-15 08:25 -0400
                        Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-11 22:51 -0500
                          Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 22:08 -0600
                            Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-13 12:39 -0500
                              Re: Refuting the halting problem proofs with fully operational code (switch statement not relevant) olcott <NoOne@NoWhere.com> - 2021-03-13 12:01 -0600
                                Re: Refuting the halting problem proofs with fully operational code (switch statement not relevant) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:56 -0500
                              Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-13 11:01 -0700
                                Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-13 12:33 -0600
            Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:55 +0000
              Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 21:07 -0600
                Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:34 +0000
            Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:16 -0500
          Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:47 +0000
            Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:55 -0600
              Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:27 +0000
              Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-09 20:38 -0700
                Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 21:42 -0600
                  Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-09 21:24 -0700
                    Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-09 22:30 -0600
                      Re: Refuting the halting problem proofs with fully operational code (UTM decider) André G. Isaak <agisaak@gm.invalid> - 2021-03-09 21:58 -0700
                        Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-10 09:19 -0600
                          Re: Refuting the halting problem proofs with fully operational code (UTM decider) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 08:43 -0700
                            Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 10:03 -0600
                              Re: Refuting the halting problem proofs with fully operational code (one point at a time) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 09:33 -0700
                                Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 11:35 -0600
                                  Re: Refuting the halting problem proofs with fully operational code (one point at a time) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 10:57 -0700
                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 12:09 -0600
                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 12:09 -0700
                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 14:01 -0600
                                          Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 13:36 -0700
                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 15:01 -0600
                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 14:13 -0700
                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 16:23 -0600
                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 15:48 -0700
                                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 17:01 -0600
                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 16:58 -0700
                                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 18:34 -0600
                                                          Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 17:45 -0700
                                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 19:05 -0600
                                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 20:36 -0700
                                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 21:40 -0600
                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 23:49 +0000
                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 17:57 -0600
                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 00:18 +0000
                                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 19:01 -0600
                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 02:43 +0000
                                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 20:53 -0600
                                                          Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 03:04 +0000
                                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 21:24 -0600
                                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 23:51 -0500
                                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 23:12 -0600
                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 09:43 -0700
                                                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 11:13 -0600
                                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 11:23 -0600
                                                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 11:47 -0700
                                                                          Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:00 -0600
                                                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 12:23 -0700
                                                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:41 -0600
                                                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:04 +0000
                                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:22 -0600
                                                                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 00:07 +0000
                                                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:00 +0000
                                                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:20 -0600
                                                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:56 +0000
                                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 10:38 -0700
                                                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 11:50 -0600
                                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 18:54 +0000
                                                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:03 -0600
                                                                          Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 12:44 -0700
                                                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:50 -0600
                                                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 13:34 -0700
                                                                                Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-11 12:42 -0800
                                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:01 -0600
                                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 14:12 -0700
                                                                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:26 -0600
                                                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:54 +0000
                                                                                    Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:52 +0000
                                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:46 -0600
                                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-11 23:41 +0000
                                                                                    Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-11 17:56 -0600
                                                                                      Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:52 +0000
                                                                                        Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-11 19:10 -0600
                                                                                          Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-13 00:21 +0000
                                                                                            Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-12 19:57 -0600
                                                                                              Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:59 -0500
                                                                                              Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 01:50 +0000
                                                                                                Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-13 20:07 -0600
                                                                          Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 20:52 +0000
                                                                            Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:15 -0600
                                                                              Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:56 +0000
                                                                      Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 23:11 -0500
                                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 23:05 -0500
                                                        Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-10 20:39 -0800
                                                  Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 19:41 -0500
                                  Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 14:03 -0500
                                    Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 13:08 -0600
                                      Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 15:05 -0500
                                      Re: Refuting the halting problem proofs with fully operational code (one point at a time) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 21:16 +0000
                                        Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 16:26 -0600
                                          Re: Refuting the halting problem proofs with fully operational code (one point at a time) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 00:28 +0000
                                            Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 19:07 -0600
                                              Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 08:29 -0500
                                                Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-11 07:45 -0600
                                                  Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 21:52 -0500
                                                    Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-11 21:01 -0600
                              Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 19:29 -0500
                      Re: Refuting the halting problem proofs with fully operational code (UTM decider) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 05:04 +0000
                        Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-10 09:21 -0600
                          Re: Refuting the halting problem proofs with fully operational code (UTM decider) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 15:33 +0000
                            Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-10 09:45 -0600
                              Re: Refuting the halting problem proofs with fully operational code (UTM decider) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 16:10 +0000
                          Re: Refuting the halting problem proofs with fully operational code (UTM decider) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 11:45 -0500
        Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:14 -0500
    Re: Refuting the halting problem proofs with fully operational code "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-10 17:49 -0800
    Re: Refuting the halting problem proofs with fully operational code Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-13 16:19 +0100
    Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-13 14:39 -0600
    Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 14:49 -0600
      Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-13 13:38 -0800
        Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 15:51 -0600
          Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-13 14:00 -0800
            Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 16:05 -0600
              Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:07 -0500
                Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-14 03:29 -0700
                  Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <polcott2@gmail.com> - 2021-03-14 09:55 -0500
                    Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-14 10:25 -0500
                    Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 16:08 -0400
                      Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 15:13 -0500
                        Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 14:44 -0600
                          Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 16:02 -0500
                            Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 16:06 -0500
                              Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-14 23:58 +0000
                                Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 19:27 -0500
                                  Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:15 +0000
                                    Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 22:24 -0500
                                      Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:39 +0000
                                        Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 22:43 -0500
                                          Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-15 08:30 -0400
                                    Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) R Kym Horsell <kym@kymhorsell.com> - 2021-03-15 03:27 +0000
                                      Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 12:51 -0700
                                        Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 15:20 -0500
                                          Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 14:54 -0600
                                            Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 16:29 -0500
                                              Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 15:33 -0600
                                                Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 17:00 -0500
                                                  Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 18:59 -0600
                                                    Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 20:34 -0500
                                                      Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 20:53 -0600
                                                        Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 22:22 -0500
                                                          Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 22:10 -0600
                                                          Re: Refuting the halting problem proofs with fully operational code [bloody idiots] Richard Damon <Richard@Damon-Family.org> - 2021-03-16 08:04 -0400
                                          Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 14:33 -0700
                                            Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 16:56 -0500
                                              Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 15:01 -0700
                                                Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 15:04 -0700
                                                  Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 15:11 -0700
                                                Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 17:28 -0500
                                                  Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 16:01 -0700
                                                  Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 20:47 -0700
                                                    Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 22:58 -0500
                                                      Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 21:36 -0700
                                                        Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 21:39 -0700
                                                          Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <polcott2@gmail.com> - 2021-03-16 00:00 -0500
                                                            Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 22:08 -0700
                                                            Re: Refuting the halting problem proofs with fully operational code [bloody idiots] Richard Damon <Richard@Damon-Family.org> - 2021-03-16 08:05 -0400
                                                            Re: Refuting the halting problem proofs with fully operational code [bloody idiots] Richard Damon <Richard@Damon-Family.org> - 2021-03-16 08:18 -0400
                                                              Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-16 23:39 -0700
                            Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 15:09 -0600
                              Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 16:12 -0500
                                Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 15:54 -0600
                                  Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 17:18 -0500
                                    Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 17:02 -0600
                                    Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 20:31 -0400
                                  Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 17:43 -0500
                              Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 18:01 -0400
                        Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 17:55 -0400
                      Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-14 17:38 -0700
                        Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-14 19:54 -0500
                          Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-15 03:05 -0700
                            Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-15 08:09 -0500
                              Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-15 13:37 -0700
                                Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-15 15:52 -0500
                                  Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-15 14:09 -0700
                                    Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-15 16:22 -0500
                                      Re: Refuting the halting problem proofs with fully operational code (revised answer) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 14:37 -0700
              Re: Refuting the halting problem proofs with fully operational code (revised answer) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 02:26 +0000
                Re: Refuting the halting problem proofs with fully operational code (is Ben's non-halting criteria correct?) olcott <polcott2@gmail.com> - 2021-03-13 20:53 -0600
                  Re: Refuting the halting problem proofs with fully operational code (is Ben's non-halting criteria correct?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:07 +0000
                    Re: Refuting the halting problem proofs with fully operational code (is Ben's non-halting criteria correct?) olcott <NoOne@NoWhere.com> - 2021-03-14 22:32 -0500
            Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 16:09 -0600
          Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 17:02 -0500
          Re: Refuting the halting problem proofs with fully operational code (revised answer) André G. Isaak <agisaak@gm.invalid> - 2021-03-13 16:05 -0700
            Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 17:33 -0600
              Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:09 -0500
      Re: Refuting the halting problem proofs with fully operational code (revised answer) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 02:10 +0000
        Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <polcott2@gmail.com> - 2021-03-13 20:30 -0600
          Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 22:06 -0500
          Re: Refuting the halting problem proofs with fully operational code (revised answer) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 02:37 +0000

Page 19 of 23 — ← Prev page 1 … 17 18 [19] 20 21 … 23  Next page →


#29080 — Re: Refuting the halting problem proofs with fully operational code (one point at a time)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-10 19:29 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (one point at a time)
Message-ID<Pvd2I.142343$cX.10155@fx43.iad>
In reply to#29028
On 3/10/21 11:03 AM, olcott wrote:
> On 3/10/2021 9:43 AM, André G. Isaak wrote:
>> On 2021-03-10 08:19, olcott wrote:
>>> On 3/9/2021 10:58 PM, André G. Isaak wrote:
>>
>> <snippage>
>>
>>>> As I pointed out in a previous post (which you ignored), your
>>>> Halts() cannot correctly decide an H_Hat which is derived from
>>>> Halts() according to the actual rules set out by Linz, i.e. one in
>>>> which H_Hat contains a *complete copy* of Halts with some additional
>>>> state-transitions appended. Your strategy of looking for a routine
>>>> calling itself isn't going to work here since each instance of Halts
>>>> (the uppermost one, the one in the uppermost H_Hat, etc.) will have
>>>> separate addresses.
>>>>
>>>> Even using your construction with function pointers passed, it
>>>> doesn't work for the *actual* halting problem as opposed to your
>>>> weird redefined-with-subjunctives versions of it.
>>>>
>>>> André
>>>>
>>>
>>> The actual rules by Linz to not make a difference, Sipser does not
>>> use them. Once you acknowledge that I have refuted the simplest
>>> example of the halting problem counter-examples then and only then
>>> will I work on the more complex ones. I will not tolerate endless
>>> disgression from the point.
>>
>> Of course it matters. And Sipser uses the exact same rules. You're
>> hung-up on Sipser's use of the term 'subroutine' because you don't
>> grasp how Turing Machines work.
> 
> The key element of the halting problem counter-examples that makes them
> undecidable is that the input program does the opposite if whatever the
> halt decider decides.
> 
>    Once D has determined this information, it does the
>    opposite. That is, it rejects if M accepts and accepts
>    if M does not accept. (Sipser 1997:165)
> 
> Once you acknowledge that I have conquered that then I will allow the
> conversation to digress to other points. Prior to acknowledgement of
> that I will only consider these digressions as dishonest dodges used as
> a mere tactic to make sure that the point is never addressed.
> 

Except that you haven't demonstrated that. You either try to have H not
return its answer to H^, or try to define the 'right answer' to be based
on a different question.

If you every showed a trace with H (you call it Halts) actually
returning the answer to H_Hat, it would be shown to be wrong, which is
why you never have.

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


#29008 — Re: Refuting the halting problem proofs with fully operational code (UTM decider)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-10 05:04 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (UTM decider)
Message-ID<20210309205447.966@kylheku.com>
In reply to#29004
On 2021-03-10, olcott <NoOne@NoWhere.com> wrote:
> On 3/9/2021 10:24 PM, André G. Isaak wrote:
>> On 2021-03-09 20:42, olcott wrote:
>>> On 3/9/2021 9:38 PM, André G. Isaak wrote:
>>>> On 2021-03-09 19:55, olcott wrote:
>>>>> Of every possible instance of Halts() that can possibly exist there 
>>>>> are no instances that return a correct true / false value to H_Hat().
>>>>
>>>> In Linz's proof, H takes H_Hat a an *input*. H doesn't return any 
>>>> value to H_Hat anymore than sqrt(16) returns a value to 16. Halts, 
>>>> however, cannot provide a correct response to H(H_Hat, H_Hat).
>>>>
>>>> It's only in your implementation that H actually attempts to simulate 
>>>> H_Hat and H_Hat then calls a new instance of H. That's a property of 
>>>> your design, not of Linz's H. So all you're stating here is that your 
>>>> decider has a design flaw.
>>>>
>>>> André
>>>>
>>>
>>> Not really. Not at all. When we examine this in terms actual Turing 
>>> machines it gets much simpler:
>> 
>> Once again you respond with complete irreleventia.
>> 
>> You've never presented anything in terms of actual Turing Machines, so 
>> that doesn't clarify anything.
>> 
>>> On 3/8/2021 1:07 AM, Kaz Kylheku wrote:
>>>  > On 2021-03-08, olcott <NoOne@NoWhere.com> wrote:
>>>  >> Think of the halt decider as a UTM that simply simulates
>>>  >> its input until its input halts on its own or the halt
>>>  >> decider determines that its input would never halt on
>>>  >> its own thus stops simulating it.
>>>  >
>>>  > Sure; that's what a simulating halt decider would have to do,
>>>  > (universally for all programs, to be a universal halt decider).
>> 
>> And nothing above in any way goes against what I wrote. Ignoring your 
>> abuse of terminology, there's nothing in the halting problem which 
>> requires you to use a 'UTM' which emulates its inputs, and i doubt any 
>> sane person would adopt such a strategy.
>
> The thing is that any halt decider based on a UTM that simply simulates 
> its input until its input halts on its own or the halt decider 
> determines that its input would never halt on its own thus stops 
> simulating it.

Your simulator deliberately fails to take into account that the input
is based on the simulator. The simulator notices that the input has
called into he simulator, and skips that part of he execution,
pretending that the simulator is just a transparent invocation of
a recursive call of the input.

> DOES CORRECTLY DECIDE ALL THE CONVENTIONAL HALTING PROBLEM COUNTER 
> EXAMPLES AS [WOULD NOT HALT UNLESS SIMULATION ABORTED] AKA not halting.

Your decider correctly decides the wrong test case. It decides
Naive_H_Hat(Naive_H_Hat).

   u32 Naive_Halts(u32 P, u32 I)
   {
     ((void (*)(u32)) P)(I);
   }

   void Naive_H_Hat(u32 P)
   {
      if !Naive_Halts(P, P)
         AGAIN: goto AGAIN;
   }

Because your simulator ignores its own effect on the input, pretending
tha the input is recursive. Thus when

   Halts((u32) H_Hat, (u32) H_Hat)

is called and returns 0, it is actualy simulating Naive_H_Hat((u32)
Naive_H_Hat), and not H_Hat((u32) H_Hat).

Why can we say that? Because your simulation "surgically excises" the
simulation out of H_Hat. Your simulator notices that H_Hat is calling
Halts(P, P) and then causes  Halts(P, P) to behave like
Naive_Halts(P, P), rather than as a re-invocation of the simulator.

If the simulator pretends that Halts it Naive_Halts, then it has
effectively turned H_Hat into Naive_H_Hat. And of course, that is found
to be infinitely recursive.

Your previous contraption, back in November or December, worked
differently. You allowed the simulation to be nested. But its
instruction analysis omitted analyzing the instructions of the
simulator.  By not seeing those instructions, it looked as if H_Hat was
invoking itself. I recall that this problem was revealed by puzzling
discontinuities in the instruction trace. Suddenly, the instruction
pointer jumped to a different address, not implicated by any branch
instruction.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

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


#29012 — Re: Refuting the halting problem proofs with fully operational code (UTM decider)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-10 09:21 -0600
SubjectRe: Refuting the halting problem proofs with fully operational code (UTM decider)
Message-ID<LNCdnTYNqNaZedX9nZ2dnUU7-bFQAAAA@giganews.com>
In reply to#29008
On 3/9/2021 11:04 PM, Kaz Kylheku wrote:
> On 2021-03-10, olcott <NoOne@NoWhere.com> wrote:
>> On 3/9/2021 10:24 PM, André G. Isaak wrote:
>>> On 2021-03-09 20:42, olcott wrote:
>>>> On 3/9/2021 9:38 PM, André G. Isaak wrote:
>>>>> On 2021-03-09 19:55, olcott wrote:
>>>>>> Of every possible instance of Halts() that can possibly exist there
>>>>>> are no instances that return a correct true / false value to H_Hat().
>>>>>
>>>>> In Linz's proof, H takes H_Hat a an *input*. H doesn't return any
>>>>> value to H_Hat anymore than sqrt(16) returns a value to 16. Halts,
>>>>> however, cannot provide a correct response to H(H_Hat, H_Hat).
>>>>>
>>>>> It's only in your implementation that H actually attempts to simulate
>>>>> H_Hat and H_Hat then calls a new instance of H. That's a property of
>>>>> your design, not of Linz's H. So all you're stating here is that your
>>>>> decider has a design flaw.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Not really. Not at all. When we examine this in terms actual Turing
>>>> machines it gets much simpler:
>>>
>>> Once again you respond with complete irreleventia.
>>>
>>> You've never presented anything in terms of actual Turing Machines, so
>>> that doesn't clarify anything.
>>>
>>>> On 3/8/2021 1:07 AM, Kaz Kylheku wrote:
>>>>   > On 2021-03-08, olcott <NoOne@NoWhere.com> wrote:
>>>>   >> Think of the halt decider as a UTM that simply simulates
>>>>   >> its input until its input halts on its own or the halt
>>>>   >> decider determines that its input would never halt on
>>>>   >> its own thus stops simulating it.
>>>>   >
>>>>   > Sure; that's what a simulating halt decider would have to do,
>>>>   > (universally for all programs, to be a universal halt decider).
>>>
>>> And nothing above in any way goes against what I wrote. Ignoring your
>>> abuse of terminology, there's nothing in the halting problem which
>>> requires you to use a 'UTM' which emulates its inputs, and i doubt any
>>> sane person would adopt such a strategy.
>>
>> The thing is that any halt decider based on a UTM that simply simulates
>> its input until its input halts on its own or the halt decider
>> determines that its input would never halt on its own thus stops
>> simulating it.
> 
> Your simulator deliberately fails to take into account that the input
> is based on the simulator. The simulator notices that the input has
> called into he simulator, and skips that part of he execution,
> pretending that the simulator is just a transparent invocation of
> a recursive call of the input.

On 3/8/2021 1:07 AM, Kaz Kylheku wrote:
 > On 2021-03-08, olcott <NoOne@NoWhere.com> wrote:
 >> Think of the halt decider as a UTM that simply simulates
 >> its input until its input halts on its own or the halt
 >> decider determines that its input would never halt on
 >> its own thus stops simulating it.
 >
 > Sure; that's what a simulating halt decider would have to do,
 > (universally for all programs, to be a universal halt decider).


You already said that I am right about this I will not tolerate any tack 
backs.
-- 
Copyright 2021 Pete Olcott

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

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


#29017 — Re: Refuting the halting problem proofs with fully operational code (UTM decider)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-10 15:33 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (UTM decider)
Message-ID<20210310072952.662@kylheku.com>
In reply to#29012
On 2021-03-10, olcott <NoOne@NoWhere.com> wrote:
> On 3/8/2021 1:07 AM, Kaz Kylheku wrote:
> > On 2021-03-08, olcott <NoOne@NoWhere.com> wrote:
> >> Think of the halt decider as a UTM that simply simulates
> >> its input until its input halts on its own or the halt
> >> decider determines that its input would never halt on
> >> its own thus stops simulating it.
> >
> > Sure; that's what a simulating halt decider would have to do,
> > (universally for all programs, to be a universal halt decider).
>
> You already said that I am right about this I will not tolerate any tack 
> backs.

No I didn't. Note that I use the word "would" (such as in "would have to
do" above) in the ordinary way, whereby Would-Be World is not being
confused with Is World.

My statement is about the requirements, not about your work.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

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


#29023 — Re: Refuting the halting problem proofs with fully operational code (UTM decider)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-10 09:45 -0600
SubjectRe: Refuting the halting problem proofs with fully operational code (UTM decider)
Message-ID<XsednRAlwfkfdNX9nZ2dnUU7-IPNnZ2d@giganews.com>
In reply to#29017
On 3/10/2021 9:33 AM, Kaz Kylheku wrote:
> On 2021-03-10, olcott <NoOne@NoWhere.com> wrote:
>> On 3/8/2021 1:07 AM, Kaz Kylheku wrote:
>>> On 2021-03-08, olcott <NoOne@NoWhere.com> wrote:
>>>> Think of the halt decider as a UTM that simply simulates
>>>> its input until its input halts on its own or the halt
>>>> decider determines that its input would never halt on
>>>> its own thus stops simulating it.
>>>
>>> Sure; that's what a simulating halt decider would have to do,
>>> (universally for all programs, to be a universal halt decider).
>>
>> You already said that I am right about this I will not tolerate any tack
>> backs.
> 
> No I didn't. Note that I use the word "would" (such as in "would have to
> do" above) in the ordinary way, whereby Would-Be World is not being
> confused with Is World.
> 
> My statement is about the requirements, not about your work.
> 

Would as in a conditional branch statement.
If X would not halt unless halted then halt H.

-- 
Copyright 2021 Pete Olcott

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

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


#29030 — Re: Refuting the halting problem proofs with fully operational code (UTM decider)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-10 16:10 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (UTM decider)
Message-ID<20210310080914.231@kylheku.com>
In reply to#29023
On 2021-03-10, olcott <NoOne@NoWhere.com> wrote:
> On 3/10/2021 9:33 AM, Kaz Kylheku wrote:
>> On 2021-03-10, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/8/2021 1:07 AM, Kaz Kylheku wrote:
>>>> On 2021-03-08, olcott <NoOne@NoWhere.com> wrote:
>>>>> Think of the halt decider as a UTM that simply simulates
>>>>> its input until its input halts on its own or the halt
>>>>> decider determines that its input would never halt on
>>>>> its own thus stops simulating it.
>>>>
>>>> Sure; that's what a simulating halt decider would have to do,
>>>> (universally for all programs, to be a universal halt decider).
>>>
>>> You already said that I am right about this I will not tolerate any tack
>>> backs.
>> 
>> No I didn't. Note that I use the word "would" (such as in "would have to
>> do" above) in the ordinary way, whereby Would-Be World is not being
>> confused with Is World.
>> 
>> My statement is about the requirements, not about your work.
>> 
>
> Would as in a conditional branch statement.
> If X would not halt unless halted then halt H.

If X would refrain from making utterances, X would then not be speaking.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

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


#29035 — Re: Refuting the halting problem proofs with fully operational code (UTM decider)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-10 11:45 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (UTM decider)
Message-ID<mI62I.24855$2k1.14384@fx29.iad>
In reply to#29012
On 3/10/21 10:21 AM, olcott wrote:
> 
> 
> You already said that I am right about this I will not tolerate any tack
> backs.

Maybe you should realize that sometimes people make mistakes, sometimes
they are misunderstood, and sometimes the conditions behind the
statement have changed or were not fully comprehended.

Also, just because X said Y doesn't mean that this is a proof of Y. If
it was, YOU ARE AN IDIOT.

You use fuzzy, slippery, and redefined language so much that you need to
expect that at times when people understand what you mean by a question,
they will take back an answer.

Is that why you don't like may answers, I sometime see where you are
going and explicitly qualify them to avoid at least the worse of your
language abuse?

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


#28988

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-09 22:14 -0500
Message-ID<MQW1I.33814$nj1.10132@fx28.iad>
In reply to#28964
On 3/9/21 7:42 PM, olcott wrote:
> On 3/9/2021 6:29 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Eliminating pathological self-reference error from the halting problem
>>>
>>> The pathological self reference error occurs whenever a question or
>>> decision problem cannot be correctly answered because both of the
>>> yes/no or true/false answers are contradicted.
>>
>> Every instance of the halting problem has a correct yes/no answer.  This
>> is also true of all the other undecidable design problem PO ignores.
> 
> The question posed to Jack: Will your answer to this quesition be no?
> Has no correct answer that Jack can provide in exactly the same way that
> the halt decider cannot provide a correct return value to H_Hat().
> 
> Jack's question has a correct answer yet not one that Jack can provide
> because every answer that Jack provides is contradicted.
> 
> Whether or not H_Hat() halts has a correct answer yet no correct answer
> that Halts() can provide to H_Hat() because H_Hat() contradicts both
> answers by doing the opposite of whatever the halt decider decides.
> 
> When-so-ever any question or decision problem instance lacks a correct
> yes/no answer or true/false resolution because both of these values are
> contradicted then the question / decision problem instance is incorrect.
> 

Why does Halts need to be able to return the correct answer? That is
your fundamental problem, it doesn't

I suppose you have never considered that YOU could be wrong either, and
that is why you are inflicting such gibberish on the world.

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


#29090

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-03-10 17:49 -0800
Message-ID<s2bsv7$13u$1@gioia.aioe.org>
In reply to#28957
On 3/9/2021 2:56 PM, olcott wrote:
> Eliminating pathological self-reference error from the halting problem
> 
> The pathological self reference error occurs whenever a question or 
> decision problem cannot be correctly answered because both of the yes/no 
> or true/false answers are contradicted.
> 
> If we ask Jack[1] this question: Will your answer to this question be no?
> Neither answer of yes or no is correct because they are both contradicted.
> 
> When an input program is defined to do opposite of whatever the halt 
> decider decides about its halt status then we have the same pathological 
> self-reference error as Jack's question.
> 
> If the halt decider Halts() returns a value of true to H_Hat() then 
> H_Hat() would go into an infinite loop and never halt. If the halt 
> decider Halts() returns a value of false to H_Hat() then H_Hat would 
> immediately stop running.
> 
> The simplest way to define a halt decider is to make a program that 
> simply runs its input to see what it does. In technical terms this would 
> be a universal Turing machine (UTM) that has been adapted to become a 
> halt decider. This UTM would simply simulate the execution of its input 
> until its input halts on its own or the halt decider determines that its 
> input would never halt on its own and stops simulating it. In order for 
> the UTM to see what its input does it must keep track of an execution 
> trace of its input.
> 
> Every (at least partial) halt decider that decides the halting status of 
> its input on the basis of its examination of the execution trace of its 
> own simulation of this input would correctly decide the conventional 
> halting problem counter-examples as not halting.
> 
> The x86utm operating system was created so that halt deciders written in 
> the C programming language would be computationally equivalent to the 
> execution of actual Turing machines. These (at least partial) halt 
> deciders base their halting decision on examining the execution trace of 
> the x86 machine language of their input. The input is the COFF object 
> file output of a C compiler and is directly executed by the x86 emulator.
> 
> The halt decider Halts() determines that H_Hat() called it in infinite 
> recursion, on the basis of the x86 machine language execution trace 
> shown below, stop simulating its input, and decide not halting on the 
> basis that its input would not halt.
> 
> void H_Hat(u32 P)
> {
>    u32 Input_Would_Halt = Halts(P, P);
>    if (Input_Would_Halt)
>      HERE: goto HERE;
> }
> 
> 
> int main()
> {
>    u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>    Output("Input_Would_Halt = ", Input_Would_Halt);
> }
> 
> _H_Hat()
> [0000088f](01)  55              push ebp
> [00000890](02)  8bec            mov ebp,esp
> [00000892](01)  51              push ecx
> [00000893](03)  8b4508          mov eax,[ebp+08]
> [00000896](01)  50              push eax
> [00000897](03)  8b4d08          mov ecx,[ebp+08]
> [0000089a](01)  51              push ecx
> [0000089b](05)  e87ffeffff      call 0000071f
> [000008a0](03)  83c408          add esp,+08
> [000008a3](03)  8945fc          mov [ebp-04],eax
> [000008a6](04)  837dfc00        cmp dword [ebp-04],+00
> [000008aa](02)  7402            jz 000008ae
> [000008ac](02)  ebfe            jmp 000008ac
> [000008ae](02)  8be5            mov esp,ebp
> [000008b0](01)  5d              pop ebp
> [000008b1](01)  c3              ret
> 
> _main()
> [000008bf](01)  55              push ebp
> [000008c0](02)  8bec            mov ebp,esp
> [000008c2](01)  51              push ecx
> [000008c3](05)  688f080000      push 0000088f
> [000008c8](05)  688f080000      push 0000088f
> [000008cd](05)  e84dfeffff      call 0000071f
> [000008d2](03)  83c408          add esp,+08
> [000008d5](03)  8945fc          mov [ebp-04],eax
> [000008d8](03)  8b45fc          mov eax,[ebp-04]
> [000008db](01)  50              push eax
> [000008dc](05)  680b030000      push 0000030b
> [000008e1](05)  e869faffff      call 0000034f
> [000008e6](03)  83c408          add esp,+08
> [000008e9](02)  33c0            xor eax,eax
> [000008eb](02)  8be5            mov esp,ebp
> [000008ed](01)  5d              pop ebp
> [000008ee](01)  c3              ret
> 
> Columns
> (1) Execution trace sequence number
> (2) Machine address of instruction
> (3) Machine address of top of stack
> (4) Value of top of stack after instruction executed
> (5) Number of bytes of machine code
> (6) Machine language bytes
> (7) Assembly language text
> 
> (01)[000008bf][00011208][00000000](01)  55              push ebp
> (02)[000008c0][00011208][00000000](02)  8bec            mov ebp,esp
> (03)[000008c2][00011204][00000000](01)  51              push ecx
> (04)[000008c3][00011200][0000088f](05)  688f080000      push 0000088f
> (05)[000008c8][000111fc][0000088f](05)  688f080000      push 0000088f
> (06)[000008cd][000111f8][000008d2](05)  e84dfeffff      call 0000071f
> 
> (07)[0000088f][00031288][0003128c](01)  55              push ebp
> (08)[00000890][00031288][0003128c](02)  8bec            mov ebp,esp
> (09)[00000892][00031284][00021258](01)  51              push ecx
> (10)[00000893][00031284][00021258](03)  8b4508          mov eax,[ebp+08]
> (11)[00000896][00031280][0000088f](01)  50              push eax
> (12)[00000897][00031280][0000088f](03)  8b4d08          mov ecx,[ebp+08]
> (13)[0000089a][0003127c][0000088f](01)  51              push ecx
> (14)[0000089b][00031278][000008a0](05)  e87ffeffff      call 0000071f
> 
> Line(11) Push second parameter value: 0000088f to Halts()
> Line(13) Push first  parameter value: 0000088f to Halts()
> Line(14) H_Halt() calls Halts(0000088f, 0000088f)
> 
> (15)[0000088f][00042430][00042434](01)  55              push ebp
> (16)[00000890][00042430][00042434](02)  8bec            mov ebp,esp
> (17)[00000892][0004242c][00032400](01)  51              push ecx
> (18)[00000893][0004242c][00032400](03)  8b4508          mov eax,[ebp+08]
> (19)[00000896][00042428][0000088f](01)  50              push eax
> (20)[00000897][00042428][0000088f](03)  8b4d08          mov ecx,[ebp+08]
> (21)[0000089a][00042424][0000088f](01)  51              push ecx
> (22)[0000089b][00042420][000008a0](05)  e87ffeffff      call 0000071f
> 
> Line(19) Push second parameter value: 0000088f to Halts()
> Line(21) Push first  parameter value: 0000088f to Halts()
> Line(22) H_Halt() calls Halts(0000088f, 0000088f)
> 
> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat() 
> calls Halts() with the same data a second time in sequence from the same 
> machine address.
> 
> (23)[000008d2][00011204][00000000](03)  83c408          add esp,+08
> (24)[000008d5][00011204][00000000](03)  8945fc          mov [ebp-04],eax
> (25)[000008d8][00011204][00000000](03)  8b45fc          mov eax,[ebp-04]
> (26)[000008db][00011200][00000000](01)  50              push eax
> (27)[000008dc][000111fc][0000030b](05)  680b030000      push 0000030b
> (28)[000008e1][000111f8][000008e6](05)  e869faffff      call 0000034f
> Input_Would_Halt = 0
> 
> (29)[000008e6][00011204][00000000](03)  83c408          add esp,+08
> (30)[000008e9][00011204][00000000](02)  33c0            xor eax,eax
> (31)[000008eb][00011208][00000000](02)  8be5            mov esp,ebp
> (32)[000008ed][0001120c][00010000](01)  5d              pop ebp
> (33)[000008ee][00011210][00000080](01)  c3              ret
> Number_of_User_Instructions(33)
> 
> Copyright 2021 PL Olcott
> 
> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM
> [The Psychology of Self-Reference]
> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
> 
> 
> 
> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf 
> 
> 

The halting problem... If you jump off of a cliff, will you survive?

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


#29208

FromBonita Montero <Bonita.Montero@gmail.com>
Date2021-03-13 16:19 +0100
Message-ID<s2il64$fsl$1@dont-email.me>
In reply to#28957
Stop posting off-topic stuff here.

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


#29224

Fromolcott <NoOne@NoWhere.com>
Date2021-03-13 14:39 -0600
Message-ID<VsqdnbL878hjv9D9nZ2dnUU7-VfNnZ2d@giganews.com>
In reply to#28957
On 3/13/2021 10:49 AM, wij wrote:
> On Wednesday, 10 March 2021 at 06:56:40 UTC+8, olcott wrote:
>> Eliminating pathological self-reference error from the halting problem
>>
>> The pathological self reference error occurs whenever a question or
>> decision problem cannot be correctly answered because both of the yes/no
>> or true/false answers are contradicted.
>>
>> If we ask Jack[1] this question: Will your answer to this question be no?
>> Neither answer of yes or no is correct because they are both contradicted.
>>
>> When an input program is defined to do opposite of whatever the halt
>> decider decides about its halt status then we have the same pathological
>> self-reference error as Jack's question.
>>
>> If the halt decider Halts() returns a value of true to H_Hat() then
>> H_Hat() would go into an infinite loop and never halt. If the halt
>> decider Halts() returns a value of false to H_Hat() then H_Hat would
>> immediately stop running.
>>
>> The simplest way to define a halt decider is to make a program that
>> simply runs its input to see what it does. In technical terms this would
>> be a universal Turing machine (UTM) that has been adapted to become a
>> halt decider. This UTM would simply simulate the execution of its input
>> until its input halts on its own or the halt decider determines that its
>> input would never halt on its own and stops simulating it. In order for
>> the UTM to see what its input does it must keep track of an execution
>> trace of its input.
>>
>> Every (at least partial) halt decider that decides the halting status of
>> its input on the basis of its examination of the execution trace of its
>> own simulation of this input would correctly decide the conventional
>> halting problem counter-examples as not halting.
>>
>> The x86utm operating system was created so that halt deciders written in
>> the C programming language would be computationally equivalent to the
>> execution of actual Turing machines. These (at least partial) halt
>> deciders base their halting decision on examining the execution trace of
>> the x86 machine language of their input. The input is the COFF object
>> file output of a C compiler and is directly executed by the x86 emulator.
>>
>> The halt decider Halts() determines that H_Hat() called it in infinite
>> recursion, on the basis of the x86 machine language execution trace
>> shown below, stop simulating its input, and decide not halting on the
>> basis that its input would not halt.
>>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Would_Halt = Halts(P, P);
>> if (Input_Would_Halt)
>> HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>> Output("Input_Would_Halt = ", Input_Would_Halt);
>> }
>>
>> _H_Hat()
>> [0000088f](01) 55 push ebp
>> [00000890](02) 8bec mov ebp,esp
>> [00000892](01) 51 push ecx
>> [00000893](03) 8b4508 mov eax,[ebp+08]
>> [00000896](01) 50 push eax
>> [00000897](03) 8b4d08 mov ecx,[ebp+08]
>> [0000089a](01) 51 push ecx
>> [0000089b](05) e87ffeffff call 0000071f
>> [000008a0](03) 83c408 add esp,+08
>> [000008a3](03) 8945fc mov [ebp-04],eax
>> [000008a6](04) 837dfc00 cmp dword [ebp-04],+00
>> [000008aa](02) 7402 jz 000008ae
>> [000008ac](02) ebfe jmp 000008ac
>> [000008ae](02) 8be5 mov esp,ebp
>> [000008b0](01) 5d pop ebp
>> [000008b1](01) c3 ret
>>
>> _main()
>> [000008bf](01) 55 push ebp
>> [000008c0](02) 8bec mov ebp,esp
>> [000008c2](01) 51 push ecx
>> [000008c3](05) 688f080000 push 0000088f
>> [000008c8](05) 688f080000 push 0000088f
>> [000008cd](05) e84dfeffff call 0000071f
>> [000008d2](03) 83c408 add esp,+08
>> [000008d5](03) 8945fc mov [ebp-04],eax
>> [000008d8](03) 8b45fc mov eax,[ebp-04]
>> [000008db](01) 50 push eax
>> [000008dc](05) 680b030000 push 0000030b
>> [000008e1](05) e869faffff call 0000034f
>> [000008e6](03) 83c408 add esp,+08
>> [000008e9](02) 33c0 xor eax,eax
>> [000008eb](02) 8be5 mov esp,ebp
>> [000008ed](01) 5d pop ebp
>> [000008ee](01) c3 ret
>>
>> Columns
>> (1) Execution trace sequence number
>> (2) Machine address of instruction
>> (3) Machine address of top of stack
>> (4) Value of top of stack after instruction executed
>> (5) Number of bytes of machine code
>> (6) Machine language bytes
>> (7) Assembly language text
>>
>> (01)[000008bf][00011208][00000000](01) 55 push ebp
>> (02)[000008c0][00011208][00000000](02) 8bec mov ebp,esp
>> (03)[000008c2][00011204][00000000](01) 51 push ecx
>> (04)[000008c3][00011200][0000088f](05) 688f080000 push 0000088f
>> (05)[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f
>> (06)[000008cd][000111f8][000008d2](05) e84dfeffff call 0000071f
>>
>> (07)[0000088f][00031288][0003128c](01) 55 push ebp
>> (08)[00000890][00031288][0003128c](02) 8bec mov ebp,esp
>> (09)[00000892][00031284][00021258](01) 51 push ecx
>> (10)[00000893][00031284][00021258](03) 8b4508 mov eax,[ebp+08]
>> (11)[00000896][00031280][0000088f](01) 50 push eax
>> (12)[00000897][00031280][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>> (13)[0000089a][0003127c][0000088f](01) 51 push ecx
>> (14)[0000089b][00031278][000008a0](05) e87ffeffff call 0000071f
>>
>> Line(11) Push second parameter value: 0000088f to Halts()
>> Line(13) Push first parameter value: 0000088f to Halts()
>> Line(14) H_Halt() calls Halts(0000088f, 0000088f)
>>
>> (15)[0000088f][00042430][00042434](01) 55 push ebp
>> (16)[00000890][00042430][00042434](02) 8bec mov ebp,esp
>> (17)[00000892][0004242c][00032400](01) 51 push ecx
>> (18)[00000893][0004242c][00032400](03) 8b4508 mov eax,[ebp+08]
>> (19)[00000896][00042428][0000088f](01) 50 push eax
>> (20)[00000897][00042428][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>> (21)[0000089a][00042424][0000088f](01) 51 push ecx
>> (22)[0000089b][00042420][000008a0](05) e87ffeffff call 0000071f
>>
>> Line(19) Push second parameter value: 0000088f to Halts()
>> Line(21) Push first parameter value: 0000088f to Halts()
>> Line(22) H_Halt() calls Halts(0000088f, 0000088f)
>>
>> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat()
>> calls Halts() with the same data a second time in sequence from the same
>> machine address.
>>
>> (23)[000008d2][00011204][00000000](03) 83c408 add esp,+08
>> (24)[000008d5][00011204][00000000](03) 8945fc mov [ebp-04],eax
>> (25)[000008d8][00011204][00000000](03) 8b45fc mov eax,[ebp-04]
>> (26)[000008db][00011200][00000000](01) 50 push eax
>> (27)[000008dc][000111fc][0000030b](05) 680b030000 push 0000030b
>> (28)[000008e1][000111f8][000008e6](05) e869faffff call 0000034f
>> Input_Would_Halt = 0
>>
>> (29)[000008e6][00011204][00000000](03) 83c408 add esp,+08
>> (30)[000008e9][00011204][00000000](02) 33c0 xor eax,eax
>> (31)[000008eb][00011208][00000000](02) 8be5 mov esp,ebp
>> (32)[000008ed][0001120c][00010000](01) 5d pop ebp
>> (33)[000008ee][00011210][00000080](01) c3 ret
>> Number_of_User_Instructions(33)
>>
>> Copyright 2021 PL Olcott
>>
>> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM
>> [The Psychology of Self-Reference]
>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
>>
>>
>>
>> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf
>> -- 
>> Copyright 2021 Pete Olcott
>>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
> 
> There is no way to remove "the pathological self-reference", which you
> refer to as an error is also incorrect.
> Let S be a set of all non-halting programs. The ones that fit 'self-reference'
> are just a small subset of S.
> How you decide x is an element of S without simulating x is the problem.
> In this respect, your decider algorithm is still incomplele at most.
> 

If you examine the execution trace on the least two pages of the above 
link you will see that it provides a 100% complete basis for Halts() to 
correctly decide that H_Hat() would not halt.

-- 
Copyright 2021 Pete Olcott

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

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


#29225 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-13 14:49 -0600
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<Ub6dnbdqx6nBuND9nZ2dnUU7-eHNnZ2d@giganews.com>
In reply to#28957
On 3/13/2021 10:49 AM, wij wrote:
> On Wednesday, 10 March 2021 at 06:56:40 UTC+8, olcott wrote:
>> Eliminating pathological self-reference error from the halting problem
>>
>> The pathological self reference error occurs whenever a question or
>> decision problem cannot be correctly answered because both of the yes/no
>> or true/false answers are contradicted.
>>
>> If we ask Jack[1] this question: Will your answer to this question be no?
>> Neither answer of yes or no is correct because they are both contradicted.
>>
>> When an input program is defined to do opposite of whatever the halt
>> decider decides about its halt status then we have the same pathological
>> self-reference error as Jack's question.
>>
>> If the halt decider Halts() returns a value of true to H_Hat() then
>> H_Hat() would go into an infinite loop and never halt. If the halt
>> decider Halts() returns a value of false to H_Hat() then H_Hat would
>> immediately stop running.
>>
>> The simplest way to define a halt decider is to make a program that
>> simply runs its input to see what it does. In technical terms this would
>> be a universal Turing machine (UTM) that has been adapted to become a
>> halt decider. This UTM would simply simulate the execution of its input
>> until its input halts on its own or the halt decider determines that its
>> input would never halt on its own and stops simulating it. In order for
>> the UTM to see what its input does it must keep track of an execution
>> trace of its input.
>>
>> Every (at least partial) halt decider that decides the halting status of
>> its input on the basis of its examination of the execution trace of its
>> own simulation of this input would correctly decide the conventional
>> halting problem counter-examples as not halting.
>>
>> The x86utm operating system was created so that halt deciders written in
>> the C programming language would be computationally equivalent to the
>> execution of actual Turing machines. These (at least partial) halt
>> deciders base their halting decision on examining the execution trace of
>> the x86 machine language of their input. The input is the COFF object
>> file output of a C compiler and is directly executed by the x86 emulator.
>>
>> The halt decider Halts() determines that H_Hat() called it in infinite
>> recursion, on the basis of the x86 machine language execution trace
>> shown below, stop simulating its input, and decide not halting on the
>> basis that its input would not halt.
>>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Would_Halt = Halts(P, P);
>> if (Input_Would_Halt)
>> HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>> Output("Input_Would_Halt = ", Input_Would_Halt);
>> }
>>
>> _H_Hat()
>> [0000088f](01) 55 push ebp
>> [00000890](02) 8bec mov ebp,esp
>> [00000892](01) 51 push ecx
>> [00000893](03) 8b4508 mov eax,[ebp+08]
>> [00000896](01) 50 push eax
>> [00000897](03) 8b4d08 mov ecx,[ebp+08]
>> [0000089a](01) 51 push ecx
>> [0000089b](05) e87ffeffff call 0000071f
>> [000008a0](03) 83c408 add esp,+08
>> [000008a3](03) 8945fc mov [ebp-04],eax
>> [000008a6](04) 837dfc00 cmp dword [ebp-04],+00
>> [000008aa](02) 7402 jz 000008ae
>> [000008ac](02) ebfe jmp 000008ac
>> [000008ae](02) 8be5 mov esp,ebp
>> [000008b0](01) 5d pop ebp
>> [000008b1](01) c3 ret
>>
>> _main()
>> [000008bf](01) 55 push ebp
>> [000008c0](02) 8bec mov ebp,esp
>> [000008c2](01) 51 push ecx
>> [000008c3](05) 688f080000 push 0000088f
>> [000008c8](05) 688f080000 push 0000088f
>> [000008cd](05) e84dfeffff call 0000071f
>> [000008d2](03) 83c408 add esp,+08
>> [000008d5](03) 8945fc mov [ebp-04],eax
>> [000008d8](03) 8b45fc mov eax,[ebp-04]
>> [000008db](01) 50 push eax
>> [000008dc](05) 680b030000 push 0000030b
>> [000008e1](05) e869faffff call 0000034f
>> [000008e6](03) 83c408 add esp,+08
>> [000008e9](02) 33c0 xor eax,eax
>> [000008eb](02) 8be5 mov esp,ebp
>> [000008ed](01) 5d pop ebp
>> [000008ee](01) c3 ret
>>
>> Columns
>> (1) Execution trace sequence number
>> (2) Machine address of instruction
>> (3) Machine address of top of stack
>> (4) Value of top of stack after instruction executed
>> (5) Number of bytes of machine code
>> (6) Machine language bytes
>> (7) Assembly language text
>>
>> (01)[000008bf][00011208][00000000](01) 55 push ebp
>> (02)[000008c0][00011208][00000000](02) 8bec mov ebp,esp
>> (03)[000008c2][00011204][00000000](01) 51 push ecx
>> (04)[000008c3][00011200][0000088f](05) 688f080000 push 0000088f
>> (05)[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f
>> (06)[000008cd][000111f8][000008d2](05) e84dfeffff call 0000071f
>>
>> (07)[0000088f][00031288][0003128c](01) 55 push ebp
>> (08)[00000890][00031288][0003128c](02) 8bec mov ebp,esp
>> (09)[00000892][00031284][00021258](01) 51 push ecx
>> (10)[00000893][00031284][00021258](03) 8b4508 mov eax,[ebp+08]
>> (11)[00000896][00031280][0000088f](01) 50 push eax
>> (12)[00000897][00031280][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>> (13)[0000089a][0003127c][0000088f](01) 51 push ecx
>> (14)[0000089b][00031278][000008a0](05) e87ffeffff call 0000071f
>>
>> Line(11) Push second parameter value: 0000088f to Halts()
>> Line(13) Push first parameter value: 0000088f to Halts()
>> Line(14) H_Halt() calls Halts(0000088f, 0000088f)
>>
>> (15)[0000088f][00042430][00042434](01) 55 push ebp
>> (16)[00000890][00042430][00042434](02) 8bec mov ebp,esp
>> (17)[00000892][0004242c][00032400](01) 51 push ecx
>> (18)[00000893][0004242c][00032400](03) 8b4508 mov eax,[ebp+08]
>> (19)[00000896][00042428][0000088f](01) 50 push eax
>> (20)[00000897][00042428][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>> (21)[0000089a][00042424][0000088f](01) 51 push ecx
>> (22)[0000089b][00042420][000008a0](05) e87ffeffff call 0000071f
>>
>> Line(19) Push second parameter value: 0000088f to Halts()
>> Line(21) Push first parameter value: 0000088f to Halts()
>> Line(22) H_Halt() calls Halts(0000088f, 0000088f)
>>
>> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat()
>> calls Halts() with the same data a second time in sequence from the same
>> machine address.
>>
>> (23)[000008d2][00011204][00000000](03) 83c408 add esp,+08
>> (24)[000008d5][00011204][00000000](03) 8945fc mov [ebp-04],eax
>> (25)[000008d8][00011204][00000000](03) 8b45fc mov eax,[ebp-04]
>> (26)[000008db][00011200][00000000](01) 50 push eax
>> (27)[000008dc][000111fc][0000030b](05) 680b030000 push 0000030b
>> (28)[000008e1][000111f8][000008e6](05) e869faffff call 0000034f
>> Input_Would_Halt = 0
>>
>> (29)[000008e6][00011204][00000000](03) 83c408 add esp,+08
>> (30)[000008e9][00011204][00000000](02) 33c0 xor eax,eax
>> (31)[000008eb][00011208][00000000](02) 8be5 mov esp,ebp
>> (32)[000008ed][0001120c][00010000](01) 5d pop ebp
>> (33)[000008ee][00011210][00000080](01) c3 ret
>> Number_of_User_Instructions(33)
>>
>> Copyright 2021 PL Olcott
>>
>> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM
>> [The Psychology of Self-Reference]
>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
>>
>>
>>
>> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf
>> -- 
>> Copyright 2021 Pete Olcott
>>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
> 
> There is no way to remove "the pathological self-reference", which you
> refer to as an error is also incorrect.

When the halting problem criteria is:
Does the input program halt on its input?

It is possible to define an input that does the opposite of whatever the 
halt decider decides.

When the halting problem criteria is:
Would the input program halt if the halt decider never stopped 
simulating it?

Then any input that does the opposite of whatever the halt decider 
decides becomes decidable.

The halt decider stops simulating this input on the basis that it is 
calling the halt decider in what would otherwise be infinite recursion 
then the halt decider reports that the input would not halt.

> Let S be a set of all non-halting programs. The ones that fit 'self-reference'
> are just a small subset of S.
> How you decide x is an element of S without simulating x is the problem.
> In this respect, your decider algorithm is still incomplele at most.
> 
> Your posts are becoming annoying.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#29230 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-03-13 13:38 -0800
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<8334e432-45bd-4b56-af1c-f637bff669b0n@googlegroups.com>
In reply to#29225
On Saturday, 13 March 2021 at 20:49:39 UTC, olcott wrote:
> On 3/13/2021 10:49 AM, wij wrote: 
> > On Wednesday, 10 March 2021 at 06:56:40 UTC+8, olcott wrote: 
> >> Eliminating pathological self-reference error from the halting problem 
> >> 
> >> The pathological self reference error occurs whenever a question or 
> >> decision problem cannot be correctly answered because both of the yes/no 
> >> or true/false answers are contradicted. 
> >> 
> >> If we ask Jack[1] this question: Will your answer to this question be no? 
> >> Neither answer of yes or no is correct because they are both contradicted. 
> >> 
> >> When an input program is defined to do opposite of whatever the halt 
> >> decider decides about its halt status then we have the same pathological 
> >> self-reference error as Jack's question. 
> >> 
> >> If the halt decider Halts() returns a value of true to H_Hat() then 
> >> H_Hat() would go into an infinite loop and never halt. If the halt 
> >> decider Halts() returns a value of false to H_Hat() then H_Hat would 
> >> immediately stop running. 
> >> 
> >> The simplest way to define a halt decider is to make a program that 
> >> simply runs its input to see what it does. In technical terms this would 
> >> be a universal Turing machine (UTM) that has been adapted to become a 
> >> halt decider. This UTM would simply simulate the execution of its input 
> >> until its input halts on its own or the halt decider determines that its 
> >> input would never halt on its own and stops simulating it. In order for 
> >> the UTM to see what its input does it must keep track of an execution 
> >> trace of its input. 
> >> 
> >> Every (at least partial) halt decider that decides the halting status of 
> >> its input on the basis of its examination of the execution trace of its 
> >> own simulation of this input would correctly decide the conventional 
> >> halting problem counter-examples as not halting. 
> >> 
> >> The x86utm operating system was created so that halt deciders written in 
> >> the C programming language would be computationally equivalent to the 
> >> execution of actual Turing machines. These (at least partial) halt 
> >> deciders base their halting decision on examining the execution trace of 
> >> the x86 machine language of their input. The input is the COFF object 
> >> file output of a C compiler and is directly executed by the x86 emulator. 
> >> 
> >> The halt decider Halts() determines that H_Hat() called it in infinite 
> >> recursion, on the basis of the x86 machine language execution trace 
> >> shown below, stop simulating its input, and decide not halting on the 
> >> basis that its input would not halt. 
> >> 
> >> void H_Hat(u32 P) 
> >> { 
> >> u32 Input_Would_Halt = Halts(P, P); 
> >> if (Input_Would_Halt) 
> >> HERE: goto HERE; 
> >> } 
> >> 
> >> 
> >> int main() 
> >> { 
> >> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat); 
> >> Output("Input_Would_Halt = ", Input_Would_Halt); 
> >> } 
> >> 
> >> _H_Hat() 
> >> [0000088f](01) 55 push ebp 
> >> [00000890](02) 8bec mov ebp,esp 
> >> [00000892](01) 51 push ecx 
> >> [00000893](03) 8b4508 mov eax,[ebp+08] 
> >> [00000896](01) 50 push eax 
> >> [00000897](03) 8b4d08 mov ecx,[ebp+08] 
> >> [0000089a](01) 51 push ecx 
> >> [0000089b](05) e87ffeffff call 0000071f 
> >> [000008a0](03) 83c408 add esp,+08 
> >> [000008a3](03) 8945fc mov [ebp-04],eax 
> >> [000008a6](04) 837dfc00 cmp dword [ebp-04],+00 
> >> [000008aa](02) 7402 jz 000008ae 
> >> [000008ac](02) ebfe jmp 000008ac 
> >> [000008ae](02) 8be5 mov esp,ebp 
> >> [000008b0](01) 5d pop ebp 
> >> [000008b1](01) c3 ret 
> >> 
> >> _main() 
> >> [000008bf](01) 55 push ebp 
> >> [000008c0](02) 8bec mov ebp,esp 
> >> [000008c2](01) 51 push ecx 
> >> [000008c3](05) 688f080000 push 0000088f 
> >> [000008c8](05) 688f080000 push 0000088f 
> >> [000008cd](05) e84dfeffff call 0000071f 
> >> [000008d2](03) 83c408 add esp,+08 
> >> [000008d5](03) 8945fc mov [ebp-04],eax 
> >> [000008d8](03) 8b45fc mov eax,[ebp-04] 
> >> [000008db](01) 50 push eax 
> >> [000008dc](05) 680b030000 push 0000030b 
> >> [000008e1](05) e869faffff call 0000034f 
> >> [000008e6](03) 83c408 add esp,+08 
> >> [000008e9](02) 33c0 xor eax,eax 
> >> [000008eb](02) 8be5 mov esp,ebp 
> >> [000008ed](01) 5d pop ebp 
> >> [000008ee](01) c3 ret 
> >> 
> >> Columns 
> >> (1) Execution trace sequence number 
> >> (2) Machine address of instruction 
> >> (3) Machine address of top of stack 
> >> (4) Value of top of stack after instruction executed 
> >> (5) Number of bytes of machine code 
> >> (6) Machine language bytes 
> >> (7) Assembly language text 
> >> 
> >> (01)[000008bf][00011208][00000000](01) 55 push ebp 
> >> (02)[000008c0][00011208][00000000](02) 8bec mov ebp,esp 
> >> (03)[000008c2][00011204][00000000](01) 51 push ecx 
> >> (04)[000008c3][00011200][0000088f](05) 688f080000 push 0000088f 
> >> (05)[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f 
> >> (06)[000008cd][000111f8][000008d2](05) e84dfeffff call 0000071f 
> >> 
> >> (07)[0000088f][00031288][0003128c](01) 55 push ebp 
> >> (08)[00000890][00031288][0003128c](02) 8bec mov ebp,esp 
> >> (09)[00000892][00031284][00021258](01) 51 push ecx 
> >> (10)[00000893][00031284][00021258](03) 8b4508 mov eax,[ebp+08] 
> >> (11)[00000896][00031280][0000088f](01) 50 push eax 
> >> (12)[00000897][00031280][0000088f](03) 8b4d08 mov ecx,[ebp+08] 
> >> (13)[0000089a][0003127c][0000088f](01) 51 push ecx 
> >> (14)[0000089b][00031278][000008a0](05) e87ffeffff call 0000071f 
> >> 
> >> Line(11) Push second parameter value: 0000088f to Halts() 
> >> Line(13) Push first parameter value: 0000088f to Halts() 
> >> Line(14) H_Halt() calls Halts(0000088f, 0000088f) 
> >> 
> >> (15)[0000088f][00042430][00042434](01) 55 push ebp 
> >> (16)[00000890][00042430][00042434](02) 8bec mov ebp,esp 
> >> (17)[00000892][0004242c][00032400](01) 51 push ecx 
> >> (18)[00000893][0004242c][00032400](03) 8b4508 mov eax,[ebp+08] 
> >> (19)[00000896][00042428][0000088f](01) 50 push eax 
> >> (20)[00000897][00042428][0000088f](03) 8b4d08 mov ecx,[ebp+08] 
> >> (21)[0000089a][00042424][0000088f](01) 51 push ecx 
> >> (22)[0000089b][00042420][000008a0](05) e87ffeffff call 0000071f 
> >> 
> >> Line(19) Push second parameter value: 0000088f to Halts() 
> >> Line(21) Push first parameter value: 0000088f to Halts() 
> >> Line(22) H_Halt() calls Halts(0000088f, 0000088f) 
> >> 
> >> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat() 
> >> calls Halts() with the same data a second time in sequence from the same 
> >> machine address. 
> >> 
> >> (23)[000008d2][00011204][00000000](03) 83c408 add esp,+08 
> >> (24)[000008d5][00011204][00000000](03) 8945fc mov [ebp-04],eax 
> >> (25)[000008d8][00011204][00000000](03) 8b45fc mov eax,[ebp-04] 
> >> (26)[000008db][00011200][00000000](01) 50 push eax 
> >> (27)[000008dc][000111fc][0000030b](05) 680b030000 push 0000030b 
> >> (28)[000008e1][000111f8][000008e6](05) e869faffff call 0000034f 
> >> Input_Would_Halt = 0 
> >> 
> >> (29)[000008e6][00011204][00000000](03) 83c408 add esp,+08 
> >> (30)[000008e9][00011204][00000000](02) 33c0 xor eax,eax 
> >> (31)[000008eb][00011208][00000000](02) 8be5 mov esp,ebp 
> >> (32)[000008ed][0001120c][00010000](01) 5d pop ebp 
> >> (33)[000008ee][00011210][00000080](01) c3 ret 
> >> Number_of_User_Instructions(33) 
> >> 
> >> Copyright 2021 PL Olcott 
> >> 
> >> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM 
> >> [The Psychology of Self-Reference] 
> >> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ 
> >> 
> >> 
> >> 
> >> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf 
> >> -- 
> >> Copyright 2021 Pete Olcott 
> >> 
> >> "Great spirits have always encountered violent opposition from mediocre 
> >> minds." Einstein    
> > 
> > There is no way to remove "the pathological self-reference", which you 
> > refer to as an error is also incorrect.
> When the halting problem criteria is:
> Does the input program halt on its input?
> It is possible to define an input that does the opposite of whatever the 
> halt decider decides. 
> 
> When the halting problem criteria is:
> Would the input program halt if the halt decider never stopped 
> simulating it?
> Then any input that does the opposite of whatever the halt decider 
> decides becomes decidable. 
> 
OK, so we call H_Hat(H_Hat). It calls H, which detects what would be infinite 
recursion (because of the way H is written), and returns "no", this won't halt 
unless I halt it. So H_Hat doesn't go into the infinite loop, and halts.

Now we call H(H_Hat, H_Hat). Same thing happens. H simulates H_Hat, causing
an endless recursion, which H eventually terminates. So H returns "no": , this
won't halt unless I halt it".

But H has got it wrong. You've got to somehow flag that the H-directed halt in
H_Hat doesn't count. 

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


#29231 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-13 15:51 -0600
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<IPadnagT29NlrtD9nZ2dnUU7-anNnZ2d@giganews.com>
In reply to#29230
On 3/13/2021 3:38 PM, Malcolm McLean wrote:
> On Saturday, 13 March 2021 at 20:49:39 UTC, olcott wrote:
>> On 3/13/2021 10:49 AM, wij wrote:
>>> On Wednesday, 10 March 2021 at 06:56:40 UTC+8, olcott wrote:
>>>> Eliminating pathological self-reference error from the halting problem
>>>>
>>>> The pathological self reference error occurs whenever a question or
>>>> decision problem cannot be correctly answered because both of the yes/no
>>>> or true/false answers are contradicted.
>>>>
>>>> If we ask Jack[1] this question: Will your answer to this question be no?
>>>> Neither answer of yes or no is correct because they are both contradicted.
>>>>
>>>> When an input program is defined to do opposite of whatever the halt
>>>> decider decides about its halt status then we have the same pathological
>>>> self-reference error as Jack's question.
>>>>
>>>> If the halt decider Halts() returns a value of true to H_Hat() then
>>>> H_Hat() would go into an infinite loop and never halt. If the halt
>>>> decider Halts() returns a value of false to H_Hat() then H_Hat would
>>>> immediately stop running.
>>>>
>>>> The simplest way to define a halt decider is to make a program that
>>>> simply runs its input to see what it does. In technical terms this would
>>>> be a universal Turing machine (UTM) that has been adapted to become a
>>>> halt decider. This UTM would simply simulate the execution of its input
>>>> until its input halts on its own or the halt decider determines that its
>>>> input would never halt on its own and stops simulating it. In order for
>>>> the UTM to see what its input does it must keep track of an execution
>>>> trace of its input.
>>>>
>>>> Every (at least partial) halt decider that decides the halting status of
>>>> its input on the basis of its examination of the execution trace of its
>>>> own simulation of this input would correctly decide the conventional
>>>> halting problem counter-examples as not halting.
>>>>
>>>> The x86utm operating system was created so that halt deciders written in
>>>> the C programming language would be computationally equivalent to the
>>>> execution of actual Turing machines. These (at least partial) halt
>>>> deciders base their halting decision on examining the execution trace of
>>>> the x86 machine language of their input. The input is the COFF object
>>>> file output of a C compiler and is directly executed by the x86 emulator.
>>>>
>>>> The halt decider Halts() determines that H_Hat() called it in infinite
>>>> recursion, on the basis of the x86 machine language execution trace
>>>> shown below, stop simulating its input, and decide not halting on the
>>>> basis that its input would not halt.
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Would_Halt = Halts(P, P);
>>>> if (Input_Would_Halt)
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>> Output("Input_Would_Halt = ", Input_Would_Halt);
>>>> }
>>>>
>>>> _H_Hat()
>>>> [0000088f](01) 55 push ebp
>>>> [00000890](02) 8bec mov ebp,esp
>>>> [00000892](01) 51 push ecx
>>>> [00000893](03) 8b4508 mov eax,[ebp+08]
>>>> [00000896](01) 50 push eax
>>>> [00000897](03) 8b4d08 mov ecx,[ebp+08]
>>>> [0000089a](01) 51 push ecx
>>>> [0000089b](05) e87ffeffff call 0000071f
>>>> [000008a0](03) 83c408 add esp,+08
>>>> [000008a3](03) 8945fc mov [ebp-04],eax
>>>> [000008a6](04) 837dfc00 cmp dword [ebp-04],+00
>>>> [000008aa](02) 7402 jz 000008ae
>>>> [000008ac](02) ebfe jmp 000008ac
>>>> [000008ae](02) 8be5 mov esp,ebp
>>>> [000008b0](01) 5d pop ebp
>>>> [000008b1](01) c3 ret
>>>>
>>>> _main()
>>>> [000008bf](01) 55 push ebp
>>>> [000008c0](02) 8bec mov ebp,esp
>>>> [000008c2](01) 51 push ecx
>>>> [000008c3](05) 688f080000 push 0000088f
>>>> [000008c8](05) 688f080000 push 0000088f
>>>> [000008cd](05) e84dfeffff call 0000071f
>>>> [000008d2](03) 83c408 add esp,+08
>>>> [000008d5](03) 8945fc mov [ebp-04],eax
>>>> [000008d8](03) 8b45fc mov eax,[ebp-04]
>>>> [000008db](01) 50 push eax
>>>> [000008dc](05) 680b030000 push 0000030b
>>>> [000008e1](05) e869faffff call 0000034f
>>>> [000008e6](03) 83c408 add esp,+08
>>>> [000008e9](02) 33c0 xor eax,eax
>>>> [000008eb](02) 8be5 mov esp,ebp
>>>> [000008ed](01) 5d pop ebp
>>>> [000008ee](01) c3 ret
>>>>
>>>> Columns
>>>> (1) Execution trace sequence number
>>>> (2) Machine address of instruction
>>>> (3) Machine address of top of stack
>>>> (4) Value of top of stack after instruction executed
>>>> (5) Number of bytes of machine code
>>>> (6) Machine language bytes
>>>> (7) Assembly language text
>>>>
>>>> (01)[000008bf][00011208][00000000](01) 55 push ebp
>>>> (02)[000008c0][00011208][00000000](02) 8bec mov ebp,esp
>>>> (03)[000008c2][00011204][00000000](01) 51 push ecx
>>>> (04)[000008c3][00011200][0000088f](05) 688f080000 push 0000088f
>>>> (05)[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f
>>>> (06)[000008cd][000111f8][000008d2](05) e84dfeffff call 0000071f
>>>>
>>>> (07)[0000088f][00031288][0003128c](01) 55 push ebp
>>>> (08)[00000890][00031288][0003128c](02) 8bec mov ebp,esp
>>>> (09)[00000892][00031284][00021258](01) 51 push ecx
>>>> (10)[00000893][00031284][00021258](03) 8b4508 mov eax,[ebp+08]
>>>> (11)[00000896][00031280][0000088f](01) 50 push eax
>>>> (12)[00000897][00031280][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>>>> (13)[0000089a][0003127c][0000088f](01) 51 push ecx
>>>> (14)[0000089b][00031278][000008a0](05) e87ffeffff call 0000071f
>>>>
>>>> Line(11) Push second parameter value: 0000088f to Halts()
>>>> Line(13) Push first parameter value: 0000088f to Halts()
>>>> Line(14) H_Halt() calls Halts(0000088f, 0000088f)
>>>>
>>>> (15)[0000088f][00042430][00042434](01) 55 push ebp
>>>> (16)[00000890][00042430][00042434](02) 8bec mov ebp,esp
>>>> (17)[00000892][0004242c][00032400](01) 51 push ecx
>>>> (18)[00000893][0004242c][00032400](03) 8b4508 mov eax,[ebp+08]
>>>> (19)[00000896][00042428][0000088f](01) 50 push eax
>>>> (20)[00000897][00042428][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>>>> (21)[0000089a][00042424][0000088f](01) 51 push ecx
>>>> (22)[0000089b][00042420][000008a0](05) e87ffeffff call 0000071f
>>>>
>>>> Line(19) Push second parameter value: 0000088f to Halts()
>>>> Line(21) Push first parameter value: 0000088f to Halts()
>>>> Line(22) H_Halt() calls Halts(0000088f, 0000088f)
>>>>
>>>> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat()
>>>> calls Halts() with the same data a second time in sequence from the same
>>>> machine address.
>>>>
>>>> (23)[000008d2][00011204][00000000](03) 83c408 add esp,+08
>>>> (24)[000008d5][00011204][00000000](03) 8945fc mov [ebp-04],eax
>>>> (25)[000008d8][00011204][00000000](03) 8b45fc mov eax,[ebp-04]
>>>> (26)[000008db][00011200][00000000](01) 50 push eax
>>>> (27)[000008dc][000111fc][0000030b](05) 680b030000 push 0000030b
>>>> (28)[000008e1][000111f8][000008e6](05) e869faffff call 0000034f
>>>> Input_Would_Halt = 0
>>>>
>>>> (29)[000008e6][00011204][00000000](03) 83c408 add esp,+08
>>>> (30)[000008e9][00011204][00000000](02) 33c0 xor eax,eax
>>>> (31)[000008eb][00011208][00000000](02) 8be5 mov esp,ebp
>>>> (32)[000008ed][0001120c][00010000](01) 5d pop ebp
>>>> (33)[000008ee][00011210][00000080](01) c3 ret
>>>> Number_of_User_Instructions(33)
>>>>
>>>> Copyright 2021 PL Olcott
>>>>
>>>> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM
>>>> [The Psychology of Self-Reference]
>>>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
>>>>
>>>>
>>>>
>>>> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf
>>>> -- 
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> "Great spirits have always encountered violent opposition from mediocre
>>>> minds." Einstein
>>>
>>> There is no way to remove "the pathological self-reference", which you
>>> refer to as an error is also incorrect.
>> When the halting problem criteria is:
>> Does the input program halt on its input?
>> It is possible to define an input that does the opposite of whatever the
>> halt decider decides.
>>
>> When the halting problem criteria is:
>> Would the input program halt if the halt decider never stopped
>> simulating it?
>> Then any input that does the opposite of whatever the halt decider
>> decides becomes decidable.
>>
> OK, so we call H_Hat(H_Hat). It calls H, which detects what would be infinite
> recursion (because of the way H is written), and returns "no", this won't halt
> unless I halt it. So H_Hat doesn't go into the infinite loop, and halts.
> 
> Now we call H(H_Hat, H_Hat). Same thing happens. H simulates H_Hat, causing
> an endless recursion, which H eventually terminates. So H returns "no": , this
> won't halt unless I halt it".
> 
> But H has got it wrong. You've got to somehow flag that the H-directed halt in
> H_Hat doesn't count.
> 
> 

No not true. The global halt decider is called on main() so both 
instances are correctly terminated because of what would otherwise be 
infinite recursion.

When the halt decider is based on adapting a UTM then nothing can slip 
past the analysis of the halt decider.

-- 
Copyright 2021 Pete Olcott

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

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


#29234 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-03-13 14:00 -0800
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<6d672d52-eb15-442b-88af-f4ed1e045b72n@googlegroups.com>
In reply to#29231
On Saturday, 13 March 2021 at 21:51:59 UTC, olcott wrote:
> On 3/13/2021 3:38 PM, Malcolm McLean wrote: 
> > On Saturday, 13 March 2021 at 20:49:39 UTC, olcott wrote: 
> >> On 3/13/2021 10:49 AM, wij wrote: 
> >>> On Wednesday, 10 March 2021 at 06:56:40 UTC+8, olcott wrote: 
> >>>> Eliminating pathological self-reference error from the halting problem 
> >>>> 
> >>>> The pathological self reference error occurs whenever a question or 
> >>>> decision problem cannot be correctly answered because both of the yes/no 
> >>>> or true/false answers are contradicted. 
> >>>> 
> >>>> If we ask Jack[1] this question: Will your answer to this question be no? 
> >>>> Neither answer of yes or no is correct because they are both contradicted. 
> >>>> 
> >>>> When an input program is defined to do opposite of whatever the halt 
> >>>> decider decides about its halt status then we have the same pathological 
> >>>> self-reference error as Jack's question. 
> >>>> 
> >>>> If the halt decider Halts() returns a value of true to H_Hat() then 
> >>>> H_Hat() would go into an infinite loop and never halt. If the halt 
> >>>> decider Halts() returns a value of false to H_Hat() then H_Hat would 
> >>>> immediately stop running. 
> >>>> 
> >>>> The simplest way to define a halt decider is to make a program that 
> >>>> simply runs its input to see what it does. In technical terms this would 
> >>>> be a universal Turing machine (UTM) that has been adapted to become a 
> >>>> halt decider. This UTM would simply simulate the execution of its input 
> >>>> until its input halts on its own or the halt decider determines that its 
> >>>> input would never halt on its own and stops simulating it. In order for 
> >>>> the UTM to see what its input does it must keep track of an execution 
> >>>> trace of its input. 
> >>>> 
> >>>> Every (at least partial) halt decider that decides the halting status of 
> >>>> its input on the basis of its examination of the execution trace of its 
> >>>> own simulation of this input would correctly decide the conventional 
> >>>> halting problem counter-examples as not halting. 
> >>>> 
> >>>> The x86utm operating system was created so that halt deciders written in 
> >>>> the C programming language would be computationally equivalent to the 
> >>>> execution of actual Turing machines. These (at least partial) halt 
> >>>> deciders base their halting decision on examining the execution trace of 
> >>>> the x86 machine language of their input. The input is the COFF object 
> >>>> file output of a C compiler and is directly executed by the x86 emulator. 
> >>>> 
> >>>> The halt decider Halts() determines that H_Hat() called it in infinite 
> >>>> recursion, on the basis of the x86 machine language execution trace 
> >>>> shown below, stop simulating its input, and decide not halting on the 
> >>>> basis that its input would not halt. 
> >>>> 
> >>>> void H_Hat(u32 P) 
> >>>> { 
> >>>> u32 Input_Would_Halt = Halts(P, P); 
> >>>> if (Input_Would_Halt) 
> >>>> HERE: goto HERE; 
> >>>> } 
> >>>> 
> >>>> 
> >>>> int main() 
> >>>> { 
> >>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat); 
> >>>> Output("Input_Would_Halt = ", Input_Would_Halt); 
> >>>> } 
> >>>> 
> >>>> _H_Hat() 
> >>>> [0000088f](01) 55 push ebp 
> >>>> [00000890](02) 8bec mov ebp,esp 
> >>>> [00000892](01) 51 push ecx 
> >>>> [00000893](03) 8b4508 mov eax,[ebp+08] 
> >>>> [00000896](01) 50 push eax 
> >>>> [00000897](03) 8b4d08 mov ecx,[ebp+08] 
> >>>> [0000089a](01) 51 push ecx 
> >>>> [0000089b](05) e87ffeffff call 0000071f 
> >>>> [000008a0](03) 83c408 add esp,+08 
> >>>> [000008a3](03) 8945fc mov [ebp-04],eax 
> >>>> [000008a6](04) 837dfc00 cmp dword [ebp-04],+00 
> >>>> [000008aa](02) 7402 jz 000008ae 
> >>>> [000008ac](02) ebfe jmp 000008ac 
> >>>> [000008ae](02) 8be5 mov esp,ebp 
> >>>> [000008b0](01) 5d pop ebp 
> >>>> [000008b1](01) c3 ret 
> >>>> 
> >>>> _main() 
> >>>> [000008bf](01) 55 push ebp 
> >>>> [000008c0](02) 8bec mov ebp,esp 
> >>>> [000008c2](01) 51 push ecx 
> >>>> [000008c3](05) 688f080000 push 0000088f 
> >>>> [000008c8](05) 688f080000 push 0000088f 
> >>>> [000008cd](05) e84dfeffff call 0000071f 
> >>>> [000008d2](03) 83c408 add esp,+08 
> >>>> [000008d5](03) 8945fc mov [ebp-04],eax 
> >>>> [000008d8](03) 8b45fc mov eax,[ebp-04] 
> >>>> [000008db](01) 50 push eax 
> >>>> [000008dc](05) 680b030000 push 0000030b 
> >>>> [000008e1](05) e869faffff call 0000034f 
> >>>> [000008e6](03) 83c408 add esp,+08 
> >>>> [000008e9](02) 33c0 xor eax,eax 
> >>>> [000008eb](02) 8be5 mov esp,ebp 
> >>>> [000008ed](01) 5d pop ebp 
> >>>> [000008ee](01) c3 ret 
> >>>> 
> >>>> Columns 
> >>>> (1) Execution trace sequence number 
> >>>> (2) Machine address of instruction 
> >>>> (3) Machine address of top of stack 
> >>>> (4) Value of top of stack after instruction executed 
> >>>> (5) Number of bytes of machine code 
> >>>> (6) Machine language bytes 
> >>>> (7) Assembly language text 
> >>>> 
> >>>> (01)[000008bf][00011208][00000000](01) 55 push ebp 
> >>>> (02)[000008c0][00011208][00000000](02) 8bec mov ebp,esp 
> >>>> (03)[000008c2][00011204][00000000](01) 51 push ecx 
> >>>> (04)[000008c3][00011200][0000088f](05) 688f080000 push 0000088f 
> >>>> (05)[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f 
> >>>> (06)[000008cd][000111f8][000008d2](05) e84dfeffff call 0000071f 
> >>>> 
> >>>> (07)[0000088f][00031288][0003128c](01) 55 push ebp 
> >>>> (08)[00000890][00031288][0003128c](02) 8bec mov ebp,esp 
> >>>> (09)[00000892][00031284][00021258](01) 51 push ecx 
> >>>> (10)[00000893][00031284][00021258](03) 8b4508 mov eax,[ebp+08] 
> >>>> (11)[00000896][00031280][0000088f](01) 50 push eax 
> >>>> (12)[00000897][00031280][0000088f](03) 8b4d08 mov ecx,[ebp+08] 
> >>>> (13)[0000089a][0003127c][0000088f](01) 51 push ecx 
> >>>> (14)[0000089b][00031278][000008a0](05) e87ffeffff call 0000071f 
> >>>> 
> >>>> Line(11) Push second parameter value: 0000088f to Halts() 
> >>>> Line(13) Push first parameter value: 0000088f to Halts() 
> >>>> Line(14) H_Halt() calls Halts(0000088f, 0000088f) 
> >>>> 
> >>>> (15)[0000088f][00042430][00042434](01) 55 push ebp 
> >>>> (16)[00000890][00042430][00042434](02) 8bec mov ebp,esp 
> >>>> (17)[00000892][0004242c][00032400](01) 51 push ecx 
> >>>> (18)[00000893][0004242c][00032400](03) 8b4508 mov eax,[ebp+08] 
> >>>> (19)[00000896][00042428][0000088f](01) 50 push eax 
> >>>> (20)[00000897][00042428][0000088f](03) 8b4d08 mov ecx,[ebp+08] 
> >>>> (21)[0000089a][00042424][0000088f](01) 51 push ecx 
> >>>> (22)[0000089b][00042420][000008a0](05) e87ffeffff call 0000071f 
> >>>> 
> >>>> Line(19) Push second parameter value: 0000088f to Halts() 
> >>>> Line(21) Push first parameter value: 0000088f to Halts() 
> >>>> Line(22) H_Halt() calls Halts(0000088f, 0000088f) 
> >>>> 
> >>>> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat() 
> >>>> calls Halts() with the same data a second time in sequence from the same 
> >>>> machine address. 
> >>>> 
> >>>> (23)[000008d2][00011204][00000000](03) 83c408 add esp,+08 
> >>>> (24)[000008d5][00011204][00000000](03) 8945fc mov [ebp-04],eax 
> >>>> (25)[000008d8][00011204][00000000](03) 8b45fc mov eax,[ebp-04] 
> >>>> (26)[000008db][00011200][00000000](01) 50 push eax 
> >>>> (27)[000008dc][000111fc][0000030b](05) 680b030000 push 0000030b 
> >>>> (28)[000008e1][000111f8][000008e6](05) e869faffff call 0000034f 
> >>>> Input_Would_Halt = 0 
> >>>> 
> >>>> (29)[000008e6][00011204][00000000](03) 83c408 add esp,+08 
> >>>> (30)[000008e9][00011204][00000000](02) 33c0 xor eax,eax 
> >>>> (31)[000008eb][00011208][00000000](02) 8be5 mov esp,ebp 
> >>>> (32)[000008ed][0001120c][00010000](01) 5d pop ebp 
> >>>> (33)[000008ee][00011210][00000080](01) c3 ret 
> >>>> Number_of_User_Instructions(33) 
> >>>> 
> >>>> Copyright 2021 PL Olcott 
> >>>> 
> >>>> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM 
> >>>> [The Psychology of Self-Reference] 
> >>>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ 
> >>>> 
> >>>> 
> >>>> 
> >>>> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf 
> >>>> -- 
> >>>> Copyright 2021 Pete Olcott 
> >>>> 
> >>>> "Great spirits have always encountered violent opposition from mediocre 
> >>>> minds." Einstein 
> >>> 
> >>> There is no way to remove "the pathological self-reference", which you 
> >>> refer to as an error is also incorrect. 
> >> When the halting problem criteria is: 
> >> Does the input program halt on its input? 
> >> It is possible to define an input that does the opposite of whatever the 
> >> halt decider decides. 
> >> 
> >> When the halting problem criteria is: 
> >> Would the input program halt if the halt decider never stopped 
> >> simulating it? 
> >> Then any input that does the opposite of whatever the halt decider 
> >> decides becomes decidable. 
> >> 
> > OK, so we call H_Hat(H_Hat). It calls H, which detects what would be infinite 
> > recursion (because of the way H is written), and returns "no", this won't halt 
> > unless I halt it. So H_Hat doesn't go into the infinite loop, and halts. 
> > 
> > Now we call H(H_Hat, H_Hat). Same thing happens. H simulates H_Hat, causing 
> > an endless recursion, which H eventually terminates. So H returns "no": , this 
> > won't halt unless I halt it". 
> > 
> > But H has got it wrong. You've got to somehow flag that the H-directed halt in 
> > H_Hat doesn't count. 
> > 
> >
> No not true. The global halt decider is called on main() so both 
> instances are correctly terminated because of what would otherwise be 
> infinite recursion. 
>
RIght, so the supervisor is placed outside of H, and it is this which decides the 
halting / would not halt unless halted status of the program. 
> 
> When the halt decider is based on adapting a UTM then nothing can slip 
> past the analysis of the halt decider.
>
You can't solve the halting problem this way, e.g. determine the halting
status of a famous unknown problem. However you can pick up tight loops
or simple infinite recursion.

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


#29236 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-13 16:05 -0600
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<yMqdnbZmIZy2qtD9nZ2dnUU7-avNnZ2d@giganews.com>
In reply to#29234
On 3/13/2021 4:00 PM, Malcolm McLean wrote:
> On Saturday, 13 March 2021 at 21:51:59 UTC, olcott wrote:
>> On 3/13/2021 3:38 PM, Malcolm McLean wrote:
>>> On Saturday, 13 March 2021 at 20:49:39 UTC, olcott wrote:
>>>> On 3/13/2021 10:49 AM, wij wrote:
>>>>> On Wednesday, 10 March 2021 at 06:56:40 UTC+8, olcott wrote:
>>>>>> Eliminating pathological self-reference error from the halting problem
>>>>>>
>>>>>> The pathological self reference error occurs whenever a question or
>>>>>> decision problem cannot be correctly answered because both of the yes/no
>>>>>> or true/false answers are contradicted.
>>>>>>
>>>>>> If we ask Jack[1] this question: Will your answer to this question be no?
>>>>>> Neither answer of yes or no is correct because they are both contradicted.
>>>>>>
>>>>>> When an input program is defined to do opposite of whatever the halt
>>>>>> decider decides about its halt status then we have the same pathological
>>>>>> self-reference error as Jack's question.
>>>>>>
>>>>>> If the halt decider Halts() returns a value of true to H_Hat() then
>>>>>> H_Hat() would go into an infinite loop and never halt. If the halt
>>>>>> decider Halts() returns a value of false to H_Hat() then H_Hat would
>>>>>> immediately stop running.
>>>>>>
>>>>>> The simplest way to define a halt decider is to make a program that
>>>>>> simply runs its input to see what it does. In technical terms this would
>>>>>> be a universal Turing machine (UTM) that has been adapted to become a
>>>>>> halt decider. This UTM would simply simulate the execution of its input
>>>>>> until its input halts on its own or the halt decider determines that its
>>>>>> input would never halt on its own and stops simulating it. In order for
>>>>>> the UTM to see what its input does it must keep track of an execution
>>>>>> trace of its input.
>>>>>>
>>>>>> Every (at least partial) halt decider that decides the halting status of
>>>>>> its input on the basis of its examination of the execution trace of its
>>>>>> own simulation of this input would correctly decide the conventional
>>>>>> halting problem counter-examples as not halting.
>>>>>>
>>>>>> The x86utm operating system was created so that halt deciders written in
>>>>>> the C programming language would be computationally equivalent to the
>>>>>> execution of actual Turing machines. These (at least partial) halt
>>>>>> deciders base their halting decision on examining the execution trace of
>>>>>> the x86 machine language of their input. The input is the COFF object
>>>>>> file output of a C compiler and is directly executed by the x86 emulator.
>>>>>>
>>>>>> The halt decider Halts() determines that H_Hat() called it in infinite
>>>>>> recursion, on the basis of the x86 machine language execution trace
>>>>>> shown below, stop simulating its input, and decide not halting on the
>>>>>> basis that its input would not halt.
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Input_Would_Halt = Halts(P, P);
>>>>>> if (Input_Would_Halt)
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>> Output("Input_Would_Halt = ", Input_Would_Halt);
>>>>>> }
>>>>>>
>>>>>> _H_Hat()
>>>>>> [0000088f](01) 55 push ebp
>>>>>> [00000890](02) 8bec mov ebp,esp
>>>>>> [00000892](01) 51 push ecx
>>>>>> [00000893](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00000896](01) 50 push eax
>>>>>> [00000897](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000089a](01) 51 push ecx
>>>>>> [0000089b](05) e87ffeffff call 0000071f
>>>>>> [000008a0](03) 83c408 add esp,+08
>>>>>> [000008a3](03) 8945fc mov [ebp-04],eax
>>>>>> [000008a6](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>> [000008aa](02) 7402 jz 000008ae
>>>>>> [000008ac](02) ebfe jmp 000008ac
>>>>>> [000008ae](02) 8be5 mov esp,ebp
>>>>>> [000008b0](01) 5d pop ebp
>>>>>> [000008b1](01) c3 ret
>>>>>>
>>>>>> _main()
>>>>>> [000008bf](01) 55 push ebp
>>>>>> [000008c0](02) 8bec mov ebp,esp
>>>>>> [000008c2](01) 51 push ecx
>>>>>> [000008c3](05) 688f080000 push 0000088f
>>>>>> [000008c8](05) 688f080000 push 0000088f
>>>>>> [000008cd](05) e84dfeffff call 0000071f
>>>>>> [000008d2](03) 83c408 add esp,+08
>>>>>> [000008d5](03) 8945fc mov [ebp-04],eax
>>>>>> [000008d8](03) 8b45fc mov eax,[ebp-04]
>>>>>> [000008db](01) 50 push eax
>>>>>> [000008dc](05) 680b030000 push 0000030b
>>>>>> [000008e1](05) e869faffff call 0000034f
>>>>>> [000008e6](03) 83c408 add esp,+08
>>>>>> [000008e9](02) 33c0 xor eax,eax
>>>>>> [000008eb](02) 8be5 mov esp,ebp
>>>>>> [000008ed](01) 5d pop ebp
>>>>>> [000008ee](01) c3 ret
>>>>>>
>>>>>> Columns
>>>>>> (1) Execution trace sequence number
>>>>>> (2) Machine address of instruction
>>>>>> (3) Machine address of top of stack
>>>>>> (4) Value of top of stack after instruction executed
>>>>>> (5) Number of bytes of machine code
>>>>>> (6) Machine language bytes
>>>>>> (7) Assembly language text
>>>>>>
>>>>>> (01)[000008bf][00011208][00000000](01) 55 push ebp
>>>>>> (02)[000008c0][00011208][00000000](02) 8bec mov ebp,esp
>>>>>> (03)[000008c2][00011204][00000000](01) 51 push ecx
>>>>>> (04)[000008c3][00011200][0000088f](05) 688f080000 push 0000088f
>>>>>> (05)[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f
>>>>>> (06)[000008cd][000111f8][000008d2](05) e84dfeffff call 0000071f
>>>>>>
>>>>>> (07)[0000088f][00031288][0003128c](01) 55 push ebp
>>>>>> (08)[00000890][00031288][0003128c](02) 8bec mov ebp,esp
>>>>>> (09)[00000892][00031284][00021258](01) 51 push ecx
>>>>>> (10)[00000893][00031284][00021258](03) 8b4508 mov eax,[ebp+08]
>>>>>> (11)[00000896][00031280][0000088f](01) 50 push eax
>>>>>> (12)[00000897][00031280][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> (13)[0000089a][0003127c][0000088f](01) 51 push ecx
>>>>>> (14)[0000089b][00031278][000008a0](05) e87ffeffff call 0000071f
>>>>>>
>>>>>> Line(11) Push second parameter value: 0000088f to Halts()
>>>>>> Line(13) Push first parameter value: 0000088f to Halts()
>>>>>> Line(14) H_Halt() calls Halts(0000088f, 0000088f)
>>>>>>
>>>>>> (15)[0000088f][00042430][00042434](01) 55 push ebp
>>>>>> (16)[00000890][00042430][00042434](02) 8bec mov ebp,esp
>>>>>> (17)[00000892][0004242c][00032400](01) 51 push ecx
>>>>>> (18)[00000893][0004242c][00032400](03) 8b4508 mov eax,[ebp+08]
>>>>>> (19)[00000896][00042428][0000088f](01) 50 push eax
>>>>>> (20)[00000897][00042428][0000088f](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> (21)[0000089a][00042424][0000088f](01) 51 push ecx
>>>>>> (22)[0000089b][00042420][000008a0](05) e87ffeffff call 0000071f
>>>>>>
>>>>>> Line(19) Push second parameter value: 0000088f to Halts()
>>>>>> Line(21) Push first parameter value: 0000088f to Halts()
>>>>>> Line(22) H_Halt() calls Halts(0000088f, 0000088f)
>>>>>>
>>>>>> Infinite Recursion Detected Simulation Stopped on the basis that H_Hat()
>>>>>> calls Halts() with the same data a second time in sequence from the same
>>>>>> machine address.
>>>>>>
>>>>>> (23)[000008d2][00011204][00000000](03) 83c408 add esp,+08
>>>>>> (24)[000008d5][00011204][00000000](03) 8945fc mov [ebp-04],eax
>>>>>> (25)[000008d8][00011204][00000000](03) 8b45fc mov eax,[ebp-04]
>>>>>> (26)[000008db][00011200][00000000](01) 50 push eax
>>>>>> (27)[000008dc][000111fc][0000030b](05) 680b030000 push 0000030b
>>>>>> (28)[000008e1][000111f8][000008e6](05) e869faffff call 0000034f
>>>>>> Input_Would_Halt = 0
>>>>>>
>>>>>> (29)[000008e6][00011204][00000000](03) 83c408 add esp,+08
>>>>>> (30)[000008e9][00011204][00000000](02) 33c0 xor eax,eax
>>>>>> (31)[000008eb][00011208][00000000](02) 8be5 mov esp,ebp
>>>>>> (32)[000008ed][0001120c][00010000](01) 5d pop ebp
>>>>>> (33)[000008ee][00011210][00000080](01) c3 ret
>>>>>> Number_of_User_Instructions(33)
>>>>>>
>>>>>> Copyright 2021 PL Olcott
>>>>>>
>>>>>> [1] sci.logic --- Daryl McCullough --- Jun 25, 2004, 6:30:39 PM
>>>>>> [The Psychology of Self-Reference]
>>>>>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
>>>>>>
>>>>>>
>>>>>>
>>>>>> http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf
>>>>>> -- 
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> "Great spirits have always encountered violent opposition from mediocre
>>>>>> minds." Einstein
>>>>>
>>>>> There is no way to remove "the pathological self-reference", which you
>>>>> refer to as an error is also incorrect.
>>>> When the halting problem criteria is:
>>>> Does the input program halt on its input?
>>>> It is possible to define an input that does the opposite of whatever the
>>>> halt decider decides.
>>>>
>>>> When the halting problem criteria is:
>>>> Would the input program halt if the halt decider never stopped
>>>> simulating it?
>>>> Then any input that does the opposite of whatever the halt decider
>>>> decides becomes decidable.
>>>>
>>> OK, so we call H_Hat(H_Hat). It calls H, which detects what would be infinite
>>> recursion (because of the way H is written), and returns "no", this won't halt
>>> unless I halt it. So H_Hat doesn't go into the infinite loop, and halts.
>>>
>>> Now we call H(H_Hat, H_Hat). Same thing happens. H simulates H_Hat, causing
>>> an endless recursion, which H eventually terminates. So H returns "no": , this
>>> won't halt unless I halt it".
>>>
>>> But H has got it wrong. You've got to somehow flag that the H-directed halt in
>>> H_Hat doesn't count.
>>>
>>>
>> No not true. The global halt decider is called on main() so both
>> instances are correctly terminated because of what would otherwise be
>> infinite recursion.
>>
> RIght, so the supervisor is placed outside of H, and it is this which decides the
> halting / would not halt unless halted status of the program.

When the Halt decider is based on a UTM then the halt decider is the 
supervisor of every computation.

>>
>> When the halt decider is based on adapting a UTM then nothing can slip
>> past the analysis of the halt decider.
>>
> You can't solve the halting problem this way, e.g. determine the halting
> status of a famous unknown problem. However you can pick up tight loops
> or simple infinite recursion.
> 

The "do the opposite of whatever the halt decider decides" of the 
conventional proofs becomes decidable, they are decided as would not halt.


-- 
Copyright 2021 Pete Olcott

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

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


#29245 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-13 21:07 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<bde3I.151827$rU.17082@fx39.iad>
In reply to#29236
On 3/13/21 5:05 PM, olcott wrote:
>>
> 
> When the Halt decider is based on a UTM then the halt decider is the
> supervisor of every computation.

Nonsense. In a Turing Machine Model of computation there is no such
things as a 'supervisor'.

THe UTM will be a self-contained computation, which apparently you plan
to modify to make it a Halt Decider. That Halt Decider now becomes a
fully self-contained computation, which gets modified when H^ is built.
Nothing in H gets to be 'outside' H^, H^ is based on the TOTAL
computation of H.

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


#29257 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-03-14 03:29 -0700
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<589cab40-4b43-4740-9bd2-94360f79955an@googlegroups.com>
In reply to#29245
On Sunday, 14 March 2021 at 02:07:06 UTC, Richard Damon wrote:
> On 3/13/21 5:05 PM, olcott wrote: 
> >> 
> > 
> > When the Halt decider is based on a UTM then the halt decider is the 
> > supervisor of every computation.
> Nonsense. In a Turing Machine Model of computation there is no such 
> things as a 'supervisor'. 
>
You can write a near-UTM, which steps through the test machine, and has
some loop detction logic to detect if it gets stuck.Then it breaks out
of the loop and reports "non-halting". That's a reasonable approach to
writing a decider which might even be practically useful, as most programming
errors which cause hangs put the program into a tight loop.
You can scale it up to detect more complex looping behaviour. But you will 
soon get into a mess of complexity. It can't detect all non-halting machines.

However PO has added another step, which is that the supervisor runs
"main". 
>
> THe UTM will be a self-contained computation, which apparently you plan 
> to modify to make it a Halt Decider. That Halt Decider now becomes a 
> fully self-contained computation, which gets modified when H^ is built. 
> Nothing in H gets to be 'outside' H^, H^ is based on the TOTAL 
> computation of H.
>
That's how Linz specified the problem. That's not how PO has laid out his
system. In order to get round Linz's proof you have to change Linz's system
somehow, as PO acknowledges. The solution he has chosen, based on
what he has said recently, is to wrap main() in a  supervisor. 

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


#29258 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

Fromolcott <polcott2@gmail.com>
Date2021-03-14 09:55 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<s2l84a$8lp$1@dont-email.me>
In reply to#29257
On 3/14/2021 5:29 AM, Malcolm McLean wrote:
> On Sunday, 14 March 2021 at 02:07:06 UTC, Richard Damon wrote:
>> On 3/13/21 5:05 PM, olcott wrote:
>>>>
>>>
>>> When the Halt decider is based on a UTM then the halt decider is the
>>> supervisor of every computation.
>> Nonsense. In a Turing Machine Model of computation there is no such
>> things as a 'supervisor'.
>>
> You can write a near-UTM, which steps through the test machine, and has
> some loop detction logic to detect if it gets stuck.Then it breaks out
> of the loop and reports "non-halting". That's a reasonable approach to
> writing a decider which might even be practically useful, as most programming
> errors which cause hangs put the program into a tight loop.
> You can scale it up to detect more complex looping behaviour. But you will
> soon get into a mess of complexity. It can't detect all non-halting machines.
> 
> However PO has added another step, which is that the supervisor runs
> "main".
>>
>> THe UTM will be a self-contained computation, which apparently you plan
>> to modify to make it a Halt Decider. That Halt Decider now becomes a
>> fully self-contained computation, which gets modified when H^ is built.
>> Nothing in H gets to be 'outside' H^, H^ is based on the TOTAL
>> computation of H.
>>
> That's how Linz specified the problem. That's not how PO has laid out his
> system. In order to get round Linz's proof you have to change Linz's system
> somehow, as PO acknowledges. The solution he has chosen, based on
> what he has said recently, is to wrap main() in a  supervisor.
> 

We are not wrapping main() in a supervisor exactly.
More accurately the x86utm operating system is the master UTM that 
applies its system level halt decider to every user computation.

The program under test:H_Hat() and the tester:Halts() are distinctly 
different computations. It is the conflation of these two that creates 
the pathological self-reference error.

The teacher does not share the students grade.
When the halt decider determines that the simulation of its input must 
be aborted to prevent its infinite execution the input <is> a 
non-halting computation. As Ben pointed out its ridiculous to construe 
that a computation is a halting computation if the only reason that it 
halts is that its exection was aborted.

-- 
Copyright 2021 Pete Olcott "Great spirits have always encountered
violent opposition from mediocre minds." Einstein

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


#29259 — Re: Refuting the halting problem proofs with fully operational code (revised answer)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-14 10:25 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (revised answer)
Message-ID<bsGdnY-VJcSYttP9nZ2dnUU7-audnZ2d@giganews.com>
In reply to#29258
On 3/14/2021 9:55 AM, olcott wrote:
> On 3/14/2021 5:29 AM, Malcolm McLean wrote:
>> On Sunday, 14 March 2021 at 02:07:06 UTC, Richard Damon wrote:
>>> On 3/13/21 5:05 PM, olcott wrote:
>>>>>
>>>>
>>>> When the Halt decider is based on a UTM then the halt decider is the
>>>> supervisor of every computation.
>>> Nonsense. In a Turing Machine Model of computation there is no such
>>> things as a 'supervisor'.
>>>
>> You can write a near-UTM, which steps through the test machine, and has
>> some loop detction logic to detect if it gets stuck.Then it breaks out
>> of the loop and reports "non-halting". That's a reasonable approach to
>> writing a decider which might even be practically useful, as most 
>> programming
>> errors which cause hangs put the program into a tight loop.
>> You can scale it up to detect more complex looping behaviour. But you 
>> will
>> soon get into a mess of complexity. It can't detect all non-halting 
>> machines.
>>
>> However PO has added another step, which is that the supervisor runs
>> "main".
>>>
>>> THe UTM will be a self-contained computation, which apparently you plan
>>> to modify to make it a Halt Decider. That Halt Decider now becomes a
>>> fully self-contained computation, which gets modified when H^ is built.
>>> Nothing in H gets to be 'outside' H^, H^ is based on the TOTAL
>>> computation of H.
>>>
>> That's how Linz specified the problem. That's not how PO has laid out his
>> system. In order to get round Linz's proof you have to change Linz's 
>> system
>> somehow, as PO acknowledges. The solution he has chosen, based on
>> what he has said recently, is to wrap main() in a  supervisor.
>>
> 
> We are not wrapping main() in a supervisor exactly.
> More accurately the x86utm operating system is the master UTM that 
> applies its system level halt decider to every user computation.
> 
> The program under test:H_Hat() and the tester:Halts() are distinctly 
> different computations. It is the conflation of these two that creates 
> the pathological self-reference error.
> 
> The teacher does not share the students grade.
> When the halt decider determines that the simulation of its input must 
> be aborted to prevent its infinite execution the input <is> a 
> non-halting computation. As Ben pointed out its ridiculous to construe 
> that a computation is a halting computation if the only reason that it 
> halts is that its execution was aborted.
> 

http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf

-- 
Copyright 2021 Pete Olcott

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

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


Page 19 of 23 — ← Prev page 1 … 17 18 [19] 20 21 … 23  Next page →

Back to top | Article view | comp.theory


csiph-web