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


#39973 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 12:14 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<taqdnaolBqCNYcz8nZ2dnUU7-TWdnZ2d@giganews.com>
In reply to#39971
On 9/27/2021 12:05 PM, Jeff Barnett wrote:
> On 9/27/2021 8:19 AM, olcott wrote:
>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>       <CRAP DELETED>
>>>>
>>>> So then maybe you are stupid or ignorant, The actual code itself 
>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless 
>>>> H(P,P) aborts the simulation of its input. In that case the 
>>>> simulation is cut off at 0xc41. In no case does this code reach 
>>>> final state 0xc50.
>>>
>>> <CRAP DELETED>
>>>
>>> So you now admit that your x86 simulator is flawed? Or maybe it 
>>> isn't, but you set it up wrong or are using it incorrectly? You need 
>>> to do something other than software; you're just not very good at it 
>>> you know. Working in an area where you are inadequate causes you to 
>>> act like a bad person out of frustration. Here you are calling Andre 
>>> stupid and ignorant for trying to help you and make you better. You 
>>> should say "thank you" instead of being such a crappy person. You 
>>> should change your area of study to something simple like cooking 
>>> rice. A few successes would improve your self image and stop the name 
>>> calling and tantrums. You are no longer 3 years old. Time to mature a 
>>> little.
>>
>> You are a clueless wonder that only has utterly baseless nay saying.
> 
> More name calling; so out of control. a recapitulation of the "terrible 
> threes". Concentrate; control yourself; be grateful for help offered to 
> you. Time's short; strive for adulthood now. We are all rooting for you. 
> Give life as an adult a chance while you have that opportunity. Good luck.

That you are a clueless wonder relative to your utterly baseless nay 
saying about my work is self-evidently true to anyone having sufficient 
understanding of the underlying subject matter.

-- 
Copyright 2021 Pete Olcott

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

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


#39975 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromJeff Barnett <jbb@notatt.com>
Date2021-09-27 11:52 -0600
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<sit0cv$3hi$1@dont-email.me>
In reply to#39973
On 9/27/2021 11:14 AM, olcott wrote:
> On 9/27/2021 12:05 PM, Jeff Barnett wrote:
>>> You are a clueless wonder that only has utterly baseless nay saying.
>>
>> More name calling; so out of control. a recapitulation of the 
>> "terrible threes". Concentrate; control yourself; be grateful for help 
>> offered to you. Time's short; strive for adulthood now. We are all 
>> rooting for you. Give life as an adult a chance while you have that 
>> opportunity. Good luck.
> 
> That you are a clueless wonder relative to your utterly baseless nay 
> saying about my work is self-evidently true to anyone having sufficient 
> understanding of the underlying subject matter.

You are in a loop, just like your ill-conceived simulator. Do give life 
as an adult a chance. Life only gives us limited opportunities to do 
better. Carpe diem! And best of luck with adulthood; we are all rooting 
for you.
-- 
Jeff Barnett

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


#39977 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 13:08 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<VLudnRfaIu41lc_8nZ2dnUU7-c_NnZ2d@giganews.com>
In reply to#39975
On 9/27/2021 12:52 PM, Jeff Barnett wrote:
> On 9/27/2021 11:14 AM, olcott wrote:
>> On 9/27/2021 12:05 PM, Jeff Barnett wrote:
>>>> You are a clueless wonder that only has utterly baseless nay saying.
>>>
>>> More name calling; so out of control. a recapitulation of the 
>>> "terrible threes". Concentrate; control yourself; be grateful for 
>>> help offered to you. Time's short; strive for adulthood now. We are 
>>> all rooting for you. Give life as an adult a chance while you have 
>>> that opportunity. Good luck.
>>
>> That you are a clueless wonder relative to your utterly baseless nay 
>> saying about my work is self-evidently true to anyone having 
>> sufficient understanding of the underlying subject matter.
> 
> You are in a loop, just like your ill-conceived simulator. Do give life 
> as an adult a chance. Life only gives us limited opportunities to do 
> better. Carpe diem! And best of luck with adulthood; we are all rooting 
> for you.

This is the key basis of my refutation of the halting theorem:
The halting theorem counter-examples present infinitely nested 
simulation (non-halting) behavior to every simulating halt decider.

All of the "rebuttals" have taken the form of the strawman error:
The halting theorem does not specify a simulating halt decider.
This is no actual rebuttal to the original claim at all.

-- 
Copyright 2021 Pete Olcott

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

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


#39974 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 12:41 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<IZudnYjB1fr4n8_8nZ2dnUU7-X_NnZ2d@giganews.com>
In reply to#39971
On 9/27/2021 12:05 PM, Jeff Barnett wrote:
> On 9/27/2021 8:19 AM, olcott wrote:
>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>       <CRAP DELETED>
>>>>
>>>> So then maybe you are stupid or ignorant, The actual code itself 
>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless 
>>>> H(P,P) aborts the simulation of its input. In that case the 
>>>> simulation is cut off at 0xc41. In no case does this code reach 
>>>> final state 0xc50.
>>>
>>> <CRAP DELETED>
>>>
>>> So you now admit that your x86 simulator is flawed? Or maybe it 
>>> isn't, but you set it up wrong or are using it incorrectly? You need 
>>> to do something other than software; you're just not very good at it 
>>> you know. Working in an area where you are inadequate causes you to 
>>> act like a bad person out of frustration. Here you are calling Andre 
>>> stupid and ignorant for trying to help you and make you better. You 
>>> should say "thank you" instead of being such a crappy person. You 
>>> should change your area of study to something simple like cooking 
>>> rice. A few successes would improve your self image and stop the name 
>>> calling and tantrums. You are no longer 3 years old. Time to mature a 
>>> little.
>>
>> You are a clueless wonder that only has utterly baseless nay saying.
> 
> More name calling; so out of control. a recapitulation of the "terrible 
> threes". Concentrate; control yourself; be grateful for help offered to 
> you. Time's short; strive for adulthood now. We are all rooting for you. 
> Give life as an adult a chance while you have that opportunity. Good luck.

You are the only one with utterly baseless critique of my work. The only 
critique of the {essence of my work} that has not been baseless has been 
the key issue of what is required for a C function to meet the standard 
of the theory of computation computable function.

There have been numerous times when I used a technical term of the art 
in ways that slightly differ from their conventional meaning. Some of 
these times may be accurately construed as errors. Some of these times 
are cases where the term of the art was the closest approximation to the 
meaning that I intended thus not exactly an actual error. Imprecise use 
of terms of the art may reduce my credibility yet has no impact 
what-so-ever on the validity of the essence of my work.

It is true that without the reviews of my work on comp.theory that my 
work would have never been completed. This deserves gratitude to the 
reviewers of my work on comp.theory. Even though what these reviewers 
presented as an error was almost never any actual error at all these 
reviews did help me increasingly clarify my position to best address 
objections to this position.

The most exasperating critique of my work is when reviewers essentially 
disagree that a {black cat} is either {black} or a {cat}.

_P()
[00000c36](01)  55          push ebp
[00000c37](02)  8bec        mov ebp,esp
[00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
[00000c3c](01)  50          push eax
[00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
[00000c40](01)  51          push ecx
[00000c41](05)  e820fdffff  call 00000966    // call H
[00000c46](03)  83c408      add esp,+08
[00000c49](02)  85c0        test eax,eax
[00000c4b](02)  7402        jz 00000c4f
[00000c4d](02)  ebfe        jmp 00000c4d
[00000c4f](01)  5d          pop ebp
[00000c50](01)  c3          ret
Size in bytes:(0027) [00000c50]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============

Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55          push ebp
[00000c37][002117ca][002117ce] 8bec        mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50          push eax       // push P
[00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51          push ecx       // push P
[00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)

Disagreeing that the input to H(P,P) never reaches its final state of 
0xc50 whether or not simulating halt decider H stops simulating its 
input is one of the cases where a {black cat} is denied being either 
{black} or a {cat}.


-- 
Copyright 2021 Pete Olcott

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

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


#39976 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromJeff Barnett <jbb@notatt.com>
Date2021-09-27 12:05 -0600
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<sit150$9ge$1@dont-email.me>
In reply to#39974
On 9/27/2021 11:41 AM, olcott wrote:
> On 9/27/2021 12:05 PM, Jeff Barnett wrote:
>> On 9/27/2021 8:19 AM, olcott wrote:
>>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>>       <CRAP DELETED>
>>>>>
>>>>> So then maybe you are stupid or ignorant, The actual code itself 
>>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless 
>>>>> H(P,P) aborts the simulation of its input. In that case the 
>>>>> simulation is cut off at 0xc41. In no case does this code reach 
>>>>> final state 0xc50.
>>>>
>>>> <CRAP DELETED>
>>>>
>>>> So you now admit that your x86 simulator is flawed? Or maybe it 
>>>> isn't, but you set it up wrong or are using it incorrectly? You need 
>>>> to do something other than software; you're just not very good at it 
>>>> you know. Working in an area where you are inadequate causes you to 
>>>> act like a bad person out of frustration. Here you are calling Andre 
>>>> stupid and ignorant for trying to help you and make you better. You 
>>>> should say "thank you" instead of being such a crappy person. You 
>>>> should change your area of study to something simple like cooking 
>>>> rice. A few successes would improve your self image and stop the 
>>>> name calling and tantrums. You are no longer 3 years old. Time to 
>>>> mature a little.
>>>
>>> You are a clueless wonder that only has utterly baseless nay saying.
>>
>> More name calling; so out of control. a recapitulation of the 
>> "terrible threes". Concentrate; control yourself; be grateful for help 
>> offered to you. Time's short; strive for adulthood now. We are all 
>> rooting for you. Give life as an adult a chance while you have that 
>> opportunity. Good luck.
> 
> You are the only one with utterly baseless critique of my work. The only 
> critique of the {essence of my work} that has not been baseless has been 
> the key issue of what is required for a C function to meet the standard 
> of the theory of computation computable function.
> 
> There have been numerous times when I used a technical term of the art 
> in ways that slightly differ from their conventional meaning. Some of 
> these times may be accurately construed as errors. Some of these times 
> are cases where the term of the art was the closest approximation to the 
> meaning that I intended thus not exactly an actual error. Imprecise use 
> of terms of the art may reduce my credibility yet has no impact 
> what-so-ever on the validity of the essence of my work.
> 
> It is true that without the reviews of my work on comp.theory that my 
> work would have never been completed. This deserves gratitude to the 
> reviewers of my work on comp.theory. Even though what these reviewers 
> presented as an error was almost never any actual error at all these 
> reviews did help me increasingly clarify my position to best address 
> objections to this position.
> 
> The most exasperating critique of my work is when reviewers essentially 
> disagree that a {black cat} is either {black} or a {cat}.
> 
> _P()
> [00000c36](01)  55          push ebp
> [00000c37](02)  8bec        mov ebp,esp
> [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
> [00000c3c](01)  50          push eax
> [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
> [00000c40](01)  51          push ecx
> [00000c41](05)  e820fdffff  call 00000966    // call H
> [00000c46](03)  83c408      add esp,+08
> [00000c49](02)  85c0        test eax,eax
> [00000c4b](02)  7402        jz 00000c4f
> [00000c4d](02)  ebfe        jmp 00000c4d
> [00000c4f](01)  5d          pop ebp
> [00000c50](01)  c3          ret
> Size in bytes:(0027) [00000c50]
> 
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> 
> Begin Local Halt Decider Simulation at Machine Address:c36
> [00000c36][002117ca][002117ce] 55          push ebp
> [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
> [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
> [00000c3c][002117c6][00000c36] 50          push eax       // push P
> [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
> [00000c40][002117c2][00000c36] 51          push ecx       // push P
> [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
> 
> Disagreeing that the input to H(P,P) never reaches its final state of 
> 0xc50 whether or not simulating halt decider H stops simulating its 
> input is one of the cases where a {black cat} is denied being either 
> {black} or a {cat}.

You are still out of control. Ben will not let you off from specific 
lies and contradictions no matter how much you try to change the 
subject. I, on the other hand, will not let you off from your childish 
(NB, I did not say child-like) behavior until we can see a maturation 
process started. Given your off the mark, ignorant ideas and tantrums, 
can you imagine how these howlers are perceived at the end of your messages:

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

A copyright! I can't imagine anyone else dumb enough to write such 
dribble. No not a soul. And as the king/queen of mediocrity, well can 
you imagine the giggle when anyone reads it? Who do they think it's 
about. Do you need a hint?
-- 
Jeff Barnett

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


#39979 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 13:31 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<J8udneU4C5mSk8_8nZ2dnUU7-cXNnZ2d@giganews.com>
In reply to#39976
On 9/27/2021 1:05 PM, Jeff Barnett wrote:
> On 9/27/2021 11:41 AM, olcott wrote:
>> On 9/27/2021 12:05 PM, Jeff Barnett wrote:
>>> On 9/27/2021 8:19 AM, olcott wrote:
>>>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>>>       <CRAP DELETED>
>>>>>>
>>>>>> So then maybe you are stupid or ignorant, The actual code itself 
>>>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless 
>>>>>> H(P,P) aborts the simulation of its input. In that case the 
>>>>>> simulation is cut off at 0xc41. In no case does this code reach 
>>>>>> final state 0xc50.
>>>>>
>>>>> <CRAP DELETED>
>>>>>
>>>>> So you now admit that your x86 simulator is flawed? Or maybe it 
>>>>> isn't, but you set it up wrong or are using it incorrectly? You 
>>>>> need to do something other than software; you're just not very good 
>>>>> at it you know. Working in an area where you are inadequate causes 
>>>>> you to act like a bad person out of frustration. Here you are 
>>>>> calling Andre stupid and ignorant for trying to help you and make 
>>>>> you better. You should say "thank you" instead of being such a 
>>>>> crappy person. You should change your area of study to something 
>>>>> simple like cooking rice. A few successes would improve your self 
>>>>> image and stop the name calling and tantrums. You are no longer 3 
>>>>> years old. Time to mature a little.
>>>>
>>>> You are a clueless wonder that only has utterly baseless nay saying.
>>>
>>> More name calling; so out of control. a recapitulation of the 
>>> "terrible threes". Concentrate; control yourself; be grateful for 
>>> help offered to you. Time's short; strive for adulthood now. We are 
>>> all rooting for you. Give life as an adult a chance while you have 
>>> that opportunity. Good luck.
>>
>> You are the only one with utterly baseless critique of my work. The 
>> only critique of the {essence of my work} that has not been baseless 
>> has been the key issue of what is required for a C function to meet 
>> the standard of the theory of computation computable function.
>>
>> There have been numerous times when I used a technical term of the art 
>> in ways that slightly differ from their conventional meaning. Some of 
>> these times may be accurately construed as errors. Some of these times 
>> are cases where the term of the art was the closest approximation to 
>> the meaning that I intended thus not exactly an actual error. 
>> Imprecise use of terms of the art may reduce my credibility yet has no 
>> impact what-so-ever on the validity of the essence of my work.
>>
>> It is true that without the reviews of my work on comp.theory that my 
>> work would have never been completed. This deserves gratitude to the 
>> reviewers of my work on comp.theory. Even though what these reviewers 
>> presented as an error was almost never any actual error at all these 
>> reviews did help me increasingly clarify my position to best address 
>> objections to this position.
>>
>> The most exasperating critique of my work is when reviewers 
>> essentially disagree that a {black cat} is either {black} or a {cat}.
>>
>> _P()
>> [00000c36](01)  55          push ebp
>> [00000c37](02)  8bec        mov ebp,esp
>> [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
>> [00000c3c](01)  50          push eax
>> [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
>> [00000c40](01)  51          push ecx
>> [00000c41](05)  e820fdffff  call 00000966    // call H
>> [00000c46](03)  83c408      add esp,+08
>> [00000c49](02)  85c0        test eax,eax
>> [00000c4b](02)  7402        jz 00000c4f
>> [00000c4d](02)  ebfe        jmp 00000c4d
>> [00000c4f](01)  5d          pop ebp
>> [00000c50](01)  c3          ret
>> Size in bytes:(0027) [00000c50]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>>
>> Begin Local Halt Decider Simulation at Machine Address:c36
>> [00000c36][002117ca][002117ce] 55          push ebp
>> [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>> [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>> [00000c3c][002117c6][00000c36] 50          push eax       // push P
>> [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>> [00000c40][002117c2][00000c36] 51          push ecx       // push P
>> [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
>>
>> Disagreeing that the input to H(P,P) never reaches its final state of 
>> 0xc50 whether or not simulating halt decider H stops simulating its 
>> input is one of the cases where a {black cat} is denied being either 
>> {black} or a {cat}.
> 
> You are still out of control. Ben will not let you off from specific 
> lies and contradictions no matter how much you try to change the 
> subject. 

This is the key basis of my refutation of the halting theorem:
The halting theorem counter-examples present infinitely nested 
simulation (non-halting) behavior to every simulating halt decider.

I presented this to Ben more than four years ago and he successfully 
changed the subject with various dishonest dodges so that it could not 
be properly evaluated until now.

Infinitely Recursive input on HP Proofs
peteolcott
Mar 11, 2017, 3:13:03 PM
https://groups.google.com/g/comp.theory/c/NcFS02hKs1U

All of the "rebuttals" have taken the form of the strawman error:
The halting theorem does not specify a simulating halt decider.
This is no actual rebuttal to the original claim at all.



-- 
Copyright 2021 Pete Olcott

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

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


#39980 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromJeff Barnett <jbb@notatt.com>
Date2021-09-27 12:53 -0600
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<sit40a$upf$1@dont-email.me>
In reply to#39979
On 9/27/2021 12:31 PM, olcott wrote:
    <CRAP SNAP>

> This is the key basis of my refutation of the halting theorem:
> The halting theorem counter-examples present infinitely nested 
> simulation (non-halting) behavior to every simulating halt decider.
> 
> I presented this to Ben more than four years ago and he successfully 
> changed the subject with various dishonest dodges so that it could not 
> be properly evaluated until now.
> 
> Infinitely Recursive input on HP Proofs
> peteolcott
> Mar 11, 2017, 3:13:03 PM
> https://groups.google.com/g/comp.theory/c/NcFS02hKs1U
> 
> All of the "rebuttals" have taken the form of the strawman error:
> The halting theorem does not specify a simulating halt decider.
> This is no actual rebuttal to the original claim at all.


No one but you has been dishonest. And that is a two decade truth. If 
Martin Davis or Peter Lintz said they now had doubt of the halting 
theorem, the world would be excited. We would expect to learn something 
new about model theory or a new theory of computation. Also, most of us 
would be a little sad: Since this was an extremely well pawed over area, 
we would expect the insight to occur at such a deep level that we may or 
may not be able to enjoy it either through lack of ability or of 
knowledge at the state of the art. You, on the other hand are repeating 
problems first discussed and analyzed by the pre Greeks. Today, the liar 
paradox is for the amusement of school children, not logicians or 
mathematicians. You are several thousand years late. The issues which 
drive you are the stuff of Penny Problem Solver collections. There is a 
book called "What is the name of this book?". Get a copy and read it 
while there is time.

In any event, stop this childish repetition of non sense. Give adulthood 
a chance. We are not all destined for fame and immortality for our brain 
power. It's certain you are not. Even if your brain was adequate to do 
world class work, your personality disorders disqualify you. You refuse 
to listen, you refuse to learn, and you throw constant tantrums. The 
technical world is much too sophisticated for a genius to walk in off 
the streets and present a new earth shaking method to bake bread, let 
alone do a new computation theory. You really do need to study more and 
learn from the masters.

Your current plan has made you appear (and be) a classic case of 
ignorance morphed into stupidity. You need to grow up.
Jeff Barnett

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


#39981 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 14:07 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<_bidnQSYRcPsi8_8nZ2dnUU7-RXNnZ2d@giganews.com>
In reply to#39980
On 9/27/2021 1:53 PM, Jeff Barnett wrote:
> On 9/27/2021 12:31 PM, olcott wrote:
>     <CRAP SNAP>
> 
>> This is the key basis of my refutation of the halting theorem:
>> The halting theorem counter-examples present infinitely nested 
>> simulation (non-halting) behavior to every simulating halt decider.
>>
>> I presented this to Ben more than four years ago and he successfully 
>> changed the subject with various dishonest dodges so that it could not 
>> be properly evaluated until now.
>>
>> Infinitely Recursive input on HP Proofs
>> peteolcott
>> Mar 11, 2017, 3:13:03 PM
>> https://groups.google.com/g/comp.theory/c/NcFS02hKs1U
>>
>> All of the "rebuttals" have taken the form of the strawman error:
>> The halting theorem does not specify a simulating halt decider.
>> This is no actual rebuttal to the original claim at all.
> 
> 
> No one but you has been dishonest. 

I triple dog dare you to show how the above key basis of my refutation 
is incorrect.  https://www.youtube.com/watch?v=ZLZj3zOUZNs

-- 
Copyright 2021 Pete Olcott

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

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


#39983 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-27 20:52 +0100
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<87h7e5u775.fsf@bsb.me.uk>
In reply to#39979
olcott <NoOne@NoWhere.com> writes:

> This is the key basis of my refutation of the halting theorem:
> The halting theorem counter-examples present infinitely nested
> simulation (non-halting) behavior to every simulating halt decider.

This is one reason a simulator can't be a halt decider.  Of course you
know this, which is why your putative decider is not a simulator but a
partial simulator.  It too fails to be a halt decider, as does every
Turing machine.  That's why you must declare false to be the correct
answer for some halting computations.

> This is the key basis of my refutation of the halting theorem:

You would have to find a logical flaw in the proofs.  All of them.  But
you have not even read the "proper" proof in Linz.  The one that you can
understand is only presented for historical reasons.

The fact that a simulator can't be a halt decider (and there are more
reasons for that than the one you cite above) does not show a flaw in
any proof.

> All of the "rebuttals" have taken the form of the strawman error:
> The halting theorem does not specify a simulating halt decider.
> This is no actual rebuttal to the original claim at all.

No, the rebuttals start with a simple fact: false is not the correct
answer for a halting computation.  The rest of the rebuttal comes from
you (it has to since you are carefully hiding the code):

  "Halts(Confound_Halts, Confound_Halts) returns false."
  Message-ID: <2aidnV9e3qQaOCDCnZ2dnUU7-c3NnZ2d@giganews.com>

and

  "The input to Halts is only finite because..."
  Message-ID: <6eSdnYuLBrIuVFzCnZ2dnUU7-cPNnZ2d@giganews.com>

Your wording is poor, but you've been very clear about what you mean:
computations that "only" halt for reasons you consider "special" can be
declared non-halting.  This is not what the halting problem is about[1].

You have nothing at all, but you have told some very grandiose lies, and
insulted a lot of people along the way and I think that's what really
matters to you.

[1] Ironically, this Peter Olcott "Other Halting problem" is also
undecidable, given the definition you often give for the "special"
reasons.  So you don't even have a POOH decider.

-- 
Ben.

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


#39986 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 15:44 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<Gb6dnd4FDLS0sM_8nZ2dnUU7-IXNnZ2d@giganews.com>
In reply to#39983
On 9/27/2021 2:52 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> This is the key basis of my refutation of the halting theorem:
>> The halting theorem counter-examples present infinitely nested
>> simulation (non-halting) behavior to every simulating halt decider.
> 
> This is one reason a simulator can't be a halt decider.  

Of course you know that I am net talking about a simulator being used as 
it it was a halt decider thus your reply is the same dishonest dodge 
intentional (thus dishonest) strawman error as always.

> Of course you
> know this, which is why your putative decider is not a simulator but a
> partial simulator.  It too fails to be a halt decider, as does every
> Turing machine.  That's why you must declare false to be the correct
> answer for some halting computations.
> 
>> This is the key basis of my refutation of the halting theorem:
> 
> You would have to find a logical flaw in the proofs.  All of them.  But
> you have not even read the "proper" proof in Linz.  The one that you can
> understand is only presented for historical reasons.
> 

The logical flaw is that the halting theorem attempts to show that the 
halting problem is undecidable by a counter-example that is clearly 
decidable as non-halting.

> The fact that a simulator can't be a halt decider (and there are more
> reasons for that than the one you cite above) does not show a flaw in
> any proof.
> 

Of course a simulator cannot by itself be a halt decider and it is 
ridiculously dishonest of you to imply that this is what I mean.

>> All of the "rebuttals" have taken the form of the strawman error:
>> The halting theorem does not specify a simulating halt decider.
>> This is no actual rebuttal to the original claim at all.
> 
> No, the rebuttals start with a simple fact: false is not the correct
> answer for a halting computation.  The rest of the rebuttal comes from
> you (it has to since you are carefully hiding the code):
> 

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

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

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
// because the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx DOES NOT HALT

The computation of Ĥ applied to ⟨Ĥ⟩ is a distinctly different 
computation than the computation of the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ 
by Ĥ.qx.

If we want to specify a computation that is equivalent to Ĥ applied to 
⟨Ĥ⟩ we must specify H applied to ⟨Ĥ⟩ ⟨Ĥ⟩. H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy

The difference is that the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ invokes a copy of Ĥ.qx 
whereas the input to H does not invoke a copy of H.

The pathological self-reference error that I first discovered in 2004 is 
the key to finally resolved these otherwise undecidable decision problem 
inputs.

comp.theory
Halting Problem Final Conclusion
Peter Olcott Sep 5, 2004,

The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.
https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ



-- 
Copyright 2021 Pete Olcott

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

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


#40000 — 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)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-28 02:45 +0100
SubjectIt'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)
Message-ID<877df1scav.fsf_-_@bsb.me.uk>
In reply to#39986
olcott <NoOne@NoWhere.com> writes:

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

>>> This is the key basis of my refutation of the halting theorem:
>>
>> You would have to find a logical flaw in the proofs.  All of them.  But
>> you have not even read the "proper" proof in Linz.  The one that you can
>> understand is only presented for historical reasons.
>
> The logical flaw is that the halting theorem attempts to show that the
> halting problem is undecidable by a counter-example that is clearly
> decidable as non-halting.

But first you changed the definition of halting:

  "This definition of halting circumvents the pathological
  self-reference error for every simulating halt decider:

  An input is decided to be halting only if its simulation never needs
  to be stopped by any simulating halt decider anywhere in its entire
  invocation chain."

The result is that you are no longer talking the halting problem.  It's
a new problem: the Peter Olcott Other Halting problem where a decider
that rejects some halting computation is "correct".

"On that basis" (you go on to say):

  Ĥ(<Ĥ>) ⊢* Ĥ.qn
  H(<Ĥ>,<Ĥ>) ⊢* H.qn

clearly showing H rejecting a halting computation.  You are admirably
clear.  To avoid the problem present in the proof, you redefine halting
so that H rejecting <Ĥ>,<Ĥ> is declared to be correct.

>>> All of the "rebuttals" have taken the form of the strawman error:
>>> The halting theorem does not specify a simulating halt decider.
>>> This is no actual rebuttal to the original claim at all.
>>
>> No, the rebuttals start with a simple fact: false is not the correct
>> answer for a halting computation.  The rest of the rebuttal comes from
>> you (it has to since you are carefully hiding the code):

You cut the part where I quote you acknowledging that
Halts(Confound_Halts, Confound_Halts) returns false despite
Confound_Halts(Confound_Halts) being a finite computation.

But no matter, it was there about TMs in 2017:

  On that basis
  Ĥ(<Ĥ>) ⊢* Ĥ.qn
  H(<Ĥ>,<Ĥ>) ⊢* H.qn

"That basis" being "the other kind of halting that does not mean
halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>).

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt

You have the wrong annotations again.  This is simple dishonesty because
I've told just the other day not to leave off the crucial texts.  You
have no valid excuse to keep doing it.  You can't change what Linz says
a halt decider must do and have any credibility in talking about the
halting problem.

This all appears to be nothing but a pathetic attempt to hide what you
have been clear about in the past because you can add the correct
annotations without contradicting yourself:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if Ĥ applied to ⟨Ĥ⟩ halts

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

You have defined the "basis" on which rejecting a halting computation is
"correct" so the specification is now easy to meet.

-- 
Ben.

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


#40003 — 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)

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 21:05 -0500
SubjectRe: 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)
Message-ID<F5CdnaQUNenj5c_8nZ2dnUU7-cPNnZ2d@giganews.com>
In reply to#40000
9/27/2021 8:45 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
> 
>>>> This is the key basis of my refutation of the halting theorem:
>>>
>>> You would have to find a logical flaw in the proofs.  All of them.  But
>>> you have not even read the "proper" proof in Linz.  The one that you can
>>> understand is only presented for historical reasons.
>>
>> The logical flaw is that the halting theorem attempts to show that the
>> halting problem is undecidable by a counter-example that is clearly
>> decidable as non-halting.
> 
> But first you changed the definition of halting:
> 
>    "This definition of halting circumvents the pathological
>    self-reference error for every simulating halt decider:
> 
>    An input is decided to be halting only if its simulation never needs
>    to be stopped by any simulating halt decider anywhere in its entire
>    invocation chain."
> 
> The result is that you are no longer talking the halting problem.  It's
> a new problem: the Peter Olcott Other Halting problem where a decider
> that rejects some halting computation is "correct".
> 
> "On that basis" (you go on to say):
> 
>    Ĥ(<Ĥ>) ⊢* Ĥ.qn
>    H(<Ĥ>,<Ĥ>) ⊢* H.qn
> 
> clearly showing H rejecting a halting computation.  You are admirably
> clear.  To avoid the problem present in the proof, you redefine halting
> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct.
> 
>>>> All of the "rebuttals" have taken the form of the strawman error:
>>>> The halting theorem does not specify a simulating halt decider.
>>>> This is no actual rebuttal to the original claim at all.
>>>
>>> No, the rebuttals start with a simple fact: false is not the correct
>>> answer for a halting computation.  The rest of the rebuttal comes from
>>> you (it has to since you are carefully hiding the code):
> 
> You cut the part where I quote you acknowledging that
> Halts(Confound_Halts, Confound_Halts) returns false despite
> Confound_Halts(Confound_Halts) being a finite computation.
> 
> But no matter, it was there about TMs in 2017:
> 
>    On that basis
>    Ĥ(<Ĥ>) ⊢* Ĥ.qn
>    H(<Ĥ>,<Ĥ>) ⊢* H.qn
> 
> "That basis" being "the other kind of halting that does not mean
> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>).
> 
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> You have the wrong annotations again.  This is simple dishonesty because
> I've told just the other day not to leave off the crucial texts.  You
> have no valid excuse to keep doing it.  You can't change what Linz says
> a halt decider must do and have any credibility in talking about the
> halting problem.
> 
> This all appears to be nothing but a pathetic attempt to hide what you
> have been clear about in the past because you can add the correct
> annotations without contradicting yourself:
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if Ĥ applied to ⟨Ĥ⟩ halts
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if Ĥ applied to ⟨Ĥ⟩ does not halt
> 

It is not about Ĥ applied to ⟨Ĥ⟩
It is about Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩

The halt decider is not at Ĥ.q0 it is at Ĥ.qx

You know that the input to a halt decider is a TM description and not a 
TM. This means that you know that it is not about whether or not Ĥ halts.

It it about whether or not the simulation of the first parameter ⟨Ĥ⟩ to 
Ĥ.qx halts on its input ⟨Ĥ⟩.



-- 
Copyright 2021 Pete Olcott

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

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


#40006 — 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)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-27 20:40 -0600
SubjectRe: 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)
Message-ID<sitvb7$iia$1@dont-email.me>
In reply to#40003
On 2021-09-27 20:05, olcott wrote:
> 9/27/2021 8:45 PM, Ben Bacarisse wrote:

> You know that the input to a halt decider is a TM description and not a 
> TM. This means that you know that it is not about whether or not Ĥ halts.
> 
> It it about whether or not the simulation of the first parameter ⟨Ĥ⟩ to 
> Ĥ.qx halts on its input ⟨Ĥ⟩.

The position you're taking here is, to put it bluntly, simply absurd.

A halt decider takes a description of a computation as its input. It is 
supposed to determine whether the computation described by that 
description halts.

So of course H(H_Hat, H_Hat) is being asked whether H_Hat(H_Hat) halts. 
It doesn't matter whether your H works by simulating or by some other 
more sensible means. The question is about the behaviour of the actual 
Turing Machine H_Hat applied to a description of H_Hat.

That you think a 'description of a computation' could possibly refer to 
anything other than the independent computation being described is truly 
mystifying. Why would anyone possibly care about what happens in some 
simulation if that simulation doesn't reflect the behaviour of the 
actual computation described?

If you don't grasp this, then you don't even understand the problem 
which the Linz proof is concerned with. If you don't understand the 
problem, how can you possibly understand the proof, let alone 'refute' it?

André

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

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


#40008 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 21:52 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<1vOdncXXw_nkHs_8nZ2dnUU7-YHNnZ2d@giganews.com>
In reply to#40006
On 9/27/2021 9:40 PM, André G. Isaak wrote:
> On 2021-09-27 20:05, olcott wrote:
>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
> 
>> You know that the input to a halt decider is a TM description and not 
>> a TM. This means that you know that it is not about whether or not Ĥ 
>> halts.
>>
>> It it about whether or not the simulation of the first parameter ⟨Ĥ⟩ 
>> to Ĥ.qx halts on its input ⟨Ĥ⟩.
> 
> The position you're taking here is, to put it bluntly, simply absurd.
> 
> A halt decider takes a description of a computation as its input. It is 
> supposed to determine whether the computation described by that 
> description halts.
> 

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

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

I merely adapted the Linz annotations to be more clear.
It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.

H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.

Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

It turns out that when the input program P calls the same halt decider H 
that is deciding its halting status this is computationally distinct 
from another identically coded halt decider H1 that is not called by the 
input program P.

Olcott C/x86 H and H1 are being transformed into pure functions.
https://en.wikipedia.org/wiki/Pure_function
I do not expect that the results will change.

> So of course H(H_Hat, H_Hat) is being asked whether H_Hat(H_Hat) halts. 
> It doesn't matter whether your H works by simulating or by some other 
> more sensible means. The question is about the behaviour of the actual 
> Turing Machine H_Hat applied to a description of H_Hat.
> 
> That you think a 'description of a computation' could possibly refer to 
> anything other than the independent computation being described is truly 
> mystifying. Why would anyone possibly care about what happens in some 
> simulation if that simulation doesn't reflect the behaviour of the 
> actual computation described?
> 
> If you don't grasp this, then you don't even understand the problem 
> which the Linz proof is concerned with. If you don't understand the 
> problem, how can you possibly understand the proof, let alone 'refute' it?
> 
> André
> 


-- 
Copyright 2021 Pete Olcott

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

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


#40010 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-27 21:14 -0600
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<siu1bl$t2e$1@dont-email.me>
In reply to#40008
On 2021-09-27 20:52, olcott wrote:
> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>> On 2021-09-27 20:05, olcott wrote:
>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>
>>> You know that the input to a halt decider is a TM description and not 
>>> a TM. This means that you know that it is not about whether or not Ĥ 
>>> halts.
>>>
>>> It it about whether or not the simulation of the first parameter ⟨Ĥ⟩ 
>>> to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>
>> The position you're taking here is, to put it bluntly, simply absurd.
>>
>> A halt decider takes a description of a computation as its input. It 
>> is supposed to determine whether the computation described by that 
>> description halts.
>>
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> I merely adapted the Linz annotations to be more clear.
> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.

I was not commenting on your (mis)use of notation and nothing in your 
response even remotely addressed what I was saying. I was commenting on 
the ridiculous statement that "You know that the input to a halt decider 
is a TM description and not a TM. This means that you know that it is 
not about whether or not Ĥ halts."

This statement is simply wrong. Spectacularly wrong. If you don't 
understand what the halting problem is even about, you shouldn't be 
working on it at all.

André

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

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


#40011 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 22:28 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<PKGdnfCNfZVRFs_8nZ2dnUU7-I_NnZ2d@giganews.com>
In reply to#40010
On 9/27/2021 10:14 PM, André G. Isaak wrote:
> On 2021-09-27 20:52, olcott wrote:
>> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>>> On 2021-09-27 20:05, olcott wrote:
>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>
>>>> You know that the input to a halt decider is a TM description and 
>>>> not a TM. This means that you know that it is not about whether or 
>>>> not Ĥ halts.
>>>>
>>>> It it about whether or not the simulation of the first parameter ⟨Ĥ⟩ 
>>>> to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>>
>>> The position you're taking here is, to put it bluntly, simply absurd.
>>>
>>> A halt decider takes a description of a computation as its input. It 
>>> is supposed to determine whether the computation described by that 
>>> description halts.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> I merely adapted the Linz annotations to be more clear.
>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.
> 
> I was not commenting on your (mis)use of notation and nothing in your 
> response even remotely addressed what I was saying. I was commenting on 
> the ridiculous statement that "You know that the input to a halt decider 
> is a TM description and not a TM. This means that you know that it is 
> not about whether or not Ĥ halts."
> 
> This statement is simply wrong. Spectacularly wrong. If you don't 
> understand what the halting problem is even about, you shouldn't be 
> working on it at all.
> 
> André
> 

It may seem that way to you only because you have not bothered to think 
it all the way through.

It may be that you fail to comprehend the following, yet a failure of 
comprehension is less than no rebuttal at all:

H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.

Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

It turns out that when the input program P calls the same halt decider H 
that is deciding its halting status this is computationally distinct 
from another identically coded halt decider H1 that is not called by the 
input program P.


-- 
Copyright 2021 Pete Olcott

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

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


#40012 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-27 23:35 -0400
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<%3w4J.54673$6U3.18515@fx43.iad>
In reply to#40011
On 9/27/21 11:28 PM, olcott wrote:
> On 9/27/2021 10:14 PM, André G. Isaak wrote:
>> On 2021-09-27 20:52, olcott wrote:
>>> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>>>> On 2021-09-27 20:05, olcott wrote:
>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>
>>>>> You know that the input to a halt decider is a TM description and
>>>>> not a TM. This means that you know that it is not about whether or
>>>>> not Ĥ halts.
>>>>>
>>>>> It it about whether or not the simulation of the first parameter
>>>>> ⟨Ĥ⟩ to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>>>
>>>> The position you're taking here is, to put it bluntly, simply absurd.
>>>>
>>>> A halt decider takes a description of a computation as its input. It
>>>> is supposed to determine whether the computation described by that
>>>> description halts.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>
>>> I merely adapted the Linz annotations to be more clear.
>>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
>>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.
>>
>> I was not commenting on your (mis)use of notation and nothing in your
>> response even remotely addressed what I was saying. I was commenting
>> on the ridiculous statement that "You know that the input to a halt
>> decider is a TM description and not a TM. This means that you know
>> that it is not about whether or not Ĥ halts."
>>
>> This statement is simply wrong. Spectacularly wrong. If you don't
>> understand what the halting problem is even about, you shouldn't be
>> working on it at all.
>>
>> André
>>
> 
> It may seem that way to you only because you have not bothered to think
> it all the way through.
> 
> It may be that you fail to comprehend the following, yet a failure of
> comprehension is less than no rebuttal at all:
> 
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.
> 
> Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
> 
> It turns out that when the input program P calls the same halt decider H
> that is deciding its halting status this is computationally distinct
> from another identically coded halt decider H1 that is not called by the
> input program P.
> 
> 

Only if the Halt Decider isn't a computation, and thus not really a decider.

A Computation *ALWAYS* returns the same answer for the same input, in
EVERY Case.

P(I) needs to ALWAYS return the same answer, even if P works in part by
simulating part of its input, and that input includes a copy of P.

There is not 'recursive' exception to the definition of a computation.

THus if H1 and H are REALLY the exact same algorithm (so equivalent
Turing Machines) H1(P,I) must always give the same answer as H(P,I)

If they give different answers, they aren't the same machine.

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


#40013 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-27 22:46 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<9LGdnfDaitqeDc_8nZ2dnUU7-NnNnZ2d@giganews.com>
In reply to#40012
On 9/27/2021 10:35 PM, Richard Damon wrote:
> On 9/27/21 11:28 PM, olcott wrote:
>> On 9/27/2021 10:14 PM, André G. Isaak wrote:
>>> On 2021-09-27 20:52, olcott wrote:
>>>> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>>>>> On 2021-09-27 20:05, olcott wrote:
>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>>
>>>>>> You know that the input to a halt decider is a TM description and
>>>>>> not a TM. This means that you know that it is not about whether or
>>>>>> not Ĥ halts.
>>>>>>
>>>>>> It it about whether or not the simulation of the first parameter
>>>>>> ⟨Ĥ⟩ to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>>>>
>>>>> The position you're taking here is, to put it bluntly, simply absurd.
>>>>>
>>>>> A halt decider takes a description of a computation as its input. It
>>>>> is supposed to determine whether the computation described by that
>>>>> description halts.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> I merely adapted the Linz annotations to be more clear.
>>>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
>>>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.
>>>
>>> I was not commenting on your (mis)use of notation and nothing in your
>>> response even remotely addressed what I was saying. I was commenting
>>> on the ridiculous statement that "You know that the input to a halt
>>> decider is a TM description and not a TM. This means that you know
>>> that it is not about whether or not Ĥ halts."
>>>
>>> This statement is simply wrong. Spectacularly wrong. If you don't
>>> understand what the halting problem is even about, you shouldn't be
>>> working on it at all.
>>>
>>> André
>>>
>>
>> It may seem that way to you only because you have not bothered to think
>> it all the way through.
>>
>> It may be that you fail to comprehend the following, yet a failure of
>> comprehension is less than no rebuttal at all:
>>
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.
>>
>> Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> It turns out that when the input program P calls the same halt decider H
>> that is deciding its halting status this is computationally distinct
>> from another identically coded halt decider H1 that is not called by the
>> input program P.
>>
>>
> 
> Only if the Halt Decider isn't a computation, and thus not really a decider.
> 
> A Computation *ALWAYS* returns the same answer for the same input, in
> EVERY Case.
> 
> P(I) needs to ALWAYS return the same answer, even if P works in part by
> simulating part of its input, and that input includes a copy of P.
> 
> There is not 'recursive' exception to the definition of a computation.
> 
> THus if H1 and H are REALLY the exact same algorithm (so equivalent
> Turing Machines) H1(P,I) must always give the same answer as H(P,I)
> 
> If they give different answers, they aren't the same machine.
> 

Once the halt status "impossible" input has been correctly decided prior 
false assumptions about these things will be required to change.

If any problem is studied to a much greater extent that anyone has ever 
studied it before brand new insights become possible.

I use the same {first principles} method that Elon Musk uses:
https://jamesclear.com/first-principles

-- 
Copyright 2021 Pete Olcott

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

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


#40019 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-28 06:27 -0400
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<16C4J.16074$_n1.1710@fx14.iad>
In reply to#40013
On 9/27/21 11:46 PM, olcott wrote:
> On 9/27/2021 10:35 PM, Richard Damon wrote:
>> On 9/27/21 11:28 PM, olcott wrote:
>>> On 9/27/2021 10:14 PM, André G. Isaak wrote:
>>>> On 2021-09-27 20:52, olcott wrote:
>>>>> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>>>>>> On 2021-09-27 20:05, olcott wrote:
>>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>>>
>>>>>>> You know that the input to a halt decider is a TM description and
>>>>>>> not a TM. This means that you know that it is not about whether or
>>>>>>> not Ĥ halts.
>>>>>>>
>>>>>>> It it about whether or not the simulation of the first parameter
>>>>>>> ⟨Ĥ⟩ to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>>>>>
>>>>>> The position you're taking here is, to put it bluntly, simply absurd.
>>>>>>
>>>>>> A halt decider takes a description of a computation as its input. It
>>>>>> is supposed to determine whether the computation described by that
>>>>>> description halts.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> I merely adapted the Linz annotations to be more clear.
>>>>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
>>>>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.
>>>>
>>>> I was not commenting on your (mis)use of notation and nothing in your
>>>> response even remotely addressed what I was saying. I was commenting
>>>> on the ridiculous statement that "You know that the input to a halt
>>>> decider is a TM description and not a TM. This means that you know
>>>> that it is not about whether or not Ĥ halts."
>>>>
>>>> This statement is simply wrong. Spectacularly wrong. If you don't
>>>> understand what the halting problem is even about, you shouldn't be
>>>> working on it at all.
>>>>
>>>> André
>>>>
>>>
>>> It may seem that way to you only because you have not bothered to think
>>> it all the way through.
>>>
>>> It may be that you fail to comprehend the following, yet a failure of
>>> comprehension is less than no rebuttal at all:
>>>
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.
>>>
>>> Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to
>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> It turns out that when the input program P calls the same halt decider H
>>> that is deciding its halting status this is computationally distinct
>>> from another identically coded halt decider H1 that is not called by the
>>> input program P.
>>>
>>>
>>
>> Only if the Halt Decider isn't a computation, and thus not really a
>> decider.
>>
>> A Computation *ALWAYS* returns the same answer for the same input, in
>> EVERY Case.
>>
>> P(I) needs to ALWAYS return the same answer, even if P works in part by
>> simulating part of its input, and that input includes a copy of P.
>>
>> There is not 'recursive' exception to the definition of a computation.
>>
>> THus if H1 and H are REALLY the exact same algorithm (so equivalent
>> Turing Machines) H1(P,I) must always give the same answer as H(P,I)
>>
>> If they give different answers, they aren't the same machine.
>>
> 
> Once the halt status "impossible" input has been correctly decided prior
> false assumptions about these things will be required to change.
> 
> If any problem is studied to a much greater extent that anyone has ever
> studied it before brand new insights become possible.
> 
> I use the same {first principles} method that Elon Musk uses:
> https://jamesclear.com/first-principles
> 

But, you are NOT allowed to change the definitions of what the Halt
Decider is supposed to do, like what it is answering about. PERIOD.

Just because you find that it is impossible to build a decider to its
specifications, does NOT mean that the problem is improperly defined,
and that you get to change the problem.

Maybe if you actually understood WHY the Halting Problem is defined the
way it is, it would help.

First Principles work on problems where you do understand what is
needed, but existing methodologies aren't getting there, or not efficiently.

In this case, you seem to think the goal is something like the software
concept of detecting run-away programs that are going to use up the
computer resources, but that isn't what the halting problem is about.

You 'answer' would be like Elon Musk deciding that the easy way to get
to 'Mars' would be to buy a big stretch of desolate landscape and
building a place there that he called 'Mars', and letting people pay him
to go there.

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


#40022 — Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function

Fromolcott <NoOne@NoWhere.com>
Date2021-09-28 09:20 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<GZCdnUmtt7EEuc78nZ2dnUU7-TfNnZ2d@giganews.com>
In reply to#40019
On 9/28/2021 5:27 AM, Richard Damon wrote:
> On 9/27/21 11:46 PM, olcott wrote:
>> On 9/27/2021 10:35 PM, Richard Damon wrote:
>>> On 9/27/21 11:28 PM, olcott wrote:
>>>> On 9/27/2021 10:14 PM, André G. Isaak wrote:
>>>>> On 2021-09-27 20:52, olcott wrote:
>>>>>> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>>>>>>> On 2021-09-27 20:05, olcott wrote:
>>>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>>>>
>>>>>>>> You know that the input to a halt decider is a TM description and
>>>>>>>> not a TM. This means that you know that it is not about whether or
>>>>>>>> not Ĥ halts.
>>>>>>>>
>>>>>>>> It it about whether or not the simulation of the first parameter
>>>>>>>> ⟨Ĥ⟩ to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>>>>>>
>>>>>>> The position you're taking here is, to put it bluntly, simply absurd.
>>>>>>>
>>>>>>> A halt decider takes a description of a computation as its input. It
>>>>>>> is supposed to determine whether the computation described by that
>>>>>>> description halts.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> I merely adapted the Linz annotations to be more clear.
>>>>>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
>>>>>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.
>>>>>
>>>>> I was not commenting on your (mis)use of notation and nothing in your
>>>>> response even remotely addressed what I was saying. I was commenting
>>>>> on the ridiculous statement that "You know that the input to a halt
>>>>> decider is a TM description and not a TM. This means that you know
>>>>> that it is not about whether or not Ĥ halts."
>>>>>
>>>>> This statement is simply wrong. Spectacularly wrong. If you don't
>>>>> understand what the halting problem is even about, you shouldn't be
>>>>> working on it at all.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> It may seem that way to you only because you have not bothered to think
>>>> it all the way through.
>>>>
>>>> It may be that you fail to comprehend the following, yet a failure of
>>>> comprehension is less than no rebuttal at all:
>>>>
>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.
>>>>
>>>> Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> It turns out that when the input program P calls the same halt decider H
>>>> that is deciding its halting status this is computationally distinct
>>>> from another identically coded halt decider H1 that is not called by the
>>>> input program P.
>>>>
>>>>
>>>
>>> Only if the Halt Decider isn't a computation, and thus not really a
>>> decider.
>>>
>>> A Computation *ALWAYS* returns the same answer for the same input, in
>>> EVERY Case.
>>>
>>> P(I) needs to ALWAYS return the same answer, even if P works in part by
>>> simulating part of its input, and that input includes a copy of P.
>>>
>>> There is not 'recursive' exception to the definition of a computation.
>>>
>>> THus if H1 and H are REALLY the exact same algorithm (so equivalent
>>> Turing Machines) H1(P,I) must always give the same answer as H(P,I)
>>>
>>> If they give different answers, they aren't the same machine.
>>>
>>
>> Once the halt status "impossible" input has been correctly decided prior
>> false assumptions about these things will be required to change.
>>
>> If any problem is studied to a much greater extent that anyone has ever
>> studied it before brand new insights become possible.
>>
>> I use the same {first principles} method that Elon Musk uses:
>> https://jamesclear.com/first-principles
>>
> 
> But, you are NOT allowed to change the definitions of what the Halt
> Decider is supposed to do, like what it is answering about. PERIOD.
> 

If a simulated input never reaches its own final state whether or not 
the simulator simulates this input forever or aborts the simulation of 
this input we can know that this simulated input never halts according 
to the conventional meaning of halting.

> Just because you find that it is impossible to build a decider to its
> specifications, does NOT mean that the problem is improperly defined,
> and that you get to change the problem.
> 
> Maybe if you actually understood WHY the Halting Problem is defined the
> way it is, it would help.
> 
> First Principles work on problems where you do understand what is
> needed, but existing methodologies aren't getting there, or not efficiently.
> 

The key aspect of first principles reasoning is to utterly discard all 
assumptions and begin thinking everything through again from scratch.

I call my system categorically exhaustive reasoning by empirically 
testing categories of possibilities that I have not yet proven to be 
impossible using a process of elimination until I interpolate on an 
optimal solution.

> In this case, you seem to think the goal is something like the software
> concept of detecting run-away programs that are going to use up the
> computer resources, but that isn't what the halting problem is about.
> 
> You 'answer' would be like Elon Musk deciding that the easy way to get
> to 'Mars' would be to buy a big stretch of desolate landscape and
> building a place there that he called 'Mars', and letting people pay him
> to go there.
> 


-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web