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


Groups > comp.theory > #39388 > unrolled thread

Why do theory of computation problems require pure functions?

Started byolcott <NoOne@NoWhere.com>
First post2021-09-17 21:40 -0500
Last post2021-09-19 23:11 +0100
Articles 20 on this page of 243 — 10 participants

Back to article view | Back to comp.theory


Contents

  Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-17 21:40 -0500
    Re: Why do theory of computation problems require pure functions? "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-09-17 21:48 -0700
    Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-17 22:50 -0600
      Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 00:02 -0600
        Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 00:13 -0600
          Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 00:29 -0600
      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 08:54 -0500
        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 10:43 -0400
          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 09:49 -0500
            Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 09:02 -0600
              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:13 -0500
              Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:23 -0400
                Re: Why do theory of computation problems require pure functions? olcott <polcott2@gmail.com> - 2021-09-18 10:28 -0500
                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:42 -0400
                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:51 -0500
                      Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 12:00 -0400
                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:34 -0500
                Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:29 -0600
                  Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 11:31 -0600
                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 12:47 -0500
                      Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:34 -0400
                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:45 -0500
                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:06 -0400
                            Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 15:20 -0500
                              Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 21:46 +0100
                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 16:06 -0500
                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:14 -0400
                                  Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:58 +0100
                              Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:04 -0400
            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:13 -0400
              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:19 -0500
                Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:25 -0400
                  Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:37 -0500
                    Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:44 -0400
                      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:08 -0500
                        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 12:32 -0400
                          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 12:04 -0500
                            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:12 -0400
                              Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:02 +0100
                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 16:11 -0500
                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:30 -0400
                                  Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:03 +0100
        Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 09:01 -0600
          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:10 -0500
            Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:09 -0600
              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:36 -0500
    Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 07:14 -0400
    Re: Why do theory of computation problems require pure functions? Andy Walker <anw@cuboid.co.uk> - 2021-09-18 13:02 +0100
      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 08:57 -0500
        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 10:53 -0400
        Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 09:04 -0600
          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:17 -0500
            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:24 -0400
              Re: Why do theory of computation problems require pure functions? olcott <polcott2@gmail.com> - 2021-09-18 10:29 -0500
                Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:37 -0400
                  Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:39 -0500
                    Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:52 -0400
                      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:15 -0500
                        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 12:28 -0400
                          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:50 -0500
                            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:08 -0400
                              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:30 -0500
                                Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:52 -0400
                                  Re: Why do theory of computation problems require pure functions? [mow lawn] olcott <NoOne@NoWhere.com> - 2021-09-18 15:07 -0500
                                    Re: Why do theory of computation problems require pure functions? [mow lawn] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:55 -0400
                                      Re: Why do theory of computation problems require pure functions? [mow lawn] olcott <NoOne@NoWhere.com> - 2021-09-18 16:22 -0500
                                        Re: Why do theory of computation problems require pure functions? [mow lawn] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:38 -0400
                                          Re: Why do theory of computation problems require pure functions? [mow lawn] olcott <NoOne@NoWhere.com> - 2021-09-18 16:48 -0500
                                            Re: Why do theory of computation problems require pure functions? [mow lawn] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:01 -0400
                                              Re: Why do theory of computation problems require pure functions? [defeat Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 17:10 -0500
                                                Re: Why do theory of computation problems require pure functions? [defeat Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:26 -0400
                Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:55 +0100
            Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:10 -0600
              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:39 -0500
                Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:52 -0600
                  Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 12:08 -0500
                    Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:24 -0400
                      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:39 -0500
                        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:57 -0400
                          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 15:17 -0500
                            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:45 -0400
                              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 15:55 -0500
                                Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:11 -0400
                                Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 16:08 -0600
                                  Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:15 -0500
                                    Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 16:28 -0600
                                      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:32 -0500
                                        Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 16:55 -0600
                                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:58 -0400
                                          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:58 -0500
                                            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 19:09 -0400
                                              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 22:32 -0500
                                                Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 22:10 -0600
                                                  Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 22:19 -0600
                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 00:12 -0500
                                                      Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 00:00 -0600
                                                        Re: Why do theory of computation problems require pure functions?[ decidability decider citation ] olcott <NoOne@NoWhere.com> - 2021-09-19 06:56 -0500
                                                          Re: Why do theory of computation problems require pure functions?[ decidability decider citation ] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 08:05 -0600
                                                      Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 06:28 -0400
                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 09:34 -0500
                                                      Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 09:40 -0600
                                                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 10:46 -0500
                                                          Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 10:11 -0600
                                                            Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 11:39 -0500
                                                              Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 10:56 -0600
                                                                Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 12:07 -0500
                                                                  Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 11:25 -0600
                                                                    Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 12:54 -0500
                                                                      Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 12:24 -0600
                                                                        Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 13:33 -0500
                                                                          Re: Why do theory of computation problems require pure functions? [ PSR error] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 15:11 -0400
                                                                          Re: Why do theory of computation problems require pure functions? [ PSR error] Andy Walker <anw@cuboid.co.uk> - 2021-09-19 20:22 +0100
                                                                            Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 14:31 -0500
                                                                              Re: Why do theory of computation problems require pure functions? [ PSR error] Andy Walker <anw@cuboid.co.uk> - 2021-09-19 21:39 +0100
                                                                              Re: Why do theory of computation problems require pure functions? [ PSR error] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 18:59 -0400
                                                                          Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 13:23 -0600
                                                                            Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 14:37 -0500
                                                                              Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 13:45 -0600
                                                                              Re: Why do theory of computation problems require pure functions? [ PSR error] Andy Walker <anw@cuboid.co.uk> - 2021-09-19 21:33 +0100
                                                                  Re: Why do theory of computation problems require pure functions? [ PSR error] Jeff Barnett <jbb@notatt.com> - 2021-09-19 11:36 -0600
                                                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 13:37 -0400
                                                Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 06:31 -0400
                                            Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 17:14 -0600
                                          Re: Why do theory of computation problems require pure functions? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-18 16:11 -0700
                                            Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 17:16 -0600
                                              Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:52 +0100
                                            Re: Why do theory of computation problems require pure functions? [ Bingo !] olcott <NoOne@NoWhere.com> - 2021-09-18 18:17 -0500
                                              Re: Why do theory of computation problems require pure functions? [ Bingo !] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 19:20 -0400
                                            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 19:17 -0400
                                            Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:38 +0100
                                              Re: Why do theory of computation problems require pure functions? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-19 15:36 -0700
                                                Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 00:01 +0100
                                                  Re: Why do theory of computation problems require pure functions? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-19 16:23 -0700
                                                    Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 00:37 +0100
                                                      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 20:49 -0500
                                                        Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 10:54 +0100
                                                          Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 08:58 -0500
                                                            Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:02 -0400
                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 20:21 -0500
                                                      Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 11:00 +0100
                                                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 09:21 -0500
                                                          Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 23:06 +0100
                                                            Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 18:33 -0500
                                                              Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:00 +0100
                                                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 19:14 -0500
                                                                  Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:56 +0100
                                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 20:11 -0500
                                                                      Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 02:45 +0100
                                                                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 20:49 -0500
                                                                          Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:30 +0100
                                                                            Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 21:38 -0500
                                                                              Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:50 +0100
                                                                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 22:09 -0500
                                                                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:29 -0400
                                                                                  Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-22 01:44 +0100
                                                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-21 19:56 -0500
                                                                                      Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-22 23:58 +0100
                                                                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:05 -0400
                                                                            Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 22:13 -0500
                                                                              Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:35 -0400
                                                                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-21 10:21 -0500
                                                                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-21 22:12 -0400
                                                                      Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:16 -0400
                                                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:12 -0400
                                                                    Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-20 21:25 -0500
                                                                      Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:21 -0400
                                                                        Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-20 23:03 -0500
                                                                          Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 00:42 -0400
                                                                            Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-20 23:55 -0500
                                                                              Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 01:17 -0400
                                                                              Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 08:23 -0400
                                                                                Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 10:19 -0500
                                                                                  Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-21 11:51 -0600
                                                                                    Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 13:22 -0500
                                                                                      Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-21 12:43 -0600
                                                                                        Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 14:25 -0500
                                                                                          Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 21:33 -0400
                                                                                          Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-21 21:45 -0600
                                                                                            Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 23:05 -0500
                                                                                              Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-22 07:03 -0400
                                                                                              Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-22 14:46 -0600
                                                                                                Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-22 15:52 -0500
                                                                                                  Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-22 19:55 -0400
                                                                                      Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 19:23 -0400
                                                                                  Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 19:21 -0400
                                                                                    Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 18:56 -0500
                                                                                      Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 21:39 -0400
                                                                                      Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-22 08:01 -0400
                                                                            Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 10:16 -0500
                                                                              Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 22:10 -0400
                                                              Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 21:28 -0400
                                                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 20:33 -0500
                                                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:21 -0400
                                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 21:35 -0500
                                                                      Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:45 +0100
                                                                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 22:07 -0500
                                                                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:24 -0400
                                                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:04 -0400
                                                Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 20:18 -0500
                                                  Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 19:48 -0600
                                                    Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 21:00 -0500
                                                      Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 22:10 -0400
                                                      Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 20:20 -0600
                                                        Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 21:55 -0500
                                                          Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 22:16 -0600
                                                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 06:47 -0400
                                                            Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 09:22 -0500
                                                              Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:19 -0400
                                                  Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 22:15 -0400
                                        Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 18:21 -0600
                                          Re: Why do theory of computation problems require pure functions? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-09-19 03:15 +0100
                                    Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:29 -0400
                        Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:54 +0100
                          Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 17:02 -0500
                            Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:24 -0400
                              Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 17:29 -0500
                                Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:35 -0400
                            Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 00:43 +0100
                              Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-19 20:56 -0500
                                Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 22:22 -0400
                                Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 10:54 +0100
                                  Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-20 09:02 -0500
                                    Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 23:05 +0100
                                      Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-20 18:37 -0500
                                        Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:43 +0100
                                          Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-20 19:51 -0500
                                            Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:10 +0100
                                        Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:27 -0400
                          Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:32 -0400
                            Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:07 +0100
                Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 14:55 -0400
                  Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:06 -0500
                    Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:40 -0400
                      Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:52 -0500
                        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:15 -0400
            Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:51 +0100
              Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:00 -0500
                Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:26 +0100
      Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:45 +0100
        Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:51 -0400
          Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 23:24 +0100
        Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 16:57 -0500
          Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:11 +0100

Page 2 of 13 — ← Prev page 1 [2] 3 4 … 13  Next page →


#39446

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 15:34 -0400
Message-ID<obr1J.14738$IO1.10022@fx19.iad>
In reply to#39438
On 9/18/21 1:47 PM, olcott wrote:
> On 9/18/2021 12:31 PM, Jeff Barnett wrote:
>> On 9/18/2021 10:29 AM, André G. Isaak wrote:
>>> On 2021-09-18 09:23, Richard Damon wrote:
>>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>>> On 2021-09-18 08:49, olcott wrote:
>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>
>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>> execution trace by itself necessarily completely disqualify my system
>>>>>> from applying to the halting problem or not?
>>>>>>
>>>>>> a) Yes
>>>>>> b) No
>>>>>
>>>>> (a) Yes.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> That is incorrect, as it is quite possible to have a program that IS a
>>>> computation that still has a static variable, it a categorical No
>>>> can be
>>>> disproven.
>>>
>>> Perhaps a better way of putting it would be that if a function
>>> absolutely *requires* a static variable to achieve the desired
>>> result, then it does not represent a computation.
>>>
>>> I went with (a) because Olcott is incapable of processing answers
>>> which include anything resembling 'details' or 'nuance'. All answers
>>> must be completely black and white.
>>
>> I will point out that there was a serious flaw within one of the early
>> ALGOL specs: there was an ambiguity about when a "new" own binding
>> should be created. There was a famous little program that exhibited
>> different behavior depending on the interpretation used for owns.
>> Under one interpretation it computed a Legendre polynomial and a
>> Jacobi polynomial under another. (Note, I may have the polynomial
>> class names confused.) There where compilers implemented with each
>> interpretation and some discussions finally spotted the spec problem.
>>
>> A computation can be implemented with an own (= static) that is used
>> within it, e.g., a static for an instantiation of an object. N.B. That
>> a computation, by definition, cannot be reused or reentered. 
> 
> In order for H to be able to see that itself is being called in
> infinitely nested simulation it must be able to maintain the execution
> trace of its input that is not erased between nested simulations of
> itself. This is currently achieved using a variable that is directly
> stored in its own machine code. Every nested simulation of itself has
> access to this variable.

Just because you need to do it to detect something doesn't mean you are
allowed to do it.

In fact, the whole fact that H is being called recursively it a
dependency from the problem statement, as H^ is supposed to have a COPY
of the algorithm of H, not just call the same piece of code.

As has been pointed out, Turing Machines can't 'call' code in other
Turing machines, so the way you have implemented the operation itself is
a break of the computational equivalence needed for the problem.

This hasn't been a major point of argument, as you method fails for more
basic problems. It is a fact that having H identify that it is being
given a copy of itself to simulate to even allow this sort of test is an
impossible task. (The problem is that there are an infinite number of
ways to encode a given equivalence class of Turing Machines, so it is an
unsolvable pattern matching task),

> 
>> In fact, a computation can do virtually anything within its self. The
>> PO problem is that he insists on putting a non functioning boundary
>> around what he calls a computation.
>>
>> One other non novel observation: the use of any variable/binding is
>> equivalent in many senses to the use of a static/own. It all depends
>> on how you describe the rules/semantics of the program execution.
>>
>> In other words, "What we have been calling a computation must be like
>> a function in that its behavior is repeatable. It is not necessary
>> that its interior implementation be of purely functional parts; that
>> illusion must only be maintained in the description at its exterior
>> boundary."
> 
> 

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


#39449

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 14:45 -0500
Message-ID<FZGdnZ6kka1a3Nv8nZ2dnUU7-d_NnZ2d@giganews.com>
In reply to#39446
On 9/18/2021 2:34 PM, Richard Damon wrote:
> On 9/18/21 1:47 PM, olcott wrote:
>> On 9/18/2021 12:31 PM, Jeff Barnett wrote:
>>> On 9/18/2021 10:29 AM, André G. Isaak wrote:
>>>> On 2021-09-18 09:23, Richard Damon wrote:
>>>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>>>> On 2021-09-18 08:49, olcott wrote:
>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>
>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>> execution trace by itself necessarily completely disqualify my system
>>>>>>> from applying to the halting problem or not?
>>>>>>>
>>>>>>> a) Yes
>>>>>>> b) No
>>>>>>
>>>>>> (a) Yes.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> That is incorrect, as it is quite possible to have a program that IS a
>>>>> computation that still has a static variable, it a categorical No
>>>>> can be
>>>>> disproven.
>>>>
>>>> Perhaps a better way of putting it would be that if a function
>>>> absolutely *requires* a static variable to achieve the desired
>>>> result, then it does not represent a computation.
>>>>
>>>> I went with (a) because Olcott is incapable of processing answers
>>>> which include anything resembling 'details' or 'nuance'. All answers
>>>> must be completely black and white.
>>>
>>> I will point out that there was a serious flaw within one of the early
>>> ALGOL specs: there was an ambiguity about when a "new" own binding
>>> should be created. There was a famous little program that exhibited
>>> different behavior depending on the interpretation used for owns.
>>> Under one interpretation it computed a Legendre polynomial and a
>>> Jacobi polynomial under another. (Note, I may have the polynomial
>>> class names confused.) There where compilers implemented with each
>>> interpretation and some discussions finally spotted the spec problem.
>>>
>>> A computation can be implemented with an own (= static) that is used
>>> within it, e.g., a static for an instantiation of an object. N.B. That
>>> a computation, by definition, cannot be reused or reentered.
>>
>> In order for H to be able to see that itself is being called in
>> infinitely nested simulation it must be able to maintain the execution
>> trace of its input that is not erased between nested simulations of
>> itself. This is currently achieved using a variable that is directly
>> stored in its own machine code. Every nested simulation of itself has
>> access to this variable.
> 
> Just because you need to do it to detect something doesn't mean you are
> allowed to do it.
> 
> In fact, the whole fact that H is being called recursively it a
> dependency from the problem statement, as H^ is supposed to have a COPY
> of the algorithm of H, not just call the same piece of code.
> 
> As has been pointed out, Turing Machines can't 'call' code in other
> Turing machines, so the way you have implemented the operation itself is
> a break of the computational equivalence needed for the problem.
> 

Because a machine that recursively simulates itself is most closely 
modeled by a function that calls itself recursively I use the term call 
instead of the more precisely correct term simulate.

If it is not allowed for a machine to be able to keep track of its own 
recursive invocations then it would seem that the halting problem 
counter examples can be correctly refuted yet the means to refute them 
is simply not allowed.

> This hasn't been a major point of argument, as you method fails for more
> basic problems. It is a fact that having H identify that it is being
> given a copy of itself to simulate to even allow this sort of test is an
> impossible task. (The problem is that there are an infinite number of
> ways to encode a given equivalence class of Turing Machines, so it is an
> unsolvable pattern matching task),
> 
>>
>>> In fact, a computation can do virtually anything within its self. The
>>> PO problem is that he insists on putting a non functioning boundary
>>> around what he calls a computation.
>>>
>>> One other non novel observation: the use of any variable/binding is
>>> equivalent in many senses to the use of a static/own. It all depends
>>> on how you describe the rules/semantics of the program execution.
>>>
>>> In other words, "What we have been calling a computation must be like
>>> a function in that its behavior is repeatable. It is not necessary
>>> that its interior implementation be of purely functional parts; that
>>> illusion must only be maintained in the description at its exterior
>>> boundary."
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39453

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 16:06 -0400
Message-ID<CFr1J.79025$g81.11143@fx33.iad>
In reply to#39449
On 9/18/21 3:45 PM, olcott wrote:
> On 9/18/2021 2:34 PM, Richard Damon wrote:
>> On 9/18/21 1:47 PM, olcott wrote:
>>> On 9/18/2021 12:31 PM, Jeff Barnett wrote:
>>>> On 9/18/2021 10:29 AM, André G. Isaak wrote:
>>>>> On 2021-09-18 09:23, Richard Damon wrote:
>>>>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>>>>> On 2021-09-18 08:49, olcott wrote:
>>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>
>>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>>> execution trace by itself necessarily completely disqualify my
>>>>>>>> system
>>>>>>>> from applying to the halting problem or not?
>>>>>>>>
>>>>>>>> a) Yes
>>>>>>>> b) No
>>>>>>>
>>>>>>> (a) Yes.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> That is incorrect, as it is quite possible to have a program that
>>>>>> IS a
>>>>>> computation that still has a static variable, it a categorical No
>>>>>> can be
>>>>>> disproven.
>>>>>
>>>>> Perhaps a better way of putting it would be that if a function
>>>>> absolutely *requires* a static variable to achieve the desired
>>>>> result, then it does not represent a computation.
>>>>>
>>>>> I went with (a) because Olcott is incapable of processing answers
>>>>> which include anything resembling 'details' or 'nuance'. All answers
>>>>> must be completely black and white.
>>>>
>>>> I will point out that there was a serious flaw within one of the early
>>>> ALGOL specs: there was an ambiguity about when a "new" own binding
>>>> should be created. There was a famous little program that exhibited
>>>> different behavior depending on the interpretation used for owns.
>>>> Under one interpretation it computed a Legendre polynomial and a
>>>> Jacobi polynomial under another. (Note, I may have the polynomial
>>>> class names confused.) There where compilers implemented with each
>>>> interpretation and some discussions finally spotted the spec problem.
>>>>
>>>> A computation can be implemented with an own (= static) that is used
>>>> within it, e.g., a static for an instantiation of an object. N.B. That
>>>> a computation, by definition, cannot be reused or reentered.
>>>
>>> In order for H to be able to see that itself is being called in
>>> infinitely nested simulation it must be able to maintain the execution
>>> trace of its input that is not erased between nested simulations of
>>> itself. This is currently achieved using a variable that is directly
>>> stored in its own machine code. Every nested simulation of itself has
>>> access to this variable.
>>
>> Just because you need to do it to detect something doesn't mean you are
>> allowed to do it.
>>
>> In fact, the whole fact that H is being called recursively it a
>> dependency from the problem statement, as H^ is supposed to have a COPY
>> of the algorithm of H, not just call the same piece of code.
>>
>> As has been pointed out, Turing Machines can't 'call' code in other
>> Turing machines, so the way you have implemented the operation itself is
>> a break of the computational equivalence needed for the problem.
>>
> 
> Because a machine that recursively simulates itself is most closely
> modeled by a function that calls itself recursively I use the term call
> instead of the more precisely correct term simulate.

No, a machine that simulates itself is most closely modeled by a machine
that simulates itself.

After all, wasn't the WHOLE reason for using an x86 simulator was so you
could do actual simulation.

> 
> If it is not allowed for a machine to be able to keep track of its own
> recursive invocations then it would seem that the halting problem
> counter examples can be correctly refuted yet the means to refute them
> is simply not allowed.

Turing Machine do NOT have recursive invocations. They don't have a
'call stack' to implement that.  Recursive algorithms tend to be
translated into iterative methods when converted into Turing Machines.

Yes, you could build a Turing Machine that represents the computation
that your program here describes, (which would use other methods that
actual recusion to do that part, but the issue is that this then becomes
just a single monolithic machine, and NOT the H / H^ pairing as
described by Linz.

As I have said, you H, by the way you do its input, isn't the equivalent
of the machine H described by Linz. And here, that difference becomes
important. To match Linz, H needs to get its input machine from an
independent virtual address space from itself.

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


#39457

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 15:20 -0500
Message-ID<4dqdnWn4K8mO19v8nZ2dnUU7-d2dnZ2d@giganews.com>
In reply to#39453
On 9/18/2021 3:06 PM, Richard Damon wrote:
> On 9/18/21 3:45 PM, olcott wrote:
>> On 9/18/2021 2:34 PM, Richard Damon wrote:
>>> On 9/18/21 1:47 PM, olcott wrote:
>>>> On 9/18/2021 12:31 PM, Jeff Barnett wrote:
>>>>> On 9/18/2021 10:29 AM, André G. Isaak wrote:
>>>>>> On 2021-09-18 09:23, Richard Damon wrote:
>>>>>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>>>>>> On 2021-09-18 08:49, olcott wrote:
>>>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>>>> execution trace by itself necessarily completely disqualify my
>>>>>>>>> system
>>>>>>>>> from applying to the halting problem or not?
>>>>>>>>>
>>>>>>>>> a) Yes
>>>>>>>>> b) No
>>>>>>>>
>>>>>>>> (a) Yes.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> That is incorrect, as it is quite possible to have a program that
>>>>>>> IS a
>>>>>>> computation that still has a static variable, it a categorical No
>>>>>>> can be
>>>>>>> disproven.
>>>>>>
>>>>>> Perhaps a better way of putting it would be that if a function
>>>>>> absolutely *requires* a static variable to achieve the desired
>>>>>> result, then it does not represent a computation.
>>>>>>
>>>>>> I went with (a) because Olcott is incapable of processing answers
>>>>>> which include anything resembling 'details' or 'nuance'. All answers
>>>>>> must be completely black and white.
>>>>>
>>>>> I will point out that there was a serious flaw within one of the early
>>>>> ALGOL specs: there was an ambiguity about when a "new" own binding
>>>>> should be created. There was a famous little program that exhibited
>>>>> different behavior depending on the interpretation used for owns.
>>>>> Under one interpretation it computed a Legendre polynomial and a
>>>>> Jacobi polynomial under another. (Note, I may have the polynomial
>>>>> class names confused.) There where compilers implemented with each
>>>>> interpretation and some discussions finally spotted the spec problem.
>>>>>
>>>>> A computation can be implemented with an own (= static) that is used
>>>>> within it, e.g., a static for an instantiation of an object. N.B. That
>>>>> a computation, by definition, cannot be reused or reentered.
>>>>
>>>> In order for H to be able to see that itself is being called in
>>>> infinitely nested simulation it must be able to maintain the execution
>>>> trace of its input that is not erased between nested simulations of
>>>> itself. This is currently achieved using a variable that is directly
>>>> stored in its own machine code. Every nested simulation of itself has
>>>> access to this variable.
>>>
>>> Just because you need to do it to detect something doesn't mean you are
>>> allowed to do it.
>>>
>>> In fact, the whole fact that H is being called recursively it a
>>> dependency from the problem statement, as H^ is supposed to have a COPY
>>> of the algorithm of H, not just call the same piece of code.
>>>
>>> As has been pointed out, Turing Machines can't 'call' code in other
>>> Turing machines, so the way you have implemented the operation itself is
>>> a break of the computational equivalence needed for the problem.
>>>
>>
>> Because a machine that recursively simulates itself is most closely
>> modeled by a function that calls itself recursively I use the term call
>> instead of the more precisely correct term simulate.
> 
> No, a machine that simulates itself is most closely modeled by a machine
> that simulates itself.
> 
> After all, wasn't the WHOLE reason for using an x86 simulator was so you
> could do actual simulation.
> 
>>
>> If it is not allowed for a machine to be able to keep track of its own
>> recursive invocations then it would seem that the halting problem
>> counter examples can be correctly refuted yet the means to refute them
>> is simply not allowed.
> 
> Turing Machine do NOT have recursive invocations. They don't have a
> 'call stack' to implement that.  Recursive algorithms tend to be
> translated into iterative methods when converted into Turing Machines.
> 
> Yes, you could build a Turing Machine that represents the computation
> that your program here describes, (which would use other methods that
> actual recusion to do that part, but the issue is that this then becomes
> just a single monolithic machine, and NOT the H / H^ pairing as
> described by Linz.
> 
> As I have said, you H, by the way you do its input, isn't the equivalent
> of the machine H described by Linz. And here, that difference becomes
> important. To match Linz, H needs to get its input machine from an
> independent virtual address space from itself.
> 

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt

When the Linz H is a simulating halt decider then the exact Linz
Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.

-- 
Copyright 2021 Pete Olcott

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

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


#39459

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-18 21:46 +0100
Message-ID<87zgs9bohx.fsf@bsb.me.uk>
In reply to#39457
olcott <NoOne@NoWhere.com> writes:

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>
> When the Linz H is a simulating halt decider then the exact Linz
> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.

No TM meets Linz's specification for H, so "the Linz H" cannot be a
"simulating halt decider".

-- 
Ben.

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


#39464

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 16:06 -0500
Message-ID<vqGdnU06GcRPydv8nZ2dnUU7-dXNnZ2d@giganews.com>
In reply to#39459
On 9/18/2021 3:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> When the Linz H is a simulating halt decider then the exact Linz
>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.
> 
> No TM meets Linz's specification for H, so "the Linz H" cannot be a
> "simulating halt decider".
> 

The Linz conclusion does not apply to a simulating halt decider.
No one ever bothered to think this ALL THE WAY THROUGH before.
To think this 100% ALL THE WAY THROUGH it must actually be fulled 
encoded as working software.


-- 
Copyright 2021 Pete Olcott

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

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


#39467

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 17:14 -0400
Message-ID<mFs1J.75976$z%4.19678@fx37.iad>
In reply to#39464
On 9/18/21 5:06 PM, olcott wrote:
> On 9/18/2021 3:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>
>>> When the Linz H is a simulating halt decider then the exact Linz
>>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.
>>
>> No TM meets Linz's specification for H, so "the Linz H" cannot be a
>> "simulating halt decider".
>>
> 
> The Linz conclusion does not apply to a simulating halt decider.
> No one ever bothered to think this ALL THE WAY THROUGH before.
> To think this 100% ALL THE WAY THROUGH it must actually be fulled
> encoded as working software.
> 

What is the actual ERROR in the logic of Linz's proof that you claim exists.

What did he not take into account.

Your problem is that your H is not a computation as H1(P,P) returns a
different answer than H(P,P) inside of P, but you claim them to be
identical machines.

iIdentical machines given the same input must produce the same results.

Ergo, you claims are shown to be incorrect.

Either H1 and H are NOT actually the same computation, and thus P (Linz
H^) was formed incorrectly, or H/H1 is not actually a Computation, and
thus not the equivalent of a Turing Machine and thus not a possible H.

Linz H, the Correct Halt Decider, is still shown to not exists, not even
as a simulating Halt Decider.

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


#39572

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-19 22:58 +0100
Message-ID<87zgs88bxf.fsf@bsb.me.uk>
In reply to#39464
olcott <NoOne@NoWhere.com> writes:

> On 9/18/2021 3:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>
>>> When the Linz H is a simulating halt decider then the exact Linz
>>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.
>> No TM meets Linz's specification for H, so "the Linz H" cannot be a
>> "simulating halt decider".
>
> The Linz conclusion does not apply to a simulating halt decider.

Yes, it does.  There is a theorem that says so.  There are many
independent proofs of the theorem.  You have shown no flaw in any of
those proofs, let alone all of them.  You have not even read Linz's
"proper" proof and you refuse to look at others.  You don't get to say
you've done it with secret C code you won't post.

-- 
Ben.

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


#39463

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 17:04 -0400
Message-ID<qvs1J.41728$md6.31100@fx36.iad>
In reply to#39457
On 9/18/21 4:20 PM, olcott wrote:
> On 9/18/2021 3:06 PM, Richard Damon wrote:

>> Turing Machine do NOT have recursive invocations. They don't have a
>> 'call stack' to implement that.  Recursive algorithms tend to be
>> translated into iterative methods when converted into Turing Machines.
>>
>> Yes, you could build a Turing Machine that represents the computation
>> that your program here describes, (which would use other methods that
>> actual recusion to do that part, but the issue is that this then becomes
>> just a single monolithic machine, and NOT the H / H^ pairing as
>> described by Linz.
>>
>> As I have said, you H, by the way you do its input, isn't the equivalent
>> of the machine H described by Linz. And here, that difference becomes
>> important. To match Linz, H needs to get its input machine from an
>> independent virtual address space from itself.
>>
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> When the Linz H is a simulating halt decider then the exact Linz
> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.
> 

But recursive simulation is NOT recursive invocations.

And, if H is able to answer H <H^> <H^> then the decider in H needs to
know how to limit the recursion, so H^ <H^> won't be an infinite
recursion either.

Thus we can say that the logic from H.q0 ⊢* must either have an
algorithm that can somehow detect this form of reference and break out
of it so it can answer, or it doesn't in which case H won't answer the
question H <H^> <H^> and fail.

If H does go from H.q0 <H^> <H^> ⊢* H.qn to indicate that it decides
that <H^> <H^> represents a non-halting computation then we KNOW that

H^.q0 <H^>  ⊢*  H^.qx <H^> <H^>  ⊢* H^.qn which halts, due to the
equivalency of algorithm from H.q0 and H^.qx and the identical inputs.

Thus H was WRONG, it decided non-halting but the machine represented by
the input is Halting.

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


#39405

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 11:13 -0400
Message-ID<lmn1J.84222$jl2.75920@fx34.iad>
In reply to#39399
On 9/18/21 10:49 AM, olcott wrote:
> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>
>> On 9/18/21 9:54 AM, olcott wrote:
>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>> On 2021-09-17 20:40, olcott wrote:
>>>>> Why do theory of computation problems require pure functions?
>>>>
>>>> Because the theory of computation isn't about C or x86. It isn't about
>>>> computer programs at all, nor about modern computers. Just because
>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>> deal with the same set of phenomena. Remember that the theory of
>>>> computation developed before there even were digital computers or
>>>> programming languages.
>>>>
>>>> Computational theory is concerned with describing *mathematical*
>>>> functions, and all mathematical functions are pure functions. A
>>>> computation is a method for determining the value of the mathematical
>>>> function f(x) for a given x. A computable function is one for which it
>>>> is possible to construct a TM which, given an input string
>>>> representing x, will determine the value of f(x).
>>>>
>>>> You can write computer programs which perform computations, but the
>>>> majority of computer programs don't.
>>>>
>>>> If you really want to learn about the theory of computation, I'd
>>>> suggest that you forget about C or x86 assembly or any sort of
>>>> computer language altogether and focus on Turing Machines.
>>>>
>>>> And don't try to mentally translate anything you read about Turing
>>>> Machines into computer languages. Don't think about loop counters, or
>>>> calls, or machine addresses, because all of these things pertain to
>>>> computers and computer programming rather than computations and they
>>>> will get in the way of you actually understanding either turing
>>>> machines or the theory of computation more generally.
>>>>
>>>> André
>>>>
>>>
>>> I only need to know this for one reason.
>>>
>>> When my halt decider is examining the behavior of its input and the
>>> input calls this halt decider in infinite recursion it cannot keep track
>>> of the behavior of this input without having a single pseudo static
>>> variable that is directly embedded in its machine code.
>>>
>>> This pseudo static variable stores the ongoing execution trace. When the
>>> variable is an ordinary local variable it loses all of its data between
>>> each recursive simulation.
>>>
>>> It still seems to be a pure function of its input in that
>>> (1) The function return values are identical for identical arguments
>>>
>>
>> I think the key issue is that if you want to talk about the plain
>> behavior of C / x86 code, then you need to talk about the ACTUAL
>> behavior of that code, which means that the call to H within the
>> simulated machine needs to be seen as a call to H, and NOT some logical
>> transformation.
>>
>> If you want to do the transformation, your need to actually PROVE that
>> this transform is legitimate under the conditions you want to make it,
>> and that needs a very FORMAL argument based on accepted truths and
>> principles. Your 'argument' based on H not affecting P until after it
>> makes its decision so it can ignore its effect, is one of those
>> arguments that just seems 'obvious' but you haven't actually proved it.
>> You don't seem to uhderstand that nature of how to prove something like
>> this.
>>
>> 'Obvious' things can be wrong, like it seems obvious that the order you
>> add up a series shouldn't affect the result, even if the number of terms
>> in infinite, but there are simple proofs to show that for SOME infinite
>> sums, the order you take the terms can make a difference, dispite it
>> seeming contrary to the nature of addition (infinities break a lot of
>> common sense).
>>
>>
>> A key point about your 'static' variable problem. 
> 
> There is only a single question here, not the myriad of questions that
> you refer to.
> 
> Does my use of a single static variable that holds the ongoing execution
> trace by itself necessarily completely disqualify my system from
> applying to the halting problem or not?
> 
> a) Yes
> b) No

Error of the Complex Question, just like the question of "Have you
stopped lying about your Halt Decider?".

It isn't the existence of a static variable itself that might disqualify
your system for applying to the halting problem, but does the existence
of that variable, and the way that your program uses it mean that H is
not an actual Computation. The existence of the variable opens the door
to it being disqualified, but the actual disqualification needs more
information.

If EVERY call to H(P,I) for a given P and I returns the exact same
answer every time, then H is still a computation.

The key point here is that When H decides on the call H(P,P) and in that
simulation of P(P) there is a call to H(P,P) then the 'correct' answer
for H needs to take into account that this simulated WILL do exactly the
same thing as the H that is doing the simulation, so if the simulating H
is going to answer Non-Halting, the behavior of the simulated machine
will be based on that simulated H also returning that same answer. Yes,
H is not going to have simulated to that point of the simulated machines
execution, so the simulating H will not be able to see that result, but
that IS the behavior of the machine that it is simulating, and thus
affect what is the 'Right' answer for H to give.

> 
>> If H really WAS a real
>> simulator, then there is no issue with the static variable as only one
>> copy of H is actually execution, all the other copies are just
>> simulation, so the one variable holding the execution trace hold the
>> execution trace of the simulation that it is doing, and there is no
>> issue.
>>
>> The only way that the issue you describe becomes a real issue is if H
>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>> applies some sort of 'transform' to the execution, and you need to have
>> some very good proof that this transform is actually valid, and that the
>> resulting H, which passes data to embedded copies of itself, and thus
>> knows of stuff of its environment beyond what it is supposed to know is
>> actually the equivalent of the decider that doesn't do any of that
>> 'illegal' operations. My guess is that your H is actually NOT the
>> equivalent of such an actual computation and does actually behave
>> differently depending on execution environment, and thus fails to meet
>> the basic requirements.
>>
>> Remember, if the H inside H^ doesn't behave exactly identical to the H
>> that is deciding on that H^, then you aren't working on the right
>> definitions of the system.
>>
>> This seems to be one of your fundamental tripping point, and is one of
>> the issues with doing proofs like this in non-Turing Machine environment
>> (like C/x86 or even RASP) that 'code fragments' can be non-computations
>> and thus not the equivalent of a Turing Machine.
>>
> 
> 

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


#39408

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 10:19 -0500
Message-ID<Nc6dnYaBOsvxntv8nZ2dnUU7-QednZ2d@giganews.com>
In reply to#39405
On 9/18/2021 10:13 AM, Richard Damon wrote:
> On 9/18/21 10:49 AM, olcott wrote:
>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>
>>> On 9/18/21 9:54 AM, olcott wrote:
>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>> Why do theory of computation problems require pure functions?
>>>>>
>>>>> Because the theory of computation isn't about C or x86. It isn't about
>>>>> computer programs at all, nor about modern computers. Just because
>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>> computation developed before there even were digital computers or
>>>>> programming languages.
>>>>>
>>>>> Computational theory is concerned with describing *mathematical*
>>>>> functions, and all mathematical functions are pure functions. A
>>>>> computation is a method for determining the value of the mathematical
>>>>> function f(x) for a given x. A computable function is one for which it
>>>>> is possible to construct a TM which, given an input string
>>>>> representing x, will determine the value of f(x).
>>>>>
>>>>> You can write computer programs which perform computations, but the
>>>>> majority of computer programs don't.
>>>>>
>>>>> If you really want to learn about the theory of computation, I'd
>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>> computer language altogether and focus on Turing Machines.
>>>>>
>>>>> And don't try to mentally translate anything you read about Turing
>>>>> Machines into computer languages. Don't think about loop counters, or
>>>>> calls, or machine addresses, because all of these things pertain to
>>>>> computers and computer programming rather than computations and they
>>>>> will get in the way of you actually understanding either turing
>>>>> machines or the theory of computation more generally.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I only need to know this for one reason.
>>>>
>>>> When my halt decider is examining the behavior of its input and the
>>>> input calls this halt decider in infinite recursion it cannot keep track
>>>> of the behavior of this input without having a single pseudo static
>>>> variable that is directly embedded in its machine code.
>>>>
>>>> This pseudo static variable stores the ongoing execution trace. When the
>>>> variable is an ordinary local variable it loses all of its data between
>>>> each recursive simulation.
>>>>
>>>> It still seems to be a pure function of its input in that
>>>> (1) The function return values are identical for identical arguments
>>>>
>>>
>>> I think the key issue is that if you want to talk about the plain
>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>> behavior of that code, which means that the call to H within the
>>> simulated machine needs to be seen as a call to H, and NOT some logical
>>> transformation.
>>>
>>> If you want to do the transformation, your need to actually PROVE that
>>> this transform is legitimate under the conditions you want to make it,
>>> and that needs a very FORMAL argument based on accepted truths and
>>> principles. Your 'argument' based on H not affecting P until after it
>>> makes its decision so it can ignore its effect, is one of those
>>> arguments that just seems 'obvious' but you haven't actually proved it.
>>> You don't seem to uhderstand that nature of how to prove something like
>>> this.
>>>
>>> 'Obvious' things can be wrong, like it seems obvious that the order you
>>> add up a series shouldn't affect the result, even if the number of terms
>>> in infinite, but there are simple proofs to show that for SOME infinite
>>> sums, the order you take the terms can make a difference, dispite it
>>> seeming contrary to the nature of addition (infinities break a lot of
>>> common sense).
>>>
>>>
>>> A key point about your 'static' variable problem.
>>
>> There is only a single question here, not the myriad of questions that
>> you refer to.
>>
>> Does my use of a single static variable that holds the ongoing execution
>> trace by itself necessarily completely disqualify my system from
>> applying to the halting problem or not?
>>
>> a) Yes
>> b) No
> 
> Error of the Complex Question, just like the question of "Have you
> stopped lying about your Halt Decider?".
> 
> It isn't the existence of a static variable itself that might disqualify
> your system for applying to the halting problem,

André disagrees so one of you must be wrong.

>  but does the existence
> of that variable, and the way that your program uses it mean that H is
> not an actual Computation. The existence of the variable opens the door
> to it being disqualified, but the actual disqualification needs more
> information.
> 
> If EVERY call to H(P,I) for a given P and I returns the exact same
> answer every time, then H is still a computation.
> 
> The key point here is that When H decides on the call H(P,P) and in that
> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
> for H needs to take into account that this simulated WILL do exactly the
> same thing as the H that is doing the simulation, so if the simulating H
> is going to answer Non-Halting, the behavior of the simulated machine
> will be based on that simulated H also returning that same answer. Yes,
> H is not going to have simulated to that point of the simulated machines
> execution, so the simulating H will not be able to see that result, but
> that IS the behavior of the machine that it is simulating, and thus
> affect what is the 'Right' answer for H to give.
> 
>>
>>> If H really WAS a real
>>> simulator, then there is no issue with the static variable as only one
>>> copy of H is actually execution, all the other copies are just
>>> simulation, so the one variable holding the execution trace hold the
>>> execution trace of the simulation that it is doing, and there is no
>>> issue.
>>>
>>> The only way that the issue you describe becomes a real issue is if H
>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>> applies some sort of 'transform' to the execution, and you need to have
>>> some very good proof that this transform is actually valid, and that the
>>> resulting H, which passes data to embedded copies of itself, and thus
>>> knows of stuff of its environment beyond what it is supposed to know is
>>> actually the equivalent of the decider that doesn't do any of that
>>> 'illegal' operations. My guess is that your H is actually NOT the
>>> equivalent of such an actual computation and does actually behave
>>> differently depending on execution environment, and thus fails to meet
>>> the basic requirements.
>>>
>>> Remember, if the H inside H^ doesn't behave exactly identical to the H
>>> that is deciding on that H^, then you aren't working on the right
>>> definitions of the system.
>>>
>>> This seems to be one of your fundamental tripping point, and is one of
>>> the issues with doing proofs like this in non-Turing Machine environment
>>> (like C/x86 or even RASP) that 'code fragments' can be non-computations
>>> and thus not the equivalent of a Turing Machine.
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39411

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 11:25 -0400
Message-ID<Cxn1J.130331$o45.17922@fx46.iad>
In reply to#39408
On 9/18/21 11:19 AM, olcott wrote:
> On 9/18/2021 10:13 AM, Richard Damon wrote:
>> On 9/18/21 10:49 AM, olcott wrote:
>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>
>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>
>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>> about
>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>> computation developed before there even were digital computers or
>>>>>> programming languages.
>>>>>>
>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>> computation is a method for determining the value of the mathematical
>>>>>> function f(x) for a given x. A computable function is one for
>>>>>> which it
>>>>>> is possible to construct a TM which, given an input string
>>>>>> representing x, will determine the value of f(x).
>>>>>>
>>>>>> You can write computer programs which perform computations, but the
>>>>>> majority of computer programs don't.
>>>>>>
>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>
>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>> Machines into computer languages. Don't think about loop counters, or
>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>> computers and computer programming rather than computations and they
>>>>>> will get in the way of you actually understanding either turing
>>>>>> machines or the theory of computation more generally.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> I only need to know this for one reason.
>>>>>
>>>>> When my halt decider is examining the behavior of its input and the
>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>> track
>>>>> of the behavior of this input without having a single pseudo static
>>>>> variable that is directly embedded in its machine code.
>>>>>
>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>> When the
>>>>> variable is an ordinary local variable it loses all of its data
>>>>> between
>>>>> each recursive simulation.
>>>>>
>>>>> It still seems to be a pure function of its input in that
>>>>> (1) The function return values are identical for identical arguments
>>>>>
>>>>
>>>> I think the key issue is that if you want to talk about the plain
>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>> behavior of that code, which means that the call to H within the
>>>> simulated machine needs to be seen as a call to H, and NOT some logical
>>>> transformation.
>>>>
>>>> If you want to do the transformation, your need to actually PROVE that
>>>> this transform is legitimate under the conditions you want to make it,
>>>> and that needs a very FORMAL argument based on accepted truths and
>>>> principles. Your 'argument' based on H not affecting P until after it
>>>> makes its decision so it can ignore its effect, is one of those
>>>> arguments that just seems 'obvious' but you haven't actually proved it.
>>>> You don't seem to uhderstand that nature of how to prove something like
>>>> this.
>>>>
>>>> 'Obvious' things can be wrong, like it seems obvious that the order you
>>>> add up a series shouldn't affect the result, even if the number of
>>>> terms
>>>> in infinite, but there are simple proofs to show that for SOME infinite
>>>> sums, the order you take the terms can make a difference, dispite it
>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>> common sense).
>>>>
>>>>
>>>> A key point about your 'static' variable problem.
>>>
>>> There is only a single question here, not the myriad of questions that
>>> you refer to.
>>>
>>> Does my use of a single static variable that holds the ongoing execution
>>> trace by itself necessarily completely disqualify my system from
>>> applying to the halting problem or not?
>>>
>>> a) Yes
>>> b) No
>>
>> Error of the Complex Question, just like the question of "Have you
>> stopped lying about your Halt Decider?".
>>
>> It isn't the existence of a static variable itself that might disqualify
>> your system for applying to the halting problem,
> 
> André disagrees so one of you must be wrong.

Then take his answer and go away as you admit defeat.


> 
>>  but does the existence
>> of that variable, and the way that your program uses it mean that H is
>> not an actual Computation. The existence of the variable opens the door
>> to it being disqualified, but the actual disqualification needs more
>> information.
>>
>> If EVERY call to H(P,I) for a given P and I returns the exact same
>> answer every time, then H is still a computation.
>>
>> The key point here is that When H decides on the call H(P,P) and in that
>> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
>> for H needs to take into account that this simulated WILL do exactly the
>> same thing as the H that is doing the simulation, so if the simulating H
>> is going to answer Non-Halting, the behavior of the simulated machine
>> will be based on that simulated H also returning that same answer. Yes,
>> H is not going to have simulated to that point of the simulated machines
>> execution, so the simulating H will not be able to see that result, but
>> that IS the behavior of the machine that it is simulating, and thus
>> affect what is the 'Right' answer for H to give.
>>
>>>
>>>> If H really WAS a real
>>>> simulator, then there is no issue with the static variable as only one
>>>> copy of H is actually execution, all the other copies are just
>>>> simulation, so the one variable holding the execution trace hold the
>>>> execution trace of the simulation that it is doing, and there is no
>>>> issue.
>>>>
>>>> The only way that the issue you describe becomes a real issue is if H
>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>> applies some sort of 'transform' to the execution, and you need to have
>>>> some very good proof that this transform is actually valid, and that
>>>> the
>>>> resulting H, which passes data to embedded copies of itself, and thus
>>>> knows of stuff of its environment beyond what it is supposed to know is
>>>> actually the equivalent of the decider that doesn't do any of that
>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>> equivalent of such an actual computation and does actually behave
>>>> differently depending on execution environment, and thus fails to meet
>>>> the basic requirements.
>>>>
>>>> Remember, if the H inside H^ doesn't behave exactly identical to the H
>>>> that is deciding on that H^, then you aren't working on the right
>>>> definitions of the system.
>>>>
>>>> This seems to be one of your fundamental tripping point, and is one of
>>>> the issues with doing proofs like this in non-Turing Machine
>>>> environment
>>>> (like C/x86 or even RASP) that 'code fragments' can be non-computations
>>>> and thus not the equivalent of a Turing Machine.
>>>>
>>>
>>>
>>
> 
> 

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


#39415

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 10:37 -0500
Message-ID<goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>
In reply to#39411
On 9/18/2021 10:25 AM, Richard Damon wrote:
> On 9/18/21 11:19 AM, olcott wrote:
>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>> On 9/18/21 10:49 AM, olcott wrote:
>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>
>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>
>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>> about
>>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>> computation developed before there even were digital computers or
>>>>>>> programming languages.
>>>>>>>
>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>> computation is a method for determining the value of the mathematical
>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>> which it
>>>>>>> is possible to construct a TM which, given an input string
>>>>>>> representing x, will determine the value of f(x).
>>>>>>>
>>>>>>> You can write computer programs which perform computations, but the
>>>>>>> majority of computer programs don't.
>>>>>>>
>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>
>>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>>> Machines into computer languages. Don't think about loop counters, or
>>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>>> computers and computer programming rather than computations and they
>>>>>>> will get in the way of you actually understanding either turing
>>>>>>> machines or the theory of computation more generally.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> I only need to know this for one reason.
>>>>>>
>>>>>> When my halt decider is examining the behavior of its input and the
>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>> track
>>>>>> of the behavior of this input without having a single pseudo static
>>>>>> variable that is directly embedded in its machine code.
>>>>>>
>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>> When the
>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>> between
>>>>>> each recursive simulation.
>>>>>>
>>>>>> It still seems to be a pure function of its input in that
>>>>>> (1) The function return values are identical for identical arguments
>>>>>>
>>>>>
>>>>> I think the key issue is that if you want to talk about the plain
>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>> behavior of that code, which means that the call to H within the
>>>>> simulated machine needs to be seen as a call to H, and NOT some logical
>>>>> transformation.
>>>>>
>>>>> If you want to do the transformation, your need to actually PROVE that
>>>>> this transform is legitimate under the conditions you want to make it,
>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>> principles. Your 'argument' based on H not affecting P until after it
>>>>> makes its decision so it can ignore its effect, is one of those
>>>>> arguments that just seems 'obvious' but you haven't actually proved it.
>>>>> You don't seem to uhderstand that nature of how to prove something like
>>>>> this.
>>>>>
>>>>> 'Obvious' things can be wrong, like it seems obvious that the order you
>>>>> add up a series shouldn't affect the result, even if the number of
>>>>> terms
>>>>> in infinite, but there are simple proofs to show that for SOME infinite
>>>>> sums, the order you take the terms can make a difference, dispite it
>>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>>> common sense).
>>>>>
>>>>>
>>>>> A key point about your 'static' variable problem.
>>>>
>>>> There is only a single question here, not the myriad of questions that
>>>> you refer to.
>>>>
>>>> Does my use of a single static variable that holds the ongoing execution
>>>> trace by itself necessarily completely disqualify my system from
>>>> applying to the halting problem or not?
>>>>
>>>> a) Yes
>>>> b) No
>>>
>>> Error of the Complex Question, just like the question of "Have you
>>> stopped lying about your Halt Decider?".
>>>
>>> It isn't the existence of a static variable itself that might disqualify
>>> your system for applying to the halting problem,
>>
>> André disagrees so one of you must be wrong.
> 
> Then take his answer and go away as you admit defeat.
> 

That is not how categorically exhaustive reasoning works. Categorically 
exhaustive reasoning eliminates the possibility of the error of 
omission. It results in limited subject domain omniscience.

It only stops when
(1) A solution is found.
(2) No solution exist within omniscience.

> 
>>
>>>   but does the existence
>>> of that variable, and the way that your program uses it mean that H is
>>> not an actual Computation. The existence of the variable opens the door
>>> to it being disqualified, but the actual disqualification needs more
>>> information.
>>>
>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>> answer every time, then H is still a computation.
>>>
>>> The key point here is that When H decides on the call H(P,P) and in that
>>> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
>>> for H needs to take into account that this simulated WILL do exactly the
>>> same thing as the H that is doing the simulation, so if the simulating H
>>> is going to answer Non-Halting, the behavior of the simulated machine
>>> will be based on that simulated H also returning that same answer. Yes,
>>> H is not going to have simulated to that point of the simulated machines
>>> execution, so the simulating H will not be able to see that result, but
>>> that IS the behavior of the machine that it is simulating, and thus
>>> affect what is the 'Right' answer for H to give.
>>>
>>>>
>>>>> If H really WAS a real
>>>>> simulator, then there is no issue with the static variable as only one
>>>>> copy of H is actually execution, all the other copies are just
>>>>> simulation, so the one variable holding the execution trace hold the
>>>>> execution trace of the simulation that it is doing, and there is no
>>>>> issue.
>>>>>
>>>>> The only way that the issue you describe becomes a real issue is if H
>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>> applies some sort of 'transform' to the execution, and you need to have
>>>>> some very good proof that this transform is actually valid, and that
>>>>> the
>>>>> resulting H, which passes data to embedded copies of itself, and thus
>>>>> knows of stuff of its environment beyond what it is supposed to know is
>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>> equivalent of such an actual computation and does actually behave
>>>>> differently depending on execution environment, and thus fails to meet
>>>>> the basic requirements.
>>>>>
>>>>> Remember, if the H inside H^ doesn't behave exactly identical to the H
>>>>> that is deciding on that H^, then you aren't working on the right
>>>>> definitions of the system.
>>>>>
>>>>> This seems to be one of your fundamental tripping point, and is one of
>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>> environment
>>>>> (like C/x86 or even RASP) that 'code fragments' can be non-computations
>>>>> and thus not the equivalent of a Turing Machine.
>>>>>
>>>>
>>>>
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39418

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 11:44 -0400
Message-ID<gPn1J.36462$ol1.15837@fx42.iad>
In reply to#39415
On 9/18/21 11:37 AM, olcott wrote:
> On 9/18/2021 10:25 AM, Richard Damon wrote:
>> On 9/18/21 11:19 AM, olcott wrote:
>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>
>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>> about
>>>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>> computation developed before there even were digital computers or
>>>>>>>> programming languages.
>>>>>>>>
>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>> computation is a method for determining the value of the
>>>>>>>> mathematical
>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>> which it
>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>
>>>>>>>> You can write computer programs which perform computations, but the
>>>>>>>> majority of computer programs don't.
>>>>>>>>
>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>
>>>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>> counters, or
>>>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>>>> computers and computer programming rather than computations and
>>>>>>>> they
>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> I only need to know this for one reason.
>>>>>>>
>>>>>>> When my halt decider is examining the behavior of its input and the
>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>> track
>>>>>>> of the behavior of this input without having a single pseudo static
>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>
>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>> When the
>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>> between
>>>>>>> each recursive simulation.
>>>>>>>
>>>>>>> It still seems to be a pure function of its input in that
>>>>>>> (1) The function return values are identical for identical arguments
>>>>>>>
>>>>>>
>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>> behavior of that code, which means that the call to H within the
>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>> logical
>>>>>> transformation.
>>>>>>
>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>> that
>>>>>> this transform is legitimate under the conditions you want to make
>>>>>> it,
>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>> principles. Your 'argument' based on H not affecting P until after it
>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>> proved it.
>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>> like
>>>>>> this.
>>>>>>
>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>> order you
>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>> terms
>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>> infinite
>>>>>> sums, the order you take the terms can make a difference, dispite it
>>>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>>>> common sense).
>>>>>>
>>>>>>
>>>>>> A key point about your 'static' variable problem.
>>>>>
>>>>> There is only a single question here, not the myriad of questions that
>>>>> you refer to.
>>>>>
>>>>> Does my use of a single static variable that holds the ongoing
>>>>> execution
>>>>> trace by itself necessarily completely disqualify my system from
>>>>> applying to the halting problem or not?
>>>>>
>>>>> a) Yes
>>>>> b) No
>>>>
>>>> Error of the Complex Question, just like the question of "Have you
>>>> stopped lying about your Halt Decider?".
>>>>
>>>> It isn't the existence of a static variable itself that might
>>>> disqualify
>>>> your system for applying to the halting problem,
>>>
>>> André disagrees so one of you must be wrong.
>>
>> Then take his answer and go away as you admit defeat.
>>
> 
> That is not how categorically exhaustive reasoning works. Categorically
> exhaustive reasoning eliminates the possibility of the error of
> omission. It results in limited subject domain omniscience.
> 
> It only stops when
> (1) A solution is found.
> (2) No solution exist within omniscience.

But your question, as I explained, was not categorically exhaustive.

Have you stopped lying about your Halt Decider?

> 
>>
>>>
>>>>   but does the existence
>>>> of that variable, and the way that your program uses it mean that H is
>>>> not an actual Computation. The existence of the variable opens the door
>>>> to it being disqualified, but the actual disqualification needs more
>>>> information.
>>>>
>>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>>> answer every time, then H is still a computation.
>>>>
>>>> The key point here is that When H decides on the call H(P,P) and in
>>>> that
>>>> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
>>>> for H needs to take into account that this simulated WILL do exactly
>>>> the
>>>> same thing as the H that is doing the simulation, so if the
>>>> simulating H
>>>> is going to answer Non-Halting, the behavior of the simulated machine
>>>> will be based on that simulated H also returning that same answer. Yes,
>>>> H is not going to have simulated to that point of the simulated
>>>> machines
>>>> execution, so the simulating H will not be able to see that result, but
>>>> that IS the behavior of the machine that it is simulating, and thus
>>>> affect what is the 'Right' answer for H to give.
>>>>
>>>>>
>>>>>> If H really WAS a real
>>>>>> simulator, then there is no issue with the static variable as only
>>>>>> one
>>>>>> copy of H is actually execution, all the other copies are just
>>>>>> simulation, so the one variable holding the execution trace hold the
>>>>>> execution trace of the simulation that it is doing, and there is no
>>>>>> issue.
>>>>>>
>>>>>> The only way that the issue you describe becomes a real issue is if H
>>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>>> applies some sort of 'transform' to the execution, and you need to
>>>>>> have
>>>>>> some very good proof that this transform is actually valid, and that
>>>>>> the
>>>>>> resulting H, which passes data to embedded copies of itself, and thus
>>>>>> knows of stuff of its environment beyond what it is supposed to
>>>>>> know is
>>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>>> equivalent of such an actual computation and does actually behave
>>>>>> differently depending on execution environment, and thus fails to
>>>>>> meet
>>>>>> the basic requirements.
>>>>>>
>>>>>> Remember, if the H inside H^ doesn't behave exactly identical to
>>>>>> the H
>>>>>> that is deciding on that H^, then you aren't working on the right
>>>>>> definitions of the system.
>>>>>>
>>>>>> This seems to be one of your fundamental tripping point, and is
>>>>>> one of
>>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>>> environment
>>>>>> (like C/x86 or even RASP) that 'code fragments' can be
>>>>>> non-computations
>>>>>> and thus not the equivalent of a Turing Machine.
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
> 
> 

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


#39422

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 11:08 -0500
Message-ID<qYmdneD7KY-Pktv8nZ2dnUU7-YHNnZ2d@giganews.com>
In reply to#39418
On 9/18/2021 10:44 AM, Richard Damon wrote:
> On 9/18/21 11:37 AM, olcott wrote:
>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>> On 9/18/21 11:19 AM, olcott wrote:
>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>
>>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>>> about
>>>>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>>> computation developed before there even were digital computers or
>>>>>>>>> programming languages.
>>>>>>>>>
>>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>> mathematical
>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>> which it
>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>
>>>>>>>>> You can write computer programs which perform computations, but the
>>>>>>>>> majority of computer programs don't.
>>>>>>>>>
>>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>
>>>>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>> counters, or
>>>>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>> they
>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> I only need to know this for one reason.
>>>>>>>>
>>>>>>>> When my halt decider is examining the behavior of its input and the
>>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>>> track
>>>>>>>> of the behavior of this input without having a single pseudo static
>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>
>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>> When the
>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>> between
>>>>>>>> each recursive simulation.
>>>>>>>>
>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>> (1) The function return values are identical for identical arguments
>>>>>>>>
>>>>>>>
>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>> logical
>>>>>>> transformation.
>>>>>>>
>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>> that
>>>>>>> this transform is legitimate under the conditions you want to make
>>>>>>> it,
>>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>>> principles. Your 'argument' based on H not affecting P until after it
>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>> proved it.
>>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>>> like
>>>>>>> this.
>>>>>>>
>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>> order you
>>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>>> terms
>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>> infinite
>>>>>>> sums, the order you take the terms can make a difference, dispite it
>>>>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>>>>> common sense).
>>>>>>>
>>>>>>>
>>>>>>> A key point about your 'static' variable problem.
>>>>>>
>>>>>> There is only a single question here, not the myriad of questions that
>>>>>> you refer to.
>>>>>>
>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>> execution
>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>> applying to the halting problem or not?
>>>>>>
>>>>>> a) Yes
>>>>>> b) No
>>>>>
>>>>> Error of the Complex Question, just like the question of "Have you
>>>>> stopped lying about your Halt Decider?".
>>>>>
>>>>> It isn't the existence of a static variable itself that might
>>>>> disqualify
>>>>> your system for applying to the halting problem,
>>>>
>>>> André disagrees so one of you must be wrong.
>>>
>>> Then take his answer and go away as you admit defeat.
>>>
>>
>> That is not how categorically exhaustive reasoning works. Categorically
>> exhaustive reasoning eliminates the possibility of the error of
>> omission. It results in limited subject domain omniscience.
>>
>> It only stops when
>> (1) A solution is found.
>> (2) No solution exist within omniscience.
> 
> But your question, as I explained, was not categorically exhaustive.
> 

Polar (yes/no) questions only have {yes, no} answers.
{yes,no} completely exhausts the entire category of answers to polar 
(yes/no) questions.

> Have you stopped lying about your Halt Decider?

To the best of my knowledge I have only actually lied once in the last 
ten years. I lied to a close friend about a very hurtful truth to 
protect them from this very hurtful truth.

I do the best that I can to always tell the truth for two reasons:
(1) I have a very deep passion for mathematically formalizing the notion 
of analytical truth and this is the sole reason why I pursue:
   (a) The Halting Problem
   (b) Gödel's 1931 incompleteness theorem
   (c) The Tarski Undefinability theorem
   (d) The Liar Paradox

(2) I honestly believe that people intentionally spreading dangerous 
lies such as 2020 election fraud and covid-19 disinformation may be 
eternally incinerated:

Revelation 21:8 KJV ...all liars, shall have their part in the lake 
which burneth with fire and brimstone: which is the second death.

If we take that verse literally then to err on the safe side one should 
refrain from all lies great and small.


>>>
>>>>
>>>>>    but does the existence
>>>>> of that variable, and the way that your program uses it mean that H is
>>>>> not an actual Computation. The existence of the variable opens the door
>>>>> to it being disqualified, but the actual disqualification needs more
>>>>> information.
>>>>>
>>>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>>>> answer every time, then H is still a computation.
>>>>>
>>>>> The key point here is that When H decides on the call H(P,P) and in
>>>>> that
>>>>> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
>>>>> for H needs to take into account that this simulated WILL do exactly
>>>>> the
>>>>> same thing as the H that is doing the simulation, so if the
>>>>> simulating H
>>>>> is going to answer Non-Halting, the behavior of the simulated machine
>>>>> will be based on that simulated H also returning that same answer. Yes,
>>>>> H is not going to have simulated to that point of the simulated
>>>>> machines
>>>>> execution, so the simulating H will not be able to see that result, but
>>>>> that IS the behavior of the machine that it is simulating, and thus
>>>>> affect what is the 'Right' answer for H to give.
>>>>>
>>>>>>
>>>>>>> If H really WAS a real
>>>>>>> simulator, then there is no issue with the static variable as only
>>>>>>> one
>>>>>>> copy of H is actually execution, all the other copies are just
>>>>>>> simulation, so the one variable holding the execution trace hold the
>>>>>>> execution trace of the simulation that it is doing, and there is no
>>>>>>> issue.
>>>>>>>
>>>>>>> The only way that the issue you describe becomes a real issue is if H
>>>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>>>> applies some sort of 'transform' to the execution, and you need to
>>>>>>> have
>>>>>>> some very good proof that this transform is actually valid, and that
>>>>>>> the
>>>>>>> resulting H, which passes data to embedded copies of itself, and thus
>>>>>>> knows of stuff of its environment beyond what it is supposed to
>>>>>>> know is
>>>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>>>> equivalent of such an actual computation and does actually behave
>>>>>>> differently depending on execution environment, and thus fails to
>>>>>>> meet
>>>>>>> the basic requirements.
>>>>>>>
>>>>>>> Remember, if the H inside H^ doesn't behave exactly identical to
>>>>>>> the H
>>>>>>> that is deciding on that H^, then you aren't working on the right
>>>>>>> definitions of the system.
>>>>>>>
>>>>>>> This seems to be one of your fundamental tripping point, and is
>>>>>>> one of
>>>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>>>> environment
>>>>>>> (like C/x86 or even RASP) that 'code fragments' can be
>>>>>>> non-computations
>>>>>>> and thus not the equivalent of a Turing Machine.
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39429

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 12:32 -0400
Message-ID<Swo1J.31123$nR3.24966@fx38.iad>
In reply to#39422
On 9/18/21 12:08 PM, olcott wrote:
> On 9/18/2021 10:44 AM, Richard Damon wrote:
>> On 9/18/21 11:37 AM, olcott wrote:
>>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>>> On 9/18/21 11:19 AM, olcott wrote:
>>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>>
>>>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>>>> about
>>>>>>>>>> computer programs at all, nor about modern computers. Just
>>>>>>>>>> because
>>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean
>>>>>>>>>> they
>>>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>>>> computation developed before there even were digital computers or
>>>>>>>>>> programming languages.
>>>>>>>>>>
>>>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>>> mathematical
>>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>>> which it
>>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>>
>>>>>>>>>> You can write computer programs which perform computations,
>>>>>>>>>> but the
>>>>>>>>>> majority of computer programs don't.
>>>>>>>>>>
>>>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>>
>>>>>>>>>> And don't try to mentally translate anything you read about
>>>>>>>>>> Turing
>>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>>> counters, or
>>>>>>>>>> calls, or machine addresses, because all of these things
>>>>>>>>>> pertain to
>>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>>> they
>>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I only need to know this for one reason.
>>>>>>>>>
>>>>>>>>> When my halt decider is examining the behavior of its input and
>>>>>>>>> the
>>>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>>>> track
>>>>>>>>> of the behavior of this input without having a single pseudo
>>>>>>>>> static
>>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>>
>>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>>> When the
>>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>>> between
>>>>>>>>> each recursive simulation.
>>>>>>>>>
>>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>> arguments
>>>>>>>>>
>>>>>>>>
>>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>>> logical
>>>>>>>> transformation.
>>>>>>>>
>>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>>> that
>>>>>>>> this transform is legitimate under the conditions you want to make
>>>>>>>> it,
>>>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>>>> principles. Your 'argument' based on H not affecting P until
>>>>>>>> after it
>>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>>> proved it.
>>>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>>>> like
>>>>>>>> this.
>>>>>>>>
>>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>>> order you
>>>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>>>> terms
>>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>>> infinite
>>>>>>>> sums, the order you take the terms can make a difference,
>>>>>>>> dispite it
>>>>>>>> seeming contrary to the nature of addition (infinities break a
>>>>>>>> lot of
>>>>>>>> common sense).
>>>>>>>>
>>>>>>>>
>>>>>>>> A key point about your 'static' variable problem.
>>>>>>>
>>>>>>> There is only a single question here, not the myriad of questions
>>>>>>> that
>>>>>>> you refer to.
>>>>>>>
>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>> execution
>>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>>> applying to the halting problem or not?
>>>>>>>
>>>>>>> a) Yes
>>>>>>> b) No
>>>>>>
>>>>>> Error of the Complex Question, just like the question of "Have you
>>>>>> stopped lying about your Halt Decider?".
>>>>>>
>>>>>> It isn't the existence of a static variable itself that might
>>>>>> disqualify
>>>>>> your system for applying to the halting problem,
>>>>>
>>>>> André disagrees so one of you must be wrong.
>>>>
>>>> Then take his answer and go away as you admit defeat.
>>>>
>>>
>>> That is not how categorically exhaustive reasoning works. Categorically
>>> exhaustive reasoning eliminates the possibility of the error of
>>> omission. It results in limited subject domain omniscience.
>>>
>>> It only stops when
>>> (1) A solution is found.
>>> (2) No solution exist within omniscience.
>>
>> But your question, as I explained, was not categorically exhaustive.
>>
> 
> Polar (yes/no) questions only have {yes, no} answers.
> {yes,no} completely exhausts the entire category of answers to polar
> (yes/no) questions.

As long as you take the answer only for the question exactly as asked.

No, the presence of a static local variable doesn't IN ITSELF disqualify
a piece of code from being a Computation, but does greatly increase the
possibility that it is not.

> 
>> Have you stopped lying about your Halt Decider?
> 
> To the best of my knowledge I have only actually lied once in the last
> ten years. I lied to a close friend about a very hurtful truth to
> protect them from this very hurtful truth.

Since it has been reported that you claimed years ago that you did have
a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
and you have since retracted that statement, wasn't the first statement
a LIE.

> 
> I do the best that I can to always tell the truth for two reasons:
> (1) I have a very deep passion for mathematically formalizing the notion
> of analytical truth and this is the sole reason why I pursue:
>   (a) The Halting Problem
>   (b) Gödel's 1931 incompleteness theorem
>   (c) The Tarski Undefinability theorem
>   (d) The Liar Paradox
> 
> (2) I honestly believe that people intentionally spreading dangerous
> lies such as 2020 election fraud and covid-19 disinformation may be
> eternally incinerated:
> 
> Revelation 21:8 KJV ...all liars, shall have their part in the lake
> which burneth with fire and brimstone: which is the second death.
> 
> If we take that verse literally then to err on the safe side one should
> refrain from all lies great and small.
> 
> 
>>>>
>>>>>
>>>>>>    but does the existence
>>>>>> of that variable, and the way that your program uses it mean that
>>>>>> H is
>>>>>> not an actual Computation. The existence of the variable opens the
>>>>>> door
>>>>>> to it being disqualified, but the actual disqualification needs more
>>>>>> information.
>>>>>>
>>>>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>>>>> answer every time, then H is still a computation.
>>>>>>
>>>>>> The key point here is that When H decides on the call H(P,P) and in
>>>>>> that
>>>>>> simulation of P(P) there is a call to H(P,P) then the 'correct'
>>>>>> answer
>>>>>> for H needs to take into account that this simulated WILL do exactly
>>>>>> the
>>>>>> same thing as the H that is doing the simulation, so if the
>>>>>> simulating H
>>>>>> is going to answer Non-Halting, the behavior of the simulated machine
>>>>>> will be based on that simulated H also returning that same answer.
>>>>>> Yes,
>>>>>> H is not going to have simulated to that point of the simulated
>>>>>> machines
>>>>>> execution, so the simulating H will not be able to see that
>>>>>> result, but
>>>>>> that IS the behavior of the machine that it is simulating, and thus
>>>>>> affect what is the 'Right' answer for H to give.
>>>>>>
>>>>>>>
>>>>>>>> If H really WAS a real
>>>>>>>> simulator, then there is no issue with the static variable as only
>>>>>>>> one
>>>>>>>> copy of H is actually execution, all the other copies are just
>>>>>>>> simulation, so the one variable holding the execution trace hold
>>>>>>>> the
>>>>>>>> execution trace of the simulation that it is doing, and there is no
>>>>>>>> issue.
>>>>>>>>
>>>>>>>> The only way that the issue you describe becomes a real issue is
>>>>>>>> if H
>>>>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>>>>> applies some sort of 'transform' to the execution, and you need to
>>>>>>>> have
>>>>>>>> some very good proof that this transform is actually valid, and
>>>>>>>> that
>>>>>>>> the
>>>>>>>> resulting H, which passes data to embedded copies of itself, and
>>>>>>>> thus
>>>>>>>> knows of stuff of its environment beyond what it is supposed to
>>>>>>>> know is
>>>>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>>>>> equivalent of such an actual computation and does actually behave
>>>>>>>> differently depending on execution environment, and thus fails to
>>>>>>>> meet
>>>>>>>> the basic requirements.
>>>>>>>>
>>>>>>>> Remember, if the H inside H^ doesn't behave exactly identical to
>>>>>>>> the H
>>>>>>>> that is deciding on that H^, then you aren't working on the right
>>>>>>>> definitions of the system.
>>>>>>>>
>>>>>>>> This seems to be one of your fundamental tripping point, and is
>>>>>>>> one of
>>>>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>>>>> environment
>>>>>>>> (like C/x86 or even RASP) that 'code fragments' can be
>>>>>>>> non-computations
>>>>>>>> and thus not the equivalent of a Turing Machine.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
> 
> 

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


#39435

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 12:04 -0500
Message-ID<0fKdndonloWPgdv8nZ2dnUU7-KnNnZ2d@giganews.com>
In reply to#39429
On 9/18/2021 11:32 AM, Richard Damon wrote:
> On 9/18/21 12:08 PM, olcott wrote:
>> On 9/18/2021 10:44 AM, Richard Damon wrote:
>>> On 9/18/21 11:37 AM, olcott wrote:
>>>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>>>> On 9/18/21 11:19 AM, olcott wrote:
>>>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>>>
>>>>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>>>>> about
>>>>>>>>>>> computer programs at all, nor about modern computers. Just
>>>>>>>>>>> because
>>>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean
>>>>>>>>>>> they
>>>>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>>>>> computation developed before there even were digital computers or
>>>>>>>>>>> programming languages.
>>>>>>>>>>>
>>>>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>>>> mathematical
>>>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>>>> which it
>>>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>>>
>>>>>>>>>>> You can write computer programs which perform computations,
>>>>>>>>>>> but the
>>>>>>>>>>> majority of computer programs don't.
>>>>>>>>>>>
>>>>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>>>
>>>>>>>>>>> And don't try to mentally translate anything you read about
>>>>>>>>>>> Turing
>>>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>>>> counters, or
>>>>>>>>>>> calls, or machine addresses, because all of these things
>>>>>>>>>>> pertain to
>>>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>>>> they
>>>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I only need to know this for one reason.
>>>>>>>>>>
>>>>>>>>>> When my halt decider is examining the behavior of its input and
>>>>>>>>>> the
>>>>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>>>>> track
>>>>>>>>>> of the behavior of this input without having a single pseudo
>>>>>>>>>> static
>>>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>>>
>>>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>>>> When the
>>>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>>>> between
>>>>>>>>>> each recursive simulation.
>>>>>>>>>>
>>>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>> arguments
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>>>> logical
>>>>>>>>> transformation.
>>>>>>>>>
>>>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>>>> that
>>>>>>>>> this transform is legitimate under the conditions you want to make
>>>>>>>>> it,
>>>>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>>>>> principles. Your 'argument' based on H not affecting P until
>>>>>>>>> after it
>>>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>>>> proved it.
>>>>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>>>>> like
>>>>>>>>> this.
>>>>>>>>>
>>>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>>>> order you
>>>>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>>>>> terms
>>>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>>>> infinite
>>>>>>>>> sums, the order you take the terms can make a difference,
>>>>>>>>> dispite it
>>>>>>>>> seeming contrary to the nature of addition (infinities break a
>>>>>>>>> lot of
>>>>>>>>> common sense).
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> A key point about your 'static' variable problem.
>>>>>>>>
>>>>>>>> There is only a single question here, not the myriad of questions
>>>>>>>> that
>>>>>>>> you refer to.
>>>>>>>>
>>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>>> execution
>>>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>>>> applying to the halting problem or not?
>>>>>>>>
>>>>>>>> a) Yes
>>>>>>>> b) No
>>>>>>>
>>>>>>> Error of the Complex Question, just like the question of "Have you
>>>>>>> stopped lying about your Halt Decider?".
>>>>>>>
>>>>>>> It isn't the existence of a static variable itself that might
>>>>>>> disqualify
>>>>>>> your system for applying to the halting problem,
>>>>>>
>>>>>> André disagrees so one of you must be wrong.
>>>>>
>>>>> Then take his answer and go away as you admit defeat.
>>>>>
>>>>
>>>> That is not how categorically exhaustive reasoning works. Categorically
>>>> exhaustive reasoning eliminates the possibility of the error of
>>>> omission. It results in limited subject domain omniscience.
>>>>
>>>> It only stops when
>>>> (1) A solution is found.
>>>> (2) No solution exist within omniscience.
>>>
>>> But your question, as I explained, was not categorically exhaustive.
>>>
>>
>> Polar (yes/no) questions only have {yes, no} answers.
>> {yes,no} completely exhausts the entire category of answers to polar
>> (yes/no) questions.
> 
> As long as you take the answer only for the question exactly as asked.
> 
> No, the presence of a static local variable doesn't IN ITSELF disqualify
> a piece of code from being a Computation, but does greatly increase the
> possibility that it is not.
> 
>>
>>> Have you stopped lying about your Halt Decider?
>>
>> To the best of my knowledge I have only actually lied once in the last
>> ten years. I lied to a close friend about a very hurtful truth to
>> protect them from this very hurtful truth.
> 
> Since it has been reported that you claimed years ago that you did have
> a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
> and you have since retracted that statement, wasn't the first statement
> a LIE.
> 

Since the key element of the algorithm that correctly decides the halt 
status of the conventional impossible inputs was fully encoded in C and 
code written in C can be applied to Turing machines saying that I had a 
fully encoded Turing machine was poetic license.

Now that I know that Turing machine equivalence is a concept that does 
exist I can more accurately refer to my code as Turing equivalent. Even 
when I do this I must augment the common notion of Turing equivalence to 
only apply to the subset of computations that have all the memory that 
they need.

>>
>> I do the best that I can to always tell the truth for two reasons:
>> (1) I have a very deep passion for mathematically formalizing the notion
>> of analytical truth and this is the sole reason why I pursue:
>>    (a) The Halting Problem
>>    (b) Gödel's 1931 incompleteness theorem
>>    (c) The Tarski Undefinability theorem
>>    (d) The Liar Paradox
>>
>> (2) I honestly believe that people intentionally spreading dangerous
>> lies such as 2020 election fraud and covid-19 disinformation may be
>> eternally incinerated:
>>
>> Revelation 21:8 KJV ...all liars, shall have their part in the lake
>> which burneth with fire and brimstone: which is the second death.
>>
>> If we take that verse literally then to err on the safe side one should
>> refrain from all lies great and small.
>>
>>
>>>>>
>>>>>>
>>>>>>>     but does the existence
>>>>>>> of that variable, and the way that your program uses it mean that
>>>>>>> H is
>>>>>>> not an actual Computation. The existence of the variable opens the
>>>>>>> door
>>>>>>> to it being disqualified, but the actual disqualification needs more
>>>>>>> information.
>>>>>>>
>>>>>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>>>>>> answer every time, then H is still a computation.
>>>>>>>
>>>>>>> The key point here is that When H decides on the call H(P,P) and in
>>>>>>> that
>>>>>>> simulation of P(P) there is a call to H(P,P) then the 'correct'
>>>>>>> answer
>>>>>>> for H needs to take into account that this simulated WILL do exactly
>>>>>>> the
>>>>>>> same thing as the H that is doing the simulation, so if the
>>>>>>> simulating H
>>>>>>> is going to answer Non-Halting, the behavior of the simulated machine
>>>>>>> will be based on that simulated H also returning that same answer.
>>>>>>> Yes,
>>>>>>> H is not going to have simulated to that point of the simulated
>>>>>>> machines
>>>>>>> execution, so the simulating H will not be able to see that
>>>>>>> result, but
>>>>>>> that IS the behavior of the machine that it is simulating, and thus
>>>>>>> affect what is the 'Right' answer for H to give.
>>>>>>>
>>>>>>>>
>>>>>>>>> If H really WAS a real
>>>>>>>>> simulator, then there is no issue with the static variable as only
>>>>>>>>> one
>>>>>>>>> copy of H is actually execution, all the other copies are just
>>>>>>>>> simulation, so the one variable holding the execution trace hold
>>>>>>>>> the
>>>>>>>>> execution trace of the simulation that it is doing, and there is no
>>>>>>>>> issue.
>>>>>>>>>
>>>>>>>>> The only way that the issue you describe becomes a real issue is
>>>>>>>>> if H
>>>>>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>>>>>> applies some sort of 'transform' to the execution, and you need to
>>>>>>>>> have
>>>>>>>>> some very good proof that this transform is actually valid, and
>>>>>>>>> that
>>>>>>>>> the
>>>>>>>>> resulting H, which passes data to embedded copies of itself, and
>>>>>>>>> thus
>>>>>>>>> knows of stuff of its environment beyond what it is supposed to
>>>>>>>>> know is
>>>>>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>>>>>> equivalent of such an actual computation and does actually behave
>>>>>>>>> differently depending on execution environment, and thus fails to
>>>>>>>>> meet
>>>>>>>>> the basic requirements.
>>>>>>>>>
>>>>>>>>> Remember, if the H inside H^ doesn't behave exactly identical to
>>>>>>>>> the H
>>>>>>>>> that is deciding on that H^, then you aren't working on the right
>>>>>>>>> definitions of the system.
>>>>>>>>>
>>>>>>>>> This seems to be one of your fundamental tripping point, and is
>>>>>>>>> one of
>>>>>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>>>>>> environment
>>>>>>>>> (like C/x86 or even RASP) that 'code fragments' can be
>>>>>>>>> non-computations
>>>>>>>>> and thus not the equivalent of a Turing Machine.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39443

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-18 15:12 -0400
Message-ID<lSq1J.16549$nh7.11898@fx22.iad>
In reply to#39435
On 9/18/21 1:04 PM, olcott wrote:
> On 9/18/2021 11:32 AM, Richard Damon wrote:
>> On 9/18/21 12:08 PM, olcott wrote:
>>> On 9/18/2021 10:44 AM, Richard Damon wrote:
>>>> On 9/18/21 11:37 AM, olcott wrote:
>>>>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>>>>> On 9/18/21 11:19 AM, olcott wrote:
>>>>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>>>>
>>>>>>>>>>>> Because the theory of computation isn't about C or x86. It
>>>>>>>>>>>> isn't
>>>>>>>>>>>> about
>>>>>>>>>>>> computer programs at all, nor about modern computers. Just
>>>>>>>>>>>> because
>>>>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean
>>>>>>>>>>>> they
>>>>>>>>>>>> deal with the same set of phenomena. Remember that the
>>>>>>>>>>>> theory of
>>>>>>>>>>>> computation developed before there even were digital
>>>>>>>>>>>> computers or
>>>>>>>>>>>> programming languages.
>>>>>>>>>>>>
>>>>>>>>>>>> Computational theory is concerned with describing
>>>>>>>>>>>> *mathematical*
>>>>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>>>>> mathematical
>>>>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>>>>> which it
>>>>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>>>>
>>>>>>>>>>>> You can write computer programs which perform computations,
>>>>>>>>>>>> but the
>>>>>>>>>>>> majority of computer programs don't.
>>>>>>>>>>>>
>>>>>>>>>>>> If you really want to learn about the theory of computation,
>>>>>>>>>>>> I'd
>>>>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>>>>
>>>>>>>>>>>> And don't try to mentally translate anything you read about
>>>>>>>>>>>> Turing
>>>>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>>>>> counters, or
>>>>>>>>>>>> calls, or machine addresses, because all of these things
>>>>>>>>>>>> pertain to
>>>>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>>>>> they
>>>>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I only need to know this for one reason.
>>>>>>>>>>>
>>>>>>>>>>> When my halt decider is examining the behavior of its input and
>>>>>>>>>>> the
>>>>>>>>>>> input calls this halt decider in infinite recursion it cannot
>>>>>>>>>>> keep
>>>>>>>>>>> track
>>>>>>>>>>> of the behavior of this input without having a single pseudo
>>>>>>>>>>> static
>>>>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>>>>
>>>>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>>>>> When the
>>>>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>>>>> between
>>>>>>>>>>> each recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>>> arguments
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>>>>> logical
>>>>>>>>>> transformation.
>>>>>>>>>>
>>>>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>>>>> that
>>>>>>>>>> this transform is legitimate under the conditions you want to
>>>>>>>>>> make
>>>>>>>>>> it,
>>>>>>>>>> and that needs a very FORMAL argument based on accepted truths
>>>>>>>>>> and
>>>>>>>>>> principles. Your 'argument' based on H not affecting P until
>>>>>>>>>> after it
>>>>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>>>>> proved it.
>>>>>>>>>> You don't seem to uhderstand that nature of how to prove
>>>>>>>>>> something
>>>>>>>>>> like
>>>>>>>>>> this.
>>>>>>>>>>
>>>>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>>>>> order you
>>>>>>>>>> add up a series shouldn't affect the result, even if the
>>>>>>>>>> number of
>>>>>>>>>> terms
>>>>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>>>>> infinite
>>>>>>>>>> sums, the order you take the terms can make a difference,
>>>>>>>>>> dispite it
>>>>>>>>>> seeming contrary to the nature of addition (infinities break a
>>>>>>>>>> lot of
>>>>>>>>>> common sense).
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A key point about your 'static' variable problem.
>>>>>>>>>
>>>>>>>>> There is only a single question here, not the myriad of questions
>>>>>>>>> that
>>>>>>>>> you refer to.
>>>>>>>>>
>>>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>>>> execution
>>>>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>>>>> applying to the halting problem or not?
>>>>>>>>>
>>>>>>>>> a) Yes
>>>>>>>>> b) No
>>>>>>>>
>>>>>>>> Error of the Complex Question, just like the question of "Have you
>>>>>>>> stopped lying about your Halt Decider?".
>>>>>>>>
>>>>>>>> It isn't the existence of a static variable itself that might
>>>>>>>> disqualify
>>>>>>>> your system for applying to the halting problem,
>>>>>>>
>>>>>>> André disagrees so one of you must be wrong.
>>>>>>
>>>>>> Then take his answer and go away as you admit defeat.
>>>>>>
>>>>>
>>>>> That is not how categorically exhaustive reasoning works.
>>>>> Categorically
>>>>> exhaustive reasoning eliminates the possibility of the error of
>>>>> omission. It results in limited subject domain omniscience.
>>>>>
>>>>> It only stops when
>>>>> (1) A solution is found.
>>>>> (2) No solution exist within omniscience.
>>>>
>>>> But your question, as I explained, was not categorically exhaustive.
>>>>
>>>
>>> Polar (yes/no) questions only have {yes, no} answers.
>>> {yes,no} completely exhausts the entire category of answers to polar
>>> (yes/no) questions.
>>
>> As long as you take the answer only for the question exactly as asked.
>>
>> No, the presence of a static local variable doesn't IN ITSELF disqualify
>> a piece of code from being a Computation, but does greatly increase the
>> possibility that it is not.
>>
>>>
>>>> Have you stopped lying about your Halt Decider?
>>>
>>> To the best of my knowledge I have only actually lied once in the last
>>> ten years. I lied to a close friend about a very hurtful truth to
>>> protect them from this very hurtful truth.
>>
>> Since it has been reported that you claimed years ago that you did have
>> a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
>> and you have since retracted that statement, wasn't the first statement
>> a LIE.
>>
> 
> Since the key element of the algorithm that correctly decides the halt
> status of the conventional impossible inputs was fully encoded in C and
> code written in C can be applied to Turing machines saying that I had a
> fully encoded Turing machine was poetic license.

No, it is a LIE. Neither C code nor x86 code is an encoded Turing
Machine, any more than your dog spot is a cat.

Unless you have a C compiler that can generate Turing Machine Code, you
didn't have an encoded Turing Machine.

> 
> Now that I know that Turing machine equivalence is a concept that does
> exist I can more accurately refer to my code as Turing equivalent. Even
> when I do this I must augment the common notion of Turing equivalence to
> only apply to the subset of computations that have all the memory that
> they need.

So you lied out of ignorance, but it is still a lie.

You made a definitive claim that had a definitive answer, perhaps a
major part of the lie was that you implied that you actually knew what
you were talking about.

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


#39462

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-18 22:02 +0100
Message-ID<87tuihbns5.fsf@bsb.me.uk>
In reply to#39443
Richard Damon <Richard@Damon-Family.org> writes:

> On 9/18/21 1:04 PM, olcott wrote:
>> On 9/18/2021 11:32 AM, Richard Damon wrote:
>>> On 9/18/21 12:08 PM, olcott wrote:
>>>> On 9/18/2021 10:44 AM, Richard Damon wrote:

>>>>> Have you stopped lying about your Halt Decider?
>>>>
>>>> To the best of my knowledge I have only actually lied once in the last
>>>> ten years. I lied to a close friend about a very hurtful truth to
>>>> protect them from this very hurtful truth.
>>>
>>> Since it has been reported that you claimed years ago that you did have
>>> a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
>>> and you have since retracted that statement, wasn't the first statement
>>> a LIE.
>> 
>> Since the key element of the algorithm that correctly decides the halt
>> status of the conventional impossible inputs was fully encoded in C and
>> code written in C can be applied to Turing machines saying that I had a
>> fully encoded Turing machine was poetic license.
>
> No, it is a LIE. Neither C code nor x86 code is an encoded Turing
> Machine, any more than your dog spot is a cat.
>
> Unless you have a C compiler that can generate Turing Machine Code, you
> didn't have an encoded Turing Machine.
>
>> Now that I know that Turing machine equivalence is a concept that does
>> exist I can more accurately refer to my code as Turing equivalent. Even
>> when I do this I must augment the common notion of Turing equivalence to
>> only apply to the subset of computations that have all the memory that
>> they need.
>
> So you lied out of ignorance, but it is still a lie.

He calls it "poetic license", but it was simply a false claim made
during a particularly delusional episode.  The real dishonest lies were
in the cover-up.  If you read the exchanges at the time (mid Dec 2018)
it is abundantly clear that he was not taking about C code.  He really
did claim to have what everyone else understands by "an actual Turing
machine".  Even if we extend his recent defence of "poetic license" to
include the term "Universal Turing Machine", we'd have to believe that
he intended to write a C-code simulator and that that would take him a
couple of weeks!

Now I suspect the delusion was that he had a code sketch of something or
other that he was certain could be turned into "an actual Turing
machine", "fully encoded", "exactly and precisely as in Linz" (his
words) but when that hope evaporated, the backpedalling started.

-- 
Ben.

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


#39466

Fromolcott <NoOne@NoWhere.com>
Date2021-09-18 16:11 -0500
Message-ID<vuudnUs8zJ1tyNv8nZ2dnUU7-VfNnZ2d@giganews.com>
In reply to#39462
On 9/18/2021 4:02 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 9/18/21 1:04 PM, olcott wrote:
>>> On 9/18/2021 11:32 AM, Richard Damon wrote:
>>>> On 9/18/21 12:08 PM, olcott wrote:
>>>>> On 9/18/2021 10:44 AM, Richard Damon wrote:
> 
>>>>>> Have you stopped lying about your Halt Decider?
>>>>>
>>>>> To the best of my knowledge I have only actually lied once in the last
>>>>> ten years. I lied to a close friend about a very hurtful truth to
>>>>> protect them from this very hurtful truth.
>>>>
>>>> Since it has been reported that you claimed years ago that you did have
>>>> a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
>>>> and you have since retracted that statement, wasn't the first statement
>>>> a LIE.
>>>
>>> Since the key element of the algorithm that correctly decides the halt
>>> status of the conventional impossible inputs was fully encoded in C and
>>> code written in C can be applied to Turing machines saying that I had a
>>> fully encoded Turing machine was poetic license.
>>
>> No, it is a LIE. Neither C code nor x86 code is an encoded Turing
>> Machine, any more than your dog spot is a cat.
>>
>> Unless you have a C compiler that can generate Turing Machine Code, you
>> didn't have an encoded Turing Machine.
>>
>>> Now that I know that Turing machine equivalence is a concept that does
>>> exist I can more accurately refer to my code as Turing equivalent. Even
>>> when I do this I must augment the common notion of Turing equivalence to
>>> only apply to the subset of computations that have all the memory that
>>> they need.
>>
>> So you lied out of ignorance, but it is still a lie.
> 
> He calls it "poetic license", but it was simply a false claim made
> during a particularly delusional episode.  The real dishonest lies were
> in the cover-up.  If you read the exchanges at the time (mid Dec 2018)
> it is abundantly clear that he was not taking about C code.  He really
> did claim to have what everyone else understands by "an actual Turing
> machine".  Even if we extend his recent defence of "poetic license" to
> include the term "Universal Turing Machine", we'd have to believe that
> he intended to write a C-code simulator and that that would take him a
> couple of weeks!
> 
> Now I suspect the delusion was that he had a code sketch of something or
> other that he was certain could be turned into "an actual Turing
> machine", "fully encoded", "exactly and precisely as in Linz" (his
> words) but when that hope evaporated, the backpedalling started.
> 

None-the-less I do have fully operational C/x86 code now and the only 
actual issue with it is whether or not its use of two static local 
variables makes it not apply to the halting theorem.

If that is not any issue then this function refutes Rice's theorem.

int main()
{
   if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
     OutputString("Pathological self-reference error!");
}

-- 
Copyright 2021 Pete Olcott

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

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


Page 2 of 13 — ← Prev page 1 [2] 3 4 … 13  Next page →

Back to top | Article view | comp.theory


csiph-web