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 10 of 23 — ← Prev page 1 … 8 9 [10] 11 12 … 23  Next page →


#29400 — Re: Refuting the halting problem proofs [...]. (I dare you to find the error)

FromDavid Brown <david.brown@hesbynett.no>
Date2021-03-16 09:35 +0100
SubjectRe: Refuting the halting problem proofs [...]. (I dare you to find the error)
Message-ID<s2pqkv$jvd$1@dont-email.me>
In reply to#29369
On 15/03/2021 22:15, Jeff Barnett wrote:
> On 3/15/2021 8:55 AM, David Brown wrote:

>> In general, there is no way to detect that a function will not halt -
>> you can't tell if the recursion is infinite or not.
>>
>> How about this function:
>>
>> biggest_number(n) =
>>     if (n == n + 1) -> return n
>>     else -> delay(n); return biggest_number(n + 1)
>>
>> If it ever halts, it will return the first number equal to its own
>> successor.  To get there, however, it takes longer and longer between
>> each recursive call - any simulator that runs for a finite time will not
>> be able to run it long enough to see if it halts or not.  How do you
>> expect your "Halts" function to decide this case?
> 
> The "delay(n)" neither makes the above true nor does it's removal make
> the conclusion false. In other words it's cheese; a product that
> improves with aging!
> 

I agree, it is not necessary.  But I thought it might make things
clearer to Olcott - it gives the function a rapidly increasing runtime,
so that it is obviously hard to simulate the operation within any fixed
finite time-frame.

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


#29406 — Re: Refuting the halting problem proofs [...]. (I dare you to find the error)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 08:10 -0500
SubjectRe: Refuting the halting problem proofs [...]. (I dare you to find the error)
Message-ID<f5mdnYFkKJKqM839nZ2dnUU7-N_NnZ2d@giganews.com>
In reply to#29400
On 3/16/2021 3:35 AM, David Brown wrote:
> On 15/03/2021 22:15, Jeff Barnett wrote:
>> On 3/15/2021 8:55 AM, David Brown wrote:
> 
>>> In general, there is no way to detect that a function will not halt -
>>> you can't tell if the recursion is infinite or not.
>>>
>>> How about this function:
>>>
>>> biggest_number(n) =
>>>      if (n == n + 1) -> return n
>>>      else -> delay(n); return biggest_number(n + 1)
>>>
>>> If it ever halts, it will return the first number equal to its own
>>> successor.  To get there, however, it takes longer and longer between
>>> each recursive call - any simulator that runs for a finite time will not
>>> be able to run it long enough to see if it halts or not.  How do you
>>> expect your "Halts" function to decide this case?
>>
>> The "delay(n)" neither makes the above true nor does it's removal make
>> the conclusion false. In other words it's cheese; a product that
>> improves with aging!
>>
> 
> I agree, it is not necessary.  But I thought it might make things
> clearer to Olcott - it gives the function a rapidly increasing runtime,
> so that it is obviously hard to simulate the operation within any fixed
> finite time-frame.
> 

I unified the key basis of all three proofs
see the YELLOW HIGHLIGHTED portions
of these two textbook proofs:

http://www.liarparadox.org/sipser_165.pdf
http://www.liarparadox.org/kozen_233.pdf

into this simple C function that expresses this basis.

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

Any other code besides the above code is beside the point because it has 
nothing to do with refuting the proofs.

-- 
Copyright 2021 Pete Olcott

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

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


#29324 — Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-15 02:30 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)
Message-ID<20210314192421.792@kylheku.com>
In reply to#29317
On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
> The input to Test() is H_Hat();
> The input to H_Hat() is H_Hat();
>
> Test is not referring to itself H_Hat is referring to itself.

What does that have to do with whether or not Halts(P, P)
returns zero?

Where does H_Hat refer to itself? Both Test and H_Hat
receive a parameter P, and just pass it on to Halts.

P is H_Hat, and so in the case of H_Hat, P is H_Hat.  So what? H_Hat
doesn't even check for P being equal to itself; it's just passing it
down.

Isn't the infinite recursion that is detected and aborted the result of
Halts calling P(P), where P == H_Hat?

How can that not be the same regardless of which function passed P =
H_Hat to Halts?

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

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


#29327 — Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-14 22:00 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)
Message-ID<2LOdnS9VOcQvUNP9nZ2dnUU7-R3NnZ2d@giganews.com>
In reply to#29324
On 3/14/2021 9:30 PM, Kaz Kylheku wrote:
> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>> The input to Test() is H_Hat();
>> The input to H_Hat() is H_Hat();
>>
>> Test is not referring to itself H_Hat is referring to itself.
> 

Because of this key agreement I can conclude that you do want an honest 
dialogue: Since this key agreement is so important I estimate that I
will not doubt your sincerity again.

On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
 > On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
 >> So you agree that an input program that only halts because the halt
 >> decider stops simulating it <is> a non-halting computation?
 >
 > No; rather, I agree that such a program isn't deemed to have halted.
 >
 > If we are sure that the decision to stop it was correct (it is not
 > actually a halting program that was prematurely stopped) we may
 > pronounce it non-halting.

> What does that have to do with whether or not Halts(P, P)
> returns zero?
> 
> Where does H_Hat refer to itself? Both Test and H_Hat
> receive a parameter P, and just pass it on to Halts.

Because Halts simulates it input when H_Hat() calls Halts() with itself 
it specifies infinite recursion.

When Test() calls Halts() with H_Hat() this does not specify infinite 
recursion.

That is the key difference.

> P is H_Hat, and so in the case of H_Hat, P is H_Hat.  So what? H_Hat
> doesn't even check for P being equal to itself; it's just passing it
> down.
> 
> Isn't the infinite recursion that is detected and aborted the result of
> Halts calling P(P), where P == H_Hat?
> 
> How can that not be the same regardless of which function passed P =
> H_Hat to Halts?
> 

This is reformulated for brevity:
 >     void H_Hat(u32 P)
 >     {
 >        int Input_Halts = Halts(P, P);
 >     }
 >
 >     void Test(u32 P)
 >     {
 >        int Input_Halts = Halts(P, P);
 >     }
 >
01     int main(void)
02    {
03       H_Hat((u32) H_Hat);
04       Test((u32) H_Hat);
05    }

Because line 03 directly calls H_Hat with itself as input it directly 
specifies infinite recursion.

Because line 03 directly calls Test with H_Hat as input it does not 
specify infinite recursion.


-- 
Copyright 2021 Pete Olcott

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

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


#29329 — Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-15 03:13 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)
Message-ID<20210314200749.133@kylheku.com>
In reply to#29327
On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
> On 3/14/2021 9:30 PM, Kaz Kylheku wrote:
>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>> The input to Test() is H_Hat();
>>> The input to H_Hat() is H_Hat();
>>>
>>> Test is not referring to itself H_Hat is referring to itself.
>> 
>
> Because of this key agreement I can conclude that you do want an honest 
> dialogue: Since this key agreement is so important I estimate that I
> will not doubt your sincerity again.
>
> On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
> > On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
> >> So you agree that an input program that only halts because the halt
> >> decider stops simulating it <is> a non-halting computation?
> >
> > No; rather, I agree that such a program isn't deemed to have halted.
> >
> > If we are sure that the decision to stop it was correct (it is not
> > actually a halting program that was prematurely stopped) we may
> > pronounce it non-halting.
>
>> What does that have to do with whether or not Halts(P, P)
>> returns zero?
>> 
>> Where does H_Hat refer to itself? Both Test and H_Hat
>> receive a parameter P, and just pass it on to Halts.
>
> Because Halts simulates it input when H_Hat() calls Halts() with itself 
> it specifies infinite recursion.

But, shouldn't Halts simulate its input regardless of which caller
gives it the P = H_Hat argument (in both places)?

> When Test() calls Halts() with H_Hat() this does not specify infinite 
> recursion.

Say what? It's literally the same call: Halts(P, P) with P = H_Hat.

> That is the key difference.

Okay, well, you seem to believe that you are done here.

I'm just saying that you will run into this with the next people.

> This is reformulated for brevity:
> >     void H_Hat(u32 P)
> >     {
> >        int Input_Halts = Halts(P, P);
> >     }
> >
> >     void Test(u32 P)
> >     {
> >        int Input_Halts = Halts(P, P);
> >     }
> >
> 01     int main(void)
> 02    {
> 03       H_Hat((u32) H_Hat);
> 04       Test((u32) H_Hat);
> 05    }
>
> Because line 03 directly calls H_Hat with itself as input it directly 
> specifies infinite recursion.
>
> Because line 03 directly calls Test with H_Hat as input it does not 
> specify infinite recursion.

But as a software engineer, don't you know that your compiler can inline
these calls???

Test can disappear entirely. H_Hat cannot because its address is used.
But main's call to H_Hat can disappear. The above main() can be
rewritten by the C compiler to effectively be:

  int main(void)
  {
     Halts(P, P);
     Halts(P, P);
  }

What compiler are you using, with what optimization levels?

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

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


#29332 — Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-14 22:22 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)
Message-ID<lrOdncDOD8ZtT9P9nZ2dnUU7-e_NnZ2d@giganews.com>
In reply to#29329
On 3/14/2021 10:13 PM, Kaz Kylheku wrote:
> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>> On 3/14/2021 9:30 PM, Kaz Kylheku wrote:
>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>> The input to Test() is H_Hat();
>>>> The input to H_Hat() is H_Hat();
>>>>
>>>> Test is not referring to itself H_Hat is referring to itself.
>>>
>>
>> Because of this key agreement I can conclude that you do want an honest
>> dialogue: Since this key agreement is so important I estimate that I
>> will not doubt your sincerity again.
>>
>> On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
>>> On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
>>>> So you agree that an input program that only halts because the halt
>>>> decider stops simulating it <is> a non-halting computation?
>>>
>>> No; rather, I agree that such a program isn't deemed to have halted.
>>>
>>> If we are sure that the decision to stop it was correct (it is not
>>> actually a halting program that was prematurely stopped) we may
>>> pronounce it non-halting.
>>
>>> What does that have to do with whether or not Halts(P, P)
>>> returns zero?
>>>
>>> Where does H_Hat refer to itself? Both Test and H_Hat
>>> receive a parameter P, and just pass it on to Halts.
>>
>> Because Halts simulates it input when H_Hat() calls Halts() with itself
>> it specifies infinite recursion.
> 
> But, shouldn't Halts simulate its input regardless of which caller
> gives it the P = H_Hat argument (in both places)?

Sure and as soon as it determines that this input specifies infinite 
recursion it immediately stops simulating it an decides not halting.

>> When Test() calls Halts() with H_Hat() this does not specify infinite
>> recursion.
> 
> Say what? It's literally the same call: Halts(P, P) with P = H_Hat.
> 

When H_Hat() is called with itself as input this is the pathological 
self- reference error. This derives infinite recursion.

When Test() is called with H_Hat as input this is not the pathological 
self-reference error. This does not derive infinite recursion.


-- 
Copyright 2021 Pete Olcott

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

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


#29362 — Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-15 20:18 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion)
Message-ID<20210315130937.89@kylheku.com>
In reply to#29332
On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
> On 3/14/2021 10:13 PM, Kaz Kylheku wrote:
>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/14/2021 9:30 PM, Kaz Kylheku wrote:
>>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>>> The input to Test() is H_Hat();
>>>>> The input to H_Hat() is H_Hat();
>>>>>
>>>>> Test is not referring to itself H_Hat is referring to itself.
>>>>
>>>
>>> Because of this key agreement I can conclude that you do want an honest
>>> dialogue: Since this key agreement is so important I estimate that I
>>> will not doubt your sincerity again.
>>>
>>> On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
>>>> On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
>>>>> So you agree that an input program that only halts because the halt
>>>>> decider stops simulating it <is> a non-halting computation?
>>>>
>>>> No; rather, I agree that such a program isn't deemed to have halted.
>>>>
>>>> If we are sure that the decision to stop it was correct (it is not
>>>> actually a halting program that was prematurely stopped) we may
>>>> pronounce it non-halting.
>>>
>>>> What does that have to do with whether or not Halts(P, P)
>>>> returns zero?
>>>>
>>>> Where does H_Hat refer to itself? Both Test and H_Hat
>>>> receive a parameter P, and just pass it on to Halts.
>>>
>>> Because Halts simulates it input when H_Hat() calls Halts() with itself
>>> it specifies infinite recursion.
>> 
>> But, shouldn't Halts simulate its input regardless of which caller
>> gives it the P = H_Hat argument (in both places)?
>
> Sure and as soon as it determines that this input specifies infinite 
> recursion it immediately stops simulating it an decides not halting.
>
>>> When Test() calls Halts() with H_Hat() this does not specify infinite
>>> recursion.
>> 
>> Say what? It's literally the same call: Halts(P, P) with P = H_Hat.
>> 
>
> When H_Hat() is called with itself as input this is the pathological 
> self- reference error. This derives infinite recursion.

What pathology is this? Do you mean that it is pathological whenever
a C function receives a pointer to itself as a parameter?

That's a legitimate programming technique which can occur in some state
machine patterns. A function could be given itself as the continuation
to tail-call.

In the famous Y-combinator, an anonymous function is passed to itself so
that it has a reference to itself for recursion.

> When Test() is called with H_Hat as input this is not the pathological 
> self-reference error. This does not derive infinite recursion.

I don't follow this at all, sorry. What I'm saying is that I expect
these two to generate generate identical code, except for some
details of function address:

  void Test(u32 P)
  {
     u32 Input_Halts = Halts(P, P);

     ...

  void H_Hat(u32 P)
  {
     u32 Input_Halts = Halts(P, P);
     ...


and I also mentioned that calls to either of these can be
completely inlined into main, so there is no difference.

The runaway recursion is detected inside Halts(P, P), is it not?

What happens if we call this from main:

  Test((u32) Test);

That now has a "pathological" self-reference inside Test, right?
so that should now be aborted.

Or are you simply aborting any function F, that receives F as its first
parameter in the EAX register, or whatever your calling convention is?

Or does F specifically have to be H_Hat.

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

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


#29365 — Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-15 15:41 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (Kaz is getting it)
Message-ID<XtKdnd1CjqzhW9L9nZ2dnUU7-I3NnZ2d@giganews.com>
In reply to#29362
On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>> On 3/14/2021 10:13 PM, Kaz Kylheku wrote:
>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/14/2021 9:30 PM, Kaz Kylheku wrote:
>>>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The input to Test() is H_Hat();
>>>>>> The input to H_Hat() is H_Hat();
>>>>>>
>>>>>> Test is not referring to itself H_Hat is referring to itself.
>>>>>
>>>>
>>>> Because of this key agreement I can conclude that you do want an honest
>>>> dialogue: Since this key agreement is so important I estimate that I
>>>> will not doubt your sincerity again.
>>>>
>>>> On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
>>>>> On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
>>>>>> So you agree that an input program that only halts because the halt
>>>>>> decider stops simulating it <is> a non-halting computation?
>>>>>
>>>>> No; rather, I agree that such a program isn't deemed to have halted.
>>>>>
>>>>> If we are sure that the decision to stop it was correct (it is not
>>>>> actually a halting program that was prematurely stopped) we may
>>>>> pronounce it non-halting.
>>>>
>>>>> What does that have to do with whether or not Halts(P, P)
>>>>> returns zero?
>>>>>
>>>>> Where does H_Hat refer to itself? Both Test and H_Hat
>>>>> receive a parameter P, and just pass it on to Halts.
>>>>
>>>> Because Halts simulates it input when H_Hat() calls Halts() with itself
>>>> it specifies infinite recursion.
>>>
>>> But, shouldn't Halts simulate its input regardless of which caller
>>> gives it the P = H_Hat argument (in both places)?
>>
>> Sure and as soon as it determines that this input specifies infinite
>> recursion it immediately stops simulating it an decides not halting.
>>
>>>> When Test() calls Halts() with H_Hat() this does not specify infinite
>>>> recursion.
>>>
>>> Say what? It's literally the same call: Halts(P, P) with P = H_Hat.
>>>
>>
>> When H_Hat() is called with itself as input this is the pathological
>> self- reference error. This derives infinite recursion.
> 
> What pathology is this? 

I updated these two pages of the textbook proofs:
http://www.liarparadox.org/sipser_165.pdf
http://www.liarparadox.org/kozen_233.pdf

to YELLOW HIGHLIGHT the portions that show the key basis of both of 
these proofs is defining an input to the halt decider that:
"does the opposite of whatever the halt decider decides"

The YELLOW HIGHLIGHTED portion <is> the pathological part that had 
previously been proposed to "prove" that the halting problem is 
undecidable.

> Do you mean that it is pathological whenever
> a C function receives a pointer to itself as a parameter?
> 

Of course I do not mean that, I mean how the YELLOW HIGHLIGHTED portions 
of the above two textbook pages are used as the basis to "prove" halting 
problem undecidability.

> That's a legitimate programming technique which can occur in some state
> machine patterns. A function could be given itself as the continuation
> to tail-call.
> 
> In the famous Y-combinator, an anonymous function is passed to itself so
> that it has a reference to itself for recursion.
> 
>> When Test() is called with H_Hat as input this is not the pathological
>> self-reference error. This does not derive infinite recursion.
> 
> I don't follow this at all, sorry. What I'm saying is that I expect
> these two to generate generate identical code, except for some
> details of function address:
> 
>    void Test(u32 P)
>    {
>       u32 Input_Halts = Halts(P, P);
> 
>       ...
> 
>    void H_Hat(u32 P)
>    {
>       u32 Input_Halts = Halts(P, P);
>       ...
> 
> 
> and I also mentioned that calls to either of these can be
> completely inlined into main, so there is no difference.
> 
> The runaway recursion is detected inside Halts(P, P), is it not?
> 
> What happens if we call this from main:
> 
>    Test((u32) Test);
> 
> That now has a "pathological" self-reference inside Test, right?
> so that should now be aborted.

Yes I think that you "got it" now.


-- 
Copyright 2021 Pete Olcott

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

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


#29410 — Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-16 13:45 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (Kaz is getting it)
Message-ID<20210316061548.403@kylheku.com>
In reply to#29365
On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
> On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
>>> When Test() is called with H_Hat as input this is not the pathological
>>> self-reference error. This does not derive infinite recursion.
>> 
>> I don't follow this at all, sorry. What I'm saying is that I expect
>> these two to generate generate identical code, except for some
>> details of function address:
>> 
>>    void Test(u32 P)
>>    {
>>       u32 Input_Halts = Halts(P, P);
>> 
>>       ...
>> 
>>    void H_Hat(u32 P)
>>    {
>>       u32 Input_Halts = Halts(P, P);
>>       ...
>> 
>> 
>> and I also mentioned that calls to either of these can be
>> completely inlined into main, so there is no difference.
>> 
>> The runaway recursion is detected inside Halts(P, P), is it not?
>> 
>> What happens if we call this from main:
>> 
>>    Test((u32) Test);
>> 
>> That now has a "pathological" self-reference inside Test, right?
>> so that should now be aborted.
>
> Yes I think that you "got it" now.

Ah, okay; we are back full tilt on that hapless global decider program.

Unfortunately, although having multiple modes caused communication
problems, the local mode is the one which is compatible with the
concept of a function and Turing machine.

You might remember the discussion from months ago about this; I conceded
that local decider is a function because it isn't informed by global
state, only by instruction traces which it calculates itself.

At that time I wrote off the global mode as incorrect and
not worthy of further consideration.

To reiterate my position:

The global mode leaks information so that functions are no longer
pure computations based on just their arguments.

That's what explains that Halts(P, P) can return in one situation
and be aborted in another. Its behavior is influenced by some global
information about events that have happened or not happened previously
to its invocation.

If you present this to academia, you will get the same feedback, if
things even get that far. If Halts(H_Hat, H_Hat) demonstrably returns 0
in one program run, that proves that H_Hat(H_Hat) cannot be infinitely
recursive: it's obviously calling a function which calculates 0 in a
finite number of steps. So then if you turn around with a different
program run in which H_Hat is suddenly diagnosed as infinitely recursive
because it calls Halts(H_Hat, H_Hat), that's a huge red flag that you
have something unsavory going on. Questions will be asked.

Whoever you reveal your complete code to will easily be able to point
out what that problem is, in concrete terms, referencing specific parts
of your implementation and its run-time state.

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

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


#29412 — Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 09:59 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (Kaz is getting it)
Message-ID<9fSdncnjp4ZJWs39nZ2dnUU7-avNnZ2d@giganews.com>
In reply to#29410
On 3/16/2021 8:45 AM, Kaz Kylheku wrote:
> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>> On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
>>>> When Test() is called with H_Hat as input this is not the pathological
>>>> self-reference error. This does not derive infinite recursion.
>>>
>>> I don't follow this at all, sorry. What I'm saying is that I expect
>>> these two to generate generate identical code, except for some
>>> details of function address:
>>>
>>>     void Test(u32 P)
>>>     {
>>>        u32 Input_Halts = Halts(P, P);
>>>
>>>        ...
>>>
>>>     void H_Hat(u32 P)
>>>     {
>>>        u32 Input_Halts = Halts(P, P);
>>>        ...
>>>
>>>
>>> and I also mentioned that calls to either of these can be
>>> completely inlined into main, so there is no difference.
>>>
>>> The runaway recursion is detected inside Halts(P, P), is it not?
>>>
>>> What happens if we call this from main:
>>>
>>>     Test((u32) Test);
>>>
>>> That now has a "pathological" self-reference inside Test, right?
>>> so that should now be aborted.
>>
>> Yes I think that you "got it" now.
> 
> Ah, okay; we are back full tilt on that hapless global decider program.
> 
> Unfortunately, although having multiple modes caused communication
> problems, the local mode is the one which is compatible with the
> concept of a function and Turing machine.
> 
> You might remember the discussion from months ago about this; I conceded
> that local decider is a function because it isn't informed by global
> state, only by instruction traces which it calculates itself.
> 
> At that time I wrote off the global mode as incorrect and
> not worthy of further consideration.
> 
> To reiterate my position:
> 
> The global mode leaks information so that functions are no longer
> pure computations based on just their arguments.
> 

This is not the case when the global halt decider is a function of the 
global UTM that is simulating every input. Its only input is the Turing 
machine descriptions thus making its halting decision a function of 
these finite strings. The UTM is an aspect of itself.

> That's what explains that Halts(P, P) can return in one situation
> and be aborted in another. Its behavior is influenced by some global
> information about events that have happened or not happened previously
> to its invocation.

Which the global UTM aspect of the global halt decider would have as a 
part of its own internal state.

> If you present this to academia, you will get the same feedback, if

I have to make what I am proposing perfectly clear before I ever present 
it to academia. They are not going to have the patience for endless 
reviews.

> things even get that far. If Halts(H_Hat, H_Hat) demonstrably returns 0
> in one program run, that proves that H_Hat(H_Hat) cannot be infinitely
> recursive: 

It <is> infinitely recursive and the halt decider would have decided 
that if sneaky things were not being done behind its back. The 
counter-example case that you and others cite is always a case of sneaky 
things being done behind the halt decider's its back.

When people are only presented with a global halt decider based on 
adapting a global UTM this issue will never occur to them.

> it's obviously calling a function which calculates 0 in a
> finite number of steps. So then if you turn around with a different
> program run in which H_Hat is suddenly diagnosed as infinitely recursive
> because it calls Halts(H_Hat, H_Hat), that's a huge red flag that you
> have something unsavory going on. Questions will be asked.
> 

People that believe that computations that only halt because their 
execution was aborted by the halt decider are halting computations can 
simply be dismissed as incorrect.

Computer scientists will not make this mistake.

> Whoever you reveal your complete code to will easily be able to point
> out what that problem is, in concrete terms, referencing specific parts
> of your implementation and its run-time state.
> 

There is totally no need to ever see the source-code.

100% of the entire infinite recursion detection criteria is shown in the 
x86 machine language trace.

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]


#29420 — Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-16 17:26 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (Kaz is getting it)
Message-ID<20210316100627.299@kylheku.com>
In reply to#29412
On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
> On 3/16/2021 8:45 AM, Kaz Kylheku wrote:
>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
>>>>> When Test() is called with H_Hat as input this is not the pathological
>>>>> self-reference error. This does not derive infinite recursion.
>>>>
>>>> I don't follow this at all, sorry. What I'm saying is that I expect
>>>> these two to generate generate identical code, except for some
>>>> details of function address:
>>>>
>>>>     void Test(u32 P)
>>>>     {
>>>>        u32 Input_Halts = Halts(P, P);
>>>>
>>>>        ...
>>>>
>>>>     void H_Hat(u32 P)
>>>>     {
>>>>        u32 Input_Halts = Halts(P, P);
>>>>        ...
>>>>
>>>>
>>>> and I also mentioned that calls to either of these can be
>>>> completely inlined into main, so there is no difference.
>>>>
>>>> The runaway recursion is detected inside Halts(P, P), is it not?
>>>>
>>>> What happens if we call this from main:
>>>>
>>>>     Test((u32) Test);
>>>>
>>>> That now has a "pathological" self-reference inside Test, right?
>>>> so that should now be aborted.
>>>
>>> Yes I think that you "got it" now.
>> 
>> Ah, okay; we are back full tilt on that hapless global decider program.
>> 
>> Unfortunately, although having multiple modes caused communication
>> problems, the local mode is the one which is compatible with the
>> concept of a function and Turing machine.
>> 
>> You might remember the discussion from months ago about this; I conceded
>> that local decider is a function because it isn't informed by global
>> state, only by instruction traces which it calculates itself.
>> 
>> At that time I wrote off the global mode as incorrect and
>> not worthy of further consideration.
>> 
>> To reiterate my position:
>> 
>> The global mode leaks information so that functions are no longer
>> pure computations based on just their arguments.
>> 
>
> This is not the case when the global halt decider is a function of the 
> global UTM that is simulating every input. Its only input is the Turing 
> machine descriptions thus making its halting decision a function of 
> these finite strings. The UTM is an aspect of itself.

OK, if the enire program as a whole is the input to a global decider,
then whenever we produce different programs for different things---like
calling H_Hat directly, or calling some Tests function---those are
completely different inputs.

Those inputs look like compiled C programs which contain functions, but
that means nothing. Only the global decider is a function.

The entities inside the input like Halts or H_Hat are not functions.
Their behavior changes based on the exact configuration of the overall
input. E.g. sometimes Halts returns 0, and sometimes not, for apparently
the same input.

In that case, it's not clear what the global decider is exactly doing;
its results don't make any clear statement about H_Hat or Halts.

>> That's what explains that Halts(P, P) can return in one situation
>> and be aborted in another. Its behavior is influenced by some global
>> information about events that have happened or not happened previously
>> to its invocation.
>
> Which the global UTM aspect of the global halt decider would have as a 
> part of its own internal state.

The problem is that the theory requires Halts(P, P) to be TM.

Halts(P, P) is just a fragment of a tape of some master TM, so loosely
to speak.
>
>> If you present this to academia, you will get the same feedback, if
>
> I have to make what I am proposing perfectly clear before I ever present 
> it to academia. They are not going to have the patience for endless 
> reviews.
>
>> things even get that far. If Halts(H_Hat, H_Hat) demonstrably returns 0
>> in one program run, that proves that H_Hat(H_Hat) cannot be infinitely
>> recursive: 
>
> It <is> infinitely recursive and the halt decider would have decided 

But it obviously isn't, when you yourself have a test case where
Halts(H_Hat, H_Hat) cheerfully returns 0.

You are requiring people (people who know what a function is) to accept
execution traces which show that Halts(H_Hat, H_Hat) terminates in
a finite number of steps, returning 0.

Then you're asking the same people to accept that H_Hat(H_Hat),
which calls Halts(H_Hat, H_Hat) and returns if that returns 0,
is infinitely recursive.

For H_Hat(H_Hat) to recursive at all (let alone infinitely), it
cannot be the case that Halts(H_Hat, H_Hat) calculates zero in a finite
number of steps.

So you're asking rational people to accept all three of these:

1. Halts is a computational function. Therefore
   Halts(H_Hat, H_Hat) is Turing computation.
   It either terminates, or doesn't; if it terminates,
   it always terminates in the same state.

2. Halts(H_Hat, H_Hat) returns 0.

3. Halts(H_Hat, H_Hat) doesn't return.

> that if sneaky things were not being done behind its back. The 
> counter-example case that you and others cite is always a case of sneaky 
> things being done behind the halt decider's its back.

Nope; the thing is being done in the open: integrating the decider into
another function to create H_Hat.

None of these "sneaky things" do anything so cude as your own sneaky
things, namely destroy the concept of a function.

>
> When people are only presented with a global halt decider based on 
> adapting a global UTM this issue will never occur to them.
>
>> it's obviously calling a function which calculates 0 in a
>> finite number of steps. So then if you turn around with a different
>> program run in which H_Hat is suddenly diagnosed as infinitely recursive
>> because it calls Halts(H_Hat, H_Hat), that's a huge red flag that you
>> have something unsavory going on. Questions will be asked.
>> 
>
> People that believe that computations that only halt because their 
> execution was aborted by the halt decider are halting computations can 
> simply be dismissed as incorrect.

I specifically don't believe that though; I believe that when your
decider says "simulation halted due to runaway recursion" or whatever,
a runaway recursion was intercepted. I take that at face value.

Likewise, when Halts(P, P) returns 0, I take that to be a real halting
computation.

The problem is you have gamed things so that the same code (which is
supposed to be a function whose behavior depends only on its arguments)
is sometimes runaway recursive and sometimes isn't.


> Computer scientists will not make this mistake.

Computer scientists will not make the mistake of debating
with you, I'm afraid. That's the mistake they won't make.

This newsgroup is all the captives you will ever have, I'm afraid.

>> Whoever you reveal your complete code to will easily be able to point
>> out what that problem is, in concrete terms, referencing specific parts
>> of your implementation and its run-time state.
>> 
>
> There is totally no need to ever see the source-code.
>
> 100% of the entire infinite recursion detection criteria is shown in the 
> x86 machine language trace.

Your trace raises the question: huh? Halts(P, P) returned 0? But that
means ... H_Hat should have quit, so that's the wrong return value.
Wait, what?

Yes, a computer scientist will say that.

Next, they will likely ask; so, okay, what happens if you actually call
H_Hat((u32) H_Hat)? Since Halts returns 0 to it, it must simply
terminate.

Then comes the kicker: that is reported as runaway recursive and
aborted!

After that, your "no need to see the source code" will definitely
not fly.

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

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


#29421 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 13:09 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<_5SdnUYjON_4ac39nZ2dnUU7-QnNnZ2d@giganews.com>
In reply to#29420
On 3/16/2021 12:26 PM, Kaz Kylheku wrote:
> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>> On 3/16/2021 8:45 AM, Kaz Kylheku wrote:
>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
>>>>>> When Test() is called with H_Hat as input this is not the pathological
>>>>>> self-reference error. This does not derive infinite recursion.
>>>>>
>>>>> I don't follow this at all, sorry. What I'm saying is that I expect
>>>>> these two to generate generate identical code, except for some
>>>>> details of function address:
>>>>>
>>>>>      void Test(u32 P)
>>>>>      {
>>>>>         u32 Input_Halts = Halts(P, P);
>>>>>
>>>>>         ...
>>>>>
>>>>>      void H_Hat(u32 P)
>>>>>      {
>>>>>         u32 Input_Halts = Halts(P, P);
>>>>>         ...
>>>>>
>>>>>
>>>>> and I also mentioned that calls to either of these can be
>>>>> completely inlined into main, so there is no difference.
>>>>>
>>>>> The runaway recursion is detected inside Halts(P, P), is it not?
>>>>>
>>>>> What happens if we call this from main:
>>>>>
>>>>>      Test((u32) Test);
>>>>>
>>>>> That now has a "pathological" self-reference inside Test, right?
>>>>> so that should now be aborted.
>>>>
>>>> Yes I think that you "got it" now.
>>>
>>> Ah, okay; we are back full tilt on that hapless global decider program.
>>>
>>> Unfortunately, although having multiple modes caused communication
>>> problems, the local mode is the one which is compatible with the
>>> concept of a function and Turing machine.
>>>
>>> You might remember the discussion from months ago about this; I conceded
>>> that local decider is a function because it isn't informed by global
>>> state, only by instruction traces which it calculates itself.
>>>
>>> At that time I wrote off the global mode as incorrect and
>>> not worthy of further consideration.
>>>
>>> To reiterate my position:
>>>
>>> The global mode leaks information so that functions are no longer
>>> pure computations based on just their arguments.
>>>
>>
>> This is not the case when the global halt decider is a function of the
>> global UTM that is simulating every input. Its only input is the Turing
>> machine descriptions thus making its halting decision a function of
>> these finite strings. The UTM is an aspect of itself.
> 
> OK, if the enire program as a whole is the input to a global decider,
> then whenever we produce different programs for different things---like
> calling H_Hat directly, or calling some Tests function---those are
> completely different inputs.
> 
> Those inputs look like compiled C programs which contain functions, but
> that means nothing. Only the global decider is a function.
> 
> The entities inside the input like Halts or H_Hat are not functions.
> Their behavior changes based on the exact configuration of the overall
> input. E.g. sometimes Halts returns 0, and sometimes not, for apparently
> the same input.
> 
> In that case, it's not clear what the global decider is exactly doing;
> its results don't make any clear statement about H_Hat or Halts.

This adapted UTM would simply simulate the execution of its input until 
its input halts on its own or its 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. This UTM / halt decider is a pure function of its inputs.

>>> That's what explains that Halts(P, P) can return in one situation
>>> and be aborted in another. Its behavior is influenced by some global
>>> information about events that have happened or not happened previously
>>> to its invocation.
>>
>> Which the global UTM aspect of the global halt decider would have as a
>> part of its own internal state.
> 
> The problem is that the theory requires Halts(P, P) to be TM.
> 
> Halts(P, P) is just a fragment of a tape of some master TM, so loosely
> to speak.

No it is operating system level functionality that is provided to its 
sub-processes (the simulated inputs) just like "C" printf must call the 
operating system for support.

>>
>>> If you present this to academia, you will get the same feedback, if
>>
>> I have to make what I am proposing perfectly clear before I ever present
>> it to academia. They are not going to have the patience for endless
>> reviews.
>>
>>> things even get that far. If Halts(H_Hat, H_Hat) demonstrably returns 0
>>> in one program run, that proves that H_Hat(H_Hat) cannot be infinitely
>>> recursive:
>>
>> It <is> infinitely recursive and the halt decider would have decided
> 
> But it obviously isn't, when you yourself have a test case where
> Halts(H_Hat, H_Hat) cheerfully returns 0.

On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
 > On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
 >> So you agree that an input program that only halts because the halt
 >> decider stops simulating it <is> a non-halting computation?
 >
 > If we are sure that the decision to stop it was correct (it is not
 > actually a halting program that was prematurely stopped) we may
 > pronounce it non-halting.

> You are requiring people (people who know what a function is) to accept
> execution traces which show that Halts(H_Hat, H_Hat) terminates in
> a finite number of steps, returning 0.
> 
> Then you're asking the same people to accept that H_Hat(H_Hat),
> which calls Halts(H_Hat, H_Hat) and returns if that returns 0,
> is infinitely recursive.
> 

People that believe that computations that only halt because their 
execution was aborted by the halt decider are halting computations can 
simply be dismissed as incorrect.

> For H_Hat(H_Hat) to recursive at all (let alone infinitely), it
> cannot be the case that Halts(H_Hat, H_Hat) calculates zero in a finite
> number of steps.

Sure it can, you already agreed to this.
On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
 > On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
 >> So you agree that an input program that only halts because the halt
 >> decider stops simulating it <is> a non-halting computation?
 >
 > If we are sure that the decision to stop it was correct (it is not
 > actually a halting program that was prematurely stopped) we may
 > pronounce it non-halting.

> So you're asking rational people to accept all three of these:
> 
> 1. Halts is a computational function. Therefore
>     Halts(H_Hat, H_Hat) is Turing computation.
>     It either terminates, or doesn't; if it terminates,
>     it always terminates in the same state.
> 
> 2. Halts(H_Hat, H_Hat) returns 0.

People that believe that computations that only halt because their 
execution was aborted by the halt decider are halting computations can 
simply be dismissed as incorrect.

> 3. Halts(H_Hat, H_Hat) doesn't return.

I never said this.

>> that if sneaky things were not being done behind its back. The
>> counter-example case that you and others cite is always a case of sneaky
>> things being done behind the halt decider's its back.
> 
> Nope; the thing is being done in the open: integrating the decider into
> another function to create H_Hat.
> 
> None of these "sneaky things" do anything so cude as your own sneaky
> things, namely destroy the concept of a function.
> 
>>
>> When people are only presented with a global halt decider based on
>> adapting a global UTM this issue will never occur to them.
>>
>>> it's obviously calling a function which calculates 0 in a
>>> finite number of steps. So then if you turn around with a different
>>> program run in which H_Hat is suddenly diagnosed as infinitely recursive
>>> because it calls Halts(H_Hat, H_Hat), that's a huge red flag that you
>>> have something unsavory going on. Questions will be asked.
>>>
>>
>> People that believe that computations that only halt because their
>> execution was aborted by the halt decider are halting computations can
>> simply be dismissed as incorrect.
> 
> I specifically don't believe that though; I believe that when your
> decider says "simulation halted due to runaway recursion" or whatever,
> a runaway recursion was intercepted. I take that at face value.
> 
> Likewise, when Halts(P, P) returns 0, I take that to be a real halting
> computation.
> 
> The problem is you have gamed things so that the same code (which is
> supposed to be a function whose behavior depends only on its arguments)
> is sometimes runaway recursive and sometimes isn't.
H_Hat(H_Hat) was decided by Halts() to never terminate unless Halts() 
terminates it.

When Halts() determines that H_Hat(H_Hat) would terminate unless Halts() 
terminates it, Halts() reports this and then Halts() terminates.

It is not that hard.


-- 
Copyright 2021 Pete Olcott

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

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


#29422 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-16 18:38 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<20210316112243.70@kylheku.com>
In reply to#29421
On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
> On 3/16/2021 12:26 PM, Kaz Kylheku wrote:
>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/16/2021 8:45 AM, Kaz Kylheku wrote:
>>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
>>>>>>> When Test() is called with H_Hat as input this is not the pathological
>>>>>>> self-reference error. This does not derive infinite recursion.
>>>>>>
>>>>>> I don't follow this at all, sorry. What I'm saying is that I expect
>>>>>> these two to generate generate identical code, except for some
>>>>>> details of function address:
>>>>>>
>>>>>>      void Test(u32 P)
>>>>>>      {
>>>>>>         u32 Input_Halts = Halts(P, P);
>>>>>>
>>>>>>         ...
>>>>>>
>>>>>>      void H_Hat(u32 P)
>>>>>>      {
>>>>>>         u32 Input_Halts = Halts(P, P);
>>>>>>         ...
>>>>>>
>>>>>>
>>>>>> and I also mentioned that calls to either of these can be
>>>>>> completely inlined into main, so there is no difference.
>>>>>>
>>>>>> The runaway recursion is detected inside Halts(P, P), is it not?
>>>>>>
>>>>>> What happens if we call this from main:
>>>>>>
>>>>>>      Test((u32) Test);
>>>>>>
>>>>>> That now has a "pathological" self-reference inside Test, right?
>>>>>> so that should now be aborted.
>>>>>
>>>>> Yes I think that you "got it" now.
>>>>
>>>> Ah, okay; we are back full tilt on that hapless global decider program.
>>>>
>>>> Unfortunately, although having multiple modes caused communication
>>>> problems, the local mode is the one which is compatible with the
>>>> concept of a function and Turing machine.
>>>>
>>>> You might remember the discussion from months ago about this; I conceded
>>>> that local decider is a function because it isn't informed by global
>>>> state, only by instruction traces which it calculates itself.
>>>>
>>>> At that time I wrote off the global mode as incorrect and
>>>> not worthy of further consideration.
>>>>
>>>> To reiterate my position:
>>>>
>>>> The global mode leaks information so that functions are no longer
>>>> pure computations based on just their arguments.
>>>>
>>>
>>> This is not the case when the global halt decider is a function of the
>>> global UTM that is simulating every input. Its only input is the Turing
>>> machine descriptions thus making its halting decision a function of
>>> these finite strings. The UTM is an aspect of itself.
>> 
>> OK, if the enire program as a whole is the input to a global decider,
>> then whenever we produce different programs for different things---like
>> calling H_Hat directly, or calling some Tests function---those are
>> completely different inputs.
>> 
>> Those inputs look like compiled C programs which contain functions, but
>> that means nothing. Only the global decider is a function.
>> 
>> The entities inside the input like Halts or H_Hat are not functions.
>> Their behavior changes based on the exact configuration of the overall
>> input. E.g. sometimes Halts returns 0, and sometimes not, for apparently
>> the same input.
>> 
>> In that case, it's not clear what the global decider is exactly doing;
>> its results don't make any clear statement about H_Hat or Halts.
>
> This adapted UTM would simply simulate the execution of its input until 
> its input halts on its own or its halt decider determines that its input 
> would never halt on its own and stops simulating it.

That's a gaping problem: the global machine and the halt decider
function named Halts are in cahoots with each other.

This means that your machinery is susceptible to obvious methods of
attack which conceal the Halts function from the global machinery.

For instance, H_Hat could have a simulator of its own:

  void H_Hat(u32 P)
  {
     u32 Input_Halts = H_Hat_Simulate(Halts, P, P);

     if (Input_Halts)
        foo: goto foo;
  }

H_Hat_Simulate is a bona fide x86 simulator separate from yours,
packaged together with H_Hat.

Your global decider will now not see an instruction stream whereby H_Hat
is calling Halts.

> UTM to see what its input does it must keep track of an execution trace 
> of its input. This UTM / halt decider is a pure function of its inputs.
>
>> The problem is that the theory requires Halts(P, P) to be TM.
>> 
>> Halts(P, P) is just a fragment of a tape of some master TM, so loosely
>> to speak.
>
> No it is operating system level functionality that is provided to its 
> sub-processes (the simulated inputs) just like "C" printf must call the 
> operating system for support.

That's just it. Functions are not supposed to communicate with each
other using "operating system functionality" back-channels.  They cease
to be functions.

Why not just open networking sockets or pipes between the functions?
That's also "operating system functionality" like printf.

> People that believe that computations that only halt because their 
> execution was aborted by the halt decider are halting computations can 
> simply be dismissed as incorrect.

You will not be in any position to dismiss, for any reason, academics
whom you would like to accept your work.
>
>> The problem is you have gamed things so that the same code (which is
>> supposed to be a function whose behavior depends only on its arguments)
>> is sometimes runaway recursive and sometimes isn't.
> H_Hat(H_Hat) was decided by Halts() to never terminate unless Halts() 
> terminates it.

If the "unless ..." condition ever occurs, then:

   "decided to ... unless ..."

means precisely the same thing as:

   "sometimes decided and sometimes not"

Which is good for nothing.

> When Halts() determines that H_Hat(H_Hat) would terminate unless Halts() 
> terminates it, Halts() reports this and then Halts() terminates.

That report is the form of a zero return value, which makes H_Hat
naturally halting. Unless you've screwed with behind-the scenes
machinations in the execution model, by means of which you can procure
any behavior you wish.

It's damned by its inconsistency though.

Your work is not correct because it is inconsistent. Inconsistency in
logic is incorrectness.

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


#29429 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 14:14 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<ftedndKSEcDknsz9nZ2dnUU7-efNnZ2d@giganews.com>
In reply to#29422
On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>> On 3/16/2021 12:26 PM, Kaz Kylheku wrote:
>>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/16/2021 8:45 AM, Kaz Kylheku wrote:
>>>>> On 2021-03-15, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 3/15/2021 3:18 PM, Kaz Kylheku wrote:
>>>>>>>> When Test() is called with H_Hat as input this is not the pathological
>>>>>>>> self-reference error. This does not derive infinite recursion.
>>>>>>>
>>>>>>> I don't follow this at all, sorry. What I'm saying is that I expect
>>>>>>> these two to generate generate identical code, except for some
>>>>>>> details of function address:
>>>>>>>
>>>>>>>       void Test(u32 P)
>>>>>>>       {
>>>>>>>          u32 Input_Halts = Halts(P, P);
>>>>>>>
>>>>>>>          ...
>>>>>>>
>>>>>>>       void H_Hat(u32 P)
>>>>>>>       {
>>>>>>>          u32 Input_Halts = Halts(P, P);
>>>>>>>          ...
>>>>>>>
>>>>>>>
>>>>>>> and I also mentioned that calls to either of these can be
>>>>>>> completely inlined into main, so there is no difference.
>>>>>>>
>>>>>>> The runaway recursion is detected inside Halts(P, P), is it not?
>>>>>>>
>>>>>>> What happens if we call this from main:
>>>>>>>
>>>>>>>       Test((u32) Test);
>>>>>>>
>>>>>>> That now has a "pathological" self-reference inside Test, right?
>>>>>>> so that should now be aborted.
>>>>>>
>>>>>> Yes I think that you "got it" now.
>>>>>
>>>>> Ah, okay; we are back full tilt on that hapless global decider program.
>>>>>
>>>>> Unfortunately, although having multiple modes caused communication
>>>>> problems, the local mode is the one which is compatible with the
>>>>> concept of a function and Turing machine.
>>>>>
>>>>> You might remember the discussion from months ago about this; I conceded
>>>>> that local decider is a function because it isn't informed by global
>>>>> state, only by instruction traces which it calculates itself.
>>>>>
>>>>> At that time I wrote off the global mode as incorrect and
>>>>> not worthy of further consideration.
>>>>>
>>>>> To reiterate my position:
>>>>>
>>>>> The global mode leaks information so that functions are no longer
>>>>> pure computations based on just their arguments.
>>>>>
>>>>
>>>> This is not the case when the global halt decider is a function of the
>>>> global UTM that is simulating every input. Its only input is the Turing
>>>> machine descriptions thus making its halting decision a function of
>>>> these finite strings. The UTM is an aspect of itself.
>>>
>>> OK, if the enire program as a whole is the input to a global decider,
>>> then whenever we produce different programs for different things---like
>>> calling H_Hat directly, or calling some Tests function---those are
>>> completely different inputs.
>>>
>>> Those inputs look like compiled C programs which contain functions, but
>>> that means nothing. Only the global decider is a function.
>>>
>>> The entities inside the input like Halts or H_Hat are not functions.
>>> Their behavior changes based on the exact configuration of the overall
>>> input. E.g. sometimes Halts returns 0, and sometimes not, for apparently
>>> the same input.
>>>
>>> In that case, it's not clear what the global decider is exactly doing;
>>> its results don't make any clear statement about H_Hat or Halts.
>>
>> This adapted UTM would simply simulate the execution of its input until
>> its input halts on its own or its halt decider determines that its input
>> would never halt on its own and stops simulating it.
> 
> That's a gaping problem: the global machine and the halt decider
> function named Halts are in cahoots with each other.

A universal Turing machine (UTM) that has been adapted to become a halt 
decider are the same single TM.

> This means that your machinery is susceptible to obvious methods of
> attack which conceal the Halts function from the global machinery.
> 
> For instance, H_Hat could have a simulator of its own:
> 
>    void H_Hat(u32 P)
>    {
>       u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
> 
>       if (Input_Halts)
>          foo: goto foo;
>    }
> 

If you understand that nothing at all can possibly execute at all unless 
the halt decider simulates it you should see that this will not work.

> H_Hat_Simulate is a bona fide x86 simulator separate from yours,
> packaged together with H_Hat.
> 
> Your global decider will now not see an instruction stream whereby H_Hat
> is calling Halts.
> 
>> UTM to see what its input does it must keep track of an execution trace
>> of its input. This UTM / halt decider is a pure function of its inputs.
>>
>>> The problem is that the theory requires Halts(P, P) to be TM.
>>>
>>> Halts(P, P) is just a fragment of a tape of some master TM, so loosely
>>> to speak.
>>
>> No it is operating system level functionality that is provided to its
>> sub-processes (the simulated inputs) just like "C" printf must call the
>> operating system for support.
> 
> That's just it. Functions are not supposed to communicate with each
> other using "operating system functionality" back-channels.  They cease
> to be functions.
> 
> Why not just open networking sockets or pipes between the functions?
> That's also "operating system functionality" like printf.
> 
>> People that believe that computations that only halt because their
>> execution was aborted by the halt decider are halting computations can
>> simply be dismissed as incorrect.
> 
> You will not be in any position to dismiss, for any reason, academics
> whom you would like to accept your work.

You already agreed.

On 3/14/2021 5:11 PM, Kaz Kylheku wrote:
 > On 2021-03-14, olcott <NoOne@NoWhere.com> wrote:
 >> So you agree that an input program that only halts because the halt
 >> decider stops simulating it <is> a non-halting computation?
 >
 > If we are sure that the decision to stop it was correct (it is not
 > actually a halting program that was prematurely stopped) we may
 > pronounce it non-halting.

-- 
Copyright 2021 Pete Olcott

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

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


#29434 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-16 19:46 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<20210316124356.443@kylheku.com>
In reply to#29429
On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
> On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
>> This means that your machinery is susceptible to obvious methods of
>> attack which conceal the Halts function from the global machinery.
>> 
>> For instance, H_Hat could have a simulator of its own:
>> 
>>    void H_Hat(u32 P)
>>    {
>>       u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
>> 
>>       if (Input_Halts)
>>          foo: goto foo;
>>    }
>> 
>
> If you understand that nothing at all can possibly execute at all unless 
> the halt decider simulates it you should see that this will not work.

How will it not work? H_Hat_Simulate is just a big subroutine
that the author of H_Hat has provided. It has nothing to do with the
surrounding simulator. The simulator obligingly runs that subroutine.
That subroutine traces the execution of Halts using its own virtual
CPU state, represented as objects and variables.

Your simulator just sees that subroutine going in circles, not even
realizing that Halts is being executed by it.

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

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


#29438 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 14:55 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<4s2dnWAloaKkkMz9nZ2dnUU7-WfNnZ2d@giganews.com>
In reply to#29434
On 3/16/2021 2:46 PM, Kaz Kylheku wrote:
> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>> On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
>>> This means that your machinery is susceptible to obvious methods of
>>> attack which conceal the Halts function from the global machinery.
>>>
>>> For instance, H_Hat could have a simulator of its own:
>>>
>>>     void H_Hat(u32 P)
>>>     {
>>>        u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
>>>
>>>        if (Input_Halts)
>>>           foo: goto foo;
>>>     }
>>>
>>
>> If you understand that nothing at all can possibly execute at all unless
>> the halt decider simulates it you should see that this will not work.
> 
> How will it not work? H_Hat_Simulate is just a big subroutine
> that the author of H_Hat has provided. It has nothing to do with the
> surrounding simulator. The simulator obligingly runs that subroutine.
> That subroutine traces the execution of Halts using its own virtual
> CPU state, represented as objects and variables.
> 
> Your simulator just sees that subroutine going in circles, not even
> realizing that Halts is being executed by it.
> 

All code that is not a part of the UTM / halt decider is only simulated 
by the UTM / halt decider,

thus the complete execution trace of H_Hat_Simulate(Halts, P, P) is seen 
by the UTM / halt decider.

-- 
Copyright 2021 Pete Olcott

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

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


#29443 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-16 20:11 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<20210316131058.454@kylheku.com>
In reply to#29438
On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
> On 3/16/2021 2:46 PM, Kaz Kylheku wrote:
>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
>>>> This means that your machinery is susceptible to obvious methods of
>>>> attack which conceal the Halts function from the global machinery.
>>>>
>>>> For instance, H_Hat could have a simulator of its own:
>>>>
>>>>     void H_Hat(u32 P)
>>>>     {
>>>>        u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
>>>>
>>>>        if (Input_Halts)
>>>>           foo: goto foo;
>>>>     }
>>>>
>>>
>>> If you understand that nothing at all can possibly execute at all unless
>>> the halt decider simulates it you should see that this will not work.
>> 
>> How will it not work? H_Hat_Simulate is just a big subroutine
>> that the author of H_Hat has provided. It has nothing to do with the
>> surrounding simulator. The simulator obligingly runs that subroutine.
>> That subroutine traces the execution of Halts using its own virtual
>> CPU state, represented as objects and variables.
>> 
>> Your simulator just sees that subroutine going in circles, not even
>> realizing that Halts is being executed by it.
>> 
>
> All code that is not a part of the UTM / halt decider is only simulated 
> by the UTM / halt decider,
>
> thus the complete execution trace of H_Hat_Simulate(Halts, P, P) is seen 
> by the UTM / halt decider.

Correct. And how do you think that helps you? You don't know whether
that excution trace is calling Halts or rendering a game of Pac Man in a
virtual frame buffer.

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

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


#29447 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 15:21 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<xI2dnQvsRfvfjsz9nZ2dnUU7-b3NnZ2d@giganews.com>
In reply to#29443
On 3/16/2021 3:11 PM, Kaz Kylheku wrote:
> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>> On 3/16/2021 2:46 PM, Kaz Kylheku wrote:
>>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
>>>>> This means that your machinery is susceptible to obvious methods of
>>>>> attack which conceal the Halts function from the global machinery.
>>>>>
>>>>> For instance, H_Hat could have a simulator of its own:
>>>>>
>>>>>      void H_Hat(u32 P)
>>>>>      {
>>>>>         u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
>>>>>
>>>>>         if (Input_Halts)
>>>>>            foo: goto foo;
>>>>>      }
>>>>>
>>>>
>>>> If you understand that nothing at all can possibly execute at all unless
>>>> the halt decider simulates it you should see that this will not work.
>>>
>>> How will it not work? H_Hat_Simulate is just a big subroutine
>>> that the author of H_Hat has provided. It has nothing to do with the
>>> surrounding simulator. The simulator obligingly runs that subroutine.
>>> That subroutine traces the execution of Halts using its own virtual
>>> CPU state, represented as objects and variables.
>>>
>>> Your simulator just sees that subroutine going in circles, not even
>>> realizing that Halts is being executed by it.
>>>
>>
>> All code that is not a part of the UTM / halt decider is only simulated
>> by the UTM / halt decider,
>>
>> thus the complete execution trace of H_Hat_Simulate(Halts, P, P) is seen
>> by the UTM / halt decider.
> 
> Correct. And how do you think that helps you? You don't know whether
> that excution trace is calling Halts or rendering a game of Pac Man in a
> virtual frame buffer.
> 

Since TMs have no direct memory addressing I have no idea how a UTM 
knows which location on its type to begin simulating, maybe it is psychic?

For a machines with direct memory addressing different machine addresses 
specify different functionality.

-- 
Copyright 2021 Pete Olcott

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

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


#29450 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-16 20:27 +0000
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<20210316132433.386@kylheku.com>
In reply to#29447
On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
> On 3/16/2021 3:11 PM, Kaz Kylheku wrote:
>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/16/2021 2:46 PM, Kaz Kylheku wrote:
>>>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
>>>>>> This means that your machinery is susceptible to obvious methods of
>>>>>> attack which conceal the Halts function from the global machinery.
>>>>>>
>>>>>> For instance, H_Hat could have a simulator of its own:
>>>>>>
>>>>>>      void H_Hat(u32 P)
>>>>>>      {
>>>>>>         u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
>>>>>>
>>>>>>         if (Input_Halts)
>>>>>>            foo: goto foo;
>>>>>>      }
>>>>>>
>>>>>
>>>>> If you understand that nothing at all can possibly execute at all unless
>>>>> the halt decider simulates it you should see that this will not work.
>>>>
>>>> How will it not work? H_Hat_Simulate is just a big subroutine
>>>> that the author of H_Hat has provided. It has nothing to do with the
>>>> surrounding simulator. The simulator obligingly runs that subroutine.
>>>> That subroutine traces the execution of Halts using its own virtual
>>>> CPU state, represented as objects and variables.
>>>>
>>>> Your simulator just sees that subroutine going in circles, not even
>>>> realizing that Halts is being executed by it.
>>>>
>>>
>>> All code that is not a part of the UTM / halt decider is only simulated
>>> by the UTM / halt decider,
>>>
>>> thus the complete execution trace of H_Hat_Simulate(Halts, P, P) is seen
>>> by the UTM / halt decider.
>> 
>> Correct. And how do you think that helps you? You don't know whether
>> that excution trace is calling Halts or rendering a game of Pac Man in a
>> virtual frame buffer.
>> 
>
> Since TMs have no direct memory addressing I have no idea how a UTM 
> knows which location on its type to begin simulating, maybe it is psychic?

I don't see how your present babble is connected any more to the above
debate.

In H_Hat_Simulate(Halts, P, P), Halts is a pointer expression lifting
the address of Halts. The simulator initializes itself to start
executing that, and prepares P and P in the argument space. Then it
steps through the instructions begining at Halts.

Your "UTM" will not realize that Halts is being called; it's simulating
the execution of H_Hat_Simulate.

You would have to write additional code to fight this subterfuge.

It's an eternal arms race, in which H_Hat always has the last word.

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

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


#29454 — Re: Refuting the halting problem proofs with fully operational code (It is not that hard.)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-16 16:19 -0500
SubjectRe: Refuting the halting problem proofs with fully operational code (It is not that hard.)
Message-ID<Yp6dnZBQn8JLvcz9nZ2dnUU7-bWdnZ2d@giganews.com>
In reply to#29450
On 3/16/2021 3:27 PM, Kaz Kylheku wrote:
> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>> On 3/16/2021 3:11 PM, Kaz Kylheku wrote:
>>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/16/2021 2:46 PM, Kaz Kylheku wrote:
>>>>> On 2021-03-16, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 3/16/2021 1:38 PM, Kaz Kylheku wrote:
>>>>>>> This means that your machinery is susceptible to obvious methods of
>>>>>>> attack which conceal the Halts function from the global machinery.
>>>>>>>
>>>>>>> For instance, H_Hat could have a simulator of its own:
>>>>>>>
>>>>>>>       void H_Hat(u32 P)
>>>>>>>       {
>>>>>>>          u32 Input_Halts = H_Hat_Simulate(Halts, P, P);
>>>>>>>
>>>>>>>          if (Input_Halts)
>>>>>>>             foo: goto foo;
>>>>>>>       }
>>>>>>>
>>>>>>
>>>>>> If you understand that nothing at all can possibly execute at all unless
>>>>>> the halt decider simulates it you should see that this will not work.
>>>>>
>>>>> How will it not work? H_Hat_Simulate is just a big subroutine
>>>>> that the author of H_Hat has provided. It has nothing to do with the
>>>>> surrounding simulator. The simulator obligingly runs that subroutine.
>>>>> That subroutine traces the execution of Halts using its own virtual
>>>>> CPU state, represented as objects and variables.
>>>>>
>>>>> Your simulator just sees that subroutine going in circles, not even
>>>>> realizing that Halts is being executed by it.
>>>>>
>>>>
>>>> All code that is not a part of the UTM / halt decider is only simulated
>>>> by the UTM / halt decider,
>>>>
>>>> thus the complete execution trace of H_Hat_Simulate(Halts, P, P) is seen
>>>> by the UTM / halt decider.
>>>
>>> Correct. And how do you think that helps you? You don't know whether
>>> that excution trace is calling Halts or rendering a game of Pac Man in a
>>> virtual frame buffer.
>>>
>>
>> Since TMs have no direct memory addressing I have no idea how a UTM
>> knows which location on its type to begin simulating, maybe it is psychic?
> 
> I don't see how your present babble is connected any more to the above
> debate.
> 
> In H_Hat_Simulate(Halts, P, P), Halts is a pointer expression lifting
> the address of Halts. The simulator initializes itself to start
> executing that, and prepares P and P in the argument space. Then it
> steps through the instructions begining at Halts.
> 
> Your "UTM" will not realize that Halts is being called; it's simulating
> the execution of H_Hat_Simulate.

My UTM "sees" EVERYTHING and it knows its own machine address.


-- 
Copyright 2021 Pete Olcott

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

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


Page 10 of 23 — ← Prev page 1 … 8 9 [10] 11 12 … 23  Next page →

Back to top | Article view | comp.theory


csiph-web