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 6 of 12 — ← Prev page 1 … 4 5 [6] 7 8 … 12  Next page →


#39717

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-09-21 22:30 -0700
Message-ID<2d0f7e40-b2c3-464d-8a5f-13feef8917c3n@googlegroups.com>
In reply to#39709
On Wednesday, 22 September 2021 at 03:25:36 UTC+1, 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. 
> 
That's a sketch of the Linz proof translated to C.
But only a sketch. Anyone can see why halt_decider must get the call wrong.
But only if halt_decider is written in a legitimate way. There are various tricks
we can use in C to make it return inconsistent results. That's partly why Linz
uses Turing machines.

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


#39718

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 02:05 -0500
Message-ID<luudnTzjvLxYSNf8nZ2dnUU7-WGdnZ2d@giganews.com>
In reply to#39717
On 9/22/2021 12:30 AM, Malcolm McLean wrote:
> On Wednesday, 22 September 2021 at 03:25:36 UTC+1, 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.
>>
> That's a sketch of the Linz proof translated to C.
> But only a sketch. Anyone can see why halt_decider must get the call wrong.
> But only if halt_decider is written in a legitimate way. There are various tricks
> we can use in C to make it return inconsistent results. That's partly why Linz
> uses Turing machines.
> 

I think that it may end up with the same H1/H system that decides its 
input correctly.

-- 
Copyright 2021 Pete Olcott

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

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


#39719

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-22 06:36 -0400
Message-ID<OGD2J.41392$ol1.12889@fx42.iad>
In reply to#39718
On 9/22/21 3:05 AM, olcott wrote:
> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>> On Wednesday, 22 September 2021 at 03:25:36 UTC+1, 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.
>>>
>> That's a sketch of the Linz proof translated to C.
>> But only a sketch. Anyone can see why halt_decider must get the call
>> wrong.
>> But only if halt_decider is written in a legitimate way. There are
>> various tricks
>> we can use in C to make it return inconsistent results. That's partly
>> why Linz
>> uses Turing machines.
>>
> 
> I think that it may end up with the same H1/H system that decides its
> input correctly.
> 

Watch out. If you end up needing a different computation to decide than
what P is built on, you have failed.

The answer that H^/P gets from its use of the decider MUST match the
answer that the decider give as its grand decision or you haven't built
things by the rules.

Of course, the way H^/P is designed, that answer will be wrong, which is
why no Computation can give the right answer.

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


#39738

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

> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>> On Wednesday, 22 September 2021 at 03:25:36 UTC+1, 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.
>>>
>> That's a sketch of the Linz proof translated to C.
>> But only a sketch. Anyone can see why halt_decider must get the call wrong.
>> But only if halt_decider is written in a legitimate way. There are various tricks
>> we can use in C to make it return inconsistent results. That's partly why Linz
>> uses Turing machines.

And why PO does not!

> I think that it may end up with the same H1/H system that decides its
> input correctly.

You think it may end up there?  You had a "correct" decider for the key
case in Dec 2018:

  "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
  specs does not exist. I now have a fully encoded pair of Turing
  Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.

  "I have proven that this argument is not valid by making an H that
  decides (Ĥ, Ĥ)."

That's way more impressive than the two and half years you've spent
going backwards to something that only /may/ end up deciding its input
correctly.

If only you had all of the exact Turing machine description -- the
actual instructions -- for such an H.  No one could argue with that!
Oh, you do:

  "I ... more importantly encoded all of the exact TMD instructions of
  the Linz Turing machine H that correctly decides halting for its fully
  encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.

Gosh!  Publish this and the argument will be over (and I know which way
it will go!).

-- 
Ben.

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


#39740

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 18:35 -0500
Message-ID<QrudnTfgTNNGINb8nZ2dnUU7-YOdnZ2d@giganews.com>
In reply to#39738
On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>>> On Wednesday, 22 September 2021 at 03:25:36 UTC+1, 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.
>>>>
>>> That's a sketch of the Linz proof translated to C.
>>> But only a sketch. Anyone can see why halt_decider must get the call wrong.
>>> But only if halt_decider is written in a legitimate way. There are various tricks
>>> we can use in C to make it return inconsistent results. That's partly why Linz
>>> uses Turing machines.
> 
> And why PO does not!
> 
>> I think that it may end up with the same H1/H system that decides its
>> input correctly.
> 
> You think it may end up there?  You had a "correct" decider for the key
> case in Dec 2018:
> 
>    "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>    specs does not exist. I now have a fully encoded pair of Turing
>    Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
> 
>    "I have proven that this argument is not valid by making an H that
>    decides (Ĥ, Ĥ)."
> 
> That's way more impressive than the two and half years you've spent
> going backwards to something that only /may/ end up deciding its input
> correctly.
> 
> If only you had all of the exact Turing machine description -- the
> actual instructions -- for such an H.  No one could argue with that!

Sure and they wouldn't argue because they could never decipher the 
hundreds of millions of pages of execution trace.


> Oh, you do:
> 
>    "I ... more importantly encoded all of the exact TMD instructions of
>    the Linz Turing machine H that correctly decides halting for its fully
>    encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
> 
> Gosh!  Publish this and the argument will be over (and I know which way
> it will go!).
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39742

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

> On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:

>>>> That's a sketch of the Linz proof translated to C.  But only a
>>>> sketch. Anyone can see why halt_decider must get the call wrong.
>>>> But only if halt_decider is written in a legitimate way. There are
>>>> various tricks we can use in C to make it return inconsistent
>>>> results. That's partly why Linz uses Turing machines.
>>
>> And why PO does not!
>> 
>>> I think that it may end up with the same H1/H system that decides its
>>> input correctly.
>>
>> You think it may end up there?  You had a "correct" decider for the key
>> case in Dec 2018:
>>
>>    "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>>    specs does not exist. I now have a fully encoded pair of Turing
>>    Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
>>
>>    "I have proven that this argument is not valid by making an H that
>>    decides (Ĥ, Ĥ)."
>>
>> That's way more impressive than the two and half years you've spent
>> going backwards to something that only /may/ end up deciding its input
>> correctly.
>>
>> If only you had all of the exact Turing machine description -- the
>> actual instructions -- for such an H.  No one could argue with that!
>
> Sure and they wouldn't argue because they could never decipher the
> hundreds of millions of pages of execution trace.

Oh!  So you lied when you said that the decision your H gives is "easily
verifiably correct".

>> Oh, you do:
>>    "I ... more importantly encoded all of the exact TMD instructions of
>>    the Linz Turing machine H that correctly decides halting for its fully
>>    encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
>>
>> Gosh!  Publish this and the argument will be over (and I know which way
>> it will go!).

-- 
Ben.

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


#39746

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 19:11 -0500
Message-ID<yLSdnaVMYofdW9b8nZ2dnUU7-TmdnZ2d@giganews.com>
In reply to#39742
On 9/22/2021 6:47 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
> 
>>>>> That's a sketch of the Linz proof translated to C.  But only a
>>>>> sketch. Anyone can see why halt_decider must get the call wrong.
>>>>> But only if halt_decider is written in a legitimate way. There are
>>>>> various tricks we can use in C to make it return inconsistent
>>>>> results. That's partly why Linz uses Turing machines.
>>>
>>> And why PO does not!
>>>
>>>> I think that it may end up with the same H1/H system that decides its
>>>> input correctly.
>>>
>>> You think it may end up there?  You had a "correct" decider for the key
>>> case in Dec 2018:
>>>
>>>     "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>>>     specs does not exist. I now have a fully encoded pair of Turing
>>>     Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
>>>
>>>     "I have proven that this argument is not valid by making an H that
>>>     decides (Ĥ, Ĥ)."
>>>
>>> That's way more impressive than the two and half years you've spent
>>> going backwards to something that only /may/ end up deciding its input
>>> correctly.
>>>
>>> If only you had all of the exact Turing machine description -- the
>>> actual instructions -- for such an H.  No one could argue with that!
>>
>> Sure and they wouldn't argue because they could never decipher the
>> hundreds of millions of pages of execution trace.
> 
> Oh!  So you lied when you said that the decision your H gives is "easily
> verifiably correct".
> 

Everyone here knows that you are intentionally misconstruing everything 
that I say. Many of those won't admit it because they are doing the same 
thing. Malcolm is the only one here that is definitely not doing this.

>>> Oh, you do:
>>>     "I ... more importantly encoded all of the exact TMD instructions of
>>>     the Linz Turing machine H that correctly decides halting for its fully
>>>     encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
>>>
>>> Gosh!  Publish this and the argument will be over (and I know which way
>>> it will go!).
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39750

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-22 20:34 -0400
Message-ID<iYP2J.116207$Kv2.11807@fx47.iad>
In reply to#39746
On 9/22/21 8:11 PM, olcott wrote:
> Everyone here knows that you are intentionally misconstruing everything
> that I say. Many of those won't admit it because they are doing the same
> thing. Malcolm is the only one here that is definitely not doing this.
> 

People don't intentionally misconstue what you are saying.

YOU are sloppy and contradictory in what you say. You refuse to STICK to
a given definition but keep on changing you mind what things are
supposed to mean, and then don't make a clear retraction of the old.

It seems that some of this is INTENTIONAL (i.e. a way to LIE) as some of
your logic is based on words chaning their meaning between similar
statements, or being slightly misuse to try to pull in aspects that
aren't actually there.

Some of this may be a mental deficiency in yourself, which is ok, but
people can only help you if you admit it, describe it, and not get
defensive about it.

I have started to think that you may be mentally unable to actual do a
real logical proof because your brain just doesn't have the needed
neural pathways.

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


#39755

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-23 02:52 +0100
Message-ID<87ee9g12iw.fsf@bsb.me.uk>
In reply to#39746
olcott <NoOne@NoWhere.com> writes:

> On 9/22/2021 6:47 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>> 
>>>>>> That's a sketch of the Linz proof translated to C.  But only a
>>>>>> sketch. Anyone can see why halt_decider must get the call wrong.
>>>>>> But only if halt_decider is written in a legitimate way. There are
>>>>>> various tricks we can use in C to make it return inconsistent
>>>>>> results. That's partly why Linz uses Turing machines.
>>>>
>>>> And why PO does not!
>>>>
>>>>> I think that it may end up with the same H1/H system that decides its
>>>>> input correctly.
>>>>
>>>> You think it may end up there?  You had a "correct" decider for the key
>>>> case in Dec 2018:
>>>>
>>>>     "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>>>>     specs does not exist. I now have a fully encoded pair of Turing
>>>>     Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
>>>>
>>>>     "I have proven that this argument is not valid by making an H that
>>>>     decides (Ĥ, Ĥ)."
>>>>
>>>> That's way more impressive than the two and half years you've spent
>>>> going backwards to something that only /may/ end up deciding its input
>>>> correctly.
>>>>
>>>> If only you had all of the exact Turing machine description -- the
>>>> actual instructions -- for such an H.  No one could argue with that!
>>>
>>> Sure and they wouldn't argue because they could never decipher the
>>> hundreds of millions of pages of execution trace.
>>
>> Oh!  So you lied when you said that the decision your H gives is "easily
>> verifiably correct".
>
> Everyone here knows that you are intentionally misconstruing
> everything that I say. Many of those won't admit it because they are
> doing the same thing. Malcolm is the only one here that is definitely
> not doing this.

How should one construe your claim to have the exact instructions of a
TM, H, that correctly decides the halting of its (H^, H^) pair such that
it's correctness is easy to verify?  What is the correct way to read
your words from back then?

>>>> Oh, you do:
>>>>     "I ... more importantly encoded all of the exact TMD instructions of
>>>>     the Linz Turing machine H that correctly decides halting for its fully
>>>>     encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
>>>>
>>>> Gosh!  Publish this and the argument will be over (and I know which way
>>>> it will go!).

-- 
Ben.

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


#39756

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 20:57 -0500
Message-ID<oZadndLgscS4Qtb8nZ2dnUU7-dOdnZ2d@giganews.com>
In reply to#39755
On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/22/2021 6:47 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>>>
>>>>>>> That's a sketch of the Linz proof translated to C.  But only a
>>>>>>> sketch. Anyone can see why halt_decider must get the call wrong.
>>>>>>> But only if halt_decider is written in a legitimate way. There are
>>>>>>> various tricks we can use in C to make it return inconsistent
>>>>>>> results. That's partly why Linz uses Turing machines.
>>>>>
>>>>> And why PO does not!
>>>>>
>>>>>> I think that it may end up with the same H1/H system that decides its
>>>>>> input correctly.
>>>>>
>>>>> You think it may end up there?  You had a "correct" decider for the key
>>>>> case in Dec 2018:
>>>>>
>>>>>      "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>>>>>      specs does not exist. I now have a fully encoded pair of Turing
>>>>>      Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
>>>>>
>>>>>      "I have proven that this argument is not valid by making an H that
>>>>>      decides (Ĥ, Ĥ)."
>>>>>
>>>>> That's way more impressive than the two and half years you've spent
>>>>> going backwards to something that only /may/ end up deciding its input
>>>>> correctly.
>>>>>
>>>>> If only you had all of the exact Turing machine description -- the
>>>>> actual instructions -- for such an H.  No one could argue with that!
>>>>
>>>> Sure and they wouldn't argue because they could never decipher the
>>>> hundreds of millions of pages of execution trace.
>>>
>>> Oh!  So you lied when you said that the decision your H gives is "easily
>>> verifiably correct".
>>
>> Everyone here knows that you are intentionally misconstruing
>> everything that I say. Many of those won't admit it because they are
>> doing the same thing. Malcolm is the only one here that is definitely
>> not doing this.
> 
> How should one construe your claim to have the exact instructions of a
> TM, H, that correctly decides the halting of its (H^, H^) pair such that
> it's correctness is easy to verify?  What is the correct way to read
> your words from back then?
> 

As a closed subject.

>>>>> Oh, you do:
>>>>>      "I ... more importantly encoded all of the exact TMD instructions of
>>>>>      the Linz Turing machine H that correctly decides halting for its fully
>>>>>      encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
>>>>>
>>>>> Gosh!  Publish this and the argument will be over (and I know which way
>>>>> it will go!).
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39757

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-23 03:04 +0100
Message-ID<878rzo11zk.fsf@bsb.me.uk>
In reply to#39756
olcott <NoOne@NoWhere.com> writes:

> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/22/2021 6:47 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>>>>
>>>>>>>> That's a sketch of the Linz proof translated to C.  But only a
>>>>>>>> sketch. Anyone can see why halt_decider must get the call wrong.
>>>>>>>> But only if halt_decider is written in a legitimate way. There are
>>>>>>>> various tricks we can use in C to make it return inconsistent
>>>>>>>> results. That's partly why Linz uses Turing machines.
>>>>>>
>>>>>> And why PO does not!
>>>>>>
>>>>>>> I think that it may end up with the same H1/H system that decides its
>>>>>>> input correctly.
>>>>>>
>>>>>> You think it may end up there?  You had a "correct" decider for the key
>>>>>> case in Dec 2018:
>>>>>>
>>>>>>      "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>>>>>>      specs does not exist. I now have a fully encoded pair of Turing
>>>>>>      Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
>>>>>>
>>>>>>      "I have proven that this argument is not valid by making an H that
>>>>>>      decides (Ĥ, Ĥ)."
>>>>>>
>>>>>> That's way more impressive than the two and half years you've spent
>>>>>> going backwards to something that only /may/ end up deciding its input
>>>>>> correctly.
>>>>>>
>>>>>> If only you had all of the exact Turing machine description -- the
>>>>>> actual instructions -- for such an H.  No one could argue with that!
>>>>>
>>>>> Sure and they wouldn't argue because they could never decipher the
>>>>> hundreds of millions of pages of execution trace.
>>>>
>>>> Oh!  So you lied when you said that the decision your H gives is "easily
>>>> verifiably correct".
>>>
>>> Everyone here knows that you are intentionally misconstruing
>>> everything that I say. Many of those won't admit it because they are
>>> doing the same thing. Malcolm is the only one here that is definitely
>>> not doing this.
>>
>> How should one construe your claim to have the exact instructions of a
>> TM, H, that correctly decides the halting of its (H^, H^) pair such that
>> it's correctness is easy to verify?  What is the correct way to read
>> your words from back then? 
>
> As a closed subject.

You mean it was not true and you wish you'd never said it?  That would
make it a closed subject.  I have no wish to rake over embarrassing old
mistakes.  But while you continue to stand by what you said whilst
continuing to work on something you say you solved nearly three years
ago, the subject remains very much open.

>>>>>> Oh, you do:
>>>>>>      "I ... more importantly encoded all of the exact TMD instructions of
>>>>>>      the Linz Turing machine H that correctly decides halting for its fully
>>>>>>      encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
>>>>>>
>>>>>> Gosh!  Publish this and the argument will be over (and I know which way
>>>>>> it will go!).

-- 
Ben.

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


#39759

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 21:07 -0500
Message-ID<B-WdnVABq93YfNb8nZ2dnUU7-TudnZ2d@giganews.com>
In reply to#39757
On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/22/2021 6:47 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/22/2021 6:22 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 9/22/2021 12:30 AM, Malcolm McLean wrote:
>>>>>
>>>>>>>>> That's a sketch of the Linz proof translated to C.  But only a
>>>>>>>>> sketch. Anyone can see why halt_decider must get the call wrong.
>>>>>>>>> But only if halt_decider is written in a legitimate way. There are
>>>>>>>>> various tricks we can use in C to make it return inconsistent
>>>>>>>>> results. That's partly why Linz uses Turing machines.
>>>>>>>
>>>>>>> And why PO does not!
>>>>>>>
>>>>>>>> I think that it may end up with the same H1/H system that decides its
>>>>>>>> input correctly.
>>>>>>>
>>>>>>> You think it may end up there?  You had a "correct" decider for the key
>>>>>>> case in Dec 2018:
>>>>>>>
>>>>>>>       "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
>>>>>>>       specs does not exist. I now have a fully encoded pair of Turing
>>>>>>>       Machines H / Ĥ proving them wrong."    Peter Olcott, Dec 15th 2018.
>>>>>>>
>>>>>>>       "I have proven that this argument is not valid by making an H that
>>>>>>>       decides (Ĥ, Ĥ)."
>>>>>>>
>>>>>>> That's way more impressive than the two and half years you've spent
>>>>>>> going backwards to something that only /may/ end up deciding its input
>>>>>>> correctly.
>>>>>>>
>>>>>>> If only you had all of the exact Turing machine description -- the
>>>>>>> actual instructions -- for such an H.  No one could argue with that!
>>>>>>
>>>>>> Sure and they wouldn't argue because they could never decipher the
>>>>>> hundreds of millions of pages of execution trace.
>>>>>
>>>>> Oh!  So you lied when you said that the decision your H gives is "easily
>>>>> verifiably correct".
>>>>
>>>> Everyone here knows that you are intentionally misconstruing
>>>> everything that I say. Many of those won't admit it because they are
>>>> doing the same thing. Malcolm is the only one here that is definitely
>>>> not doing this.
>>>
>>> How should one construe your claim to have the exact instructions of a
>>> TM, H, that correctly decides the halting of its (H^, H^) pair such that
>>> it's correctness is easy to verify?  What is the correct way to read
>>> your words from back then?
>>
>> As a closed subject.
> 
> You mean it was not true and you wish you'd never said it?  


If I said that I had the cure for ever known cancer and I have this cure 
written in German and it turned out that this was a correct cure yet it 
was written in English this would be of negligible consequence.

I had the essence of correct solution for how the Linz H correctly 
decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of a TM 
description language. The key essence of what I said was and is true.


> That would
> make it a closed subject.  I have no wish to rake over embarrassing old
> mistakes.  But while you continue to stand by what you said whilst
> continuing to work on something you say you solved nearly three years
> ago, the subject remains very much open.
> 
>>>>>>> Oh, you do:
>>>>>>>       "I ... more importantly encoded all of the exact TMD instructions of
>>>>>>>       the Linz Turing machine H that correctly decides halting for its fully
>>>>>>>       encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec 14th 2018.
>>>>>>>
>>>>>>> Gosh!  Publish this and the argument will be over (and I know which way
>>>>>>> it will go!).
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39764

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-22 22:31 -0400
Message-ID<nGR2J.1479$yk1.648@fx13.iad>
In reply to#39759
On 9/22/21 10:07 PM, olcott wrote:
> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>
>> You mean it was not true and you wish you'd never said it?  
> 
> 
> If I said that I had the cure for ever known cancer and I have this cure
> written in German and it turned out that this was a correct cure yet it
> was written in English this would be of negligible consequence.

Except that you don't have the solution in the wrong language. Instead
of a cure for cancer, you have a way to a new way to drink soup up your
nose with a straw.

> 
> I had the essence of correct solution for how the Linz H correctly
> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of a TM
> description language. The key essence of what I said was and is true.

Except that you didn't, or you wouldn't be having to redo it yet AGAIN.

What take are you on? I have lost track.

> 
> 
>> That would
>> make it a closed subject.  I have no wish to rake over embarrassing old
>> mistakes.  But while you continue to stand by what you said whilst
>> continuing to work on something you say you solved nearly three years
>> ago, the subject remains very much open.
>>
>>>>>>>> Oh, you do:
>>>>>>>>       "I ... more importantly encoded all of the exact TMD
>>>>>>>> instructions of
>>>>>>>>       the Linz Turing machine H that correctly decides halting
>>>>>>>> for its fully
>>>>>>>>       encoded input pair: (Ĥ, Ĥ)."           Peter Olcott, Dec
>>>>>>>> 14th 2018.
>>>>>>>>
>>>>>>>> Gosh!  Publish this and the argument will be over (and I know
>>>>>>>> which way
>>>>>>>> it will go!).
>>
> 
> 

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


#39767

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-23 03:37 +0100
Message-ID<87wnn8yq2y.fsf@bsb.me.uk>
In reply to#39759
olcott <NoOne@NoWhere.com> writes:

> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:

>>>> How should one construe your claim to have the exact instructions of a
>>>> TM, H, that correctly decides the halting of its (H^, H^) pair such that
>>>> it's correctness is easy to verify?  What is the correct way to read
>>>> your words from back then?
>>>
>>> As a closed subject.
>>
>> You mean it was not true and you wish you'd never said it?  
>
> If I said that I had the cure for ever known cancer and I have this
> cure written in German and it turned out that this was a correct cure
> yet it was written in English this would be of negligible consequence.

And we would be just as baffled as to why you won't publish your German
cancer cure as we are about your continuing to hide an "easily
verifiably correct" solution to H(H^, H^).

> I had the essence of correct solution for how the Linz H correctly
> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of a TM 
> description language.

And you then consciously and deliberately wrote:

  "I ... more importantly encoded all of the exact TMD instructions of
  the Linz Turing machine H that correctly decides halting for its fully
  encoded input pair: (Ĥ, Ĥ)."

Don't you think that merits an apology given that people had no choice
but to take you at your word?

> The key essence of what I said was and is true.

The key essence is that, apparently, your C sketch's answer is "easily
verifiably correct".  That makes it a thousand times better than what
you are working on now.  Publish it.

-- 
Ben.

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


#39770

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 21:56 -0500
Message-ID<Ypmdnf7k_Ppycdb8nZ2dnUU7-cXNnZ2d@giganews.com>
In reply to#39767
On 9/22/2021 9:37 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
> 
>>>>> How should one construe your claim to have the exact instructions of a
>>>>> TM, H, that correctly decides the halting of its (H^, H^) pair such that
>>>>> it's correctness is easy to verify?  What is the correct way to read
>>>>> your words from back then?
>>>>
>>>> As a closed subject.
>>>
>>> You mean it was not true and you wish you'd never said it?
>>
>> If I said that I had the cure for ever known cancer and I have this
>> cure written in German and it turned out that this was a correct cure
>> yet it was written in English this would be of negligible consequence.
> 
> And we would be just as baffled as to why you won't publish your German
> cancer cure as we are about your continuing to hide an "easily
> verifiably correct" solution to H(H^, H^).
> 
>> I had the essence of correct solution for how the Linz H correctly
>> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of a TM
>> description language.
> 
> And you then consciously and deliberately wrote:
> 
>    "I ... more importantly encoded all of the exact TMD instructions of
>    the Linz Turing machine H that correctly decides halting for its fully
>    encoded input pair: (Ĥ, Ĥ)."
> 
> Don't you think that merits an apology given that people had no choice
> but to take you at your word?
> 
>> The key essence of what I said was and is true.
> 
> The key essence is that, apparently, your C sketch's answer is "easily
> verifiably correct".  That makes it a thousand times better than what
> you are working on now.  Publish it.
> 

The key essence of what I need to do before I publish is make sure that 
what I have is a proper computation or adapt it to become one.

Because several people here are apparently nothing more than naysayers 
making sure to always disagree with whatever I say it is difficult for 
me to assess the actual requirements of a computation expressed in C/x86.

Richard seems to have some good insights yet these are mixed in with 
complete ignorance of basic software engineering principles. You have 
never claimed to understand any aspect of software engineering at all.

It seems utterly incomprehensible that all computations are required to 
be a single monolithic block. Richard is probably just talking out of 
his ass on this one.


-- 
Copyright 2021 Pete Olcott

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

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


#39775

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-22 23:17 -0400
Message-ID<elS2J.175644$T_8.151209@fx48.iad>
In reply to#39770
On 9/22/21 10:56 PM, olcott wrote:
> On 9/22/2021 9:37 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>>
>>>>>> How should one construe your claim to have the exact instructions
>>>>>> of a
>>>>>> TM, H, that correctly decides the halting of its (H^, H^) pair
>>>>>> such that
>>>>>> it's correctness is easy to verify?  What is the correct way to read
>>>>>> your words from back then?
>>>>>
>>>>> As a closed subject.
>>>>
>>>> You mean it was not true and you wish you'd never said it?
>>>
>>> If I said that I had the cure for ever known cancer and I have this
>>> cure written in German and it turned out that this was a correct cure
>>> yet it was written in English this would be of negligible consequence.
>>
>> And we would be just as baffled as to why you won't publish your German
>> cancer cure as we are about your continuing to hide an "easily
>> verifiably correct" solution to H(H^, H^).
>>
>>> I had the essence of correct solution for how the Linz H correctly
>>> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of a TM
>>> description language.
>>
>> And you then consciously and deliberately wrote:
>>
>>    "I ... more importantly encoded all of the exact TMD instructions of
>>    the Linz Turing machine H that correctly decides halting for its fully
>>    encoded input pair: (Ĥ, Ĥ)."
>>
>> Don't you think that merits an apology given that people had no choice
>> but to take you at your word?
>>
>>> The key essence of what I said was and is true.
>>
>> The key essence is that, apparently, your C sketch's answer is "easily
>> verifiably correct".  That makes it a thousand times better than what
>> you are working on now.  Publish it.
>>
> 
> The key essence of what I need to do before I publish is make sure that
> what I have is a proper computation or adapt it to become one.

So, you are admitting that what you have isn't a Computation. Good first
step.

> 
> Because several people here are apparently nothing more than naysayers
> making sure to always disagree with whatever I say it is difficult for
> me to assess the actual requirements of a computation expressed in C/x86.

The languge that you are writing in doesn't matter.
> 
> Richard seems to have some good insights yet these are mixed in with
> complete ignorance of basic software engineering principles. You have
> never claimed to understand any aspect of software engineering at all.

I think you will find that I know software better than you do.

From everything I have heard, I have been writing software for longer,
and been in higher responsibility positions. As well as I am still
gainfully employed in a position  where I am being paid to do it.

> 
> It seems utterly incomprehensible that all computations are required to
> be a single monolithic block. Richard is probably just talking out of
> his ass on this one.
> 
> 

I have never said they need to be a single monolithic function block.
That is you not understanding what I am saying, perhaps because you can
only think of keeping things together as a monolithic block.

A Computation includes ALL of the code that is part of it. I C that
means it includes the function you call and all the functions that it calls.

C is NOT good at expressing this for 'large scale' computations. Yes, if
it is small enough that a single function works right, then it works.

Otherwise, it just doesn't get expressed in the C language.

At the assembly/machine level, one thing you can do is use linker
instructions to place all the needed code into a single 'program segment'

Of course the bigger problem is that C/x86 is not the right environment
to be making detailed arguemnts about what a Computation is, as that
architecture is full of ways to make a code fragment not be one.

And, unless you are careful in how you compile your code, your copy
operation is likely going to break the code, you really do need it to
FULLY Position independent.

Now, if you really want to understand what a computation is, what you
need to do is study how Turing Machines actually work. Write a few
simple programs as Turing Machines to see how it works.

The problem is you need to really be able to think in different
paradigms which seems to be beyond your ability.

Have you ever worked with REAL stack machines instead of machines with
registger files? That requires a different way of thinking.

How about machines with very limited RAM but large serial tapes for
storage. That needs a different way to solve problems.

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


#39779

Fromolcott <NoOne@NoWhere.com>
Date2021-09-22 23:02 -0500
Message-ID<xcydnR16zsn8Ydb8nZ2dnUU7-SXNnZ2d@giganews.com>
In reply to#39775
On 9/22/2021 10:17 PM, Richard Damon wrote:
> On 9/22/21 10:56 PM, olcott wrote:
>> On 9/22/2021 9:37 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>>>
>>>>>>> How should one construe your claim to have the exact instructions
>>>>>>> of a
>>>>>>> TM, H, that correctly decides the halting of its (H^, H^) pair
>>>>>>> such that
>>>>>>> it's correctness is easy to verify?  What is the correct way to read
>>>>>>> your words from back then?
>>>>>>
>>>>>> As a closed subject.
>>>>>
>>>>> You mean it was not true and you wish you'd never said it?
>>>>
>>>> If I said that I had the cure for ever known cancer and I have this
>>>> cure written in German and it turned out that this was a correct cure
>>>> yet it was written in English this would be of negligible consequence.
>>>
>>> And we would be just as baffled as to why you won't publish your German
>>> cancer cure as we are about your continuing to hide an "easily
>>> verifiably correct" solution to H(H^, H^).
>>>
>>>> I had the essence of correct solution for how the Linz H correctly
>>>> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of a TM
>>>> description language.
>>>
>>> And you then consciously and deliberately wrote:
>>>
>>>     "I ... more importantly encoded all of the exact TMD instructions of
>>>     the Linz Turing machine H that correctly decides halting for its fully
>>>     encoded input pair: (Ĥ, Ĥ)."
>>>
>>> Don't you think that merits an apology given that people had no choice
>>> but to take you at your word?
>>>
>>>> The key essence of what I said was and is true.
>>>
>>> The key essence is that, apparently, your C sketch's answer is "easily
>>> verifiably correct".  That makes it a thousand times better than what
>>> you are working on now.  Publish it.
>>>
>>
>> The key essence of what I need to do before I publish is make sure that
>> what I have is a proper computation or adapt it to become one.
> 
> So, you are admitting that what you have isn't a Computation. Good first
> step.
> 

I am acknowledging the possibility that my proof is not in the required 
form.

>>
>> Because several people here are apparently nothing more than naysayers
>> making sure to always disagree with whatever I say it is difficult for
>> me to assess the actual requirements of a computation expressed in C/x86.
> 
> The languge that you are writing in doesn't matter.

I need to know how to make C/x86 a computation.

>>
>> Richard seems to have some good insights yet these are mixed in with
>> complete ignorance of basic software engineering principles. You have
>> never claimed to understand any aspect of software engineering at all.
> 
> I think you will find that I know software better than you do.
> 
>  From everything I have heard, I have been writing software for longer,
> and been in higher responsibility positions. As well as I am still
> gainfully employed in a position  where I am being paid to do it.
> 

It is not a matter of mere subjective credibility.

it is a matter of whether or not you can figure out the architectural 
design of simulating partial halt decider for the following case given 
that H has access to an x86 emulator:

void P(u32 x)
{
   H(x, x);
}

int main()
{
   Output("Input_Halts = ", H((u32)P, (u32)P));
}


>>
>> It seems utterly incomprehensible that all computations are required to
>> be a single monolithic block. Richard is probably just talking out of
>> his ass on this one.
>>
>>
> 
> I have never said they need to be a single monolithic function block.
> That is you not understanding what I am saying, perhaps because you can
> only think of keeping things together as a monolithic block.
> 
> A Computation includes ALL of the code that is part of it. I C that
> means it includes the function you call and all the functions that it calls.
> 

That is fine then. That is the way that I already understood it to be.
When P copies its own machine code it does not copy the code of H.

> C is NOT good at expressing this for 'large scale' computations. Yes, if
> it is small enough that a single function works right, then it works.
> 
> Otherwise, it just doesn't get expressed in the C language.
> 
> At the assembly/machine level, one thing you can do is use linker
> instructions to place all the needed code into a single 'program segment'
> 

I can't allow the linker to get involved at all. My system directly 
executes Microsoft generated COFF object files.

> Of course the bigger problem is that C/x86 is not the right environment
> to be making detailed arguemnts about what a Computation is, as that
> architecture is full of ways to make a code fragment not be one.
> 
> And, unless you are careful in how you compile your code, your copy
> operation is likely going to break the code, you really do need it to
> FULLY Position independent.
> 

I have already handled all this. I am quite good at the x86 language.

> Now, if you really want to understand what a computation is, what you
> need to do is study how Turing Machines actually work. Write a few
> simple programs as Turing Machines to see how it works.
> 

I haven't the time I may not be alive that long. I must stay focused.

> The problem is you need to really be able to think in different
> paradigms which seems to be beyond your ability.
> 
> Have you ever worked with REAL stack machines instead of machines with
> registger files? That requires a different way of thinking.
> 
> How about machines with very limited RAM but large serial tapes for
> storage. That needs a different way to solve problems.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39782

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-23 00:23 -0400
Message-ID<WiT2J.36947$rsCb.7264@fx01.iad>
In reply to#39779
On 9/23/21 12:02 AM, olcott wrote:
> On 9/22/2021 10:17 PM, Richard Damon wrote:
>> On 9/22/21 10:56 PM, olcott wrote:
>>> On 9/22/2021 9:37 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>>>>
>>>>>>>> How should one construe your claim to have the exact instructions
>>>>>>>> of a
>>>>>>>> TM, H, that correctly decides the halting of its (H^, H^) pair
>>>>>>>> such that
>>>>>>>> it's correctness is easy to verify?  What is the correct way to
>>>>>>>> read
>>>>>>>> your words from back then?
>>>>>>>
>>>>>>> As a closed subject.
>>>>>>
>>>>>> You mean it was not true and you wish you'd never said it?
>>>>>
>>>>> If I said that I had the cure for ever known cancer and I have this
>>>>> cure written in German and it turned out that this was a correct cure
>>>>> yet it was written in English this would be of negligible consequence.
>>>>
>>>> And we would be just as baffled as to why you won't publish your German
>>>> cancer cure as we are about your continuing to hide an "easily
>>>> verifiably correct" solution to H(H^, H^).
>>>>
>>>>> I had the essence of correct solution for how the Linz H correctly
>>>>> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of
>>>>> a TM
>>>>> description language.
>>>>
>>>> And you then consciously and deliberately wrote:
>>>>
>>>>     "I ... more importantly encoded all of the exact TMD
>>>> instructions of
>>>>     the Linz Turing machine H that correctly decides halting for its
>>>> fully
>>>>     encoded input pair: (Ĥ, Ĥ)."
>>>>
>>>> Don't you think that merits an apology given that people had no choice
>>>> but to take you at your word?
>>>>
>>>>> The key essence of what I said was and is true.
>>>>
>>>> The key essence is that, apparently, your C sketch's answer is "easily
>>>> verifiably correct".  That makes it a thousand times better than what
>>>> you are working on now.  Publish it.
>>>>
>>>
>>> The key essence of what I need to do before I publish is make sure that
>>> what I have is a proper computation or adapt it to become one.
>>
>> So, you are admitting that what you have isn't a Computation. Good first
>> step.
>>
> 
> I am acknowledging the possibility that my proof is not in the required
> form.
> 

Good

>>>
>>> Because several people here are apparently nothing more than naysayers
>>> making sure to always disagree with whatever I say it is difficult for
>>> me to assess the actual requirements of a computation expressed in
>>> C/x86.
>>
>> The languge that you are writing in doesn't matter.
> 
> I need to know how to make C/x86 a computation.

First you need to learn what is a computaiton.

The simplest way is not to use the tools that make it not one.

> 
>>>
>>> Richard seems to have some good insights yet these are mixed in with
>>> complete ignorance of basic software engineering principles. You have
>>> never claimed to understand any aspect of software engineering at all.
>>
>> I think you will find that I know software better than you do.
>>
>>  From everything I have heard, I have been writing software for longer,
>> and been in higher responsibility positions. As well as I am still
>> gainfully employed in a position  where I am being paid to do it.
>>
> 
> It is not a matter of mere subjective credibility.

Then why do you try to claim you have such better skills than others who
are likely actually better than you are.

> 
> it is a matter of whether or not you can figure out the architectural
> design of simulating partial halt decider for the following case given
> that H has access to an x86 emulator:

I won't do it because I know it is a fools errend. I won't do your crap
for you.

Define what 'partial' it needs to handle. That can't include inputs that
are contradictory, as that is an impossible task, but that is likely the
only one you care about.

> 
> void P(u32 x)
> {
>   H(x, x);
> }
> 
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
> 
> 
>>>
>>> It seems utterly incomprehensible that all computations are required to
>>> be a single monolithic block. Richard is probably just talking out of
>>> his ass on this one.
>>>
>>>
>>
>> I have never said they need to be a single monolithic function block.
>> That is you not understanding what I am saying, perhaps because you can
>> only think of keeping things together as a monolithic block.
>>
>> A Computation includes ALL of the code that is part of it. I C that
>> means it includes the function you call and all the functions that it
>> calls.
>>
> 
> That is fine then. That is the way that I already understood it to be.
> When P copies its own machine code it does not copy the code of H.

But the code for H is PART of the Computation of P.

Function P is NOT a Computation by itself. The behavior of function P is
dependent on something besides its formal input x, namely the definition
of the function H.

To make P a computation, you need to include the code for H, and
everything that H calls and so on.

> 
>> C is NOT good at expressing this for 'large scale' computations. Yes, if
>> it is small enough that a single function works right, then it works.
>>
>> Otherwise, it just doesn't get expressed in the C language.
>>
>> At the assembly/machine level, one thing you can do is use linker
>> instructions to place all the needed code into a single 'program segment'
>>
> 
> I can't allow the linker to get involved at all. My system directly
> executes Microsoft generated COFF object files.

Then you need to add that capability into your program. You need both a
COFF file and a control file to allow you to control where pieces get
placed.

If not, just make a copy of the WHOLE program segment of your program.
That should get enough.

Basiclly your problem is you chose the wrong tool for the job. You have
a screw to put in and you grabed a jack hammer.

> 
>> Of course the bigger problem is that C/x86 is not the right environment
>> to be making detailed arguemnts about what a Computation is, as that
>> architecture is full of ways to make a code fragment not be one.
>>
>> And, unless you are careful in how you compile your code, your copy
>> operation is likely going to break the code, you really do need it to
>> FULLY Position independent.
>>
> 
> I have already handled all this. I am quite good at the x86 language.

Right, but it also means that you need the call to H to be PIC, so the
copied P calls the copied H. And all the code inside H needs to be PIC.

> 
>> Now, if you really want to understand what a computation is, what you
>> need to do is study how Turing Machines actually work. Write a few
>> simple programs as Turing Machines to see how it works.
>>
> 
> I haven't the time I may not be alive that long. I must stay focused.

Sounds like you have already wasted a few decades, maybe doing it right
the Nth time might be the right choice.

That, or give up. It is really futile to try to solve something you
don't really understand.

> 
>> The problem is you need to really be able to think in different
>> paradigms which seems to be beyond your ability.
>>
>> Have you ever worked with REAL stack machines instead of machines with
>> registger files? That requires a different way of thinking.
>>
>> How about machines with very limited RAM but large serial tapes for
>> storage. That needs a different way to solve problems.
>>
> 
> 

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


#39788

Fromolcott <NoOne@NoWhere.com>
Date2021-09-23 08:10 -0500
Message-ID<N8OdnXz4s6sw4dH8nZ2dnUU7-SHNnZ2d@giganews.com>
In reply to#39782
On 9/22/2021 11:23 PM, Richard Damon wrote:
> On 9/23/21 12:02 AM, olcott wrote:
>> On 9/22/2021 10:17 PM, Richard Damon wrote:
>>> On 9/22/21 10:56 PM, olcott wrote:
>>>> On 9/22/2021 9:37 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>>>>>
>>>>>>>>> How should one construe your claim to have the exact instructions
>>>>>>>>> of a
>>>>>>>>> TM, H, that correctly decides the halting of its (H^, H^) pair
>>>>>>>>> such that
>>>>>>>>> it's correctness is easy to verify?  What is the correct way to
>>>>>>>>> read
>>>>>>>>> your words from back then?
>>>>>>>>
>>>>>>>> As a closed subject.
>>>>>>>
>>>>>>> You mean it was not true and you wish you'd never said it?
>>>>>>
>>>>>> If I said that I had the cure for ever known cancer and I have this
>>>>>> cure written in German and it turned out that this was a correct cure
>>>>>> yet it was written in English this would be of negligible consequence.
>>>>>
>>>>> And we would be just as baffled as to why you won't publish your German
>>>>> cancer cure as we are about your continuing to hide an "easily
>>>>> verifiably correct" solution to H(H^, H^).
>>>>>
>>>>>> I had the essence of correct solution for how the Linz H correctly
>>>>>> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of
>>>>>> a TM
>>>>>> description language.
>>>>>
>>>>> And you then consciously and deliberately wrote:
>>>>>
>>>>>      "I ... more importantly encoded all of the exact TMD
>>>>> instructions of
>>>>>      the Linz Turing machine H that correctly decides halting for its
>>>>> fully
>>>>>      encoded input pair: (Ĥ, Ĥ)."
>>>>>
>>>>> Don't you think that merits an apology given that people had no choice
>>>>> but to take you at your word?
>>>>>
>>>>>> The key essence of what I said was and is true.
>>>>>
>>>>> The key essence is that, apparently, your C sketch's answer is "easily
>>>>> verifiably correct".  That makes it a thousand times better than what
>>>>> you are working on now.  Publish it.
>>>>>
>>>>
>>>> The key essence of what I need to do before I publish is make sure that
>>>> what I have is a proper computation or adapt it to become one.
>>>
>>> So, you are admitting that what you have isn't a Computation. Good first
>>> step.
>>>
>>
>> I am acknowledging the possibility that my proof is not in the required
>> form.
>>
> 
> Good
> 
>>>>
>>>> Because several people here are apparently nothing more than naysayers
>>>> making sure to always disagree with whatever I say it is difficult for
>>>> me to assess the actual requirements of a computation expressed in
>>>> C/x86.
>>>
>>> The languge that you are writing in doesn't matter.
>>
>> I need to know how to make C/x86 a computation.
> 
> First you need to learn what is a computaiton.
> 
> The simplest way is not to use the tools that make it not one.
> 
>>
>>>>
>>>> Richard seems to have some good insights yet these are mixed in with
>>>> complete ignorance of basic software engineering principles. You have
>>>> never claimed to understand any aspect of software engineering at all.
>>>
>>> I think you will find that I know software better than you do.
>>>
>>>   From everything I have heard, I have been writing software for longer,
>>> and been in higher responsibility positions. As well as I am still
>>> gainfully employed in a position  where I am being paid to do it.
>>>
>>
>> It is not a matter of mere subjective credibility.
> 
> Then why do you try to claim you have such better skills than others who
> are likely actually better than you are.
> 
>>
>> it is a matter of whether or not you can figure out the architectural
>> design of simulating partial halt decider for the following case given
>> that H has access to an x86 emulator:
> 
> I won't do it because I know it is a fools errend. I won't do your crap
> for you.
> 
> Define what 'partial' it needs to handle. That can't include inputs that
> are contradictory, as that is an impossible task, but that is likely the
> only one you care about.
> 

H merely needs to correctly decide the halt status of P.
A fully operational x86 emulator is provided.

>>
>> void P(u32 x)
>> {
>>    H(x, x);
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>>
>>>>
>>>> It seems utterly incomprehensible that all computations are required to
>>>> be a single monolithic block. Richard is probably just talking out of
>>>> his ass on this one.
>>>>
>>>>
>>>
>>> I have never said they need to be a single monolithic function block.
>>> That is you not understanding what I am saying, perhaps because you can
>>> only think of keeping things together as a monolithic block.
>>>
>>> A Computation includes ALL of the code that is part of it. I C that
>>> means it includes the function you call and all the functions that it
>>> calls.
>>>
>>
>> That is fine then. That is the way that I already understood it to be.
>> When P copies its own machine code it does not copy the code of H.
> 
> But the code for H is PART of the Computation of P.
> 

You can do it any way that you want s long as it correctly derives the 
correct answer through a correct sequence of steps.

The whole purpose of this exercise is to prove to you and the world who 
is confused and who is not confused.

> Function P is NOT a Computation by itself. The behavior of function P is
> dependent on something besides its formal input x, namely the definition
> of the function H.
> 
> To make P a computation, you need to include the code for H, and
> everything that H calls and so on.
> 

That is your job. You will either figure out the essence of this and 
know that I am correct or admit that it is over your head.

>>
>>> C is NOT good at expressing this for 'large scale' computations. Yes, if
>>> it is small enough that a single function works right, then it works.
>>>
>>> Otherwise, it just doesn't get expressed in the C language.
>>>
>>> At the assembly/machine level, one thing you can do is use linker
>>> instructions to place all the needed code into a single 'program segment'
>>>
>>
>> I can't allow the linker to get involved at all. My system directly
>> executes Microsoft generated COFF object files.
> 
> Then you need to add that capability into your program. You need both a
> COFF file and a control file to allow you to control where pieces get
> placed.
> 

Not at all. I simply directly execute main() in the COFF file.

> If not, just make a copy of the WHOLE program segment of your program.
> That should get enough.
> 

It works just fine by directly emulating the COFF object file.

> Basiclly your problem is you chose the wrong tool for the job. You have
> a screw to put in and you grabed a jack hammer.

So in other words the architectural design of a simulating halt decider 
that can detect the simplest possible case of itself being called in in 
infinitely nested simulation is over your head. I already knew that.

> 
>>
>>> Of course the bigger problem is that C/x86 is not the right environment
>>> to be making detailed arguemnts about what a Computation is, as that
>>> architecture is full of ways to make a code fragment not be one.
>>>
>>> And, unless you are careful in how you compile your code, your copy
>>> operation is likely going to break the code, you really do need it to
>>> FULLY Position independent.
>>>
>>
>> I have already handled all this. I am quite good at the x86 language.
> 
> Right, but it also means that you need the call to H to be PIC, so the
> copied P calls the copied H. And all the code inside H needs to be PIC.

Have you changed the subject to guitars?
It is the academic convention to define an acronym upon first use.
I have no idea what a PIC is.

> 
>>
>>> Now, if you really want to understand what a computation is, what you
>>> need to do is study how Turing Machines actually work. Write a few
>>> simple programs as Turing Machines to see how it works.
>>>
>>
>> I haven't the time I may not be alive that long. I must stay focused.
> 
> Sounds like you have already wasted a few decades, maybe doing it right
> the Nth time might be the right choice.
> 
> That, or give up. It is really futile to try to solve something you
> don't really understand.
> 

I can easily exactly duplicate the Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ now.
Not a good time to quit.

>>
>>> The problem is you need to really be able to think in different
>>> paradigms which seems to be beyond your ability.
>>>
>>> Have you ever worked with REAL stack machines instead of machines with
>>> registger files? That requires a different way of thinking.
>>>
>>> How about machines with very limited RAM but large serial tapes for
>>> storage. That needs a different way to solve problems.
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39800

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-23 21:42 -0400
Message-ID<D2a3J.39128$nR3.5153@fx38.iad>
In reply to#39788
On 9/23/21 9:10 AM, olcott wrote:
> On 9/22/2021 11:23 PM, Richard Damon wrote:
>> On 9/23/21 12:02 AM, olcott wrote:
>>> On 9/22/2021 10:17 PM, Richard Damon wrote:
>>>> On 9/22/21 10:56 PM, olcott wrote:
>>>>> On 9/22/2021 9:37 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/22/2021 9:04 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/22/2021 8:52 PM, Ben Bacarisse wrote:
>>>>>>
>>>>>>>>>> How should one construe your claim to have the exact instructions
>>>>>>>>>> of a
>>>>>>>>>> TM, H, that correctly decides the halting of its (H^, H^) pair
>>>>>>>>>> such that
>>>>>>>>>> it's correctness is easy to verify?  What is the correct way to
>>>>>>>>>> read
>>>>>>>>>> your words from back then?
>>>>>>>>>
>>>>>>>>> As a closed subject.
>>>>>>>>
>>>>>>>> You mean it was not true and you wish you'd never said it?
>>>>>>>
>>>>>>> If I said that I had the cure for ever known cancer and I have this
>>>>>>> cure written in German and it turned out that this was a correct
>>>>>>> cure
>>>>>>> yet it was written in English this would be of negligible
>>>>>>> consequence.
>>>>>>
>>>>>> And we would be just as baffled as to why you won't publish your
>>>>>> German
>>>>>> cancer cure as we are about your continuing to hide an "easily
>>>>>> verifiably correct" solution to H(H^, H^).
>>>>>>
>>>>>>> I had the essence of correct solution for how the Linz H correctly
>>>>>>> decides the halt status of the Linz ⟨Ĥ⟩ ⟨Ĥ⟩ written in C instead of
>>>>>>> a TM
>>>>>>> description language.
>>>>>>
>>>>>> And you then consciously and deliberately wrote:
>>>>>>
>>>>>>      "I ... more importantly encoded all of the exact TMD
>>>>>> instructions of
>>>>>>      the Linz Turing machine H that correctly decides halting for its
>>>>>> fully
>>>>>>      encoded input pair: (Ĥ, Ĥ)."
>>>>>>
>>>>>> Don't you think that merits an apology given that people had no
>>>>>> choice
>>>>>> but to take you at your word?
>>>>>>
>>>>>>> The key essence of what I said was and is true.
>>>>>>
>>>>>> The key essence is that, apparently, your C sketch's answer is
>>>>>> "easily
>>>>>> verifiably correct".  That makes it a thousand times better than what
>>>>>> you are working on now.  Publish it.
>>>>>>
>>>>>
>>>>> The key essence of what I need to do before I publish is make sure
>>>>> that
>>>>> what I have is a proper computation or adapt it to become one.
>>>>
>>>> So, you are admitting that what you have isn't a Computation. Good
>>>> first
>>>> step.
>>>>
>>>
>>> I am acknowledging the possibility that my proof is not in the required
>>> form.
>>>
>>
>> Good
>>
>>>>>
>>>>> Because several people here are apparently nothing more than naysayers
>>>>> making sure to always disagree with whatever I say it is difficult for
>>>>> me to assess the actual requirements of a computation expressed in
>>>>> C/x86.
>>>>
>>>> The languge that you are writing in doesn't matter.
>>>
>>> I need to know how to make C/x86 a computation.
>>
>> First you need to learn what is a computaiton.
>>
>> The simplest way is not to use the tools that make it not one.
>>
>>>
>>>>>
>>>>> Richard seems to have some good insights yet these are mixed in with
>>>>> complete ignorance of basic software engineering principles. You have
>>>>> never claimed to understand any aspect of software engineering at all.
>>>>
>>>> I think you will find that I know software better than you do.
>>>>
>>>>   From everything I have heard, I have been writing software for
>>>> longer,
>>>> and been in higher responsibility positions. As well as I am still
>>>> gainfully employed in a position  where I am being paid to do it.
>>>>
>>>
>>> It is not a matter of mere subjective credibility.
>>
>> Then why do you try to claim you have such better skills than others who
>> are likely actually better than you are.
>>
>>>
>>> it is a matter of whether or not you can figure out the architectural
>>> design of simulating partial halt decider for the following case given
>>> that H has access to an x86 emulator:
>>
>> I won't do it because I know it is a fools errend. I won't do your crap
>> for you.
>>
>> Define what 'partial' it needs to handle. That can't include inputs that
>> are contradictory, as that is an impossible task, but that is likely the
>> only one you care about.
>>
> 
> H merely needs to correctly decide the halt status of P.
> A fully operational x86 emulator is provided.

So you insist that I need to prove that 1 === 2?

H^/P is one machine that H can not possible give the right answer to.

As you have CORRECTLY stated, the question of what answer can H give to
decide H^/P correctly, IS the equivalent of the Liar's Paradox.

The problem with your argument is that isn't the question of the Halting
Problem. That Question is, "Give a Machine P and its input I, does the
Computation P(I) Halt in finite time or not?"

The decider is give a representation of this machine and input, and its
job is to give the right answer to that question, What does the machine
that this input is a representation do when it is actually run?

This question has a definite answer. Note, P represents a fully defined
machine, and for the machine H^, this means that for H^ to be fully
defined, so must H. Once you have defined what your claimed H is, then
the behavior of H^ is fully defined, and will be exactly the opposite of
what H predicts, so H is always wrong.

You CAN'T make the argument about what if H doesn't abort the
simulation, because that that point it is a fixed fact about whether it
will. The supposition that it behaves differently is a false
supposition, and thus not eligible to make sound decisions about the
behavior of THIS H^/P.

> 
>>>
>>> void P(u32 x)
>>> {
>>>    H(x, x);
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>>
>>>>>
>>>>> It seems utterly incomprehensible that all computations are
>>>>> required to
>>>>> be a single monolithic block. Richard is probably just talking out of
>>>>> his ass on this one.
>>>>>
>>>>>
>>>>
>>>> I have never said they need to be a single monolithic function block.
>>>> That is you not understanding what I am saying, perhaps because you can
>>>> only think of keeping things together as a monolithic block.
>>>>
>>>> A Computation includes ALL of the code that is part of it. I C that
>>>> means it includes the function you call and all the functions that it
>>>> calls.
>>>>
>>>
>>> That is fine then. That is the way that I already understood it to be.
>>> When P copies its own machine code it does not copy the code of H.
>>
>> But the code for H is PART of the Computation of P.
>>
> 
> You can do it any way that you want s long as it correctly derives the
> correct answer through a correct sequence of steps.
> 
> The whole purpose of this exercise is to prove to you and the world who
> is confused and who is not confused.


Again. you don't understand that you are asking to prove 1 == 2

> 
>> Function P is NOT a Computation by itself. The behavior of function P is
>> dependent on something besides its formal input x, namely the definition
>> of the function H.
>>
>> To make P a computation, you need to include the code for H, and
>> everything that H calls and so on.
>>
> 
> That is your job. You will either figure out the essence of this and
> know that I am correct or admit that it is over your head.

How is it my job. YOU are the one making the claim that H and P are the
equivalents to the Turing Machines in the Linz Proof.

That means that what is called H must include H, and what it is defined
to call an NOTHING else. H needs to be a self-contained executable
totally in itself.

Then P must be built that takes this definition of H, and makes its own
self contained executable that has all the code that is run when we run
P, which INCLUDES all the code of H.

Then we convert this P into some sort of representation (which might
just be a copy of the code for P), and we apply it as the input to P.

Note, the input is NOT executable, so it really should be in memory that
doesn't allow execution out of, or at least being able to show that you
aren't actually executing it.

The task you are asking to be done has been PROVEN to be impossible.

If you can show the ACTUAL error in the Linz Proof (not just that you
can 'prove' something contrary to what the proof says isn't sufficient,
you have to point out a claim that is factually incorrect.

Note, Linz does NOT 'neglect to consider' that H might be a 'Simulating
Turing Machine', because he makes aboslutely no assumptions about how
the decider works. Your simulating Halt Decider, when converted into an
actual Turing Machine (and if it meets the requirements, it will be
possible to do this) starts in a state that can be called H.q0, and then
progresses through some set of states that you get total freedom to
define and eventually ends up at either H.qn or H.qy depending on the
answer it gives. There is nothing in here that doesn't take into account
an ACTUAL Computation done by a simulator to make the decision.


> 
>>>
>>>> C is NOT good at expressing this for 'large scale' computations.
>>>> Yes, if
>>>> it is small enough that a single function works right, then it works.
>>>>
>>>> Otherwise, it just doesn't get expressed in the C language.
>>>>
>>>> At the assembly/machine level, one thing you can do is use linker
>>>> instructions to place all the needed code into a single 'program
>>>> segment'
>>>>
>>>
>>> I can't allow the linker to get involved at all. My system directly
>>> executes Microsoft generated COFF object files.
>>
>> Then you need to add that capability into your program. You need both a
>> COFF file and a control file to allow you to control where pieces get
>> placed.
>>
> 
> Not at all. I simply directly execute main() in the COFF file.

Just because you can't do it, doesn't mean it might not be a way to
acheive the requirements.

Not being able to do something does NOT give you the right to change the
requirements of the problem.

H and H^/P MUST be computations. That means whatever we define are
representing the Equivalent of these Turing Machine must meet the
properties of these machines. Thus whatever set of code represents the
Turing Machine H, must ALL and ONLY be include in what is called the
Computation H. And, whatever set of code represent the Truing Machine H^
must ALL and ONLY be include in what is called the Computation H^/P.

Both sets of code, when run as that particular Computation must be
complete and self-contained. Their 'input' must be distinct and not
actually executed (as that says that it wasn't complete). H^/P is
defined to make a copy, so that the input to H^/P can be given an input
that IS distinct from it, so we DON'T have a self-reference (which
Turing Machines can't directly represent).

> 
>> If not, just make a copy of the WHOLE program segment of your program.
>> That should get enough.
>>
> 
> It works just fine by directly emulating the COFF object file.

But if the 'input' to the decider is a COFF object file, the H^/P needs
to be giving H a COFF object file, but that isn't how you have defined
your system. I mentioned this a while back.

Maybe H needs to have as parameters a COEF file and a disk file tha it
uses as an input. H^/P reads this input file and makes a copy and sends
these two files to a its copy of H. This gets the needed isolation.

> 
>> Basiclly your problem is you chose the wrong tool for the job. You have
>> a screw to put in and you grabed a jack hammer.
> 
> So in other words the architectural design of a simulating halt decider
> that can detect the simplest possible case of itself being called in in
> infinitely nested simulation is over your head. I already knew that.
> 

It isn't over my head, it is IMPOSSIBLE, since if the decider detects
that it is in recursion and breaks that recursion to return an answer,
it can't be in infinite recursion.

That is like saying prove that 4 == 10.

>>
>>>
>>>> Of course the bigger problem is that C/x86 is not the right environment
>>>> to be making detailed arguemnts about what a Computation is, as that
>>>> architecture is full of ways to make a code fragment not be one.
>>>>
>>>> And, unless you are careful in how you compile your code, your copy
>>>> operation is likely going to break the code, you really do need it to
>>>> FULLY Position independent.
>>>>
>>>
>>> I have already handled all this. I am quite good at the x86 language.
>>
>> Right, but it also means that you need the call to H to be PIC, so the
>> copied P calls the copied H. And all the code inside H needs to be PIC.
> 
> Have you changed the subject to guitars?
> It is the academic convention to define an acronym upon first use.
> I have no idea what a PIC is.
> 


PIC = Position Independent Code. Since that is what the option is called
for most compilers, I figured you should know that one.

Maybe you DON'T know how to generate this code.

>>
>>>
>>>> Now, if you really want to understand what a computation is, what you
>>>> need to do is study how Turing Machines actually work. Write a few
>>>> simple programs as Turing Machines to see how it works.
>>>>
>>>
>>> I haven't the time I may not be alive that long. I must stay focused.
>>
>> Sounds like you have already wasted a few decades, maybe doing it right
>> the Nth time might be the right choice.
>>
>> That, or give up. It is really futile to try to solve something you
>> don't really understand.
>>
> 
> I can easily exactly duplicate the Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ now.
> Not a good time to quit.

I don't think so. Your H isn't a Computation, so you can't make it into
a Turing Machine.

When you show a H that actually IS a Computation, which means its code
is complete and not need anything new added to it code space, I will
beleive you.

Remember, that means the input tape should be able to be RW but not X
attributes.

> 
>>>
>>>> The problem is you need to really be able to think in different
>>>> paradigms which seems to be beyond your ability.
>>>>
>>>> Have you ever worked with REAL stack machines instead of machines with
>>>> registger files? That requires a different way of thinking.
>>>>
>>>> How about machines with very limited RAM but large serial tapes for
>>>> storage. That needs a different way to solve problems.
>>>>
>>>
>>>
>>
> 
> 

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


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

Back to top | Article view | comp.theory


csiph-web