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


Groups > comp.theory > #39709 > unrolled thread

It looks like I can exactly duplicate the Linz proof in x86 without static data

Started byolcott <NoOne@NoWhere.com>
First post2021-09-21 21:25 -0500
Last post2021-09-27 20:12 -0400
Articles 20 on this page of 235 — 8 participants

Back to article view | Back to comp.theory


Contents

  It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 21:25 -0500
    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-21 22:51 -0400
      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 22:20 -0500
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 06:37 -0400
      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 13:46 -0500
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 19:19 -0400
          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 18:33 -0500
            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:02 -0400
              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 19:17 -0500
                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:54 -0400
                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:45 -0500
                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:37 -0400
                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] olcott <NoOne@NoWhere.com> - 2021-09-23 07:36 -0500
                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:22 -0400
                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] olcott <NoOne@NoWhere.com> - 2021-09-23 22:17 -0500
                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:28 -0400
                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] olcott <NoOne@NoWhere.com> - 2021-09-23 22:43 -0500
                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:58 -0400
                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 09:41 -0500
                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:00 -0400
                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 19:06 -0500
                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:17 -0400
                                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 19:54 -0500
                                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 21:30 -0400
                                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 20:57 -0500
                                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 22:33 -0400
                                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 22:38 -0500
                                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 06:07 -0400
                                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-25 09:15 -0500
                                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:15 -0400
                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:49 -0500
                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:13 -0400
                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:30 -0500
                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:50 -0400
                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 22:06 -0500
                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:57 -0400
                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 07:44 -0500
    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 22:28 -0500
    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-21 21:50 -0600
      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 23:08 -0500
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 07:45 -0400
          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 09:44 -0500
            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Mr Flibble <flibble@reddwarf.jmc> - 2021-09-22 18:03 +0100
              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 12:15 -0500
            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 19:42 -0400
              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 19:00 -0500
                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:28 -0400
                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:36 -0500
                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:27 -0400
                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:36 -0500
                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:56 -0400
                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 22:12 -0500
                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 00:11 -0400
                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 07:56 -0500
                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 19:23 -0400
                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 19:17 -0500
                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 19:24 -0600
                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 20:27 -0500
                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:42 -0400
                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:35 -0400
                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 21:14 -0600
                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 22:19 -0500
                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 21:26 -0600
                                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 22:34 -0500
                                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 00:04 -0400
                                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 09:36 -0500
                                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 22:18 +0100
                                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 16:52 -0500
                                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 00:28 +0100
                                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 19:04 -0500
                                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:14 -0400
                                                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 19:51 -0500
                                                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 21:32 -0400
                                                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 20:59 -0500
                                                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 22:35 -0400
                                                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 22:39 -0500
                                                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-25 06:11 -0400
                                                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-25 09:02 -0500
                                                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:17 -0400
                                                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Jeff Barnett <jbb@notatt.com> - 2021-09-24 21:02 -0600
                                                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 22:31 -0500
                                                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Jeff Barnett <jbb@notatt.com> - 2021-09-25 01:22 -0600
                                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 21:36 +0100
                                                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-25 15:50 -0500
                                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 16:56 -0500
                                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 00:23 +0100
                                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 22:49 -0600
                                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Jeff Barnett <jbb@notatt.com> - 2021-09-24 11:35 -0600
                                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 13:40 -0500
                                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-24 13:45 -0600
                                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 16:18 -0500
                                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-24 16:47 -0600
                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-24 05:51 -0700
                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 08:12 -0500
                                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ] olcott <polcott2@gmail.com> - 2021-09-24 08:27 -0500
                                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 22:42 +0100
      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 06:46 -0400
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-22 14:50 -0600
          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 16:01 -0500
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 16:02 -0500
    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-21 22:30 -0700
      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 02:05 -0500
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 06:36 -0400
        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 00:22 +0100
          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 18:35 -0500
            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 00:47 +0100
              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 19:11 -0500
                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:34 -0400
                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 02:52 +0100
                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:57 -0500
                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 03:04 +0100
                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:07 -0500
                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:31 -0400
                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 03:37 +0100
                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:56 -0500
                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:17 -0400
                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 23:02 -0500
                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 00:23 -0400
                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 08:10 -0500
                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 21:42 -0400
                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 21:56 -0500
                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:19 -0400
                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 02:26 +0100
                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:05 -0500
                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 03:23 +0100
                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:33 -0500
                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:59 -0400
                          Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 22:17 -0500
                            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:29 -0400
                              Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 23:09 -0500
                                Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 00:29 -0400
                                  Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 08:14 -0500
                                    Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 21:47 -0400
                                      Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 22:21 -0500
                                        Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:31 -0400
            Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:16 -0400
    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 13:28 -0500
      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 14:34 -0400
        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 13:39 -0500
          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 15:40 -0400
            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 19:07 -0500
              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 21:37 -0400
                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 20:59 -0500
                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 06:28 -0400
                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:25 -0500
                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 19:48 -0400
                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 19:00 -0500
                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 20:40 -0400
              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 19:40 -0600
                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 21:53 -0400
                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 21:03 -0500
                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 20:41 -0600
                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 21:56 -0500
                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 21:04 -0600
                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 22:16 -0500
                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 21:56 -0600
                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 23:31 -0500
                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-26 23:15 -0600
                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:19 -0500
                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 11:05 -0600
                                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 12:14 -0500
                                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 11:52 -0600
                                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 13:08 -0500
                                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 12:41 -0500
                                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 12:05 -0600
                                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 13:31 -0500
                                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 12:53 -0600
                                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 14:07 -0500
                                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-27 20:52 +0100
                                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 15:44 -0500
                                          It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-28 02:45 +0100
                                            Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) olcott <NoOne@NoWhere.com> - 2021-09-27 21:05 -0500
                                              Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) André G. Isaak <agisaak@gm.invalid> - 2021-09-27 20:40 -0600
                                                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 21:52 -0500
                                                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-27 21:14 -0600
                                                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 22:28 -0500
                                                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 23:35 -0400
                                                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 22:46 -0500
                                                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 06:27 -0400
                                                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 09:20 -0500
                                                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 18:58 -0400
                                                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-27 21:48 -0600
                                                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 23:09 -0500
                                                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-27 22:21 -0600
                                                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 23:34 -0500
                                                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 00:51 -0600
                                                                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 09:02 -0500
                                                                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 08:50 -0600
                                                                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 10:20 -0500
                                                                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 10:43 -0600
                                                                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 12:05 -0500
                                                                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 11:36 -0600
                                                                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 12:49 -0500
                                                                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 13:01 -0600
                                                                                Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 14:26 -0500
                                                                                  Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 14:38 -0600
                                                                                    Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 15:57 -0500
                                                                                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 16:09 -0600
                                                                                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 17:37 -0500
                                                                                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 19:02 -0400
                                                                                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 17:07 -0600
                                                                                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 18:28 -0500
                                                                                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 17:37 -0600
                                                                                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 21:59 -0400
                                                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 06:37 -0400
                                                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 09:25 -0500
                                              Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) Richard Damon <Richard@Damon-Family.org> - 2021-09-27 22:46 -0400
                                              Re: It's halting, but not as we know it Jim Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-28 16:00 +0100
                                                When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 10:25 -0500
                                                  Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 19:04 -0400
                                                  Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 02:14 +0100
                                                    Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 20:22 -0500
                                                      Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 22:03 -0400
                                                        Re: When an input TM description can never reach its final state it is non halting Jeff Barnett <jbb@notatt.com> - 2021-09-29 00:46 -0600
                                                      Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 23:44 +0100
                                              Re: It's halting, but not as we know it Jim Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-28 16:14 +0100
                                                Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 10:36 -0500
                                                  Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 19:09 -0400
                                                  Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 02:14 +0100
                                                    Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 20:20 -0500
                                                      Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 22:05 -0400
                                                      Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 23:17 +0100
                                                        Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-29 18:22 -0500
                                                          Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-29 20:23 -0400
                                                          Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-30 02:31 +0100
                                                            Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-29 20:37 -0500
                                                              Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-30 02:51 +0100
                                                              Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-29 21:53 -0400
                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 12:12 -0500
                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 06:43 -0400
                            Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:32 -0500
                              Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 20:09 -0400
                      Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 06:33 -0400
                        Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:27 -0500
                          Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 20:12 -0400

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


#39882

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 22:31 -0500
Message-ID<UMidnRJ2a4a2BdP8nZ2dnUU7-KnNnZ2d@giganews.com>
In reply to#39881
On 9/24/2021 10:02 PM, Jeff Barnett wrote:
> On 9/24/2021 6:51 PM, olcott wrote:
>> On 9/24/2021 7:14 PM, Richard Damon wrote:
>>> On 9/24/21 8:04 PM, olcott wrote:
>>>> On 9/24/2021 6:28 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/24/2021 4:18 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A turing machine program
>>>>>>> The author you are quoting is unreliable.  Turing machines /are/
>>>>>>> programs.  Turing machine programs are "The La Brea Tar Pits" of
>>>>>>> computability.
>>>>>>
>>>>>> He is the MIT author of a TM interpreter.
>>>>>
>>>>> Something my second-year undergraduates did as an exercise.  They 
>>>>> had a
>>>>> week (but then they had other coursework at the same time).
>>>>>
>>>>>> The key point is that one instruction of the TM language is a 
>>>>>> specific
>>>>>> 5 tuple.
>>>>>
>>>>> I thought the key point was the incorrect assertion that one can talk
>>>>> about addresses in relation to TMs?  But if the key point is just to
>>>>> attach an unhelpful name to a mathematical object, then it's inline 
>>>>> with
>>>>> what you usually do.
>>>>>
>>>>
>>>> The key point that I was addressing is whether or not I know how TM's
>>>> work. I do the 5-tuple state machine says it all.
>>>>
>>>
>>> Says you can parrot things you read.
>>>
>>> Can you actaully write a simple Turing Machine that does something a
>>> least slightly interesting?
>>>
>>
>> I have two patents on deterministic OCR state machines.
>> That conclusively proves that I could write a TM interpreter entirely 
>> on the basis of the definition of the 5-tuple.
> 
> I believe that I have reviewed those patents in this form a long time 
> ago. They showed a complete lack of understanding of the problem, bad 
> software engineering, and general idiocy. In fact you are a poster child 
> for the attitude that software patents are not worth the paper they are 
> issued on. The whole frecking world agrees with this assessment; two 
> patents and not a nickle of business. Right? Right! You can't program; 
> you can't write; you are a disaster at mathematics; you write programs 
> that don't work and don't do what you think or intend. Stick to 
> trolling; it's the only think in your life that you have succeeded at.
> 
> Note to any readers other than PO: The US Patent Office, it seems, made 
> a decision several decades ago to not do much review of software patent 
> applications. They did not have the expertise and the amount of existing 
> state of the art was overwhelming and not documented by patents. 
> Further, that which was to be patented was modified regularly unlike 
> manufactured hardware. They threw up their hands and basically said "If 
> you want to know whether this patent has merit and is novel, go to court 
> and sue to find out!" Are software patent approaches as dismal in other 
> parts of the world?

As you have proven any idiot can be a mere naysayer, they don't even 
have to be alive. A not very smart bot** could do as well as you have on 
your nay saying.   ** https://en.wikipedia.org/wiki/ELIZA

-- 
Copyright 2021 Pete Olcott

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

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


#39887

FromJeff Barnett <jbb@notatt.com>
Date2021-09-25 01:22 -0600
Message-ID<simiok$2m4$1@dont-email.me>
In reply to#39882
On 9/24/2021 9:31 PM, olcott wrote:
> On 9/24/2021 10:02 PM, Jeff Barnett wrote:
>> On 9/24/2021 6:51 PM, olcott wrote:
>>> On 9/24/2021 7:14 PM, Richard Damon wrote:
>>>> On 9/24/21 8:04 PM, olcott wrote:
>>>>> On 9/24/2021 6:28 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/24/2021 4:18 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> A turing machine program
>>>>>>>> The author you are quoting is unreliable.  Turing machines /are/
>>>>>>>> programs.  Turing machine programs are "The La Brea Tar Pits" of
>>>>>>>> computability.
>>>>>>>
>>>>>>> He is the MIT author of a TM interpreter.
>>>>>>
>>>>>> Something my second-year undergraduates did as an exercise.  They 
>>>>>> had a
>>>>>> week (but then they had other coursework at the same time).
>>>>>>
>>>>>>> The key point is that one instruction of the TM language is a 
>>>>>>> specific
>>>>>>> 5 tuple.
>>>>>>
>>>>>> I thought the key point was the incorrect assertion that one can talk
>>>>>> about addresses in relation to TMs?  But if the key point is just to
>>>>>> attach an unhelpful name to a mathematical object, then it's 
>>>>>> inline with
>>>>>> what you usually do.
>>>>>>
>>>>>
>>>>> The key point that I was addressing is whether or not I know how TM's
>>>>> work. I do the 5-tuple state machine says it all.
>>>>>
>>>>
>>>> Says you can parrot things you read.
>>>>
>>>> Can you actaully write a simple Turing Machine that does something a
>>>> least slightly interesting?
>>>>
>>>
>>> I have two patents on deterministic OCR state machines.
>>> That conclusively proves that I could write a TM interpreter entirely 
>>> on the basis of the definition of the 5-tuple.
>>
>> I believe that I have reviewed those patents in this form a long time 
>> ago. They showed a complete lack of understanding of the problem, bad 
>> software engineering, and general idiocy. In fact you are a poster 
>> child for the attitude that software patents are not worth the paper 
>> they are issued on. The whole frecking world agrees with this 
>> assessment; two patents and not a nickle of business. Right? Right! 
>> You can't program; you can't write; you are a disaster at mathematics; 
>> you write programs that don't work and don't do what you think or 
>> intend. Stick to trolling; it's the only think in your life that you 
>> have succeeded at.
>>
>> Note to any readers other than PO: The US Patent Office, it seems, 
>> made a decision several decades ago to not do much review of software 
>> patent applications. They did not have the expertise and the amount of 
>> existing state of the art was overwhelming and not documented by 
>> patents. Further, that which was to be patented was modified regularly 
>> unlike manufactured hardware. They threw up their hands and basically 
>> said "If you want to know whether this patent has merit and is novel, 
>> go to court and sue to find out!" Are software patent approaches as 
>> dismal in other parts of the world?
> 
> As you have proven any idiot can be a mere naysayer, they don't even 
> have to be alive. A not very smart bot** could do as well as you have on 
> your nay saying.   ** https://en.wikipedia.org/wiki/ELIZA

In fact we implemented a version of Eliza 50 or 60 years ago and one of 
my colleagues invited a Playboy reporter to see it. The publication of 
that story caused quite a mess and I got assigned to clean it up. I 
have, on many recent occasions, thought of you in that regards: My 
question was whether I could write an Eliza script that would emulate 
you. On the positive side was the complete lack of originality, lack of 
moderate or deep understanding, and the frequent recapitulation of only 
moderately related information. On the negative side was the problem of 
making pseudo relevant responses stupid enough to pass as from you.

Reminds me of a story from cleaning up the mess from the Playboy 
article. A husband and wife who were professors of clinical psychology 
at UCLA were invited to play with Eliza (our version was actually called 
the doctor). The invitation came from the fellow who actually moved the 
code into our Lisp. The couple were laughing with tears in their eyes 
and having a hell of a good time. (There were tears in my eyes too but 
for a different reason.) Meanwhile I was thinking we have just created 
two more people who think we can do something far beyond our actual 
capabilities. They kept saying. We must have this. We must have this.

Until one of them said "We must have this to show our students exactly 
how to not do Rogerian therapy." It was at that point that I know my 
problem hadn't gotten greater.

Now you should know my problem with doing you with the Doctor: A 
knowledgeable observer would say "I need this so I can show my students 
exactly how not to do computer science, mathematics, or scholarly debate."

By the way there was a book published called "Speech Understanding 
Systems: Final Report of a Study Group", 1973. Alan Newell is the main 
author and I'm a coauthor. In it is a simulation (done using the Doctor) 
that acts like an OS agent that can answer questions about the system's 
status. That program was good enough to fool one of the OS developers 
and maintainers into believing it was real. He asked me "How in the hell 
can you get that information with a user level log in?" As you should 
infer. I like to do quality work. The problem is I don't know how to 
make an Eliza simulation dumb enough to pass as you.
-- 
Jeff Barnett

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


#39912

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 21:36 +0100
Message-ID<87wnn4v1e5.fsf@bsb.me.uk>
In reply to#39862
olcott <NoOne@NoWhere.com> writes:

> On 9/24/2021 6:28 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/24/2021 4:18 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> A turing machine program
>>>> The author you are quoting is unreliable.  Turing machines /are/
>>>> programs.  Turing machine programs are "The La Brea Tar Pits" of
>>>> computability.
>>>
>>> He is the MIT author of a TM interpreter.
>> Something my second-year undergraduates did as an exercise.  They had a
>> week (but then they had other coursework at the same time).
>> 
>>> The key point is that one instruction of the TM language is a specific
>>> 5 tuple.
>>
>> I thought the key point was the incorrect assertion that one can talk
>> about addresses in relation to TMs?  But if the key point is just to
>> attach an unhelpful name to a mathematical object, then it's inline with
>> what you usually do.
>
> The key point that I was addressing is whether or not I know how TM's
> work. I do the 5-tuple state machine says it all.

You have been showing us all how much you understand Turing machines for
years now: ({0}, {1/2^n}).

-- 
Ben.

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


#39915

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 15:50 -0500
Message-ID<Pb-dneblRqITFtL8nZ2dnUU7-audnZ2d@giganews.com>
In reply to#39912
On 9/25/2021 3:36 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/24/2021 6:28 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/24/2021 4:18 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A turing machine program
>>>>> The author you are quoting is unreliable.  Turing machines /are/
>>>>> programs.  Turing machine programs are "The La Brea Tar Pits" of
>>>>> computability.
>>>>
>>>> He is the MIT author of a TM interpreter.
>>> Something my second-year undergraduates did as an exercise.  They had a
>>> week (but then they had other coursework at the same time).
>>>
>>>> The key point is that one instruction of the TM language is a specific
>>>> 5 tuple.
>>>
>>> I thought the key point was the incorrect assertion that one can talk
>>> about addresses in relation to TMs?  But if the key point is just to
>>> attach an unhelpful name to a mathematical object, then it's inline with
>>> what you usually do.
>>
>> The key point that I was addressing is whether or not I know how TM's
>> work. I do the 5-tuple state machine says it all.
> 
> You have been showing us all how much you understand Turing machines for
> years now: ({0}, {1/2^n}).
> 

The question was not about the theoretical underpinnings it was how they 
work. A very trivial machine language specified by the 5-tuples definition.

-- 
Copyright 2021 Pete Olcott

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

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


#39848

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 16:56 -0500
Message-ID<c46dnVqraco51NP8nZ2dnUU7-QfNnZ2d@giganews.com>
In reply to#39843
On 9/24/2021 4:18 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> A turing machine program
> 
> The author you are quoting is unreliable.  Turing machines /are/
> programs.  Turing machine programs are "The La Brea Tar Pits" of
> computability.
> 

He is referring to a program written on the source code of his Turing 
machine interpreter.

-- 
Copyright 2021 Pete Olcott

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

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


#39855

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 00:23 +0100
Message-ID<87pmsxwob5.fsf@bsb.me.uk>
In reply to#39848
olcott <NoOne@NoWhere.com> writes:

> On 9/24/2021 4:18 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> A turing machine program
>> The author you are quoting is unreliable.  Turing machines /are/
>> programs.  Turing machine programs are "The La Brea Tar Pits" of
>> computability.
>
> He is referring to a program written on the source code of his Turing
> machine interpreter.

I know.

-- 
Ben.

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


#39828

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-23 22:49 -0600
Message-ID<sijlcc$i3t$1@dont-email.me>
In reply to#39822
On 2021-09-23 21:34, olcott wrote:
> On 9/23/2021 10:26 PM, André G. Isaak wrote:
>> On 2021-09-23 21:19, olcott wrote:
>>> On 9/23/2021 10:14 PM, André G. Isaak wrote:
>>>> On 2021-09-23 18:17, olcott wrote:
>>>>> On 9/23/2021 6:23 PM, Richard Damon wrote:
>>>>>>
>>>>
>>>>>>> Actual Turing machines must also have machine addresses.
>>>>>>> If you look at Turing machines that actually run an real 
>>>>>>> computers their
>>>>>>> states are stored at specific locations in memory.
>>>>>>>
>>>>>>> That these details are never specified when talking about abstract
>>>>>>> Turing machines does not mean that they are not necessary and 
>>>>>>> required.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> No, the don't. Yes, when you MODEL the on a computer, you map the 
>>>>>> states
>>>>>> to indexs of an array, but there are MANY possible maps, so there 
>>>>>> isn't
>>>>>> a specific index/address that maps to any given state.
>>>>>>
>>>>>
>>>>> Sure there is "a specific index/address that maps to any given state".
>>>>> We might not know where it is yet we do know that it must be in one 
>>>>> specific place or another. If it is literally no place then it does 
>>>>> not actually exist. When we actually write this down as a TM 
>>>>> description then these things get much more specific.
>>>>
>>>> You're being incredibly silly here. Turing Machines don't have 
>>>> machine addresses any more than a game of chess has machine addresses.
>>>>
>>>
>>> Everyone that knows much about chess knows the names of the chess 
>>> addresses.
>>
>> There are various ways of naming board positions. These are not 
>> referred to as 'addresses' let alone 'machine addresses'.
>>
>> André
>>
> 
> None-the-less they are specific locations that must be specified or 
> chess itself does not function.

Yes, they are specific locations on the chess board. But they they are 
not 'machine addresses' which refers to something rather specific which 
plays no role in chess. If you mean chess board location, then say 
'chess board location', not 'machine address'.

Machine addresses refer specifically to locations in addressable memory 
which are numbered sequentially. Lots of things in a computer have 
locations, but no machine address. For example, the contents of a 
register has no machine address. Information stored on disk has no 
machine address.

> Likewise with state transitions. The TM 
> cannot specify that is must transition to some unspecified nest state, 
> the specific next state must be explicitly specified.

Yes, which it is in the definition of the Turing Machine. But the way in 
which they are specified makes absolutely no use of 'machine addresses' 
nor of any sort of location.

> We can talk about things vaguely yet these same things cannot possibly 
> function on without all these details being explicitly specified.

And the definition of a Turing Machine *does* specify all of these 
details *very* precisely, but makes no use of machine addresses.

But you entirely ignored my most salient point which is that even though 
a program which models a TM on an x86 will make use of machine 
addresses, the Turing Machine itself does not and *can* not make any use 
of those addresses. It cannot determine whether some other machine is 
stored at the same memory address as itself because that information is 
part of the program which does the modelling, not something available to 
the TM.

André


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

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


#39835

FromJeff Barnett <jbb@notatt.com>
Date2021-09-24 11:35 -0600
Message-ID<sil28n$530$1@dont-email.me>
In reply to#39828
On 9/23/2021 10:49 PM, André G. Isaak wrote:

> But you entirely ignored my most salient point which is that even though 
> a program which models a TM on an x86 will make use of machine 
> addresses, the Turing Machine itself does not and *can* not make any use 
> of those addresses. It cannot determine whether some other machine is 
> stored at the same memory address as itself because that information is 
> part of the program which does the modelling, not something available to 
> the TM.
I think that we can say that your correspondent's implementation is a 
truly fine example of pathological self reference. It's too bad that he 
once again is hoisted by his/her own idiocy (I would say petard but I 
don't want to look it up first).
-- 
Jeff Barnett

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


#39839

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 13:40 -0500
Message-ID<h42dnf_LJe0rhtP8nZ2dnUU7-Q2dnZ2d@giganews.com>
In reply to#39828
On 9/23/2021 11:49 PM, André G. Isaak wrote:
> On 2021-09-23 21:34, olcott wrote:
>> On 9/23/2021 10:26 PM, André G. Isaak wrote:
>>> On 2021-09-23 21:19, olcott wrote:
>>>> On 9/23/2021 10:14 PM, André G. Isaak wrote:
>>>>> On 2021-09-23 18:17, olcott wrote:
>>>>>> On 9/23/2021 6:23 PM, Richard Damon wrote:
>>>>>>>
>>>>>
>>>>>>>> Actual Turing machines must also have machine addresses.
>>>>>>>> If you look at Turing machines that actually run an real 
>>>>>>>> computers their
>>>>>>>> states are stored at specific locations in memory.
>>>>>>>>
>>>>>>>> That these details are never specified when talking about abstract
>>>>>>>> Turing machines does not mean that they are not necessary and 
>>>>>>>> required.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> No, the don't. Yes, when you MODEL the on a computer, you map the 
>>>>>>> states
>>>>>>> to indexs of an array, but there are MANY possible maps, so there 
>>>>>>> isn't
>>>>>>> a specific index/address that maps to any given state.
>>>>>>>
>>>>>>
>>>>>> Sure there is "a specific index/address that maps to any given 
>>>>>> state".
>>>>>> We might not know where it is yet we do know that it must be in 
>>>>>> one specific place or another. If it is literally no place then it 
>>>>>> does not actually exist. When we actually write this down as a TM 
>>>>>> description then these things get much more specific.
>>>>>
>>>>> You're being incredibly silly here. Turing Machines don't have 
>>>>> machine addresses any more than a game of chess has machine addresses.
>>>>>
>>>>
>>>> Everyone that knows much about chess knows the names of the chess 
>>>> addresses.
>>>
>>> There are various ways of naming board positions. These are not 
>>> referred to as 'addresses' let alone 'machine addresses'.
>>>
>>> André
>>>
>>
>> None-the-less they are specific locations that must be specified or 
>> chess itself does not function.
> 
> Yes, they are specific locations on the chess board. But they they are 
> not 'machine addresses' which refers to something rather specific which 
> plays no role in chess. If you mean chess board location, then say 
> 'chess board location', not 'machine address'.
> 
> Machine addresses refer specifically to locations in addressable memory 
> which are numbered sequentially. Lots of things in a computer have 
> locations, but no machine address. For example, the contents of a 
> register has no machine address. Information stored on disk has no 
> machine address.
> 
>> Likewise with state transitions. The TM cannot specify that is must 
>> transition to some unspecified nest state, the specific next state 
>> must be explicitly specified.
> 
> Yes, which it is in the definition of the Turing Machine. But the way in 
> which they are specified makes absolutely no use of 'machine addresses' 
> nor of any sort of location.
> 
>> We can talk about things vaguely yet these same things cannot possibly 
>> function on without all these details being explicitly specified.
> 
> And the definition of a Turing Machine *does* specify all of these 
> details *very* precisely, but makes no use of machine addresses.
> 
> But you entirely ignored my most salient point which is that even though 
> a program which models a TM on an x86 will make use of machine 
> addresses, the Turing Machine itself does not and *can* not make any use 
> of those addresses. It cannot determine whether some other machine is 
> stored at the same memory address as itself because that information is 
> part of the program which does the modelling, not something available to 
> the TM.
> 
> André
> 
> 

The equivalent of a machine address in the TM model is the current_state 
/ current_input pair.

-- 
Copyright 2021 Pete Olcott

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

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


#39840

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-24 13:45 -0600
Message-ID<sil9st$lo3$1@dont-email.me>
In reply to#39839
On 2021-09-24 12:40, olcott wrote:
> On 9/23/2021 11:49 PM, André G. Isaak wrote:

>> But you entirely ignored my most salient point which is that even 
>> though a program which models a TM on an x86 will make use of machine 
>> addresses, the Turing Machine itself does not and *can* not make any 
>> use of those addresses. It cannot determine whether some other machine 
>> is stored at the same memory address as itself because that 
>> information is part of the program which does the modelling, not 
>> something available to the TM.
>>
>> André
>>
>>
> 
> The equivalent of a machine address in the TM model is the current_state 
> / current_input pair.

Please explain how the "current_state / current_input pair" can possibly 
be used in the way that you use machine addresses to identify recursion 
in your C program.

Hint: You can't because the "current_state / current_input pair" bears 
absolutely no resemblance to a machine address.

That plus the fact that TMs can't call other TMs recursively. They can't 
call other TMs at all.

André

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

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


#39844

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 16:18 -0500
Message-ID<4uGdnXIH784D3dP8nZ2dnUU7-L2dnZ2d@giganews.com>
In reply to#39840
On 9/24/2021 2:45 PM, André G. Isaak wrote:
> On 2021-09-24 12:40, olcott wrote:
>> On 9/23/2021 11:49 PM, André G. Isaak wrote:
> 
>>> But you entirely ignored my most salient point which is that even 
>>> though a program which models a TM on an x86 will make use of machine 
>>> addresses, the Turing Machine itself does not and *can* not make any 
>>> use of those addresses. It cannot determine whether some other 
>>> machine is stored at the same memory address as itself because that 
>>> information is part of the program which does the modelling, not 
>>> something available to the TM.
>>>
>>> André
>>>
>>>
>>
>> The equivalent of a machine address in the TM model is the 
>> current_state / current_input pair.
> 
> Please explain how the "current_state / current_input pair" can possibly 
> be used in the way that you use machine addresses to identify recursion 
> in your C program.
> 
> Hint: You can't because the "current_state / current_input pair" bears 
> absolutely no resemblance to a machine address.
> 
> That plus the fact that TMs can't call other TMs recursively. They can't 
> call other TMs at all.
> 
> André
> 

It is an identifiable point in the execution trace of a TM.
A unique current_state / current_input pair could specify the point 
where halt deciding begins.

-- 
Copyright 2021 Pete Olcott

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

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


#39852

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-24 16:47 -0600
Message-ID<silkiu$tu8$1@dont-email.me>
In reply to#39844
On 2021-09-24 15:18, olcott wrote:
> On 9/24/2021 2:45 PM, André G. Isaak wrote:
>> On 2021-09-24 12:40, olcott wrote:
>>> On 9/23/2021 11:49 PM, André G. Isaak wrote:
>>
>>>> But you entirely ignored my most salient point which is that even 
>>>> though a program which models a TM on an x86 will make use of 
>>>> machine addresses, the Turing Machine itself does not and *can* not 
>>>> make any use of those addresses. It cannot determine whether some 
>>>> other machine is stored at the same memory address as itself because 
>>>> that information is part of the program which does the modelling, 
>>>> not something available to the TM.
>>>>
>>>> André
>>>>
>>>>
>>>
>>> The equivalent of a machine address in the TM model is the 
>>> current_state / current_input pair.
>>
>> Please explain how the "current_state / current_input pair" can 
>> possibly be used in the way that you use machine addresses to identify 
>> recursion in your C program.
>>
>> Hint: You can't because the "current_state / current_input pair" bears 
>> absolutely no resemblance to a machine address.
>>
>> That plus the fact that TMs can't call other TMs recursively. They 
>> can't call other TMs at all.
>>
>> André
>>
> 
> It is an identifiable point in the execution trace of a TM.
> A unique current_state / current_input pair could specify the point 
> where halt deciding begins.

That doesn't answer my question.

It's perfectly possible for two entirely different TMs which perform 
entirely different functions to have an identical "current_state / 
current_input pair" in their set of state transitions, so can you tell 
that two TMs are identical using this method?

And how do you arrange for your H to 'ignore its own code' which you 
claim is necessary given that H doesn't have any access at all to its 
own state transitions and therefore can't compare those of the 
description which it is given to its own?

You really need to sit down and actually work with some real Turing 
Machines. Pick a simple one and run it using a pen and paper to keep 
track of what's going on. Then you might learn how they work and realize 
how absurd all your claims regarding them are.

André

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

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


#39829

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-09-24 05:51 -0700
Message-ID<ef4b277b-7638-4810-b929-5605fd1cfa8dn@googlegroups.com>
In reply to#39812
On Friday, 24 September 2021 at 04:14:08 UTC+1, André G. Isaak wrote:
> On 2021-09-23 18:17, olcott wrote:
> > On 9/23/2021 6:23 PM, Richard Damon wrote: 
> >> 
> 
> >>> Actual Turing machines must also have machine addresses. 
> >>> If you look at Turing machines that actually run an real computers their 
> >>> states are stored at specific locations in memory. 
> >>> 
> >>> That these details are never specified when talking about abstract 
> >>> Turing machines does not mean that they are not necessary and required. 
> >>> 
> >>> 
> >> 
> >> No, the don't. Yes, when you MODEL the on a computer, you map the states 
> >> to indexs of an array, but there are MANY possible maps, so there isn't 
> >> a specific index/address that maps to any given state. 
> >> 
> > 
> > Sure there is "a specific index/address that maps to any given state". 
> > We might not know where it is yet we do know that it must be in one 
> > specific place or another. If it is literally no place then it does not 
> > actually exist. When we actually write this down as a TM description 
> > then these things get much more specific.
> You're being incredibly silly here. Turing Machines don't have machine 
> addresses any more than a game of chess has machine addresses. 
> 
> An x86 program which plays chess or which emulates a TM will have 
> machine addresses, but those are part of that program, not part of chess 
> or of TMs. 
> 
> When running a TM, the state may be stored at a specific machine 
> address, but it might also be kept track of on a blackboard or in 
> someone's head, neither of which have 'machine addresses'. 
> 
> But, more critically, even if the TMs states or state transitions are 
> being stored in RAM at particular addresses, the TM has absolutely no 
> way access to those machine addresses. The actions taken by a TM are 
> dependent *solely* on the current state of the TM and the symbol 
> currently visible on the tape. Those actions are entirely unaffected by 
> where these things are stored in memory and the TM has absolutely no 
> knowledge of where such things are stored. 
> 
> So even if you want to foolishly insist on talking about 'machine 
> addresses' there is absolutely no possibility of a TM comparing machine 
> addresses. A TM cannot reference its own state transition table let 
> alone check whether the address of some transition is the same as the 
> address of a transition in some other TM.
> 
To make this a bit clearer, in machine code you can and frequently do the following

addresses jumptable[N];
int target = 3;
register target_address = jumptable[target];
jumpto target_address.

The address is manipulated and stored, and finally jumped to.

However a Turing machine has no close equivalent. It's normal to number the states.
However there is no way of calculating a value on the tape, then setting the state
to the one with the numerical lablel corresponding to that value.

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


#39830

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 08:12 -0500
Message-ID<JvKdndrCSdZXU9D8nZ2dnUU7-UHNnZ2d@giganews.com>
In reply to#39829
On 9/24/2021 7:51 AM, Malcolm McLean wrote:
> On Friday, 24 September 2021 at 04:14:08 UTC+1, André G. Isaak wrote:
>> On 2021-09-23 18:17, olcott wrote:
>>> On 9/23/2021 6:23 PM, Richard Damon wrote:
>>>>
>>
>>>>> Actual Turing machines must also have machine addresses.
>>>>> If you look at Turing machines that actually run an real computers their
>>>>> states are stored at specific locations in memory.
>>>>>
>>>>> That these details are never specified when talking about abstract
>>>>> Turing machines does not mean that they are not necessary and required.
>>>>>
>>>>>
>>>>
>>>> No, the don't. Yes, when you MODEL the on a computer, you map the states
>>>> to indexs of an array, but there are MANY possible maps, so there isn't
>>>> a specific index/address that maps to any given state.
>>>>
>>>
>>> Sure there is "a specific index/address that maps to any given state".
>>> We might not know where it is yet we do know that it must be in one
>>> specific place or another. If it is literally no place then it does not
>>> actually exist. When we actually write this down as a TM description
>>> then these things get much more specific.
>> You're being incredibly silly here. Turing Machines don't have machine
>> addresses any more than a game of chess has machine addresses.
>>
>> An x86 program which plays chess or which emulates a TM will have
>> machine addresses, but those are part of that program, not part of chess
>> or of TMs.
>>
>> When running a TM, the state may be stored at a specific machine
>> address, but it might also be kept track of on a blackboard or in
>> someone's head, neither of which have 'machine addresses'.
>>
>> But, more critically, even if the TMs states or state transitions are
>> being stored in RAM at particular addresses, the TM has absolutely no
>> way access to those machine addresses. The actions taken by a TM are
>> dependent *solely* on the current state of the TM and the symbol
>> currently visible on the tape. Those actions are entirely unaffected by
>> where these things are stored in memory and the TM has absolutely no
>> knowledge of where such things are stored.
>>
>> So even if you want to foolishly insist on talking about 'machine
>> addresses' there is absolutely no possibility of a TM comparing machine
>> addresses. A TM cannot reference its own state transition table let
>> alone check whether the address of some transition is the same as the
>> address of a transition in some other TM.
>>
> To make this a bit clearer, in machine code you can and frequently do the following
> 
> addresses jumptable[N];
> int target = 3;
> register target_address = jumptable[target];
> jumpto target_address.
> 
> The address is manipulated and stored, and finally jumped to.
> 
> However a Turing machine has no close equivalent. It's normal to number the states.
> However there is no way of calculating a value on the tape, then setting the state
> to the one with the numerical lablel corresponding to that value.
> 
> 

Recognizing the equivalent of a specific machine address in a TM is only 
a matter of recognizing a specific current_state / current_input pair by 
the UTM / halt decider.

-- 
Copyright 2021 Pete Olcott

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

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


#39831 — Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ]

Fromolcott <polcott2@gmail.com>
Date2021-09-24 08:27 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ]
Message-ID<sikjok$era$1@dont-email.me>
In reply to#39830
On 9/24/2021 8:12 AM, olcott wrote:
> On 9/24/2021 7:51 AM, Malcolm McLean wrote:
>> On Friday, 24 September 2021 at 04:14:08 UTC+1, André G. Isaak wrote:
>>> On 2021-09-23 18:17, olcott wrote:
>>>> On 9/23/2021 6:23 PM, Richard Damon wrote:
>>>>>
>>>
>>>>>> Actual Turing machines must also have machine addresses.
>>>>>> If you look at Turing machines that actually run an real computers 
>>>>>> their
>>>>>> states are stored at specific locations in memory.
>>>>>>
>>>>>> That these details are never specified when talking about abstract
>>>>>> Turing machines does not mean that they are not necessary and 
>>>>>> required.
>>>>>>
>>>>>>
>>>>>
>>>>> No, the don't. Yes, when you MODEL the on a computer, you map the 
>>>>> states
>>>>> to indexs of an array, but there are MANY possible maps, so there 
>>>>> isn't
>>>>> a specific index/address that maps to any given state.
>>>>>
>>>>
>>>> Sure there is "a specific index/address that maps to any given state".
>>>> We might not know where it is yet we do know that it must be in one
>>>> specific place or another. If it is literally no place then it does not
>>>> actually exist. When we actually write this down as a TM description
>>>> then these things get much more specific.
>>> You're being incredibly silly here. Turing Machines don't have machine
>>> addresses any more than a game of chess has machine addresses.
>>>
>>> An x86 program which plays chess or which emulates a TM will have
>>> machine addresses, but those are part of that program, not part of chess
>>> or of TMs.
>>>
>>> When running a TM, the state may be stored at a specific machine
>>> address, but it might also be kept track of on a blackboard or in
>>> someone's head, neither of which have 'machine addresses'.
>>>
>>> But, more critically, even if the TMs states or state transitions are
>>> being stored in RAM at particular addresses, the TM has absolutely no
>>> way access to those machine addresses. The actions taken by a TM are
>>> dependent *solely* on the current state of the TM and the symbol
>>> currently visible on the tape. Those actions are entirely unaffected by
>>> where these things are stored in memory and the TM has absolutely no
>>> knowledge of where such things are stored.
>>>
>>> So even if you want to foolishly insist on talking about 'machine
>>> addresses' there is absolutely no possibility of a TM comparing machine
>>> addresses. A TM cannot reference its own state transition table let
>>> alone check whether the address of some transition is the same as the
>>> address of a transition in some other TM.
>>>
>> To make this a bit clearer, in machine code you can and frequently do 
>> the following
>>
>> addresses jumptable[N];
>> int target = 3;
>> register target_address = jumptable[target];
>> jumpto target_address.
>>
>> The address is manipulated and stored, and finally jumped to.
>>
>> However a Turing machine has no close equivalent. It's normal to 
>> number the states.
>> However there is no way of calculating a value on the tape, then 
>> setting the state
>> to the one with the numerical lablel corresponding to that value.
>>
>>
> 
> Recognizing the equivalent of a specific machine address in a TM is only 
> a matter of recognizing a specific current_state / current_input pair by 
> the UTM / halt decider.
> 

https://patents.justia.com/inventor/peter-l-olcott
State machines are generally implemented as a table of current_input 
columns and current_state rows. The next state is merely a lookup table.

To implement my deterministic OCR there where too many possible current 
inputs 2^24 so the current state had a sorted list of possible inputs 
that are binary searched for a match. The match held the value of the 
next state.

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

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


#39845 — Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-24 22:42 +0100
SubjectRe: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ]
Message-ID<871r5dy7kf.fsf@bsb.me.uk>
In reply to#39831
olcott <polcott2@gmail.com> writes:

>>>>>>> Actual Turing machines must also have machine addresses.
>>>>>>> If you look at Turing machines that actually run an real computers their
>>>>>>> states are stored at specific locations in memory.

> State machines are generally implemented as a table of current_input
> columns and current_state rows. The next state is merely a lookup
> table.

(1) It's a fallacy to support an argument about what must be the case by
    citing what is generally the case.

Here is a simple TM implemented in a functional language:

  q0 r ('0':s) = q1 (r++"0") s
  q0 r ('1':s) = q0 (r++"1") s
  q0 r "" = r
  q1 r ('0':s) = q0 (r++"1") s
  q1 r ('1':s) = q0 (r++"1") s
  q1 r "" = q0 r []

If the implementation of this language translates source code to
combinators, and then uses graph reduction on the result, there is no
sense in which states, configurations or quintuples will have machine
addresses.  There are more things in heaven and earth, Peter, than are
dreamt of in your philosophy.

(2) You can't defend a false claim about a mathematical object by what
    might happens in representations of it (even if what happens does in
    fact turn out to be universal).

> To implement my deterministic OCR there where too many possible
> current inputs 2^24 so the current state had a sorted list of possible
> inputs that are binary searched for a match. The match held the value
> of the next state.

This was going to make you millions, wasn't it.  Long before you were
wrong about Turing machines, you were wrong about the business end of
software.

-- 
Ben.

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


#39721

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-22 06:46 -0400
Message-ID<kQD2J.14083$d82.5891@fx21.iad>
In reply to#39714
On 9/21/21 11:50 PM, André G. Isaak wrote:
> On 2021-09-21 20:25, olcott wrote:
>> void P(u8* program)
>> {
>>    u8* input;
>>    CopyMemory(program, input);
>>    u32 Input_Halts = halt_decider(program, input);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>>    u8* program = (u8*)Allocate(1024);
>>    u8* input;
>>    CopyMemory3((u8*)P, (u8*)program);
>>    CopyMemory(program, input);
>>    Output("Input_Halts = ", halt_decider(program, input));
>> }
>>
>> As with my other proofs the halt status is correctly decided.
>>
>> This paper will be completely rewritten with my new findings as soon
>> as they are fully operational. The key feasibility test elements are
>> already fully operational. The architectural design is complete.
>>
>> To the best of my current knowledge the only steps required to make
>> this system fully operational are relatively minor ordinary C/x86
>> operating system level programming.
> 
> Well, no. The other thing you need to do is write it so your H and P are
> separate *programs*, not just two functions called from within a single
> main. The halting program, after all, is about a program which can
> answer a question about another program; not a program which can answer
> a question about part of itself.
> 
> That means two separate, self-contained executables, each of which will
> contain its own copy of halt_decider which cannot therefore occupy the
> same machine address.
> 
> André
> 

No, they don't need to be separate programs, as in .exe, in actual
construction. That is an unimportant detail.

H and H^/P do need to be COMPLETE PROGRAMS in the sense that they are
self contained. His current P calling halt_decider can be a violation of
that he will probably utilize to cheat.

His function P is not a computation by itself, as it uses code that
isn't part of itself. thus we can't make a Turing Machine of 'just P'.

THus the fact that he makes a copy of 'just P' to pass to itself says
that his P isn't actually the equivalent of Linz H^.

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


#39732

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-22 14:50 -0600
Message-ID<sig4ub$qrt$1@dont-email.me>
In reply to#39721
On 2021-09-22 04:46, Richard Damon wrote:
> On 9/21/21 11:50 PM, André G. Isaak wrote:
>> On 2021-09-21 20:25, olcott wrote:
>>> void P(u8* program)
>>> {
>>>     u8* input;
>>>     CopyMemory(program, input);
>>>     u32 Input_Halts = halt_decider(program, input);
>>>     if (Input_Halts)
>>>       HERE: goto HERE;
>>> }
>>>
>>>
>>> int main()
>>> {
>>>     u8* program = (u8*)Allocate(1024);
>>>     u8* input;
>>>     CopyMemory3((u8*)P, (u8*)program);
>>>     CopyMemory(program, input);
>>>     Output("Input_Halts = ", halt_decider(program, input));
>>> }
>>>
>>> As with my other proofs the halt status is correctly decided.
>>>
>>> This paper will be completely rewritten with my new findings as soon
>>> as they are fully operational. The key feasibility test elements are
>>> already fully operational. The architectural design is complete.
>>>
>>> To the best of my current knowledge the only steps required to make
>>> this system fully operational are relatively minor ordinary C/x86
>>> operating system level programming.
>>
>> Well, no. The other thing you need to do is write it so your H and P are
>> separate *programs*, not just two functions called from within a single
>> main. The halting program, after all, is about a program which can
>> answer a question about another program; not a program which can answer
>> a question about part of itself.
>>
>> That means two separate, self-contained executables, each of which will
>> contain its own copy of halt_decider which cannot therefore occupy the
>> same machine address.
>>
>> André
>>
> 
> No, they don't need to be separate programs, as in .exe, in actual
> construction. That is an unimportant detail.
> 
> H and H^/P do need to be COMPLETE PROGRAMS in the sense that they are
> self contained.

True, but insisting they be separate .exe files would guarantee that 
they are self-contained, and I'm not convinced that Olcott is otherwise 
capable of comprehending what makes a function self-contained.

Of course, then he'd probably just move all the code into his x86utm 
'Operating System'.

André

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

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


#39734

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 16:01 -0500
Message-ID<PIqdnQp3PL4tBNb8nZ2dnUU7-ePNnZ2d@giganews.com>
In reply to#39732
On 9/22/2021 3:50 PM, André G. Isaak wrote:
> On 2021-09-22 04:46, Richard Damon wrote:
>> On 9/21/21 11:50 PM, André G. Isaak wrote:
>>> On 2021-09-21 20:25, olcott wrote:
>>>> void P(u8* program)
>>>> {
>>>>     u8* input;
>>>>     CopyMemory(program, input);
>>>>     u32 Input_Halts = halt_decider(program, input);
>>>>     if (Input_Halts)
>>>>       HERE: goto HERE;
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>>     u8* program = (u8*)Allocate(1024);
>>>>     u8* input;
>>>>     CopyMemory3((u8*)P, (u8*)program);
>>>>     CopyMemory(program, input);
>>>>     Output("Input_Halts = ", halt_decider(program, input));
>>>> }
>>>>
>>>> As with my other proofs the halt status is correctly decided.
>>>>
>>>> This paper will be completely rewritten with my new findings as soon
>>>> as they are fully operational. The key feasibility test elements are
>>>> already fully operational. The architectural design is complete.
>>>>
>>>> To the best of my current knowledge the only steps required to make
>>>> this system fully operational are relatively minor ordinary C/x86
>>>> operating system level programming.
>>>
>>> Well, no. The other thing you need to do is write it so your H and P are
>>> separate *programs*, not just two functions called from within a single
>>> main. The halting program, after all, is about a program which can
>>> answer a question about another program; not a program which can answer
>>> a question about part of itself.
>>>
>>> That means two separate, self-contained executables, each of which will
>>> contain its own copy of halt_decider which cannot therefore occupy the
>>> same machine address.
>>>
>>> André
>>>
>>
>> No, they don't need to be separate programs, as in .exe, in actual
>> construction. That is an unimportant detail.
>>
>> H and H^/P do need to be COMPLETE PROGRAMS in the sense that they are
>> self contained.
> 
> True, but insisting they be separate .exe files would guarantee that 
> they are self-contained, and I'm not convinced that Olcott is otherwise 
> capable of comprehending what makes a function self-contained.
> 
> Of course, then he'd probably just move all the code into his x86utm 
> 'Operating System'.
> 
> André
> 

This is about as self-contained as I can make it:

This is about as close as I can get to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
P has its own halt decider named H() yet P is decided by another 
different instance named H1().

void P(u8* program)
{
   u8* input;
   CopyMemory(program, input);
   u32 Input_Halts = H(program, input);
   if (Input_Halts)
     HERE: goto HERE;
}

int main()
{
   u8* input;
   CopyMemory3((u8*)P, input);
   Output("Input_Halts = ", H1((u32)P, input));
}

Soon to be completely rewritten to conform to the above newly defined 
process:

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

-- 
Copyright 2021 Pete Olcott

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

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


#39735

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 16:02 -0500
Message-ID<PIqdnQV3PL5vBNb8nZ2dnUU7-eNQAAAA@giganews.com>
In reply to#39721
On 9/22/2021 5:46 AM, Richard Damon wrote:
> On 9/21/21 11:50 PM, André G. Isaak wrote:
>> On 2021-09-21 20:25, olcott wrote:
>>> void P(u8* program)
>>> {
>>>     u8* input;
>>>     CopyMemory(program, input);
>>>     u32 Input_Halts = halt_decider(program, input);
>>>     if (Input_Halts)
>>>       HERE: goto HERE;
>>> }
>>>
>>>
>>> int main()
>>> {
>>>     u8* program = (u8*)Allocate(1024);
>>>     u8* input;
>>>     CopyMemory3((u8*)P, (u8*)program);
>>>     CopyMemory(program, input);
>>>     Output("Input_Halts = ", halt_decider(program, input));
>>> }
>>>
>>> As with my other proofs the halt status is correctly decided.
>>>
>>> This paper will be completely rewritten with my new findings as soon
>>> as they are fully operational. The key feasibility test elements are
>>> already fully operational. The architectural design is complete.
>>>
>>> To the best of my current knowledge the only steps required to make
>>> this system fully operational are relatively minor ordinary C/x86
>>> operating system level programming.
>>
>> Well, no. The other thing you need to do is write it so your H and P are
>> separate *programs*, not just two functions called from within a single
>> main. The halting program, after all, is about a program which can
>> answer a question about another program; not a program which can answer
>> a question about part of itself.
>>
>> That means two separate, self-contained executables, each of which will
>> contain its own copy of halt_decider which cannot therefore occupy the
>> same machine address.
>>
>> André
>>
> 
> No, they don't need to be separate programs, as in .exe, in actual
> construction. That is an unimportant detail.
> 
> H and H^/P do need to be COMPLETE PROGRAMS in the sense that they are
> self contained. His current P calling halt_decider can be a violation of
> that he will probably utilize to cheat.
> 
> His function P is not a computation by itself, as it uses code that
> isn't part of itself. thus we can't make a Turing Machine of 'just P'.
> 
> THus the fact that he makes a copy of 'just P' to pass to itself says
> that his P isn't actually the equivalent of Linz H^.
> 

This is about as self-contained as I can make it:

This is about as close as I can get to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
P has its own halt decider named H() yet P is decided by another 
different instance named H1().

void P(u8* program)
{
   u8* input;
   CopyMemory(program, input);
   u32 Input_Halts = H(program, input);
   if (Input_Halts)
     HERE: goto HERE;
}

int main()
{
   u8* input;
   CopyMemory3((u8*)P, input);
   Output("Input_Halts = ", H1((u32)P, input));
}

Soon to be completely rewritten to conform to the above newly defined 
process:

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation



-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web