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


#40049 — 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-28 17:07 -0600
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<sj077j$i2o$1@dont-email.me>
In reply to#40045
On 2021-09-28 16:37, olcott wrote:
> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>> On 2021-09-28 14:57, olcott wrote:
>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>
>>>> What appears to be over your head is the fact that if H is a halt 
>>>> decider, then the computation
>>>>
>>>> int main() { H(P,P); }
>>>>
>>>> is SUPPOSED to answer the question 'does the following computation 
>>>> halt':
>>>>
>>>
>>> int main() { H1(P,P); } does answer that question consistently with 
>>> the behavior of int main() { P(P); }
>>>
>>> int main() { H(P,P); } is an entirely different computation even 
>>> though H and H1 have identical machine code and identical input.
>>
>> But they're both being asked about the *same* input. So if both are 
>> halt deciders they both need to accurately describe the behaviour of 
>> int main() { P(P); }.
>>
>> Whether H1 can correctly decide this is irrelevant because your whole 
>> claim what that you'd found a way to 'refute' Linz. But since your P 
>> is derived from H, unless H(P, P) can correctly decide whether int 
>> main() { P(P); } halts, you have failed at this goal.
>>
>> And H(P, P) does *not* correctly decide this.
>>
>> André
>>
> 
> Both H1(P,P) and H(P,P) correctly decide the halt status of their input. 
> This is very very difficult to understand, yet empirically verifiable 
> none-the-less.

They both have the same input. They're both being asked whether int 
main() { P(P); } halts.

That's the question a halt decider is supposed to answer. It is *not* 
supposed to answer something about the trace of some simulated 
execution. It's supposed to answer about the *actual* computation. This 
is a simple matter of definition. It isn't open for debate.

It's not possible for them to both be right if they give different 
answers given that they are answering the exact same question.

> The empirical proof of this relies on code that is not quite implemented 
> yet. As long as pure functions H and H1 derive the same results as my 
> current functions H and H1 then we have the empirical proof.

Empirical proofs are for empirical subjects. Mathematics isn't an 
empirical subject.

André

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

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


#40052 — 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 18:28 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<zsydnenfKYeLOM78nZ2dnUU7-TWdnZ2d@giganews.com>
In reply to#40049
On 9/28/2021 6:07 PM, André G. Isaak wrote:
> On 2021-09-28 16:37, olcott wrote:
>> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>>> On 2021-09-28 14:57, olcott wrote:
>>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>>
>>>>> What appears to be over your head is the fact that if H is a halt 
>>>>> decider, then the computation
>>>>>
>>>>> int main() { H(P,P); }
>>>>>
>>>>> is SUPPOSED to answer the question 'does the following computation 
>>>>> halt':
>>>>>
>>>>
>>>> int main() { H1(P,P); } does answer that question consistently with 
>>>> the behavior of int main() { P(P); }
>>>>
>>>> int main() { H(P,P); } is an entirely different computation even 
>>>> though H and H1 have identical machine code and identical input.
>>>
>>> But they're both being asked about the *same* input. So if both are 
>>> halt deciders they both need to accurately describe the behaviour of 
>>> int main() { P(P); }.
>>>
>>> Whether H1 can correctly decide this is irrelevant because your whole 
>>> claim what that you'd found a way to 'refute' Linz. But since your P 
>>> is derived from H, unless H(P, P) can correctly decide whether int 
>>> main() { P(P); } halts, you have failed at this goal.
>>>
>>> And H(P, P) does *not* correctly decide this.
>>>
>>> André
>>>
>>
>> Both H1(P,P) and H(P,P) correctly decide the halt status of their 
>> input. This is very very difficult to understand, yet empirically 
>> verifiable none-the-less.
> 
> They both have the same input. They're both being asked whether int 
> main() { P(P); } halts.
> 
> That's the question a halt decider is supposed to answer. It is *not* 
> supposed to answer something about the trace of some simulated 
> execution. It's supposed to answer about the *actual* computation. This 
> is a simple matter of definition. It isn't open for debate.
> 
> It's not possible for them to both be right if they give different 
> answers given that they are answering the exact same question.
> 

Yes we agree, that was not the issue. Is it possible for them to have 
identical machine code and identical inputs and derive opposite results?

>> The empirical proof of this relies on code that is not quite 
>> implemented yet. As long as pure functions H and H1 derive the same 
>> results as my current functions H and H1 then we have the empirical 
>> proof.
> 
> Empirical proofs are for empirical subjects. Mathematics isn't an 
> empirical subject.
> 
> André
> 


-- 
Copyright 2021 Pete Olcott

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

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


#40053 — 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-28 17:37 -0600
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<sj08v7$r0r$1@dont-email.me>
In reply to#40052
On 2021-09-28 17:28, olcott wrote:
> On 9/28/2021 6:07 PM, André G. Isaak wrote:
>> On 2021-09-28 16:37, olcott wrote:
>>> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>>>> On 2021-09-28 14:57, olcott wrote:
>>>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>>>
>>>>>> What appears to be over your head is the fact that if H is a halt 
>>>>>> decider, then the computation
>>>>>>
>>>>>> int main() { H(P,P); }
>>>>>>
>>>>>> is SUPPOSED to answer the question 'does the following computation 
>>>>>> halt':
>>>>>>
>>>>>
>>>>> int main() { H1(P,P); } does answer that question consistently with 
>>>>> the behavior of int main() { P(P); }
>>>>>
>>>>> int main() { H(P,P); } is an entirely different computation even 
>>>>> though H and H1 have identical machine code and identical input.
>>>>
>>>> But they're both being asked about the *same* input. So if both are 
>>>> halt deciders they both need to accurately describe the behaviour of 
>>>> int main() { P(P); }.
>>>>
>>>> Whether H1 can correctly decide this is irrelevant because your 
>>>> whole claim what that you'd found a way to 'refute' Linz. But since 
>>>> your P is derived from H, unless H(P, P) can correctly decide 
>>>> whether int main() { P(P); } halts, you have failed at this goal.
>>>>
>>>> And H(P, P) does *not* correctly decide this.
>>>>
>>>> André
>>>>
>>>
>>> Both H1(P,P) and H(P,P) correctly decide the halt status of their 
>>> input. This is very very difficult to understand, yet empirically 
>>> verifiable none-the-less.
>>
>> They both have the same input. They're both being asked whether int 
>> main() { P(P); } halts.
>>
>> That's the question a halt decider is supposed to answer. It is *not* 
>> supposed to answer something about the trace of some simulated 
>> execution. It's supposed to answer about the *actual* computation. 
>> This is a simple matter of definition. It isn't open for debate.
>>
>> It's not possible for them to both be right if they give different 
>> answers given that they are answering the exact same question.
>>
> 
> Yes we agree, that was not the issue. Is it possible for them to have 
> identical machine code and identical inputs and derive opposite results?

No, we don't agree. Above you claim that "Both H1(P,P) and H(P,P) 
correctly decide the halt status of their input". I am stating that that 
is flat-out wrong. Your H(P,P) does *not* correctly decide the halting 
status of its input.

André


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

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


#40061 — 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 21:59 -0400
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<GLP4J.151454$o45.28683@fx46.iad>
In reply to#40052
On 9/28/21 7:28 PM, olcott wrote:
> On 9/28/2021 6:07 PM, André G. Isaak wrote:
>> On 2021-09-28 16:37, olcott wrote:
>>> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>>>> On 2021-09-28 14:57, olcott wrote:
>>>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>>>
>>>>>> What appears to be over your head is the fact that if H is a halt
>>>>>> decider, then the computation
>>>>>>
>>>>>> int main() { H(P,P); }
>>>>>>
>>>>>> is SUPPOSED to answer the question 'does the following computation
>>>>>> halt':
>>>>>>
>>>>>
>>>>> int main() { H1(P,P); } does answer that question consistently with
>>>>> the behavior of int main() { P(P); }
>>>>>
>>>>> int main() { H(P,P); } is an entirely different computation even
>>>>> though H and H1 have identical machine code and identical input.
>>>>
>>>> But they're both being asked about the *same* input. So if both are
>>>> halt deciders they both need to accurately describe the behaviour of
>>>> int main() { P(P); }.
>>>>
>>>> Whether H1 can correctly decide this is irrelevant because your
>>>> whole claim what that you'd found a way to 'refute' Linz. But since
>>>> your P is derived from H, unless H(P, P) can correctly decide
>>>> whether int main() { P(P); } halts, you have failed at this goal.
>>>>
>>>> And H(P, P) does *not* correctly decide this.
>>>>
>>>> André
>>>>
>>>
>>> Both H1(P,P) and H(P,P) correctly decide the halt status of their
>>> input. This is very very difficult to understand, yet empirically
>>> verifiable none-the-less.
>>
>> They both have the same input. They're both being asked whether int
>> main() { P(P); } halts.
>>
>> That's the question a halt decider is supposed to answer. It is *not*
>> supposed to answer something about the trace of some simulated
>> execution. It's supposed to answer about the *actual* computation.
>> This is a simple matter of definition. It isn't open for debate.
>>
>> It's not possible for them to both be right if they give different
>> answers given that they are answering the exact same question.
>>
> 
> Yes we agree, that was not the issue. Is it possible for them to have
> identical machine code and identical inputs and derive opposite results?

No. But it may be that the input that differs is just the PC the routine
runs at.

Think about it. The output of every normal computer opcode is strictly a
computation of the opcode and some inputs to that instruction.

Thus, if you have the identical sequence of instructions, and feed all
of them the exact same inputs, the results must be exactly the same.

If you get a difference in results, you WILL be able to trace it back to
some instruction where the first difference occured.

That instruction MUST have gotten a different input from the two copies.

EIther the opcode was different, or an input was different.

If you claim the 'inputs' are the same, this means that EVERYTHING that
goes into an instruction must have been the same.

Either your H and H1 aren't actually identical code, or the depend on
something that wasn't the same in the exection of the two copies.

> 
>>> The empirical proof of this relies on code that is not quite
>>> implemented yet. As long as pure functions H and H1 derive the same
>>> results as my current functions H and H1 then we have the empirical
>>> proof.
>>
>> Empirical proofs are for empirical subjects. Mathematics isn't an
>> empirical subject.
>>
>> André
>>
> 
> 

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


#40020 — 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:37 -0400
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<gfC4J.25207$nh7.18877@fx22.iad>
In reply to#40015
On 9/28/21 12:09 AM, olcott wrote:
> On 9/27/2021 10:48 PM, André G. Isaak wrote:
>> On 2021-09-27 21:28, 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
>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>>
>> Of course H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is not equivalent to Ĥ applied to ⟨Ĥ⟩.
>> But if H is a halt decider then by the very definition of 'halt
>> decider' H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must correctly predict the behaviour of 
>> applied to ⟨Ĥ⟩.
>>
>> And the above two statements contradict one another. You seem to be
>> claiming that A is equivalent to B but that B is not equivalent to A.
>> You should learn what 'equivalent' means.
>>
> 
> I said it incorrectly because I was thinking of my H1/H
> 
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to
> Ĥ applied to ⟨Ĥ⟩

IMPOSSIBLE. H and H^ are different operations, they can't be
computationally equivalent (unless you are thinking that ALL functions
that Halt are commputationally equivalent).

That is like saying that cos and cosh are computationally equivalent
because they use a similar summation in them.

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

THen H^ was built wrong. Since the DEFINITION of H^ is that at H^.qx it
has a copy of the computation H placed there, and the tape at that state
is by definition <H^> <H^>, if the computations at H^.qx and H are not
the same, your H^ is defined wrong.

> 
>>> 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.
>>
>> A description of a computation is a description of a computation. ⟨P⟩
>> ⟨P⟩ describes the same computation regardless of which program it is
>> passed to as an input. To say otherwise suggests you don't even grasp
>> what the term 'description' means.
>>
> 
> No it does not.

So, you are arguing that A is not A.

Sounds like YOU are in the Liar's Paradox.

> 
>> If you were tasked with coming up with a computer program which took
>> as its input a description of an airplane and determined whether that
>> airplane was flightworthy, do you seriously believe that anyone would
>> be interested in a program which determined this for anything other
>> than the actual airplane which was described? If you claim that the
>> description represents a 'different airplane' when passed to your
>> program than when the description appears independently do you
>> seriously think anyone is going to buy that?
>>
>> André
>>
> 
> 

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


#40023 — 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:25 -0500
SubjectRe: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function
Message-ID<ANednQvuh5JVuM78nZ2dnUU7-dnNnZ2d@giganews.com>
In reply to#40020
On 9/28/2021 5:37 AM, Richard Damon wrote:
> On 9/28/21 12:09 AM, olcott wrote:
>> On 9/27/2021 10:48 PM, André G. Isaak wrote:
>>> On 2021-09-27 21:28, 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
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>>
>>> Of course H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is not equivalent to Ĥ applied to ⟨Ĥ⟩.
>>> But if H is a halt decider then by the very definition of 'halt
>>> decider' H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must correctly predict the behaviour of
>>> applied to ⟨Ĥ⟩.
>>>
>>> And the above two statements contradict one another. You seem to be
>>> claiming that A is equivalent to B but that B is not equivalent to A.
>>> You should learn what 'equivalent' means.
>>>
>>
>> I said it incorrectly because I was thinking of my H1/H
>>
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to
>> Ĥ applied to ⟨Ĥ⟩
> 
> IMPOSSIBLE. H and H^ are different operations, they can't be
> computationally equivalent (unless you are thinking that ALL functions
> that Halt are commputationally equivalent).
> 

In x86utm int main() { H1(P,P); } has an execution trace that is 
essentially the same as int main() { P(P); }

> That is like saying that cos and cosh are computationally equivalent
> because they use a similar summation in them.
> 
>>
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is NOT computationally equivalent to
>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> 
> THen H^ was built wrong. Since the DEFINITION of H^ is that at H^.qx it
> has a copy of the computation H placed there, and the tape at that state
> is by definition <H^> <H^>, if the computations at H^.qx and H are not
> the same, your H^ is defined wrong.
> 
>>
>>>> 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.
>>>
>>> A description of a computation is a description of a computation. ⟨P⟩
>>> ⟨P⟩ describes the same computation regardless of which program it is
>>> passed to as an input. To say otherwise suggests you don't even grasp
>>> what the term 'description' means.
>>>
>>
>> No it does not.
> 
> So, you are arguing that A is not A.
> 
> Sounds like YOU are in the Liar's Paradox.
> 
>>
>>> If you were tasked with coming up with a computer program which took
>>> as its input a description of an airplane and determined whether that
>>> airplane was flightworthy, do you seriously believe that anyone would
>>> be interested in a program which determined this for anything other
>>> than the actual airplane which was described? If you claim that the
>>> description represents a 'different airplane' when passed to your
>>> program than when the description appears independently do you
>>> seriously think anyone is going to buy that?
>>>
>>> André
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-27 22:46 -0400
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<9mv4J.4706$yk1.4153@fx13.iad>
In reply to#40003
On 9/27/21 10:05 PM, olcott wrote:
> 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 ⟨Ĥ⟩ ⟨Ĥ⟩

Wrong.

Read the conditions above, the Definition of what H is supposed to do,
which the copy of it in H^ will also need to do, to be RIGHT, is totally
based on what H^ applied to H^ will do.

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

Right, H^ USES a copy of the Halt Decider H, and has that copy starting
at state H^.qx.

H^ is NOT a Halt Decider, it is the machine that the Halt Decider needs
to decide, and is designed to foil the Halt Decider.

> 
> 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 ⟨Ĥ⟩.
> 

WRONG.

Your FIRST statement is rignt. the input s a Turing Machine Descrption.

The input is <H^? <H^>

That input REPRESENT the Turing Machine H^ applied to the input <H^>.

The QUESTION that H is asked to decide is does that machine [ H^ applied
to <H^> ] halt when run or not, i.e does H^ Halt.

Maybe you should actually read the problem statement.

Why do you think the description of what H is supposed to do uses the
phrase if P applied to I halts (where P = H^, and I = <H^>)

Where do you see anything talking about what the simulation of the first
parameter does? THe problem doesn't even specify that H even does a
simulation, so it can't talk about what the simulation does.

I wonder if your problem is that you are so stuck on the idea that Truth
needs to be provable that you just can't even think about H needing to
make its decision on something it just has to 'figure out' and might not
be able to formally prove.

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


#40025 — Re: It's halting, but not as we know it Jim

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-28 16:00 +0100
SubjectRe: It's halting, but not as we know it Jim
Message-ID<87k0j0rbhk.fsf@bsb.me.uk>
In reply to#40003
olcott <NoOne@NoWhere.com> writes:

> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:

>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> 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.

>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if Ĥ applied to ⟨Ĥ⟩ halts
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>
> It is not about Ĥ applied to ⟨Ĥ⟩

Yes it is.  Go read those three pages from Linz again.  If you can't
understand what he is saying, you have no standing in the debate.

You can keep the extra states.  You can add any bogus annotations you
like.  But you can't remove the ones that are determined by the
specification given for H by Linz.

-- 
Ben.

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


#40029 — When an input TM description can never reach its final state it is non halting

Fromolcott <NoOne@NoWhere.com>
Date2021-09-28 10:25 -0500
SubjectWhen an input TM description can never reach its final state it is non halting
Message-ID<2Zmdnd9S2o9rrs78nZ2dnUU7-IfNnZ2d@giganews.com>
In reply to#40025
On 9/28/2021 10:00 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
> 
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>
>>> 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.
> 
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if Ĥ applied to ⟨Ĥ⟩ halts
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> It is not about Ĥ applied to ⟨Ĥ⟩
> 
> Yes it is.  Go read those three pages from Linz again.  If you can't
> understand what he is saying, you have no standing in the debate.
> 

The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
The halt decider does not decide that halt status of itself.
The halt decider decides the halt status of its input.
The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.

Since you already know these things are true denying them is dishonest.

> You can keep the extra states.  You can add any bogus annotations you
> like.  But you can't remove the ones that are determined by the
> specification given for H by Linz.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#40048 — Re: When an input TM description can never reach its final state it is non halting

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-28 19:04 -0400
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<scN4J.36018$6u6.7947@fx03.iad>
In reply to#40029
On 9/28/21 11:25 AM, olcott wrote:
> On 9/28/2021 10:00 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> 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.
>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if Ĥ applied to ⟨Ĥ⟩ halts
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> It is not about Ĥ applied to ⟨Ĥ⟩
>>
>> Yes it is.  Go read those three pages from Linz again.  If you can't
>> understand what he is saying, you have no standing in the debate.
>>
> 
> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
> The halt decider does not decide that halt status of itself.
> The halt decider decides the halt status of its input.
> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.

What does the statement:

>>>> if Ĥ applied to ⟨Ĥ⟩ halts

Mean to you? What is it that matters in this question.

If it isn't "Ĥ applied to ⟨Ĥ⟩", why does it say that?

Read what Linz says.

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


#40055 — Re: When an input TM description can never reach its final state it is non halting

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-29 02:14 +0100
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<87lf3gp4h9.fsf@bsb.me.uk>
In reply to#40029
olcott <NoOne@NoWhere.com> writes:

> On 9/28/2021 10:00 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>> 
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> 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.
>> 
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if Ĥ applied to ⟨Ĥ⟩ halts
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> It is not about Ĥ applied to ⟨Ĥ⟩
>>
>> Yes it is.  Go read those three pages from Linz again.  If you can't
>> understand what he is saying, you have no standing in the debate. 
>
> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
> The halt decider does not decide that halt status of itself.
> The halt decider decides the halt status of its input.
> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Since you already know these things are true denying them is
> dishonest.

2+2 is 4
Macron is the president of France
Linz wrote a book about automata theory

Since you already know these things are true denying them is dishonest.

You are clearly lost but you don't have the courage to ask for help, but
any side discussion is good for you because you need to draw fire from
the fact that you are not talking about the halting problem.  Once you
have re-defined what the terms mean so that H is deemed to be correct in
rejecting a halting computation, you have to draw the flack somewhere
else.

It's futile trying to get you to understand but I will point out you are
being deceptive every time you leave off Linz's perfectly correct
annotations.  They are the ones that matters.

>> You can keep the extra states.  You can add any bogus annotations you
>> like.  But you can't remove the ones that are determined by the
>> specification given for H by Linz.
>> 

-- 
Ben.

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


#40058 — Re: When an input TM description can never reach its final state it is non halting

Fromolcott <NoOne@NoWhere.com>
Date2021-09-28 20:22 -0500
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<d7qdnTevBu0hIs78nZ2dnUU7-WVQAAAA@giganews.com>
In reply to#40055
On 9/28/2021 8:14 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/28/2021 10:00 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> 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.
>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if Ĥ applied to ⟨Ĥ⟩ halts
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> It is not about Ĥ applied to ⟨Ĥ⟩
>>>
>>> Yes it is.  Go read those three pages from Linz again.  If you can't
>>> understand what he is saying, you have no standing in the debate.
>>
>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
>> The halt decider does not decide that halt status of itself.
>> The halt decider decides the halt status of its input.
>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Since you already know these things are true denying them is
>> dishonest.
> 
> 2+2 is 4
> Macron is the president of France
> Linz wrote a book about automata theory
> 
> Since you already know these things are true denying them is dishonest.
> 
> You are clearly lost but you don't have the courage to ask for help, but
> any side discussion is good for you because you need to draw fire from
> the fact that you are not talking about the halting problem.  Once you
> have re-defined what the terms mean so that H is deemed to be correct in
> rejecting a halting computation, you have to draw the flack somewhere
> else.
> 
> It's futile trying to get you to understand but I will point out you are
> being deceptive every time you leave off Linz's perfectly correct
> annotations.  They are the ones that matters.
> 

In other words you cannot possibly provide anything that would look like 
a rebuttal to even the very gullible.

>>> You can keep the extra states.  You can add any bogus annotations you
>>> like.  But you can't remove the ones that are determined by the
>>> specification given for H by Linz.
>>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#40062 — Re: When an input TM description can never reach its final state it is non halting

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-28 22:03 -0400
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<pPP4J.151455$o45.93147@fx46.iad>
In reply to#40058
On 9/28/21 9:22 PM, olcott wrote:
> On 9/28/2021 8:14 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 9/28/2021 10:00 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> 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.
>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> It is not about Ĥ applied to ⟨Ĥ⟩
>>>>
>>>> Yes it is.  Go read those three pages from Linz again.  If you can't
>>>> understand what he is saying, you have no standing in the debate.
>>>
>>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
>>> The halt decider does not decide that halt status of itself.
>>> The halt decider decides the halt status of its input.
>>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> Since you already know these things are true denying them is
>>> dishonest.
>>
>> 2+2 is 4
>> Macron is the president of France
>> Linz wrote a book about automata theory
>>
>> Since you already know these things are true denying them is dishonest.
>>
>> You are clearly lost but you don't have the courage to ask for help, but
>> any side discussion is good for you because you need to draw fire from
>> the fact that you are not talking about the halting problem.  Once you
>> have re-defined what the terms mean so that H is deemed to be correct in
>> rejecting a halting computation, you have to draw the flack somewhere
>> else.
>>
>> It's futile trying to get you to understand but I will point out you are
>> being deceptive every time you leave off Linz's perfectly correct
>> annotations.  They are the ones that matters.
>>
> 
> In other words you cannot possibly provide anything that would look like
> a rebuttal to even the very gullible.

No, he is saying you are too dumb to recognize the errors in your
arguments so you just ignore anything that people say that disagrees
with you and call it a dishonest dodge, whiich is the most dishonest
dodge of all.

You are so gullible, you have gaslight yourself into believing your own
lies.

> 
>>>> You can keep the extra states.  You can add any bogus annotations you
>>>> like.  But you can't remove the ones that are determined by the
>>>> specification given for H by Linz.
>>>>
>>
> 
> 

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


#40068 — Re: When an input TM description can never reach its final state it is non halting

FromJeff Barnett <jbb@notatt.com>
Date2021-09-29 00:46 -0600
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<sj1254$ni5$1@dont-email.me>
In reply to#40062
On 9/28/2021 8:03 PM, Richard Damon wrote:
> On 9/28/21 9:22 PM, olcott wrote:
>> On 9/28/2021 8:14 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/28/2021 10:00 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>>
>>>>>>> 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.
>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> It is not about Ĥ applied to ⟨Ĥ⟩
>>>>>
>>>>> Yes it is.  Go read those three pages from Linz again.  If you can't
>>>>> understand what he is saying, you have no standing in the debate.
>>>>
>>>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
>>>> The halt decider does not decide that halt status of itself.
>>>> The halt decider decides the halt status of its input.
>>>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> Since you already know these things are true denying them is
>>>> dishonest.
>>>
>>> 2+2 is 4
>>> Macron is the president of France
>>> Linz wrote a book about automata theory
>>>
>>> Since you already know these things are true denying them is dishonest.
>>>
>>> You are clearly lost but you don't have the courage to ask for help, but
>>> any side discussion is good for you because you need to draw fire from
>>> the fact that you are not talking about the halting problem.  Once you
>>> have re-defined what the terms mean so that H is deemed to be correct in
>>> rejecting a halting computation, you have to draw the flack somewhere
>>> else.
>>>
>>> It's futile trying to get you to understand but I will point out you are
>>> being deceptive every time you leave off Linz's perfectly correct
>>> annotations.  They are the ones that matters.
>>>
>>
>> In other words you cannot possibly provide anything that would look like
>> a rebuttal to even the very gullible.
> 
> No, he is saying you are too dumb to recognize the errors in your
> arguments so you just ignore anything that people say that disagrees
> with you and call it a dishonest dodge, whiich is the most dishonest
> dodge of all.
> 
> You are so gullible, you have gaslight yourself into believing your own
> lies.

There is another possibility: He/she has become emotionally attached to 
his "accomplishments". The actual display that the cockroach in his/her 
kitchen knows as much about the topic as he/she does has crushed his/her 
ego. If he/she became honest an admitted the utter failure of the last 
two decades of his/her life, his/her entire personality structure would 
collapse.

You have surely noticed the total resistance to everyone's attempts to 
be helpful and improve his/her state. Well that resistance is minor to 
what would be shown to a mental health professional. He/she would rather 
continue the futile fight to be recognized as a world class 
mathematician than be instantly classified as a whack job. The fact that 
the classification, in both instances, has already been determined has 
not yet penetrated his/her near empty skull.
-- 
Jeff Barnett

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


#40082 — Re: When an input TM description can never reach its final state it is non halting

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-29 23:44 +0100
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<874ka3ovc3.fsf@bsb.me.uk>
In reply to#40058
olcott <NoOne@NoWhere.com> writes:

> In other words you cannot possibly provide anything that would look
> like a rebuttal to even the very gullible.

I wonder what would constitute a "rebuttal" to you?  Linz tells us that
the halting problem is (in part) about a TM H such that

  H(<M>, w) ⊢* H.qn

if and only iff M(x) does not halts.  You change what "halting" means so
that "on that basis"

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

and you expect people to think you have something to say about the
theorem in Linz?

That's about as simple as I can put it, and it uses mostly your writing
on the topic.  But seeing the problem does rely on you knowing what
these formal symbols mean and how they are manipulated.  You can,
apparently, write the two lines above and not see that H is not "exactly
and precisely as in Linz".  I think you see the notation as vague and
suggestive rather that exact and not subject to interpretation.

-- 
Ben.

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


#40027 — Re: It's halting, but not as we know it Jim

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-28 16:14 +0100
SubjectRe: It's halting, but not as we know it Jim
Message-ID<87bl4crav2.fsf@bsb.me.uk>
In reply to#40003
olcott <NoOne@NoWhere.com> writes:

> 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 (<Ĥ>,<Ĥ>).

It's extraordinary that you complain that no one ever points out errors,
or that there arguments are all straw men, but when it's clearly pointed
out to you, using your own posts, you have nothing to say!  Not a word.

You can't say anything because rule 1 of crank posting is to never
retract anything significant.  You can't take it back but you can't
acknowledge it either since that makes it clear that you "work" is
simply irrelevant to the halting problem. 

-- 
Ben.

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


#40031 — Re: When an input TM description can never reach its final state it is non halting

Fromolcott <NoOne@NoWhere.com>
Date2021-09-28 10:36 -0500
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<HoydnUITv4Dxq878nZ2dnUU7-LvNnZ2d@giganews.com>
In reply to#40027
On 9/28/2021 10:14 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> 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 (<Ĥ>,<Ĥ>).
> 
> It's extraordinary that you complain that no one ever points out errors,
> or that there arguments are all straw men, but when it's clearly pointed
> out to you, using your own posts, you have nothing to say!  Not a word.
> 

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

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

The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
The halt decider does not decide that halt status of itself.
The halt decider decides the halt status of its input.
The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.

Since you already know these things are true denying them is dishonest.

Some people are confused and believe that they are pointing out errors 
and some people use the dishonest dodge tactic of the strawman error to 
fool others into believing that they pointed out errors.

Of recent reviews the only thing that can be reasonably construed as any 
sort of error is that my current implementation is probably not based on 
a computable function because it currently requires static local data to 
derive its result.

This shortcoming has its architectural design complete for more than a 
week. The detailed design it also almost complete. It turns out that 
implementing the complete Linz template where Ĥ copies its input make 
the halt deciding algorithm much simpler and is most naturally 
implemented as a pure function.

https://en.wikipedia.org/wiki/Pure_function

> You can't say anything because rule 1 of crank posting is to never
> retract anything significant.  You can't take it back but you can't
> acknowledge it either since that makes it clear that you "work" is
> simply irrelevant to the halting problem.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#40050 — Re: When an input TM description can never reach its final state it is non halting

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-28 19:09 -0400
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<RgN4J.43371$gc3.29971@fx12.iad>
In reply to#40031
On 9/28/21 11:36 AM, olcott wrote:
> On 9/28/2021 10:14 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> 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 (<Ĥ>,<Ĥ>).
>>
>> It's extraordinary that you complain that no one ever points out errors,
>> or that there arguments are all straw men, but when it's clearly pointed
>> out to you, using your own posts, you have nothing to say!  Not a word.
>>
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
> The halt decider does not decide that halt status of itself.
> The halt decider decides the halt status of its input.
> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
> 

Reread Linz. It NEVER says 'Simulated ...' anywhere.

It always refers to if P applied to I or M applied to w or what ever
symbols that copy is using. It is ALWAYS the TURING MACHINE applied to
ite INPUT.


> Since you already know these things are true denying them is dishonest.

You are right about this, but have the wrong target, it has been pointed
out to you enough times that either you are mentally deficient or a
pathological Liar.

> 
> Some people are confused and believe that they are pointing out errors
> and some people use the dishonest dodge tactic of the strawman error to
> fool others into believing that they pointed out errors.

YOU do the dishonest dodge and the straw man.

> 
> Of recent reviews the only thing that can be reasonably construed as any
> sort of error is that my current implementation is probably not based on
> a computable function because it currently requires static local data to
> derive its result.

No, it is construed that because you claim to copies give different answers.

> 
> This shortcoming has its architectural design complete for more than a
> week. The detailed design it also almost complete. It turns out that
> implementing the complete Linz template where Ĥ copies its input make
> the halt deciding algorithm much simpler and is most naturally
> implemented as a pure function.
> 
> https://en.wikipedia.org/wiki/Pure_function
> 
>> You can't say anything because rule 1 of crank posting is to never
>> retract anything significant.  You can't take it back but you can't
>> acknowledge it either since that makes it clear that you "work" is
>> simply irrelevant to the halting problem.
>>
> 
> 

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


#40054 — Re: When an input TM description can never reach its final state it is non halting

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-29 02:14 +0100
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<87o88cp4i3.fsf@bsb.me.uk>
In reply to#40031
olcott <NoOne@NoWhere.com> writes:

> On 9/28/2021 10:14 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> 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 (<Ĥ>,<Ĥ>).
>> It's extraordinary that you complain that no one ever points out errors,
>> or that there arguments are all straw men, but when it's clearly pointed
>> out to you, using your own posts, you have nothing to say!  Not a word.

Not a word about having switched from talking about the halting problem
to talking about your POOH problem.  Re-defining the term "halting" so
the wrong answer:

  H(<Ĥ>,<Ĥ>) ⊢* H.qn
  Ĥ(<Ĥ>) ⊢* Ĥ.qn
  
is called "correct".  You have been clear about this time and time
again.  Your code sketch of Halts was correct because of what would
happen if line 15 were commented out.  False is the correct answer for
some halting computations because they only halt for a reason you
consider special.

This switch in the problem is not hidden.  You are explicit about it.
The deception all comes about in trying to pretend that is this what
Linz was talking about.  No.  Linz was talking about actual halting:

  H(<Ĥ>,<Ĥ>) ⊢* H.qn  iff and only if   Ĥ(<Ĥ>) ⊢* oo.

That's why you must keep lying about Linz's Ĥ like this:

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

You must remove Linz's correct annotations and replace them with your
junk ones to try to hint that you are talking about an Ĥ like Linz's.

> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
> The halt decider does not decide that halt status of itself.
> The halt decider decides the halt status of its input.
> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Since you already know these things are true denying them is
> dishonest.

It's possible you are so confused that you think these things explain
why you've removed Linz's correct description of the behaviour of Ĥ.
But, one way or another, you are being deceptive and I can't do anything
but call you out on it.  I'm happy to help if you genuinely don't follow
what Linz concludes about the behaviour of Ĥ, but your track record in
understand these things is very poor.

> Some people are confused and believe that they are pointing out errors
> and some people use the dishonest dodge tactic of the strawman error
> to fool others into believing that they pointed out errors.

That's for others to judge.  I quote you explicitly replacing halting
with your own silly criterion and then stating, clear as day, that H is
correct to reject at least one halting computation:

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

I am confident that no intelligent reader will call this a strawman.
It's the simplest possible summary of why you are not addressing the
theorem you are so obsessed about.

But since you are just making up your own "Peter Olcott Other Halting"
problem, it's not really an error.  It's not even an error to replace
Linz's correct annotations about the behaviour of Ĥ with your own
because, technically, you are no longer talking about Linz H/Ĥ pair
anymore.  It's more about deception and dishonesty than it about
errors.  If you didn't try to pretend that your POOH problem is just the
same as the halting problem, we could all simply ignore your posts since
no one cares about POOH.

-- 
Ben.

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


#40057 — Re: When an input TM description can never reach its final state it is non halting

Fromolcott <NoOne@NoWhere.com>
Date2021-09-28 20:20 -0500
SubjectRe: When an input TM description can never reach its final state it is non halting
Message-ID<d7qdnTSvBu3FIs78nZ2dnUU7-WXNnZ2d@giganews.com>
In reply to#40054
On 9/28/2021 8:14 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/28/2021 10:14 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> 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 (<Ĥ>,<Ĥ>).
>>> It's extraordinary that you complain that no one ever points out errors,
>>> or that there arguments are all straw men, but when it's clearly pointed
>>> out to you, using your own posts, you have nothing to say!  Not a word.
> 
> Not a word about having switched from talking about the halting problem
> to talking about your POOH problem.  Re-defining the term "halting" so
> the wrong answer:
> 
>    H(<Ĥ>,<Ĥ>) ⊢* H.qn
>    Ĥ(<Ĥ>) ⊢* Ĥ.qn
>    
> is called "correct".  You have been clear about this time and time
> again.  Your code sketch of Halts was correct because of what would
> happen if line 15 were commented out.  False is the correct answer for
> some halting computations because they only halt for a reason you
> consider special.
> 
> This switch in the problem is not hidden.  You are explicit about it.
> The deception all comes about in trying to pretend that is this what
> Linz was talking about.  No.  Linz was talking about actual halting:
> 
>    H(<Ĥ>,<Ĥ>) ⊢* H.qn  iff and only if   Ĥ(<Ĥ>) ⊢* oo.
> 
> That's why you must keep lying about Linz's Ĥ like this:
> 
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> You must remove Linz's correct annotations and replace them with your
> junk ones to try to hint that you are talking about an Ĥ like Linz's.
> 
>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0.
>> The halt decider does not decide that halt status of itself.
>> The halt decider decides the halt status of its input.
>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Since you already know these things are true denying them is
>> dishonest.
> 
> It's possible you are so confused that you think these things explain
> why you've removed Linz's correct description of the behaviour of Ĥ.
> But, one way or another, you are being deceptive and I can't do anything
> but call you out on it.  I'm happy to help if you genuinely don't follow
> what Linz concludes about the behaviour of Ĥ, but your track record in
> understand these things is very poor.
> 
>> Some people are confused and believe that they are pointing out errors
>> and some people use the dishonest dodge tactic of the strawman error
>> to fool others into believing that they pointed out errors.
> 
> That's for others to judge.  I quote you explicitly replacing halting
> with your own silly criterion and then stating, clear as day, that H is
> correct to reject at least one halting computation:
> 
>    "On that basis
>    Ĥ(<Ĥ>) ⊢* Ĥ.qn
>    H(<Ĥ>,<Ĥ>) ⊢* H.qn"
> 
> I am confident that no intelligent reader will call this a strawman.
> It's the simplest possible summary of why you are not addressing the
> theorem you are so obsessed about.
> 
> But since you are just making up your own "Peter Olcott Other Halting"
> problem, it's not really an error.  It's not even an error to replace
> Linz's correct annotations about the behaviour of Ĥ with your own
> because, technically, you are no longer talking about Linz H/Ĥ pair
> anymore.  It's more about deception and dishonesty than it about
> errors.  If you didn't try to pretend that your POOH problem is just the
> same as the halting problem, we could all simply ignore your posts since
> no one cares about POOH.
> 

This seems to be over your head:
H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩


-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web