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


Groups > sci.logic > #170305 > unrolled thread

The Semantics of Halting

Started byNewberry <newberryxy@gmail.com>
First post2018-01-16 13:02 -0800
Last post2018-02-14 00:44 -0600
Articles 20 on this page of 310 — 14 participants

Back to article view | Back to sci.logic


Contents

  The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-16 13:02 -0800
    Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-16 13:49 -0800
    Re: The Semantics of Halting Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2018-01-17 04:04 +0000
      Re: The Semantics of Halting Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2018-01-17 10:06 +0000
        Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-17 09:48 -0600
          Re: The Semantics of Halting Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2018-01-17 16:09 +0000
            Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-17 08:21 -0800
              Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-17 16:37 +0000
                Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-17 09:28 -0800
                Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-17 09:55 -0800
                  Re: The Semantics of Halting Jim Burns <james.g.burns@att.net> - 2018-01-17 13:24 -0500
                    Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-17 21:11 -0600
                  Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-17 18:45 +0000
          Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 19:35 -0800
      Re: The Semantics of Halting Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2018-01-17 10:15 +0000
      Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-17 05:04 -0800
        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 19:34 -0800
      Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 18:23 -0800
      Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 18:38 -0800
      Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 19:22 -0800
        Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-17 19:41 -0800
          Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 20:09 -0800
          Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-17 20:12 -0800
          Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-01 10:51 -0800
        Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-18 10:09 +0000
          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-18 06:36 -0800
            Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-18 15:20 +0000
              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-18 10:49 -0600
            Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-18 09:58 -0800
              Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-18 10:59 -0800
                Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-18 11:52 -0800
                  Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-20 00:18 -0800
                    Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-20 06:34 -0800
                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-20 06:41 -0800
                      Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-20 15:05 +0000
            Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-19 01:28 +0000
              Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-18 18:37 -0800
                Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-18 20:01 -0800
                Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-18 20:02 -0800
                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-20 00:10 +0000
          Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-18 09:41 -0800
    Re: The Semantics of Halting bursejan@gmail.com - 2018-01-20 06:41 -0800
      Re: The Semantics of Halting bursejan@gmail.com - 2018-01-20 06:43 -0800
        Re: The Semantics of Halting bursejan@gmail.com - 2018-01-20 06:50 -0800
      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-20 09:12 -0600
        Re: The Semantics of Halting bursejan@gmail.com - 2018-01-20 07:18 -0800
          Re: The Semantics of Halting bursejan@gmail.com - 2018-01-20 07:20 -0800
            Re: The Semantics of Halting bursejan@gmail.com - 2018-01-20 07:23 -0800
              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-20 10:22 -0600
                Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-24 13:12 -0800
                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-24 16:31 -0800
                    Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-24 19:57 -0800
                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-24 20:15 -0800
                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-25 20:21 -0800
                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-25 21:29 -0800
                            Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-25 21:38 -0800
                              Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-25 21:59 -0800
                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 00:37 +0000
                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-26 20:21 -0800
                                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-26 20:38 -0800
                                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-26 21:23 -0800
                                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-29 20:30 -0800
                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:17 -0800
                                            Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 20:47 -0800
                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:32 -0600
                                            Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 21:00 -0800
                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:38 -0600
                                    Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-26 21:19 -0800
                                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-26 21:31 -0800
                                        Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-27 13:41 -0600
                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-27 13:15 -0800
                                            Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-27 20:00 -0600
                                            Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-27 20:08 -0800
                                              Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-28 11:48 +0000
                                                Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-29 19:51 -0800
                                                  Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-29 22:29 -0600
                                                    Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:13 -0800
                                                      Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-30 21:02 -0600
                                                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 22:02 -0800
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:46 -0600
                                                      Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 20:50 -0800
                                                        Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:37 -0600
                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-30 01:50 -0800
                                                    Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 03:46 -0800
                                                  Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-30 07:56 -0800
                                                    Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:21 -0800
                                                      Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-30 19:56 -0800
                                                        Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:59 -0600
                                                          Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-31 05:59 -0800
                                                            Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 16:03 -0600
                                                              Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-31 22:10 +0000
                                                                Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 16:21 -0600
                                                                  Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-05 15:02 +0000
                                                                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-05 16:24 -0800
                                                              Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-31 15:10 -0800
                                                                Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 16:47 -0600
                                                                  Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 23:02 +0000
                                              Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-29 19:36 -0800
                                                Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-29 22:32 -0600
                                                  Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-29 20:50 -0800
                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:19 -0800
                                                    Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-30 21:08 -0600
                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-30 23:32 -0600
                                                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 22:04 -0800
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:48 -0600
                                                            Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-31 17:31 +0000
                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 22:12 -0600
                                                                Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 22:41 -0600
                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-31 22:55 -0800
                                                                    Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-01 09:22 -0600
                                                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-01 08:36 -0800
                                                                        Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 15:15 -0600
                                                                  Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 01:23 -0600
                                                                    Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-01 09:46 -0600
                                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 14:51 -0600
                                                                        Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-01 20:58 +0000
                                                                        Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-01 17:35 -0600
                                                                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-04 16:30 -0800
                                                                    Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-01 17:36 +0000
                                                                Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-01 17:06 +0000
                                                        Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 19:45 -0600
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:16 -0600
                                                            Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 20:39 +0000
                                                            Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-02 21:38 -0600
                                                              Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-02 21:48 -0800
                                                                Re: The Semantics of Halting Jim Burns <james.g.burns@att.net> - 2018-02-03 10:56 -0500
                                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-03 15:12 -0800
                                                                    Re: The Semantics of Halting Jim Burns <james.g.burns@att.net> - 2018-02-03 20:24 -0500
                                                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-03 18:21 -0800
                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-03 16:33 -0800
                                                                    Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-03 16:51 -0800
                                                                      Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-04 13:47 +0000
                                                                    Re: The Semantics of Halting Jim Burns <james.g.burns@att.net> - 2018-02-04 19:35 -0500
                                                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-04 20:32 -0800
                                                              Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-03 14:55 -0800
                                                                Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-03 20:41 -0600
                                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-03 21:28 -0800
                                                                    Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 19:02 -0600
                                                                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-05 17:34 -0800
                                                                        Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 20:48 -0600
                                                                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-05 19:46 -0800
                                                                        Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-06 13:21 +0000
                                                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-06 08:38 -0800
                                                Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-30 07:57 -0800
                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:24 -0800
                                                    Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-30 19:48 -0800
                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:56 -0600
                                                        Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-31 05:49 -0800
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 15:40 -0600
                                                            Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-31 15:15 -0800
                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 16:50 -0600
                                                                Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-01 16:50 -0800
                                                                  Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 23:06 -0600
                                                                    Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-02 07:50 -0800
                                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-02 10:10 -0600
                                                                        Re: The Semantics of Halting Jim Burns <james.g.burns@att.net> - 2018-02-02 19:33 -0500
                                                        Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-31 15:39 +0000
                                                          Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-31 09:43 -0800
                                                            Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 22:53 -0600
                                                    Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-30 21:02 -0800
                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:43 -0600
                                                        Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-01-31 17:28 +0000
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 22:10 -0600
                                                            Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 22:51 -0600
                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 10:04 -0600
                                                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 16:30 +0000
                                                                  Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 15:12 -0600
                                                                    Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-01 21:26 +0000
                                                            Re: The Semantics of Halting Peter Percival <peterxpercival@hotmail.com> - 2018-02-01 17:48 +0000
                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-31 19:54 -0800
                                                          Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-01 18:40 -0800
                                                        Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-01 10:46 -0800
                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:25 -0800
                                                    Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-30 21:10 -0600
                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-30 23:41 -0600
                                                        Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-30 22:12 -0800
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:50 -0600
                                                            Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-01-31 09:53 -0800
                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-31 23:13 -0600
                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-31 22:24 -0800
                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-31 22:28 -0800
                                                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 11:25 +0000
                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-01 08:33 -0800
                                                                    Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 17:45 +0000
                                                                  Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 10:43 -0600
                                                                    Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 22:28 +0000
                                                                Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-01 08:05 -0800
                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-01 15:21 -0800
                                                                  Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-01 17:08 -0800
                                                                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-01 22:33 -0800
                                                                    Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-02 09:38 -0800
                                                                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-03 14:41 -0800
                                                                        Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 00:08 +0000
                                                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-03 16:31 -0800
                                                                            Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 01:19 +0000
                                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-03 22:28 -0600
                                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-04 02:24 -0800
                                                                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 21:24 +0000
                                                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-05 17:19 -0800
                                                                                    Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-06 02:40 +0000
                                                                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-06 03:18 -0800
                                                                                        Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-06 08:35 -0800
                                                                                          Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-06 13:45 -0800
                                                                                            Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-06 16:47 -0800
                                                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-06 22:40 -0600
                                                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-06 22:21 -0800
                                                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-06 23:24 -0800
                                                                                                    Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-07 09:54 -0600
                                                                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-06 22:28 -0800
                                                                                                    Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-06 22:52 -0800
                                                                                                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-06 22:36 -0800
                                                                                              Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-06 19:46 -0800
                                                                                          Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:52 +0000
                                                                                            Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-06 18:45 -0800
                                                                                              Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 18:58 -0800
                                                                                                Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 19:12 -0800
                                                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 19:25 -0800
                                                                                                  Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-08 15:31 +0000
                                                                                                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-08 19:35 -0800
                                                                                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-08 22:38 -0800
                                                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-08 23:22 -0800
                                                                                                        Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-09 09:28 -0800
                                                                                                          Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-10 22:17 -0800
                                                                                                            Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-11 00:49 -0600
                                                                                                              Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-11 00:38 -0800
                                                                                                              Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-11 12:13 +0000
                                                                                                              Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-11 07:14 -0800
                                                                                                                Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-12 18:05 -0800
                                                                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-12 18:23 -0800
                                                                                                                    Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-12 21:00 -0600
                                                                                                                      Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-12 20:39 -0800
                                                                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-12 21:26 -0800
                                                                                                                  Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 04:21 +0000
                                                                                                                    Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-13 10:12 -0600
                                                                                                                      Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 20:03 +0000
                                                                                                                        Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-13 19:24 -0600
                                                                                                                          Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 02:41 +0000
                                                                                                                            Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-13 22:34 -0600
                                                                                                                              Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 05:29 +0000
                                                                                                                                Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-14 00:22 -0600
                                                                                                                                  Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 14:05 +0000
                                                                                                                                    Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-14 09:44 -0600
                                                                                                                                      Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 16:18 +0000
                                                                                                    Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-09 11:10 -0800
                                                                                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-09 21:27 -0800
                                                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-07 17:52 -0600
                                                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 17:12 -0800
                                                                                                  Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 17:33 -0800
                                                                                                    Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-07 20:14 -0800
                                                                                                      Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 20:58 -0800
                                                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 21:08 -0800
                                                                                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 21:45 -0800
                                                                                                            Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 22:48 -0800
                                                                                                              Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 23:16 -0800
                                                                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 23:25 -0800
                                                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 21:13 -0800
                                                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 23:08 -0800
                                                                                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 23:20 -0800
                                                                                                            Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 23:29 -0800
                                                                                                            Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 23:34 -0800
                                                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-07 14:06 -0600
                                                                                                Re: The Semantics of Halting Andy Walker <anw@cuboid.co.uk> - 2018-02-08 01:52 +0000
                                                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 18:38 -0800
                                                                                                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 19:09 -0800
                                                                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-07 21:28 -0600
                                                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 19:46 -0800
                                                                                                          Re: The Semantics of Halting peteolcott <peterolcott2@gmail.com> - 2018-02-07 20:17 -0800
                                                                                                            Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 20:26 -0800
                                                                                                  Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-08 20:26 +0000
                                                                                                    Re: The Semantics of Halting Andy Walker <anw@cuboid.co.uk> - 2018-02-09 12:27 +0000
                                                                                                      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-09 23:06 -0600
                                                                                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 21:26 +0000
                                                                                                  Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 17:30 -0800
                                                                                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 14:58 -0800
                                                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-07 11:45 -0600
                                                                                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 18:25 +0000
                                                                                              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-06 22:34 -0600
                                                                                                Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 15:43 +0000
                                                                                              Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:40 +0000
                                                                        Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-03 16:40 -0800
                                                                  Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-04 16:40 -0800
                                                        Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 21:12 +0000
                                                          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-01 09:58 -0600
                                                            Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 22:00 +0000
                                                        Re: The Semantics of Halting "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 19:52 -0600
                                                          Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-01 17:30 -0800
                                                    Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-02-01 10:45 -0800
                                    Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 21:16 +0000
                                      Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-27 13:56 -0800
                                        Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 22:04 +0000
                                          Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-27 19:17 -0800
                                            Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-28 11:16 +0000
                                Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-26 18:04 -0800
                            Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-25 21:48 -0800
                    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-24 20:44 -0800
          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-20 10:14 -0600
            Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-20 17:09 +0000
              Re: The Semantics of Halting George Greene <greeneg@email.unc.edu> - 2018-01-24 13:11 -0800
            Re: The Semantics of Halting "Renee Keller" <rkeller@aol.com> - 2018-01-24 10:25 -0500
    Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-01-20 09:19 -0600
    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-01-24 15:41 -0800
    Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-07 19:58 -0800
      Re: The Semantics of Halting Newberry <newberryxy@gmail.com> - 2018-02-07 20:23 -0800
    Re: The Semantics of Halting "Ross A. Finlayson" <ross.finlayson@gmail.com> - 2018-02-13 02:21 -0800
      Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-13 16:25 -0600
        Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 00:42 +0000
          Re: The Semantics of Halting grahamcooper7@gmail.com - 2018-02-13 19:28 -0800
          Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-13 22:10 -0600
            Re: The Semantics of Halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 05:35 +0000
              Re: The Semantics of Halting Pete Olcott <Pete@NoEmail.address> - 2018-02-14 00:44 -0600

Page 13 of 16 — ← Prev page 1 … 11 12 [13] 14 15 16  Next page →


#172698

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-14 14:05 +0000
Message-ID<87vaezbr9l.fsf@bsb.me.uk>
In reply to#172683
As usual, I wrote a long reply with lots of details but then I came to
the part that makes it all pointless, so I deleted it all except for
this:

Pete Olcott <Pete@NoEmail.address> writes:
> On 2/13/2018 11:29 PM, Ben Bacarisse wrote:
<snip>
>> Here is my yes/no question.  Please give a yes/no answer but do explain
>> if your answer is no.  Do you accept that every finite string has a
>> correct yes/no answer to the question: does the string encode a TM and
>> input pair such that the TM would halt when run with that input?
>
> No.

Flat-out, factually wrong.  There is no possible progress unless your
answer to this changes.

> Because that is exactly the same as asking me does every closed WFF
> of formal language definitely evaluate to exactly one of: True or
> False.
>
> The answer to that is No. There are numerous instances of
> syntactically correct closed WFF that do not evaluate to
> True or False because these WFF are semantically incorrect.

There are no strings that do not either (a) encode a TM/input pair such
that the encoded TM would halt on the encoded input, or (b) don't.

If the string does not encode a TM and input pair, the decider must
reject.  If the string does encode such a pair, that encoded TM will
either halt or it will not halt.  No other option is possible.

You can't get out of this with analogies.

> In fact we can formally define semantically incorrect closed WFF X
> to be the case where X does not evaluate to exactly one of True or
> False.

I won't go down that rabbit hole.  Whatever you say about WFF the fact
is that a string either encodes a halting computation or it does not.
No other option is possible.  A TM that accepts or rejects based on any
other property is not a halting decider.

-- 
Ben.

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


#172711

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-14 09:44 -0600
Message-ID<maudnRS0M7jrxBnHnZ2dnUU7-Y_NnZ2d@giganews.com>
In reply to#172698
On 2/14/2018 8:05 AM, Ben Bacarisse wrote:
> As usual, I wrote a long reply with lots of details but then I came to
> the part that makes it all pointless, so I deleted it all except for
> this:
> 
> Pete Olcott <Pete@NoEmail.address> writes:
>> On 2/13/2018 11:29 PM, Ben Bacarisse wrote:
> <snip>
>>> Here is my yes/no question.  Please give a yes/no answer but do explain
>>> if your answer is no.  Do you accept that every finite string has a
>>> correct yes/no answer to the question: does the string encode a TM and
>>> input pair such that the TM would halt when run with that input?
>>
>> No.
> 
> Flat-out, factually wrong.  There is no possible progress unless your
> answer to this changes.
> 
>> Because that is exactly the same as asking me does every closed WFF
>> of formal language definitely evaluate to exactly one of: True or
>> False.
>>
>> The answer to that is No. There are numerous instances of
>> syntactically correct closed WFF that do not evaluate to
>> True or False because these WFF are semantically incorrect.
> 
> There are no strings that do not either (a) encode a TM/input pair such
> that the encoded TM would halt on the encoded input, or (b) don't.
> 
> If the string does not encode a TM and input pair, the decider must
> reject.  If the string does encode such a pair, that encoded TM will
> either halt or it will not halt.  No other option is possible.
> 
> You can't get out of this with analogies.
> 

You are now dodging the proof. Dodging the proof does not refute
the proof.

>> In fact we can formally define semantically incorrect closed WFF X
>> to be the case where X does not evaluate to exactly one of True or
>> False.
> 
> I won't go down that rabbit hole.  

The you are showing that Truth is not your goal, your goal is rebuttal
even at the cost of Truth.

> Whatever you say about WFF the fact
> is that a string either encodes a halting computation or it does not.

Liar-Paradox ≡ ~True(Liar-Paradox) // HOL with self-reference semantics
The above string is a WFF of HOL, yet it is semantically incorrect.

Definition of Turing Machine Ĥx (state transition sequence)
Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy
Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn

Ĥx [Ĥx][Ĥx]
The above string is a WFF of Turing Machine Descriptions,
yet it is semantically incorrect.

Dodging this analysis does not even count as a rebuttal.

> No other option is possible.  A TM that accepts or rejects based on any
> other property is not a halting decider.
> 


-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172717

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-14 16:18 +0000
Message-ID<87606zbl3p.fsf@bsb.me.uk>
In reply to#172711
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/14/2018 8:05 AM, Ben Bacarisse wrote:
>> As usual, I wrote a long reply with lots of details but then I came to
>> the part that makes it all pointless, so I deleted it all except for
>> this:
>>
>> Pete Olcott <Pete@NoEmail.address> writes:
>>> On 2/13/2018 11:29 PM, Ben Bacarisse wrote:
>> <snip>
>>>> Here is my yes/no question.  Please give a yes/no answer but do explain
>>>> if your answer is no.  Do you accept that every finite string has a
>>>> correct yes/no answer to the question: does the string encode a TM and
>>>> input pair such that the TM would halt when run with that input?
>>>
>>> No.
>>
>> Flat-out, factually wrong.  There is no possible progress unless your
>> answer to this changes.
>>
>>> Because that is exactly the same as asking me does every closed WFF
>>> of formal language definitely evaluate to exactly one of: True or
>>> False.
>>>
>>> The answer to that is No. There are numerous instances of
>>> syntactically correct closed WFF that do not evaluate to
>>> True or False because these WFF are semantically incorrect.
>>
>> There are no strings that do not either (a) encode a TM/input pair such
>> that the encoded TM would halt on the encoded input, or (b) don't.
>>
>> If the string does not encode a TM and input pair, the decider must
>> reject.  If the string does encode such a pair, that encoded TM will
>> either halt or it will not halt.  No other option is possible.
>>
>> You can't get out of this with analogies.
>
> You are now dodging the proof. Dodging the proof does not refute
> the proof.

I've seen no proof of anything from you.  You are denying a plain fact.
That makes discussion of halting pointless.  You need to be discussing
things as they are, not as you want them to be.

>>> In fact we can formally define semantically incorrect closed WFF X
>>> to be the case where X does not evaluate to exactly one of True or
>>> False.
>>
>> I won't go down that rabbit hole.  
>
> The you are showing that Truth is not your goal, your goal is rebuttal
> even at the cost of Truth.

No concept of truth that you can come up with alters any fact about TMs
as they are defined.  Other people are explaining far better that I
could that you don't know what you are talking about when it comes to
truth, but none of it can alter that fact that a TM halts or does not
halt (or the string is not an encoded computation).  That fact is a
simple consequence of the definition of a TM.

>> Whatever you say about WFF the fact
>> is that a string either encodes a halting computation or it does not.
>
> Liar-Paradox ≡ ~True(Liar-Paradox) // HOL with self-reference semantics
> The above string is a WFF of HOL, yet it is semantically incorrect.

A string either encodes a computation that halts or it does not.  This
is a fact untouched by any analogies you bring to the party.

> Definition of Turing Machine Ĥx

No.  It specifies some of the behaviour of a class of TMs.

>  (state transition sequence)
> Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy
> Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn
>
> Ĥx [Ĥx][Ĥx]
> The above string is a WFF of Turing Machine Descriptions,
> yet it is semantically incorrect.

You can call it semantically incorrect, morally incorrect, theologically
incorrect or anything you like because it describes an empty class of
computations.

However, it is revealing that this new construction you have come up is
is not even contradictory.  If there /were/ some deciders in the class
H, then Ĥx [Ĥx][Ĥx] simply halts (given the specification of H^x above
which you may still not understand).

It's interesting that you have not addressed this point.  Here is
another fact for you to deny.  For any decider at all called H, the way
you construct H^x means that H^x W always halts no matter what H is a
decider for and no matter what the finite string W is (the string W can
of course be [H^x][H^x]).  You helpful write that fact out for us above.
Do you, indeed, also deny this fact despite stating it for us so
clearly?

> Dodging this analysis does not even count as a rebuttal.

Your denying facts make any discussion very difficult.

>> No other option is possible.  A TM that accepts or rejects based on any
>> other property is not a halting decider.

-- 
Ben.

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


#172281

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-02-09 11:10 -0800
Message-ID<d5f38384-3041-4c77-b539-2ee48bc69915@googlegroups.com>
In reply to#172164
Everybody is really getting sick and tired of your quoting Linz like you
MAYBE UNDERSTAND it but then just LYING about it all the time and proving
thereby that your pretensions to maybe understanding it are JUST that -- PRETENSE.
On Thursday, February 8, 2018 at 6:45:03 PM UTC-5, Pete Olcott wrote:

>         ..Definition of Turing Machine Ĥx 

THIS IS NOT  a definition of a turing machine.
This is what you would call AN EXECUTION TRACE (nobody else calls it that)
of the TM Ĥx *with*Wm* as its input string.

> ..q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy 

THE ACTUAL MEANING Of the above IS NOT "a definition of TM Ĥx".
THE ACTUAL MEANING Of the above is "Start With TM Ĥx, and invoke it on the
input string Wm, and let it run until it gets to state qx, at which point
we invoke NOT Ĥx again, but ACCORDING TO THE DEFINITION OF Ĥx, H' !! H-PRIME,
NOT H^!  Or rather, H^ at this point is DEFINED AS EMULATING H', ON TWO COPIES
of our original input for H^.  H' (which is THE SAME AS H^, at this time --
H^ IS EMULATING H' here) consumes the two copies of Wm and then winds up
in state qy.  Whether this the qy-of-H' or the qy-of-H^ IS IRRELEVANT --
those are THE SAME /place-state.

> ..q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn

This is a cojpletely different outcome.
This is the opposite outcome. Both of these can't happen.
ONE OR THE OTHER of them happens depending on what H is.

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


#172313

Fromgrahamcooper7@gmail.com
Date2018-02-09 21:27 -0800
Message-ID<a34e9a4d-483f-42d3-bb14-78b13721f00e@googlegroups.com>
In reply to#172281
On Saturday, February 10, 2018 at 5:10:17 AM UTC+10, George Greene wrote:
> Everybody is really getting sick and tired of your quoting Linz like you
> MAYBE UNDERSTAND it but then just LYING about it all the time and proving
> thereby that your pretensions to maybe understanding it are JUST that -- PRETENSE.
> On Thursday, February 8, 2018 at 6:45:03 PM UTC-5, Pete Olcott wrote:
> 
> >         ..Definition of Turing Machine Ĥx 
> 
> THIS IS NOT  a definition of a turing machine.
> This is what you would call AN EXECUTION TRACE (nobody else calls it that)
> of the TM Ĥx *with*Wm* as its input string.
> 
> > ..q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy 
> 
> THE ACTUAL MEANING Of the above IS NOT "a definition of TM Ĥx".
> THE ACTUAL MEANING Of the above is "Start With TM Ĥx, and invoke it on the
> input string Wm, and let it run until it gets to state qx, at which point
> we invoke NOT Ĥx again, but ACCORDING TO THE DEFINITION OF Ĥx, H' !! H-PRIME,
> NOT H^!  Or rather, H^ at this point is DEFINED AS EMULATING H', ON TWO COPIES
> of our original input for H^.  H' (which is THE SAME AS H^, at this time --
> H^ IS EMULATING H' here) 


Actually its just a GOTO!


Each (state) is a Turing Machine state vis-a-vis and |-* means MORE THAN 1 interum TM state.


Lets save the term EMULATE for building the STATE TRANSITION TABLE on the tape and 'running' the DATA version of the TM.  




TAPE >> NUMBER >> TABLE_OF_STATE_TRANSITIONS >> EMULATE or EXAMINE



H^ is a VALID CONSTRUCTION given its FINAL STATE is replaced with the START STATE of H'.... hardly emulating H'


--------------------

H^

DOUBLE_INPUT >> HALT >> (yes)-->(toggle)<---->(toggle)




where toggle1 |- toggle2


are both TM states with 1 single transition (as opposed to multiple states inbetween |-* )


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


#172068

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-07 17:52 -0600
Message-ID<nsidnUKG5suzDObHnZ2dnUU7-TednZ2d@giganews.com>
In reply to#172049
On 2/7/2018 4:58 PM, grahamcooper7@gmail.com wrote:
> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>
>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
>>>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>>>
>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
>>>>> <snip>
>>>>>>> Maybe you think H^ exists?
>>>>>>
>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
>>>>>> would reject.
>>>>>
>>>>> H^ is not a machine.  It is a class of machines with a particular
>>>>> specification so in some sense I was wrong because that /class/ exists,
>>>>> it's just empty.
>>>>>
>>>>> I should have asked whether you think there are any machines that meet
>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
>>>>>
>>>>> <snip>
>>>>>
>>>>
>>>> Definition of Turing Machine Ĥx (infinite loop removed)
>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
>>>>
>>>> Perhaps you have not noticed, I have quit talking about the class of
>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
>>>> [Ĥx][Ĥx] evaluation sequence.
>>>
>>> Of course I noticed when you did that -- I *corrected* you when you
>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
>>
>> Right you caught my typo.
>>
>>> And I also told why you got the result of the computation wrong (I am
>>> not going to start using POlanguage).
>>>
>>
>> You are too vague here to be understandable.
>>
>> It does seem that you are still in psychological denial that a halt
>> decider must necessarily keep track of the exact state transition
>> sequence of its TMD up to a certain point.
>>
>> You keep ignoring this so I cannot tell if you understand this key
>> requirement or not. Are you ignoring it to avoid admitting that
>> you made a mistake?
>>
>>> But I was replying to what you said about H^ with a question about H^.
>>> I suppose this means you are not going to answer that question.  That is
>>> the usual way these discussions go.
>>
>> The discussion is simplified eliminating extraneous details if we
>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
>> waste time. I want the loop of this discussion to end with resolution
>> instead of getting mired in extraneous details that have become moot.
>>
>>>
>>>> The class of gibberish strings is of course not empty. The class of
>>>> gibberish strings representing TMDs that would halt on their input is
>>>> necessarily empty.
>>>
>>> That's not an answer.  I asked if the class of machines denoted by H^ is
>>> empty or not.  Do you know the answer?
>>
>> I already answered this I will answer it again this time without providing
>> the reasoning behind the answer.
>>
>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
>> subtle, thus fooling the unwary.
>>
>>>
>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
>>>> fooled me for a dozen years and thousands of hours. I first referred
>>>> to Linz (in comp.theory) back in 2006.
>>>
>>> No string of the form [H^x] exists.
>>>
>>
>> You are basing this false assumption on the notion that H does not exist.
>>
>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
>>> the string of binary digits of x, then there is no string [max(N)], not
>>> because I can't specify what it should be, but because there is no such
>>> thing.)
>>>
>>
>> You do not realize that you are hiding an unstated assumption in
>> your statements.
>>
>> [9][9]∞ is the regular expression specifying the infinite string
>> representation of the greatest natural number.
>>
>>>> All of the other HP proofs that I have ever seen gloss over the
>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
>>>> leaving out key details in their high level abstractions.
>>>
>>> No machine meeting the specification of H^x exists any more than H^.
>>> The empty class of machines is not interesting.
>>>
>>
>> It is only empty if pathological self reference is not decidable, otherwise
>> it is a set of finite strings of the language of Turing Machine Descriptions
>> that have the semantic property of pathological self reference.
>>
>>> You have failed to take the last, trivial step in the proof, despite
>>> consistently stating in symbols that H^ always transitions from state qx
>>> to state qy or qn.
>>
>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
>> is rejected as having the semantic property of pathological self reference,
>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
>> the PSR error, so H transitions to its own ((qn)) state indicating that it
>> has detected the PSR error.
>>
>> Because you are in psychological denial you cannot admit the obvious fact
>> that every halt decider must always examine the exact state transition
>> sequence of its input TMD until this decider determines:
>> (1) That the TMD would not halt.
>> (2) The the TMD would transition to a specific final state.
>>
>> -- Definition of Turing Machine Ĥx (infinite loop removed)
>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
>>
>> Ĥx [Ĥx] would:
>> (1) begin at its own state q0
>> (2) Copy its input [Ĥx] to [Ĥx2]
>> (3) Transition to its own state qx
>> (4) Begin evaluating [Ĥx] to [Ĥx2]
>>
>> Which necessarily requires Ĥx to trace the exact state
>> transition sequence of [Ĥx] until it determines that
>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
>>
>> Each TMD in this evaluation sequence would only halt because
>> it rejects erroneous input, thus the first TM in this sequence
>> H would reject the whole sequence as erroneous.
>>
> 
> 
> 
> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> 
> its the SAME CODE!!!!
> 

I switched to Ĥx so that it is clear that even removing the
infinite loop at state qy an infinite evaluation sequence is
still specified. It took me a dozen years and thousands of
hours to realize this.

Definition of Turing Machine Ĥx (infinite loop removed)
q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn

Even this single aspect of my analysis is unique in the world.
No one has ever before even suggested that the evaluation
sequence of the HP proof counter-example continues to be
infinitely recursive even without the appended infinite loop.

> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.

and so would H^2, and H^3, and H^n
Yet if H actually evaluated the infinitely recursive sequence
that it is presented with then H itself would never halt.

Every halt decider must decide only on the basis of what
its TMD would actually do, on and on to infinite recursion
unless it rejects the entire evaluation sequence as erroneous.


-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172115

Fromgrahamcooper7@gmail.com
Date2018-02-07 17:12 -0800
Message-ID<d65c9fcb-7163-4eb4-8b70-c21f93c63636@googlegroups.com>
In reply to#172068
On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> On 2/7/2018 4:58 PM, grahamcooper7@gmail.com wrote:
> > On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> >> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> >>> Pete Olcott <Pete@NoEmail.address> writes:
> >>>
> >>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> >>>>> Pete Olcott <Pete@NoEmail.address> writes:
> >>>>>
> >>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> >>>>> <snip>
> >>>>>>> Maybe you think H^ exists?
> >>>>>>
> >>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> >>>>>> would reject.
> >>>>>
> >>>>> H^ is not a machine.  It is a class of machines with a particular
> >>>>> specification so in some sense I was wrong because that /class/ exists,
> >>>>> it's just empty.
> >>>>>
> >>>>> I should have asked whether you think there are any machines that meet
> >>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> >>>>>
> >>>>> <snip>
> >>>>>
> >>>>
> >>>> Definition of Turing Machine Ĥx (infinite loop removed)
> >>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> >>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> >>>>
> >>>> Perhaps you have not noticed, I have quit talking about the class of
> >>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> >>>> [Ĥx][Ĥx] evaluation sequence.
> >>>
> >>> Of course I noticed when you did that -- I *corrected* you when you
> >>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> >>
> >> Right you caught my typo.
> >>
> >>> And I also told why you got the result of the computation wrong (I am
> >>> not going to start using POlanguage).
> >>>
> >>
> >> You are too vague here to be understandable.
> >>
> >> It does seem that you are still in psychological denial that a halt
> >> decider must necessarily keep track of the exact state transition
> >> sequence of its TMD up to a certain point.
> >>
> >> You keep ignoring this so I cannot tell if you understand this key
> >> requirement or not. Are you ignoring it to avoid admitting that
> >> you made a mistake?
> >>
> >>> But I was replying to what you said about H^ with a question about H^.
> >>> I suppose this means you are not going to answer that question.  That is
> >>> the usual way these discussions go.
> >>
> >> The discussion is simplified eliminating extraneous details if we
> >> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> >> waste time. I want the loop of this discussion to end with resolution
> >> instead of getting mired in extraneous details that have become moot.
> >>
> >>>
> >>>> The class of gibberish strings is of course not empty. The class of
> >>>> gibberish strings representing TMDs that would halt on their input is
> >>>> necessarily empty.
> >>>
> >>> That's not an answer.  I asked if the class of machines denoted by H^ is
> >>> empty or not.  Do you know the answer?
> >>
> >> I already answered this I will answer it again this time without providing
> >> the reasoning behind the answer.
> >>
> >> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> >> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> >> subtle, thus fooling the unwary.
> >>
> >>>
> >>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> >>>> fooled me for a dozen years and thousands of hours. I first referred
> >>>> to Linz (in comp.theory) back in 2006.
> >>>
> >>> No string of the form [H^x] exists.
> >>>
> >>
> >> You are basing this false assumption on the notion that H does not exist.
> >>
> >>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> >>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> >>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> >>> the string of binary digits of x, then there is no string [max(N)], not
> >>> because I can't specify what it should be, but because there is no such
> >>> thing.)
> >>>
> >>
> >> You do not realize that you are hiding an unstated assumption in
> >> your statements.
> >>
> >> [9][9]∞ is the regular expression specifying the infinite string
> >> representation of the greatest natural number.
> >>
> >>>> All of the other HP proofs that I have ever seen gloss over the
> >>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> >>>> leaving out key details in their high level abstractions.
> >>>
> >>> No machine meeting the specification of H^x exists any more than H^.
> >>> The empty class of machines is not interesting.
> >>>
> >>
> >> It is only empty if pathological self reference is not decidable, otherwise
> >> it is a set of finite strings of the language of Turing Machine Descriptions
> >> that have the semantic property of pathological self reference.
> >>
> >>> You have failed to take the last, trivial step in the proof, despite
> >>> consistently stating in symbols that H^ always transitions from state qx
> >>> to state qy or qn.
> >>
> >> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> >> is rejected as having the semantic property of pathological self reference,
> >> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> >> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> >> the PSR error, so H transitions to its own ((qn)) state indicating that it
> >> has detected the PSR error.
> >>
> >> Because you are in psychological denial you cannot admit the obvious fact
> >> that every halt decider must always examine the exact state transition
> >> sequence of its input TMD until this decider determines:
> >> (1) That the TMD would not halt.
> >> (2) The the TMD would transition to a specific final state.
> >>
> >> -- Definition of Turing Machine Ĥx (infinite loop removed)
> >> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> >> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> >>
> >> Ĥx [Ĥx] would:
> >> (1) begin at its own state q0
> >> (2) Copy its input [Ĥx] to [Ĥx2]
> >> (3) Transition to its own state qx
> >> (4) Begin evaluating [Ĥx] to [Ĥx2]
> >>
> >> Which necessarily requires Ĥx to trace the exact state
> >> transition sequence of [Ĥx] until it determines that
> >> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> >>
> >> Each TMD in this evaluation sequence would only halt because
> >> it rejects erroneous input, thus the first TM in this sequence
> >> H would reject the whole sequence as erroneous.
> >>
> > 
> > 
> > 
> > Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > 
> > its the SAME CODE!!!!
> > 
> 
> I switched to Ĥx so that it is clear that even removing the
> infinite loop at state qy an infinite evaluation sequence is
> still specified. It took me a dozen years and thousands of
> hours to realize this.
> 
> Definition of Turing Machine Ĥx (infinite loop removed)
> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> 
> Even this single aspect of my analysis is unique in the world.
> No one has ever before even suggested that the evaluation
> sequence of the HP proof counter-example continues to be
> infinitely recursive even without the appended infinite loop.
> 
> > Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> 
> and so would H^2, and H^3, and H^n
> Yet if H actually evaluated the infinitely recursive sequence
> that it is presented with then H itself would never halt.
> 
> Every halt decider must decide only on the basis of what
> its TMD would actually do, on and on to infinite recursion
> unless it rejects the entire evaluation sequence as erroneous.


OK

H^ (H^)  ............... or H^(w)


-->

H' (H^ H^)


BEGIN TEST EXECUTING H'

... does H^(H^) halt ?
... H^(H^)
... --> 
... H'(H^ H^)
... 
... BEGIN TEST EXECUTING H'
...... does H^(H^) halt ?
...... H^(H^)
...... -->
...... H'(H^ H^)
......
...... BEGIN TEST EXECUTING H'



if HALT is dumb... it will go into a loop

if HALT is smart... it will detect a loop


HALT is SPECIFIED to HALT itself, so it cant be dumb



so HALT detects a loop




INPUT #H^#

(q0)
 |
 |   INPUT #H^,H^#
 |
 |
(qx)  H'
|   |
|   |
|   |
v   v
(NO)(YES)--->(LOOP)



(qx) is the start of the HALT CODE, input H^ H^

(qx) --> (qn) and HALTS



SO IT GOT IT WRONG!

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


#172116

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-07 17:33 -0800
Message-ID<14d98ad2-e153-4ff8-b03c-87c3eeb65269@googlegroups.com>
In reply to#172115
On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> > On 2/7/2018 4:58 PM, wrote:
> > > On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> > >> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> > >>> Pete Olcott writes:
> > >>>
> > >>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> > >>>>> Pete Olcott writes:
> > >>>>>
> > >>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> > >>>>> <snip>
> > >>>>>>> Maybe you think H^ exists?
> > >>>>>>
> > >>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> > >>>>>> would reject.
> > >>>>>
> > >>>>> H^ is not a machine.  It is a class of machines with a particular
> > >>>>> specification so in some sense I was wrong because that /class/ exists,
> > >>>>> it's just empty.
> > >>>>>
> > >>>>> I should have asked whether you think there are any machines that meet
> > >>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> > >>>>>
> > >>>>> <snip>
> > >>>>>
> > >>>>
> > >>>> Definition of Turing Machine Ĥx (infinite loop removed)
> > >>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > >>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > >>>>
> > >>>> Perhaps you have not noticed, I have quit talking about the class of
> > >>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> > >>>> [Ĥx][Ĥx] evaluation sequence.
> > >>>
> > >>> Of course I noticed when you did that -- I *corrected* you when you
> > >>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> > >>
> > >> Right you caught my typo.
> > >>
> > >>> And I also told why you got the result of the computation wrong (I am
> > >>> not going to start using POlanguage).
> > >>>
> > >>
> > >> You are too vague here to be understandable.
> > >>
> > >> It does seem that you are still in psychological denial that a halt
> > >> decider must necessarily keep track of the exact state transition
> > >> sequence of its TMD up to a certain point.
> > >>
> > >> You keep ignoring this so I cannot tell if you understand this key
> > >> requirement or not. Are you ignoring it to avoid admitting that
> > >> you made a mistake?
> > >>
> > >>> But I was replying to what you said about H^ with a question about H^.
> > >>> I suppose this means you are not going to answer that question.  That is
> > >>> the usual way these discussions go.
> > >>
> > >> The discussion is simplified eliminating extraneous details if we
> > >> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> > >> waste time. I want the loop of this discussion to end with resolution
> > >> instead of getting mired in extraneous details that have become moot.
> > >>
> > >>>
> > >>>> The class of gibberish strings is of course not empty. The class of
> > >>>> gibberish strings representing TMDs that would halt on their input is
> > >>>> necessarily empty.
> > >>>
> > >>> That's not an answer.  I asked if the class of machines denoted by H^ is
> > >>> empty or not.  Do you know the answer?
> > >>
> > >> I already answered this I will answer it again this time without providing
> > >> the reasoning behind the answer.
> > >>
> > >> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> > >> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> > >> subtle, thus fooling the unwary.
> > >>
> > >>>
> > >>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> > >>>> fooled me for a dozen years and thousands of hours. I first referred
> > >>>> to Linz (in comp.theory) back in 2006.
> > >>>
> > >>> No string of the form [H^x] exists.
> > >>>
> > >>
> > >> You are basing this false assumption on the notion that H does not exist.
> > >>
> > >>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> > >>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> > >>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> > >>> the string of binary digits of x, then there is no string [max(N)], not
> > >>> because I can't specify what it should be, but because there is no such
> > >>> thing.)
> > >>>
> > >>
> > >> You do not realize that you are hiding an unstated assumption in
> > >> your statements.
> > >>
> > >> [9][9]∞ is the regular expression specifying the infinite string
> > >> representation of the greatest natural number.
> > >>
> > >>>> All of the other HP proofs that I have ever seen gloss over the
> > >>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> > >>>> leaving out key details in their high level abstractions.
> > >>>
> > >>> No machine meeting the specification of H^x exists any more than H^.
> > >>> The empty class of machines is not interesting.
> > >>>
> > >>
> > >> It is only empty if pathological self reference is not decidable, otherwise
> > >> it is a set of finite strings of the language of Turing Machine Descriptions
> > >> that have the semantic property of pathological self reference.
> > >>
> > >>> You have failed to take the last, trivial step in the proof, despite
> > >>> consistently stating in symbols that H^ always transitions from state qx
> > >>> to state qy or qn.
> > >>
> > >> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> > >> is rejected as having the semantic property of pathological self reference,
> > >> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> > >> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> > >> the PSR error, so H transitions to its own ((qn)) state indicating that it
> > >> has detected the PSR error.
> > >>
> > >> Because you are in psychological denial you cannot admit the obvious fact
> > >> that every halt decider must always examine the exact state transition
> > >> sequence of its input TMD until this decider determines:
> > >> (1) That the TMD would not halt.
> > >> (2) The the TMD would transition to a specific final state.
> > >>
> > >> -- Definition of Turing Machine Ĥx (infinite loop removed)
> > >> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > >> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > >>
> > >> Ĥx [Ĥx] would:
> > >> (1) begin at its own state q0
> > >> (2) Copy its input [Ĥx] to [Ĥx2]
> > >> (3) Transition to its own state qx
> > >> (4) Begin evaluating [Ĥx] to [Ĥx2]
> > >>
> > >> Which necessarily requires Ĥx to trace the exact state
> > >> transition sequence of [Ĥx] until it determines that
> > >> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> > >>
> > >> Each TMD in this evaluation sequence would only halt because
> > >> it rejects erroneous input, thus the first TM in this sequence
> > >> H would reject the whole sequence as erroneous.
> > >>
> > > 
> > > 
> > > 
> > > Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > 
> > > its the SAME CODE!!!!
> > > 
> > 
> > I switched to Ĥx so that it is clear that even removing the
> > infinite loop at state qy an infinite evaluation sequence is
> > still specified. It took me a dozen years and thousands of
> > hours to realize this.
> > 
> > Definition of Turing Machine Ĥx (infinite loop removed)
> > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > 
> > Even this single aspect of my analysis is unique in the world.
> > No one has ever before even suggested that the evaluation
> > sequence of the HP proof counter-example continues to be
> > infinitely recursive even without the appended infinite loop.
> > 
> > > Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > 
> > and so would H^2, and H^3, and H^n
> > Yet if H actually evaluated the infinitely recursive sequence
> > that it is presented with then H itself would never halt.
> > 
> > Every halt decider must decide only on the basis of what
> > its TMD would actually do, on and on to infinite recursion
> > unless it rejects the entire evaluation sequence as erroneous.
> 
> 
> OK
> 
> H^ (H^)  ............... or H^(w)
> 
> 
> -->
> 
> H' (H^ H^)
> 

These things are too subtle for the greastest minds in the world
to notice since 1931. If you don't pay enormously more attention
there is no chance at all that you will ever understand what I 
saying. 

You still are not paying close enough attention to see that 
I quit talking about Ĥ quite a while ago. I did this so that
people would bother to try to understand why Ĥx still specifies 
an infinitely recursive evaluation sequence even without any
infinite loop.

An infinitely recursive evaluation sequence is an entirely different 
thing than merely getting stuck in an infinite loop.

The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
from even being evaluated for halting. The whole halt/not halt
evaluation is short-circuited by BAD INPUT REJECT !!!

Definition of Turing Machine Ĥx (infinite loop removed)
q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy 
q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn

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


#172126

FromNewberry <newberryxy@gmail.com>
Date2018-02-07 20:14 -0800
Message-ID<p5gire$2oo$1@dont-email.me>
In reply to#172116
peteolcott wrote:
> On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
>> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
>>> On 2/7/2018 4:58 PM, wrote:
>>>> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
>>>>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
>>>>>> Pete Olcott writes:
>>>>>>
>>>>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
>>>>>>>> Pete Olcott writes:
>>>>>>>>
>>>>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
>>>>>>>> <snip>
>>>>>>>>>> Maybe you think H^ exists?
>>>>>>>>>
>>>>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
>>>>>>>>> would reject.
>>>>>>>>
>>>>>>>> H^ is not a machine.  It is a class of machines with a particular
>>>>>>>> specification so in some sense I was wrong because that /class/ exists,
>>>>>>>> it's just empty.
>>>>>>>>
>>>>>>>> I should have asked whether you think there are any machines that meet
>>>>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
>>>>>>>>
>>>>>>>> <snip>
>>>>>>>>
>>>>>>>
>>>>>>> Definition of Turing Machine Ĥx (infinite loop removed)
>>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
>>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
>>>>>>>
>>>>>>> Perhaps you have not noticed, I have quit talking about the class of
>>>>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
>>>>>>> [Ĥx][Ĥx] evaluation sequence.
>>>>>>
>>>>>> Of course I noticed when you did that -- I *corrected* you when you
>>>>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
>>>>>
>>>>> Right you caught my typo.
>>>>>
>>>>>> And I also told why you got the result of the computation wrong (I am
>>>>>> not going to start using POlanguage).
>>>>>>
>>>>>
>>>>> You are too vague here to be understandable.
>>>>>
>>>>> It does seem that you are still in psychological denial that a halt
>>>>> decider must necessarily keep track of the exact state transition
>>>>> sequence of its TMD up to a certain point.
>>>>>
>>>>> You keep ignoring this so I cannot tell if you understand this key
>>>>> requirement or not. Are you ignoring it to avoid admitting that
>>>>> you made a mistake?
>>>>>
>>>>>> But I was replying to what you said about H^ with a question about H^.
>>>>>> I suppose this means you are not going to answer that question.  That is
>>>>>> the usual way these discussions go.
>>>>>
>>>>> The discussion is simplified eliminating extraneous details if we
>>>>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
>>>>> waste time. I want the loop of this discussion to end with resolution
>>>>> instead of getting mired in extraneous details that have become moot.
>>>>>
>>>>>>
>>>>>>> The class of gibberish strings is of course not empty. The class of
>>>>>>> gibberish strings representing TMDs that would halt on their input is
>>>>>>> necessarily empty.
>>>>>>
>>>>>> That's not an answer.  I asked if the class of machines denoted by H^ is
>>>>>> empty or not.  Do you know the answer?
>>>>>
>>>>> I already answered this I will answer it again this time without providing
>>>>> the reasoning behind the answer.
>>>>>
>>>>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
>>>>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
>>>>> subtle, thus fooling the unwary.
>>>>>
>>>>>>
>>>>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
>>>>>>> fooled me for a dozen years and thousands of hours. I first referred
>>>>>>> to Linz (in comp.theory) back in 2006.
>>>>>>
>>>>>> No string of the form [H^x] exists.
>>>>>>
>>>>>
>>>>> You are basing this false assumption on the notion that H does not exist.
>>>>>
>>>>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
>>>>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
>>>>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
>>>>>> the string of binary digits of x, then there is no string [max(N)], not
>>>>>> because I can't specify what it should be, but because there is no such
>>>>>> thing.)
>>>>>>
>>>>>
>>>>> You do not realize that you are hiding an unstated assumption in
>>>>> your statements.
>>>>>
>>>>> [9][9]∞ is the regular expression specifying the infinite string
>>>>> representation of the greatest natural number.
>>>>>
>>>>>>> All of the other HP proofs that I have ever seen gloss over the
>>>>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
>>>>>>> leaving out key details in their high level abstractions.
>>>>>>
>>>>>> No machine meeting the specification of H^x exists any more than H^.
>>>>>> The empty class of machines is not interesting.
>>>>>>
>>>>>
>>>>> It is only empty if pathological self reference is not decidable, otherwise
>>>>> it is a set of finite strings of the language of Turing Machine Descriptions
>>>>> that have the semantic property of pathological self reference.
>>>>>
>>>>>> You have failed to take the last, trivial step in the proof, despite
>>>>>> consistently stating in symbols that H^ always transitions from state qx
>>>>>> to state qy or qn.
>>>>>
>>>>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
>>>>> is rejected as having the semantic property of pathological self reference,
>>>>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
>>>>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
>>>>> the PSR error, so H transitions to its own ((qn)) state indicating that it
>>>>> has detected the PSR error.
>>>>>
>>>>> Because you are in psychological denial you cannot admit the obvious fact
>>>>> that every halt decider must always examine the exact state transition
>>>>> sequence of its input TMD until this decider determines:
>>>>> (1) That the TMD would not halt.
>>>>> (2) The the TMD would transition to a specific final state.
>>>>>
>>>>> -- Definition of Turing Machine Ĥx (infinite loop removed)
>>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
>>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
>>>>>
>>>>> Ĥx [Ĥx] would:
>>>>> (1) begin at its own state q0
>>>>> (2) Copy its input [Ĥx] to [Ĥx2]
>>>>> (3) Transition to its own state qx
>>>>> (4) Begin evaluating [Ĥx] to [Ĥx2]
>>>>>
>>>>> Which necessarily requires Ĥx to trace the exact state
>>>>> transition sequence of [Ĥx] until it determines that
>>>>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
>>>>>
>>>>> Each TMD in this evaluation sequence would only halt because
>>>>> it rejects erroneous input, thus the first TM in this sequence
>>>>> H would reject the whole sequence as erroneous.
>>>>>
>>>>
>>>>
>>>>
>>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
>>>>
>>>> its the SAME CODE!!!!
>>>>
>>>
>>> I switched to Ĥx so that it is clear that even removing the
>>> infinite loop at state qy an infinite evaluation sequence is
>>> still specified. It took me a dozen years and thousands of
>>> hours to realize this.
>>>
>>> Definition of Turing Machine Ĥx (infinite loop removed)
>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
>>>
>>> Even this single aspect of my analysis is unique in the world.
>>> No one has ever before even suggested that the evaluation
>>> sequence of the HP proof counter-example continues to be
>>> infinitely recursive even without the appended infinite loop.
>>>
>>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
>>>
>>> and so would H^2, and H^3, and H^n
>>> Yet if H actually evaluated the infinitely recursive sequence
>>> that it is presented with then H itself would never halt.
>>>
>>> Every halt decider must decide only on the basis of what
>>> its TMD would actually do, on and on to infinite recursion
>>> unless it rejects the entire evaluation sequence as erroneous.
>>
>>
>> OK
>>
>> H^ (H^)  ............... or H^(w)
>>
>>
>> -->
>>
>> H' (H^ H^)
>>
>
> These things are too subtle for the greastest minds in the world
> to notice since 1931. If you don't pay enormously more attention
> there is no chance at all that you will ever understand what I
> saying.
>
> You still are not paying close enough attention to see that
> I quit talking about Ĥ quite a while ago. I did this so that
> people would bother to try to understand why Ĥx still specifies
> an infinitely recursive evaluation sequence even without any
> infinite loop.
>
> An infinitely recursive evaluation sequence is an entirely different
> thing than merely getting stuck in an infinite loop.

There is no intrinsic difference between recursion and iteration. Every 
recursive program can be converted into iterative program and vice 
versa. Conceptually recursion means executing the same code over and 
over again. It does not matter if you get there by "jump" or "jump to 
subroutine".

> The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
> from even being evaluated for halting. The whole halt/not halt
> evaluation is short-circuited by BAD INPUT REJECT !!!

Not sure how you are planning to distinguish legitimate recursion from 
illegitimate recursion. BTW, it does not refute the theorem, which says 
you cannot dichotomize the space.

It seems you are going to issue a third value "this was about to go to 
infinite recursion but I cut it short". The "counter-example" will 
immediately halt, and the decider failed to recognize it.

> Definition of Turing Machine Ĥx (infinite loop removed)
> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
>

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


#172132

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-07 20:58 -0800
Message-ID<de968b5f-0985-4de8-b555-7a200a4cc721@googlegroups.com>
In reply to#172126
On Wednesday, February 7, 2018 at 10:14:41 PM UTC-6, Newberry wrote:
> peteolcott wrote:
> > On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
> >> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> >>> On 2/7/2018 4:58 PM, wrote:
> >>>> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> >>>>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> >>>>>> Pete Olcott writes:
> >>>>>>
> >>>>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> >>>>>>>> Pete Olcott writes:
> >>>>>>>>
> >>>>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> >>>>>>>> <snip>
> >>>>>>>>>> Maybe you think H^ exists?
> >>>>>>>>>
> >>>>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> >>>>>>>>> would reject.
> >>>>>>>>
> >>>>>>>> H^ is not a machine.  It is a class of machines with a particular
> >>>>>>>> specification so in some sense I was wrong because that /class/ exists,
> >>>>>>>> it's just empty.
> >>>>>>>>
> >>>>>>>> I should have asked whether you think there are any machines that meet
> >>>>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> >>>>>>>>
> >>>>>>>> <snip>
> >>>>>>>>
> >>>>>>>
> >>>>>>> Definition of Turing Machine Ĥx (infinite loop removed)
> >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> >>>>>>>
> >>>>>>> Perhaps you have not noticed, I have quit talking about the class of
> >>>>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> >>>>>>> [Ĥx][Ĥx] evaluation sequence.
> >>>>>>
> >>>>>> Of course I noticed when you did that -- I *corrected* you when you
> >>>>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> >>>>>
> >>>>> Right you caught my typo.
> >>>>>
> >>>>>> And I also told why you got the result of the computation wrong (I am
> >>>>>> not going to start using POlanguage).
> >>>>>>
> >>>>>
> >>>>> You are too vague here to be understandable.
> >>>>>
> >>>>> It does seem that you are still in psychological denial that a halt
> >>>>> decider must necessarily keep track of the exact state transition
> >>>>> sequence of its TMD up to a certain point.
> >>>>>
> >>>>> You keep ignoring this so I cannot tell if you understand this key
> >>>>> requirement or not. Are you ignoring it to avoid admitting that
> >>>>> you made a mistake?
> >>>>>
> >>>>>> But I was replying to what you said about H^ with a question about H^.
> >>>>>> I suppose this means you are not going to answer that question.  That is
> >>>>>> the usual way these discussions go.
> >>>>>
> >>>>> The discussion is simplified eliminating extraneous details if we
> >>>>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> >>>>> waste time. I want the loop of this discussion to end with resolution
> >>>>> instead of getting mired in extraneous details that have become moot.
> >>>>>
> >>>>>>
> >>>>>>> The class of gibberish strings is of course not empty. The class of
> >>>>>>> gibberish strings representing TMDs that would halt on their input is
> >>>>>>> necessarily empty.
> >>>>>>
> >>>>>> That's not an answer.  I asked if the class of machines denoted by H^ is
> >>>>>> empty or not.  Do you know the answer?
> >>>>>
> >>>>> I already answered this I will answer it again this time without providing
> >>>>> the reasoning behind the answer.
> >>>>>
> >>>>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> >>>>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> >>>>> subtle, thus fooling the unwary.
> >>>>>
> >>>>>>
> >>>>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> >>>>>>> fooled me for a dozen years and thousands of hours. I first referred
> >>>>>>> to Linz (in comp.theory) back in 2006.
> >>>>>>
> >>>>>> No string of the form [H^x] exists.
> >>>>>>
> >>>>>
> >>>>> You are basing this false assumption on the notion that H does not exist.
> >>>>>
> >>>>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> >>>>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> >>>>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> >>>>>> the string of binary digits of x, then there is no string [max(N)], not
> >>>>>> because I can't specify what it should be, but because there is no such
> >>>>>> thing.)
> >>>>>>
> >>>>>
> >>>>> You do not realize that you are hiding an unstated assumption in
> >>>>> your statements.
> >>>>>
> >>>>> [9][9]∞ is the regular expression specifying the infinite string
> >>>>> representation of the greatest natural number.
> >>>>>
> >>>>>>> All of the other HP proofs that I have ever seen gloss over the
> >>>>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> >>>>>>> leaving out key details in their high level abstractions.
> >>>>>>
> >>>>>> No machine meeting the specification of H^x exists any more than H^.
> >>>>>> The empty class of machines is not interesting.
> >>>>>>
> >>>>>
> >>>>> It is only empty if pathological self reference is not decidable, otherwise
> >>>>> it is a set of finite strings of the language of Turing Machine Descriptions
> >>>>> that have the semantic property of pathological self reference.
> >>>>>
> >>>>>> You have failed to take the last, trivial step in the proof, despite
> >>>>>> consistently stating in symbols that H^ always transitions from state qx
> >>>>>> to state qy or qn.
> >>>>>
> >>>>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> >>>>> is rejected as having the semantic property of pathological self reference,
> >>>>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> >>>>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> >>>>> the PSR error, so H transitions to its own ((qn)) state indicating that it
> >>>>> has detected the PSR error.
> >>>>>
> >>>>> Because you are in psychological denial you cannot admit the obvious fact
> >>>>> that every halt decider must always examine the exact state transition
> >>>>> sequence of its input TMD until this decider determines:
> >>>>> (1) That the TMD would not halt.
> >>>>> (2) The the TMD would transition to a specific final state.
> >>>>>
> >>>>> -- Definition of Turing Machine Ĥx (infinite loop removed)
> >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> >>>>>
> >>>>> Ĥx [Ĥx] would:
> >>>>> (1) begin at its own state q0
> >>>>> (2) Copy its input [Ĥx] to [Ĥx2]
> >>>>> (3) Transition to its own state qx
> >>>>> (4) Begin evaluating [Ĥx] to [Ĥx2]
> >>>>>
> >>>>> Which necessarily requires Ĥx to trace the exact state
> >>>>> transition sequence of [Ĥx] until it determines that
> >>>>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> >>>>>
> >>>>> Each TMD in this evaluation sequence would only halt because
> >>>>> it rejects erroneous input, thus the first TM in this sequence
> >>>>> H would reject the whole sequence as erroneous.
> >>>>>
> >>>>
> >>>>
> >>>>
> >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> >>>>
> >>>> its the SAME CODE!!!!
> >>>>
> >>>
> >>> I switched to Ĥx so that it is clear that even removing the
> >>> infinite loop at state qy an infinite evaluation sequence is
> >>> still specified. It took me a dozen years and thousands of
> >>> hours to realize this.
> >>>
> >>> Definition of Turing Machine Ĥx (infinite loop removed)
> >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> >>>
> >>> Even this single aspect of my analysis is unique in the world.
> >>> No one has ever before even suggested that the evaluation
> >>> sequence of the HP proof counter-example continues to be
> >>> infinitely recursive even without the appended infinite loop.
> >>>
> >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> >>>
> >>> and so would H^2, and H^3, and H^n
> >>> Yet if H actually evaluated the infinitely recursive sequence
> >>> that it is presented with then H itself would never halt.
> >>>
> >>> Every halt decider must decide only on the basis of what
> >>> its TMD would actually do, on and on to infinite recursion
> >>> unless it rejects the entire evaluation sequence as erroneous.
> >>
> >>
> >> OK
> >>
> >> H^ (H^)  ............... or H^(w)
> >>
> >>
> >> -->
> >>
> >> H' (H^ H^)
> >>
> >
> > These things are too subtle for the greastest minds in the world
> > to notice since 1931. If you don't pay enormously more attention
> > there is no chance at all that you will ever understand what I
> > saying.
> >
> > You still are not paying close enough attention to see that
> > I quit talking about Ĥ quite a while ago. I did this so that
> > people would bother to try to understand why Ĥx still specifies
> > an infinitely recursive evaluation sequence even without any
> > infinite loop.
> >
> > An infinitely recursive evaluation sequence is an entirely different
> > thing than merely getting stuck in an infinite loop.
> 
> There is no intrinsic difference between recursion and iteration. Every 
> recursive program can be converted into iterative program and vice 
> versa. Conceptually recursion means executing the same code over and 
> over again. It does not matter if you get there by "jump" or "jump to 
> subroutine".
> 
> > The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
> > from even being evaluated for halting. The whole halt/not halt
> > evaluation is short-circuited by BAD INPUT REJECT !!!
> 
> Not sure how you are planning to distinguish legitimate recursion from 
> illegitimate recursion. BTW, it does not refute the theorem, which says 
> you cannot dichotomize the space.
> 
> It seems you are going to issue a third value "this was about to go to 
> infinite recursion but I cut it short". The "counter-example" will 
> immediately halt, and the decider failed to recognize it.
> 
> > Definition of Turing Machine Ĥx (infinite loop removed)
> > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> >

No the detector rejects BAD INPUT as it rejects English poems. 

An infinitely recursive evaluation sequence must be rejected
before any halt decision even begins to be evaluated in the 
exact same way that the Liar Paradox must be rejected without 
ever evaluating whether or not its assertion is true. 

The Liar Paradox is a syntactically correct sentence. 
Ĥx is a syntactically correct TMD. 

Both are semantically incorrect because their pathological self-reference
prevents them from even being evaluated. 

This is a very subtle distinction that has taken me at least 6,000
hours since 2004. You may actually be bright enough to understand
what I am saying. 

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


#172133

Fromgrahamcooper7@gmail.com
Date2018-02-07 21:08 -0800
Message-ID<ba764883-b226-4792-8dbd-a58f9c8f1810@googlegroups.com>
In reply to#172132
On Thursday, February 8, 2018 at 2:58:40 PM UTC+10, peteolcott wrote:
> On Wednesday, February 7, 2018 at 10:14:41 PM UTC-6, Newberry wrote:
> > peteolcott wrote:
> > > On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
> > >> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> > >>> On 2/7/2018 4:58 PM, wrote:
> > >>>> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> > >>>>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> > >>>>>> Pete Olcott writes:
> > >>>>>>
> > >>>>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> > >>>>>>>> Pete Olcott writes:
> > >>>>>>>>
> > >>>>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> > >>>>>>>> <snip>
> > >>>>>>>>>> Maybe you think H^ exists?
> > >>>>>>>>>
> > >>>>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> > >>>>>>>>> would reject.
> > >>>>>>>>
> > >>>>>>>> H^ is not a machine.  It is a class of machines with a particular
> > >>>>>>>> specification so in some sense I was wrong because that /class/ exists,
> > >>>>>>>> it's just empty.
> > >>>>>>>>
> > >>>>>>>> I should have asked whether you think there are any machines that meet
> > >>>>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> > >>>>>>>>
> > >>>>>>>> <snip>
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>> Definition of Turing Machine Ĥx (infinite loop removed)
> > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > >>>>>>>
> > >>>>>>> Perhaps you have not noticed, I have quit talking about the class of
> > >>>>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> > >>>>>>> [Ĥx][Ĥx] evaluation sequence.
> > >>>>>>
> > >>>>>> Of course I noticed when you did that -- I *corrected* you when you
> > >>>>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> > >>>>>
> > >>>>> Right you caught my typo.
> > >>>>>
> > >>>>>> And I also told why you got the result of the computation wrong (I am
> > >>>>>> not going to start using POlanguage).
> > >>>>>>
> > >>>>>
> > >>>>> You are too vague here to be understandable.
> > >>>>>
> > >>>>> It does seem that you are still in psychological denial that a halt
> > >>>>> decider must necessarily keep track of the exact state transition
> > >>>>> sequence of its TMD up to a certain point.
> > >>>>>
> > >>>>> You keep ignoring this so I cannot tell if you understand this key
> > >>>>> requirement or not. Are you ignoring it to avoid admitting that
> > >>>>> you made a mistake?
> > >>>>>
> > >>>>>> But I was replying to what you said about H^ with a question about H^.
> > >>>>>> I suppose this means you are not going to answer that question.  That is
> > >>>>>> the usual way these discussions go.
> > >>>>>
> > >>>>> The discussion is simplified eliminating extraneous details if we
> > >>>>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> > >>>>> waste time. I want the loop of this discussion to end with resolution
> > >>>>> instead of getting mired in extraneous details that have become moot.
> > >>>>>
> > >>>>>>
> > >>>>>>> The class of gibberish strings is of course not empty. The class of
> > >>>>>>> gibberish strings representing TMDs that would halt on their input is
> > >>>>>>> necessarily empty.
> > >>>>>>
> > >>>>>> That's not an answer.  I asked if the class of machines denoted by H^ is
> > >>>>>> empty or not.  Do you know the answer?
> > >>>>>
> > >>>>> I already answered this I will answer it again this time without providing
> > >>>>> the reasoning behind the answer.
> > >>>>>
> > >>>>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> > >>>>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> > >>>>> subtle, thus fooling the unwary.
> > >>>>>
> > >>>>>>
> > >>>>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> > >>>>>>> fooled me for a dozen years and thousands of hours. I first referred
> > >>>>>>> to Linz (in comp.theory) back in 2006.
> > >>>>>>
> > >>>>>> No string of the form [H^x] exists.
> > >>>>>>
> > >>>>>
> > >>>>> You are basing this false assumption on the notion that H does not exist.
> > >>>>>
> > >>>>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> > >>>>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> > >>>>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> > >>>>>> the string of binary digits of x, then there is no string [max(N)], not
> > >>>>>> because I can't specify what it should be, but because there is no such
> > >>>>>> thing.)
> > >>>>>>
> > >>>>>
> > >>>>> You do not realize that you are hiding an unstated assumption in
> > >>>>> your statements.
> > >>>>>
> > >>>>> [9][9]∞ is the regular expression specifying the infinite string
> > >>>>> representation of the greatest natural number.
> > >>>>>
> > >>>>>>> All of the other HP proofs that I have ever seen gloss over the
> > >>>>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> > >>>>>>> leaving out key details in their high level abstractions.
> > >>>>>>
> > >>>>>> No machine meeting the specification of H^x exists any more than H^.
> > >>>>>> The empty class of machines is not interesting.
> > >>>>>>
> > >>>>>
> > >>>>> It is only empty if pathological self reference is not decidable, otherwise
> > >>>>> it is a set of finite strings of the language of Turing Machine Descriptions
> > >>>>> that have the semantic property of pathological self reference.
> > >>>>>
> > >>>>>> You have failed to take the last, trivial step in the proof, despite
> > >>>>>> consistently stating in symbols that H^ always transitions from state qx
> > >>>>>> to state qy or qn.
> > >>>>>
> > >>>>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> > >>>>> is rejected as having the semantic property of pathological self reference,
> > >>>>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> > >>>>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> > >>>>> the PSR error, so H transitions to its own ((qn)) state indicating that it
> > >>>>> has detected the PSR error.
> > >>>>>
> > >>>>> Because you are in psychological denial you cannot admit the obvious fact
> > >>>>> that every halt decider must always examine the exact state transition
> > >>>>> sequence of its input TMD until this decider determines:
> > >>>>> (1) That the TMD would not halt.
> > >>>>> (2) The the TMD would transition to a specific final state.
> > >>>>>
> > >>>>> -- Definition of Turing Machine Ĥx (infinite loop removed)
> > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > >>>>>
> > >>>>> Ĥx [Ĥx] would:
> > >>>>> (1) begin at its own state q0
> > >>>>> (2) Copy its input [Ĥx] to [Ĥx2]
> > >>>>> (3) Transition to its own state qx
> > >>>>> (4) Begin evaluating [Ĥx] to [Ĥx2]
> > >>>>>
> > >>>>> Which necessarily requires Ĥx to trace the exact state
> > >>>>> transition sequence of [Ĥx] until it determines that
> > >>>>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> > >>>>>
> > >>>>> Each TMD in this evaluation sequence would only halt because
> > >>>>> it rejects erroneous input, thus the first TM in this sequence
> > >>>>> H would reject the whole sequence as erroneous.
> > >>>>>
> > >>>>
> > >>>>
> > >>>>
> > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > >>>>
> > >>>> its the SAME CODE!!!!
> > >>>>
> > >>>
> > >>> I switched to Ĥx so that it is clear that even removing the
> > >>> infinite loop at state qy an infinite evaluation sequence is
> > >>> still specified. It took me a dozen years and thousands of
> > >>> hours to realize this.
> > >>>
> > >>> Definition of Turing Machine Ĥx (infinite loop removed)
> > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > >>>
> > >>> Even this single aspect of my analysis is unique in the world.
> > >>> No one has ever before even suggested that the evaluation
> > >>> sequence of the HP proof counter-example continues to be
> > >>> infinitely recursive even without the appended infinite loop.
> > >>>
> > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > >>>
> > >>> and so would H^2, and H^3, and H^n
> > >>> Yet if H actually evaluated the infinitely recursive sequence
> > >>> that it is presented with then H itself would never halt.
> > >>>
> > >>> Every halt decider must decide only on the basis of what
> > >>> its TMD would actually do, on and on to infinite recursion
> > >>> unless it rejects the entire evaluation sequence as erroneous.
> > >>
> > >>
> > >> OK
> > >>
> > >> H^ (H^)  ............... or H^(w)
> > >>
> > >>
> > >> -->
> > >>
> > >> H' (H^ H^)
> > >>
> > >
> > > These things are too subtle for the greastest minds in the world
> > > to notice since 1931. If you don't pay enormously more attention
> > > there is no chance at all that you will ever understand what I
> > > saying.
> > >
> > > You still are not paying close enough attention to see that
> > > I quit talking about Ĥ quite a while ago. I did this so that
> > > people would bother to try to understand why Ĥx still specifies
> > > an infinitely recursive evaluation sequence even without any
> > > infinite loop.
> > >
> > > An infinitely recursive evaluation sequence is an entirely different
> > > thing than merely getting stuck in an infinite loop.
> > 
> > There is no intrinsic difference between recursion and iteration. Every 
> > recursive program can be converted into iterative program and vice 
> > versa. Conceptually recursion means executing the same code over and 
> > over again. It does not matter if you get there by "jump" or "jump to 
> > subroutine".
> > 
> > > The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
> > > from even being evaluated for halting. The whole halt/not halt
> > > evaluation is short-circuited by BAD INPUT REJECT !!!
> > 
> > Not sure how you are planning to distinguish legitimate recursion from 
> > illegitimate recursion. BTW, it does not refute the theorem, which says 
> > you cannot dichotomize the space.
> > 
> > It seems you are going to issue a third value "this was about to go to 
> > infinite recursion but I cut it short". The "counter-example" will 
> > immediately halt, and the decider failed to recognize it.
> > 
> > > Definition of Turing Machine Ĥx (infinite loop removed)
> > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > >
> 
> No the detector rejects BAD INPUT as it rejects English poems. 
> 
> An infinitely recursive evaluation sequence must be rejected
> before any halt decision even begins to be evaluated in the 
> exact same way that the Liar Paradox must be rejected without 
> ever evaluating whether or not its assertion is true. 
> 
> The Liar Paradox is a syntactically correct sentence. 
> Ĥx is a syntactically correct TMD. 
> 
> Both are semantically incorrect because their pathological self-reference
> prevents them from even being evaluated. 
> 
> This is a very subtle distinction that has taken me at least 6,000
> hours since 2004. You may actually be bright enough to understand
> what I am saying.


a DECIDER that rejects bad input

and

a DECIDER that outputs YES or NO whether the input halts or not


are 2 different things




"THE HALTING PROBLEM" is about the latter.

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


#172136

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-07 21:45 -0800
Message-ID<a1e71ab1-735a-4448-a603-f731ffa62a3c@googlegroups.com>
In reply to#172133
On Wednesday, February 7, 2018 at 11:08:32 PM UTC-6, graham...@gmail.com wrote:
> On Thursday, February 8, 2018 at 2:58:40 PM UTC+10, peteolcott wrote:
> > On Wednesday, February 7, 2018 at 10:14:41 PM UTC-6, Newberry wrote:
> > > peteolcott wrote:
> > > > On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
> > > >> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> > > >>> On 2/7/2018 4:58 PM, wrote:
> > > >>>> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> > > >>>>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> > > >>>>>> Pete Olcott writes:
> > > >>>>>>
> > > >>>>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> > > >>>>>>>> Pete Olcott writes:
> > > >>>>>>>>
> > > >>>>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> > > >>>>>>>> <snip>
> > > >>>>>>>>>> Maybe you think H^ exists?
> > > >>>>>>>>>
> > > >>>>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> > > >>>>>>>>> would reject.
> > > >>>>>>>>
> > > >>>>>>>> H^ is not a machine.  It is a class of machines with a particular
> > > >>>>>>>> specification so in some sense I was wrong because that /class/ exists,
> > > >>>>>>>> it's just empty.
> > > >>>>>>>>
> > > >>>>>>>> I should have asked whether you think there are any machines that meet
> > > >>>>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> > > >>>>>>>>
> > > >>>>>>>> <snip>
> > > >>>>>>>>
> > > >>>>>>>
> > > >>>>>>> Definition of Turing Machine Ĥx (infinite loop removed)
> > > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > >>>>>>>
> > > >>>>>>> Perhaps you have not noticed, I have quit talking about the class of
> > > >>>>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> > > >>>>>>> [Ĥx][Ĥx] evaluation sequence.
> > > >>>>>>
> > > >>>>>> Of course I noticed when you did that -- I *corrected* you when you
> > > >>>>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> > > >>>>>
> > > >>>>> Right you caught my typo.
> > > >>>>>
> > > >>>>>> And I also told why you got the result of the computation wrong (I am
> > > >>>>>> not going to start using POlanguage).
> > > >>>>>>
> > > >>>>>
> > > >>>>> You are too vague here to be understandable.
> > > >>>>>
> > > >>>>> It does seem that you are still in psychological denial that a halt
> > > >>>>> decider must necessarily keep track of the exact state transition
> > > >>>>> sequence of its TMD up to a certain point.
> > > >>>>>
> > > >>>>> You keep ignoring this so I cannot tell if you understand this key
> > > >>>>> requirement or not. Are you ignoring it to avoid admitting that
> > > >>>>> you made a mistake?
> > > >>>>>
> > > >>>>>> But I was replying to what you said about H^ with a question about H^.
> > > >>>>>> I suppose this means you are not going to answer that question.  That is
> > > >>>>>> the usual way these discussions go.
> > > >>>>>
> > > >>>>> The discussion is simplified eliminating extraneous details if we
> > > >>>>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> > > >>>>> waste time. I want the loop of this discussion to end with resolution
> > > >>>>> instead of getting mired in extraneous details that have become moot.
> > > >>>>>
> > > >>>>>>
> > > >>>>>>> The class of gibberish strings is of course not empty. The class of
> > > >>>>>>> gibberish strings representing TMDs that would halt on their input is
> > > >>>>>>> necessarily empty.
> > > >>>>>>
> > > >>>>>> That's not an answer.  I asked if the class of machines denoted by H^ is
> > > >>>>>> empty or not.  Do you know the answer?
> > > >>>>>
> > > >>>>> I already answered this I will answer it again this time without providing
> > > >>>>> the reasoning behind the answer.
> > > >>>>>
> > > >>>>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> > > >>>>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> > > >>>>> subtle, thus fooling the unwary.
> > > >>>>>
> > > >>>>>>
> > > >>>>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> > > >>>>>>> fooled me for a dozen years and thousands of hours. I first referred
> > > >>>>>>> to Linz (in comp.theory) back in 2006.
> > > >>>>>>
> > > >>>>>> No string of the form [H^x] exists.
> > > >>>>>>
> > > >>>>>
> > > >>>>> You are basing this false assumption on the notion that H does not exist.
> > > >>>>>
> > > >>>>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> > > >>>>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> > > >>>>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> > > >>>>>> the string of binary digits of x, then there is no string [max(N)], not
> > > >>>>>> because I can't specify what it should be, but because there is no such
> > > >>>>>> thing.)
> > > >>>>>>
> > > >>>>>
> > > >>>>> You do not realize that you are hiding an unstated assumption in
> > > >>>>> your statements.
> > > >>>>>
> > > >>>>> [9][9]∞ is the regular expression specifying the infinite string
> > > >>>>> representation of the greatest natural number.
> > > >>>>>
> > > >>>>>>> All of the other HP proofs that I have ever seen gloss over the
> > > >>>>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> > > >>>>>>> leaving out key details in their high level abstractions.
> > > >>>>>>
> > > >>>>>> No machine meeting the specification of H^x exists any more than H^.
> > > >>>>>> The empty class of machines is not interesting.
> > > >>>>>>
> > > >>>>>
> > > >>>>> It is only empty if pathological self reference is not decidable, otherwise
> > > >>>>> it is a set of finite strings of the language of Turing Machine Descriptions
> > > >>>>> that have the semantic property of pathological self reference.
> > > >>>>>
> > > >>>>>> You have failed to take the last, trivial step in the proof, despite
> > > >>>>>> consistently stating in symbols that H^ always transitions from state qx
> > > >>>>>> to state qy or qn.
> > > >>>>>
> > > >>>>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> > > >>>>> is rejected as having the semantic property of pathological self reference,
> > > >>>>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> > > >>>>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> > > >>>>> the PSR error, so H transitions to its own ((qn)) state indicating that it
> > > >>>>> has detected the PSR error.
> > > >>>>>
> > > >>>>> Because you are in psychological denial you cannot admit the obvious fact
> > > >>>>> that every halt decider must always examine the exact state transition
> > > >>>>> sequence of its input TMD until this decider determines:
> > > >>>>> (1) That the TMD would not halt.
> > > >>>>> (2) The the TMD would transition to a specific final state.
> > > >>>>>
> > > >>>>> -- Definition of Turing Machine Ĥx (infinite loop removed)
> > > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > >>>>>
> > > >>>>> Ĥx [Ĥx] would:
> > > >>>>> (1) begin at its own state q0
> > > >>>>> (2) Copy its input [Ĥx] to [Ĥx2]
> > > >>>>> (3) Transition to its own state qx
> > > >>>>> (4) Begin evaluating [Ĥx] to [Ĥx2]
> > > >>>>>
> > > >>>>> Which necessarily requires Ĥx to trace the exact state
> > > >>>>> transition sequence of [Ĥx] until it determines that
> > > >>>>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> > > >>>>>
> > > >>>>> Each TMD in this evaluation sequence would only halt because
> > > >>>>> it rejects erroneous input, thus the first TM in this sequence
> > > >>>>> H would reject the whole sequence as erroneous.
> > > >>>>>
> > > >>>>
> > > >>>>
> > > >>>>
> > > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > >>>>
> > > >>>> its the SAME CODE!!!!
> > > >>>>
> > > >>>
> > > >>> I switched to Ĥx so that it is clear that even removing the
> > > >>> infinite loop at state qy an infinite evaluation sequence is
> > > >>> still specified. It took me a dozen years and thousands of
> > > >>> hours to realize this.
> > > >>>
> > > >>> Definition of Turing Machine Ĥx (infinite loop removed)
> > > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > >>>
> > > >>> Even this single aspect of my analysis is unique in the world.
> > > >>> No one has ever before even suggested that the evaluation
> > > >>> sequence of the HP proof counter-example continues to be
> > > >>> infinitely recursive even without the appended infinite loop.
> > > >>>
> > > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > >>>
> > > >>> and so would H^2, and H^3, and H^n
> > > >>> Yet if H actually evaluated the infinitely recursive sequence
> > > >>> that it is presented with then H itself would never halt.
> > > >>>
> > > >>> Every halt decider must decide only on the basis of what
> > > >>> its TMD would actually do, on and on to infinite recursion
> > > >>> unless it rejects the entire evaluation sequence as erroneous.
> > > >>
> > > >>
> > > >> OK
> > > >>
> > > >> H^ (H^)  ............... or H^(w)
> > > >>
> > > >>
> > > >> -->
> > > >>
> > > >> H' (H^ H^)
> > > >>
> > > >
> > > > These things are too subtle for the greastest minds in the world
> > > > to notice since 1931. If you don't pay enormously more attention
> > > > there is no chance at all that you will ever understand what I
> > > > saying.
> > > >
> > > > You still are not paying close enough attention to see that
> > > > I quit talking about Ĥ quite a while ago. I did this so that
> > > > people would bother to try to understand why Ĥx still specifies
> > > > an infinitely recursive evaluation sequence even without any
> > > > infinite loop.
> > > >
> > > > An infinitely recursive evaluation sequence is an entirely different
> > > > thing than merely getting stuck in an infinite loop.
> > > 
> > > There is no intrinsic difference between recursion and iteration. Every 
> > > recursive program can be converted into iterative program and vice 
> > > versa. Conceptually recursion means executing the same code over and 
> > > over again. It does not matter if you get there by "jump" or "jump to 
> > > subroutine".
> > > 
> > > > The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
> > > > from even being evaluated for halting. The whole halt/not halt
> > > > evaluation is short-circuited by BAD INPUT REJECT !!!
> > > 
> > > Not sure how you are planning to distinguish legitimate recursion from 
> > > illegitimate recursion. BTW, it does not refute the theorem, which says 
> > > you cannot dichotomize the space.
> > > 
> > > It seems you are going to issue a third value "this was about to go to 
> > > infinite recursion but I cut it short". The "counter-example" will 
> > > immediately halt, and the decider failed to recognize it.
> > > 
> > > > Definition of Turing Machine Ĥx (infinite loop removed)
> > > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > >
> > 
> > No the detector rejects BAD INPUT as it rejects English poems. 
> > 
> > An infinitely recursive evaluation sequence must be rejected
> > before any halt decision even begins to be evaluated in the 
> > exact same way that the Liar Paradox must be rejected without 
> > ever evaluating whether or not its assertion is true. 
> > 
> > The Liar Paradox is a syntactically correct sentence. 
> > Ĥx is a syntactically correct TMD. 
> > 
> > Both are semantically incorrect because their pathological self-reference
> > prevents them from even being evaluated. 
> > 
> > This is a very subtle distinction that has taken me at least 6,000
> > hours since 2004. You may actually be bright enough to understand
> > what I am saying.
> 
> 
> a DECIDER that rejects bad input
> 
> and
> 
> a DECIDER that outputs YES or NO whether the input halts or not
> 
> 
> are 2 different things
> 
> 
> 
> 
> "THE HALTING PROBLEM" is about the latter.

Nope. 

The question is this:
Is the input a correct TMD that halts on its input? 
The no answer to this question includes all kinds of things.

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


#172137

Fromgrahamcooper7@gmail.com
Date2018-02-07 22:48 -0800
Message-ID<91e84f0a-b26e-478b-a2fd-7c67ce91e887@googlegroups.com>
In reply to#172136
On Thursday, February 8, 2018 at 3:45:40 PM UTC+10, peteolcott wrote:
> On Wednesday, February 7, 2018 at 11:08:32 PM UTC-6, graham...@gmail.com wrote:
> > On Thursday, February 8, 2018 at 2:58:40 PM UTC+10, peteolcott wrote:
> > > On Wednesday, February 7, 2018 at 10:14:41 PM UTC-6, Newberry wrote:
> > > > peteolcott wrote:
> > > > > On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
> > > > >> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> > > > >>> On 2/7/2018 4:58 PM, wrote:
> > > > >>>> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> > > > >>>>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> > > > >>>>>> Pete Olcott writes:
> > > > >>>>>>
> > > > >>>>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> > > > >>>>>>>> Pete Olcott writes:
> > > > >>>>>>>>
> > > > >>>>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> > > > >>>>>>>> <snip>
> > > > >>>>>>>>>> Maybe you think H^ exists?
> > > > >>>>>>>>>
> > > > >>>>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> > > > >>>>>>>>> would reject.
> > > > >>>>>>>>
> > > > >>>>>>>> H^ is not a machine.  It is a class of machines with a particular
> > > > >>>>>>>> specification so in some sense I was wrong because that /class/ exists,
> > > > >>>>>>>> it's just empty.
> > > > >>>>>>>>
> > > > >>>>>>>> I should have asked whether you think there are any machines that meet
> > > > >>>>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> > > > >>>>>>>>
> > > > >>>>>>>> <snip>
> > > > >>>>>>>>
> > > > >>>>>>>
> > > > >>>>>>> Definition of Turing Machine Ĥx (infinite loop removed)
> > > > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > >>>>>>>
> > > > >>>>>>> Perhaps you have not noticed, I have quit talking about the class of
> > > > >>>>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> > > > >>>>>>> [Ĥx][Ĥx] evaluation sequence.
> > > > >>>>>>
> > > > >>>>>> Of course I noticed when you did that -- I *corrected* you when you
> > > > >>>>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> > > > >>>>>
> > > > >>>>> Right you caught my typo.
> > > > >>>>>
> > > > >>>>>> And I also told why you got the result of the computation wrong (I am
> > > > >>>>>> not going to start using POlanguage).
> > > > >>>>>>
> > > > >>>>>
> > > > >>>>> You are too vague here to be understandable.
> > > > >>>>>
> > > > >>>>> It does seem that you are still in psychological denial that a halt
> > > > >>>>> decider must necessarily keep track of the exact state transition
> > > > >>>>> sequence of its TMD up to a certain point.
> > > > >>>>>
> > > > >>>>> You keep ignoring this so I cannot tell if you understand this key
> > > > >>>>> requirement or not. Are you ignoring it to avoid admitting that
> > > > >>>>> you made a mistake?
> > > > >>>>>
> > > > >>>>>> But I was replying to what you said about H^ with a question about H^.
> > > > >>>>>> I suppose this means you are not going to answer that question.  That is
> > > > >>>>>> the usual way these discussions go.
> > > > >>>>>
> > > > >>>>> The discussion is simplified eliminating extraneous details if we
> > > > >>>>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> > > > >>>>> waste time. I want the loop of this discussion to end with resolution
> > > > >>>>> instead of getting mired in extraneous details that have become moot.
> > > > >>>>>
> > > > >>>>>>
> > > > >>>>>>> The class of gibberish strings is of course not empty. The class of
> > > > >>>>>>> gibberish strings representing TMDs that would halt on their input is
> > > > >>>>>>> necessarily empty.
> > > > >>>>>>
> > > > >>>>>> That's not an answer.  I asked if the class of machines denoted by H^ is
> > > > >>>>>> empty or not.  Do you know the answer?
> > > > >>>>>
> > > > >>>>> I already answered this I will answer it again this time without providing
> > > > >>>>> the reasoning behind the answer.
> > > > >>>>>
> > > > >>>>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> > > > >>>>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> > > > >>>>> subtle, thus fooling the unwary.
> > > > >>>>>
> > > > >>>>>>
> > > > >>>>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> > > > >>>>>>> fooled me for a dozen years and thousands of hours. I first referred
> > > > >>>>>>> to Linz (in comp.theory) back in 2006.
> > > > >>>>>>
> > > > >>>>>> No string of the form [H^x] exists.
> > > > >>>>>>
> > > > >>>>>
> > > > >>>>> You are basing this false assumption on the notion that H does not exist.
> > > > >>>>>
> > > > >>>>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> > > > >>>>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> > > > >>>>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> > > > >>>>>> the string of binary digits of x, then there is no string [max(N)], not
> > > > >>>>>> because I can't specify what it should be, but because there is no such
> > > > >>>>>> thing.)
> > > > >>>>>>
> > > > >>>>>
> > > > >>>>> You do not realize that you are hiding an unstated assumption in
> > > > >>>>> your statements.
> > > > >>>>>
> > > > >>>>> [9][9]∞ is the regular expression specifying the infinite string
> > > > >>>>> representation of the greatest natural number.
> > > > >>>>>
> > > > >>>>>>> All of the other HP proofs that I have ever seen gloss over the
> > > > >>>>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> > > > >>>>>>> leaving out key details in their high level abstractions.
> > > > >>>>>>
> > > > >>>>>> No machine meeting the specification of H^x exists any more than H^.
> > > > >>>>>> The empty class of machines is not interesting.
> > > > >>>>>>
> > > > >>>>>
> > > > >>>>> It is only empty if pathological self reference is not decidable, otherwise
> > > > >>>>> it is a set of finite strings of the language of Turing Machine Descriptions
> > > > >>>>> that have the semantic property of pathological self reference.
> > > > >>>>>
> > > > >>>>>> You have failed to take the last, trivial step in the proof, despite
> > > > >>>>>> consistently stating in symbols that H^ always transitions from state qx
> > > > >>>>>> to state qy or qn.
> > > > >>>>>
> > > > >>>>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> > > > >>>>> is rejected as having the semantic property of pathological self reference,
> > > > >>>>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> > > > >>>>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> > > > >>>>> the PSR error, so H transitions to its own ((qn)) state indicating that it
> > > > >>>>> has detected the PSR error.
> > > > >>>>>
> > > > >>>>> Because you are in psychological denial you cannot admit the obvious fact
> > > > >>>>> that every halt decider must always examine the exact state transition
> > > > >>>>> sequence of its input TMD until this decider determines:
> > > > >>>>> (1) That the TMD would not halt.
> > > > >>>>> (2) The the TMD would transition to a specific final state.
> > > > >>>>>
> > > > >>>>> -- Definition of Turing Machine Ĥx (infinite loop removed)
> > > > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > >>>>>
> > > > >>>>> Ĥx [Ĥx] would:
> > > > >>>>> (1) begin at its own state q0
> > > > >>>>> (2) Copy its input [Ĥx] to [Ĥx2]
> > > > >>>>> (3) Transition to its own state qx
> > > > >>>>> (4) Begin evaluating [Ĥx] to [Ĥx2]
> > > > >>>>>
> > > > >>>>> Which necessarily requires Ĥx to trace the exact state
> > > > >>>>> transition sequence of [Ĥx] until it determines that
> > > > >>>>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> > > > >>>>>
> > > > >>>>> Each TMD in this evaluation sequence would only halt because
> > > > >>>>> it rejects erroneous input, thus the first TM in this sequence
> > > > >>>>> H would reject the whole sequence as erroneous.
> > > > >>>>>
> > > > >>>>
> > > > >>>>
> > > > >>>>
> > > > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > > >>>>
> > > > >>>> its the SAME CODE!!!!
> > > > >>>>
> > > > >>>
> > > > >>> I switched to Ĥx so that it is clear that even removing the
> > > > >>> infinite loop at state qy an infinite evaluation sequence is
> > > > >>> still specified. It took me a dozen years and thousands of
> > > > >>> hours to realize this.
> > > > >>>
> > > > >>> Definition of Turing Machine Ĥx (infinite loop removed)
> > > > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > >>>
> > > > >>> Even this single aspect of my analysis is unique in the world.
> > > > >>> No one has ever before even suggested that the evaluation
> > > > >>> sequence of the HP proof counter-example continues to be
> > > > >>> infinitely recursive even without the appended infinite loop.
> > > > >>>
> > > > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > > >>>
> > > > >>> and so would H^2, and H^3, and H^n
> > > > >>> Yet if H actually evaluated the infinitely recursive sequence
> > > > >>> that it is presented with then H itself would never halt.
> > > > >>>
> > > > >>> Every halt decider must decide only on the basis of what
> > > > >>> its TMD would actually do, on and on to infinite recursion
> > > > >>> unless it rejects the entire evaluation sequence as erroneous.
> > > > >>
> > > > >>
> > > > >> OK
> > > > >>
> > > > >> H^ (H^)  ............... or H^(w)
> > > > >>
> > > > >>
> > > > >> -->
> > > > >>
> > > > >> H' (H^ H^)
> > > > >>
> > > > >
> > > > > These things are too subtle for the greastest minds in the world
> > > > > to notice since 1931. If you don't pay enormously more attention
> > > > > there is no chance at all that you will ever understand what I
> > > > > saying.
> > > > >
> > > > > You still are not paying close enough attention to see that
> > > > > I quit talking about Ĥ quite a while ago. I did this so that
> > > > > people would bother to try to understand why Ĥx still specifies
> > > > > an infinitely recursive evaluation sequence even without any
> > > > > infinite loop.
> > > > >
> > > > > An infinitely recursive evaluation sequence is an entirely different
> > > > > thing than merely getting stuck in an infinite loop.
> > > > 
> > > > There is no intrinsic difference between recursion and iteration. Every 
> > > > recursive program can be converted into iterative program and vice 
> > > > versa. Conceptually recursion means executing the same code over and 
> > > > over again. It does not matter if you get there by "jump" or "jump to 
> > > > subroutine".
> > > > 
> > > > > The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
> > > > > from even being evaluated for halting. The whole halt/not halt
> > > > > evaluation is short-circuited by BAD INPUT REJECT !!!
> > > > 
> > > > Not sure how you are planning to distinguish legitimate recursion from 
> > > > illegitimate recursion. BTW, it does not refute the theorem, which says 
> > > > you cannot dichotomize the space.
> > > > 
> > > > It seems you are going to issue a third value "this was about to go to 
> > > > infinite recursion but I cut it short". The "counter-example" will 
> > > > immediately halt, and the decider failed to recognize it.
> > > > 
> > > > > Definition of Turing Machine Ĥx (infinite loop removed)
> > > > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > >
> > > 
> > > No the detector rejects BAD INPUT as it rejects English poems. 
> > > 
> > > An infinitely recursive evaluation sequence must be rejected
> > > before any halt decision even begins to be evaluated in the 
> > > exact same way that the Liar Paradox must be rejected without 
> > > ever evaluating whether or not its assertion is true. 
> > > 
> > > The Liar Paradox is a syntactically correct sentence. 
> > > Ĥx is a syntactically correct TMD. 
> > > 
> > > Both are semantically incorrect because their pathological self-reference
> > > prevents them from even being evaluated. 
> > > 
> > > This is a very subtle distinction that has taken me at least 6,000
> > > hours since 2004. You may actually be bright enough to understand
> > > what I am saying.
> > 
> > 
> > a DECIDER that rejects bad input
> > 
> > and
> > 
> > a DECIDER that outputs YES or NO whether the input halts or not
> > 
> > 
> > are 2 different things
> > 
> > 
> > 
> > 
> > "THE HALTING PROBLEM" is about the latter.
> 
> Nope. 
> 
> The question is this:
> Is the input a correct TMD that halts on its input? 
> The no answer to this question includes all kinds of things.



CORRECTNESS is defined as HALTING(.)

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


#172139

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-07 23:16 -0800
Message-ID<bd97ec58-6d7f-49ea-b1b4-c04f64762a3b@googlegroups.com>
In reply to#172137
On Thursday, February 8, 2018 at 12:48:33 AM UTC-6, graham...@gmail.com wrote:
> On Thursday, February 8, 2018 at 3:45:40 PM UTC+10, peteolcott wrote:
> > On Wednesday, February 7, 2018 at 11:08:32 PM UTC-6, graham...@gmail.com wrote:
> > > On Thursday, February 8, 2018 at 2:58:40 PM UTC+10, peteolcott wrote:
> > > > On Wednesday, February 7, 2018 at 10:14:41 PM UTC-6, Newberry wrote:
> > > > > peteolcott wrote:
> > > > > > On Wednesday, February 7, 2018 at 7:12:32 PM UTC-6, graham...@gmail.com wrote:
> > > > > >> On Thursday, February 8, 2018 at 9:52:21 AM UTC+10, Pete Olcott wrote:
> > > > > >>> On 2/7/2018 4:58 PM, wrote:
> > > > > >>>> On Thursday, February 8, 2018 at 6:06:10 AM UTC+10, Pete Olcott wrote:
> > > > > >>>>> On 2/7/2018 12:25 PM, Ben Bacarisse wrote:
> > > > > >>>>>> Pete Olcott writes:
> > > > > >>>>>>
> > > > > >>>>>>> On 2/7/2018 9:43 AM, Ben Bacarisse wrote:
> > > > > >>>>>>>> Pete Olcott writes:
> > > > > >>>>>>>>
> > > > > >>>>>>>>> On 2/6/2018 9:40 PM, Ben Bacarisse wrote:
> > > > > >>>>>>>> <snip>
> > > > > >>>>>>>>>> Maybe you think H^ exists?
> > > > > >>>>>>>>>
> > > > > >>>>>>>>> Sure H^ does exist as a semantically incorrect finite string that H
> > > > > >>>>>>>>> would reject.
> > > > > >>>>>>>>
> > > > > >>>>>>>> H^ is not a machine.  It is a class of machines with a particular
> > > > > >>>>>>>> specification so in some sense I was wrong because that /class/ exists,
> > > > > >>>>>>>> it's just empty.
> > > > > >>>>>>>>
> > > > > >>>>>>>> I should have asked whether you think there are any machines that meet
> > > > > >>>>>>>> the specification of H^ -- i.e. do you think the class is non-empty?
> > > > > >>>>>>>>
> > > > > >>>>>>>> <snip>
> > > > > >>>>>>>>
> > > > > >>>>>>>
> > > > > >>>>>>> Definition of Turing Machine Ĥx (infinite loop removed)
> > > > > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > > >>>>>>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > > >>>>>>>
> > > > > >>>>>>> Perhaps you have not noticed, I have quit talking about the class of
> > > > > >>>>>>> proposed TMDs specified by Ĥ. I am now only talking about the H
> > > > > >>>>>>> [Ĥx][Ĥx] evaluation sequence.
> > > > > >>>>>>
> > > > > >>>>>> Of course I noticed when you did that -- I *corrected* you when you
> > > > > >>>>>> wrote these lines (in another sub-thread) without changing H^ to H^x.
> > > > > >>>>>
> > > > > >>>>> Right you caught my typo.
> > > > > >>>>>
> > > > > >>>>>> And I also told why you got the result of the computation wrong (I am
> > > > > >>>>>> not going to start using POlanguage).
> > > > > >>>>>>
> > > > > >>>>>
> > > > > >>>>> You are too vague here to be understandable.
> > > > > >>>>>
> > > > > >>>>> It does seem that you are still in psychological denial that a halt
> > > > > >>>>> decider must necessarily keep track of the exact state transition
> > > > > >>>>> sequence of its TMD up to a certain point.
> > > > > >>>>>
> > > > > >>>>> You keep ignoring this so I cannot tell if you understand this key
> > > > > >>>>> requirement or not. Are you ignoring it to avoid admitting that
> > > > > >>>>> you made a mistake?
> > > > > >>>>>
> > > > > >>>>>> But I was replying to what you said about H^ with a question about H^.
> > > > > >>>>>> I suppose this means you are not going to answer that question.  That is
> > > > > >>>>>> the usual way these discussions go.
> > > > > >>>>>
> > > > > >>>>> The discussion is simplified eliminating extraneous details if we
> > > > > >>>>> focus on TMD Ĥx instead of TMD Ĥ. I am not willing to intentionally
> > > > > >>>>> waste time. I want the loop of this discussion to end with resolution
> > > > > >>>>> instead of getting mired in extraneous details that have become moot.
> > > > > >>>>>
> > > > > >>>>>>
> > > > > >>>>>>> The class of gibberish strings is of course not empty. The class of
> > > > > >>>>>>> gibberish strings representing TMDs that would halt on their input is
> > > > > >>>>>>> necessarily empty.
> > > > > >>>>>>
> > > > > >>>>>> That's not an answer.  I asked if the class of machines denoted by H^ is
> > > > > >>>>>> empty or not.  Do you know the answer?
> > > > > >>>>>
> > > > > >>>>> I already answered this I will answer it again this time without providing
> > > > > >>>>> the reasoning behind the answer.
> > > > > >>>>>
> > > > > >>>>> Ĥ does not specify a Turing Machine Description at all, it only fools the unwary
> > > > > >>>>> into believing that it specifies a TMD. Likewise with Ĥx, and this is even more
> > > > > >>>>> subtle, thus fooling the unwary.
> > > > > >>>>>
> > > > > >>>>>>
> > > > > >>>>>>> Determining that [Ĥx] is a gibberish string is enormously subtle and
> > > > > >>>>>>> fooled me for a dozen years and thousands of hours. I first referred
> > > > > >>>>>>> to Linz (in comp.theory) back in 2006.
> > > > > >>>>>>
> > > > > >>>>>> No string of the form [H^x] exists.
> > > > > >>>>>>
> > > > > >>>>>
> > > > > >>>>> You are basing this false assumption on the notion that H does not exist.
> > > > > >>>>>
> > > > > >>>>>> (To be clear, the string "[H^x]" exists but none of the strings denoted
> > > > > >>>>>> by [H^x] exit.  If I say "let max(N) denote the largest natural number",
> > > > > >>>>>> i.e. a number n such that ForAll k in N, n > k, and I use [x] to mean
> > > > > >>>>>> the string of binary digits of x, then there is no string [max(N)], not
> > > > > >>>>>> because I can't specify what it should be, but because there is no such
> > > > > >>>>>> thing.)
> > > > > >>>>>>
> > > > > >>>>>
> > > > > >>>>> You do not realize that you are hiding an unstated assumption in
> > > > > >>>>> your statements.
> > > > > >>>>>
> > > > > >>>>> [9][9]∞ is the regular expression specifying the infinite string
> > > > > >>>>> representation of the greatest natural number.
> > > > > >>>>>
> > > > > >>>>>>> All of the other HP proofs that I have ever seen gloss over the
> > > > > >>>>>>> pathological nature of inputs that would be equivalent to Ĥ and Ĥx, by
> > > > > >>>>>>> leaving out key details in their high level abstractions.
> > > > > >>>>>>
> > > > > >>>>>> No machine meeting the specification of H^x exists any more than H^.
> > > > > >>>>>> The empty class of machines is not interesting.
> > > > > >>>>>>
> > > > > >>>>>
> > > > > >>>>> It is only empty if pathological self reference is not decidable, otherwise
> > > > > >>>>> it is a set of finite strings of the language of Turing Machine Descriptions
> > > > > >>>>> that have the semantic property of pathological self reference.
> > > > > >>>>>
> > > > > >>>>>> You have failed to take the last, trivial step in the proof, despite
> > > > > >>>>>> consistently stating in symbols that H^ always transitions from state qx
> > > > > >>>>>> to state qy or qn.
> > > > > >>>>>
> > > > > >>>>> Ĥ [Ĥ] would transition to its final state (qn) indicating that its input
> > > > > >>>>> is rejected as having the semantic property of pathological self reference,
> > > > > >>>>> except that H [Ĥ][Ĥ] halts its evaluation of [Ĥ][Ĥ] before it ever examines
> > > > > >>>>> transitions to Ĥ.qy or Ĥ.qn because it detects that [Ĥ][Ĥ] specifies
> > > > > >>>>> the PSR error, so H transitions to its own ((qn)) state indicating that it
> > > > > >>>>> has detected the PSR error.
> > > > > >>>>>
> > > > > >>>>> Because you are in psychological denial you cannot admit the obvious fact
> > > > > >>>>> that every halt decider must always examine the exact state transition
> > > > > >>>>> sequence of its input TMD until this decider determines:
> > > > > >>>>> (1) That the TMD would not halt.
> > > > > >>>>> (2) The the TMD would transition to a specific final state.
> > > > > >>>>>
> > > > > >>>>> -- Definition of Turing Machine Ĥx (infinite loop removed)
> > > > > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > > >>>>> -- q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > > >>>>>
> > > > > >>>>> Ĥx [Ĥx] would:
> > > > > >>>>> (1) begin at its own state q0
> > > > > >>>>> (2) Copy its input [Ĥx] to [Ĥx2]
> > > > > >>>>> (3) Transition to its own state qx
> > > > > >>>>> (4) Begin evaluating [Ĥx] to [Ĥx2]
> > > > > >>>>>
> > > > > >>>>> Which necessarily requires Ĥx to trace the exact state
> > > > > >>>>> transition sequence of [Ĥx] until it determines that
> > > > > >>>>> [Ĥx] would not halt or [Ĥx] would transition to a final state.
> > > > > >>>>>
> > > > > >>>>> Each TMD in this evaluation sequence would only halt because
> > > > > >>>>> it rejects erroneous input, thus the first TM in this sequence
> > > > > >>>>> H would reject the whole sequence as erroneous.
> > > > > >>>>>
> > > > > >>>>
> > > > > >>>>
> > > > > >>>>
> > > > > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > > > >>>>
> > > > > >>>> its the SAME CODE!!!!
> > > > > >>>>
> > > > > >>>
> > > > > >>> I switched to Ĥx so that it is clear that even removing the
> > > > > >>> infinite loop at state qy an infinite evaluation sequence is
> > > > > >>> still specified. It took me a dozen years and thousands of
> > > > > >>> hours to realize this.
> > > > > >>>
> > > > > >>> Definition of Turing Machine Ĥx (infinite loop removed)
> > > > > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > > >>> q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > > >>>
> > > > > >>> Even this single aspect of my analysis is unique in the world.
> > > > > >>> No one has ever before even suggested that the evaluation
> > > > > >>> sequence of the HP proof counter-example continues to be
> > > > > >>> infinitely recursive even without the appended infinite loop.
> > > > > >>>
> > > > > >>>> Dude, if H goes to (qn) then H^ also goes to (qn) and halts.
> > > > > >>>
> > > > > >>> and so would H^2, and H^3, and H^n
> > > > > >>> Yet if H actually evaluated the infinitely recursive sequence
> > > > > >>> that it is presented with then H itself would never halt.
> > > > > >>>
> > > > > >>> Every halt decider must decide only on the basis of what
> > > > > >>> its TMD would actually do, on and on to infinite recursion
> > > > > >>> unless it rejects the entire evaluation sequence as erroneous.
> > > > > >>
> > > > > >>
> > > > > >> OK
> > > > > >>
> > > > > >> H^ (H^)  ............... or H^(w)
> > > > > >>
> > > > > >>
> > > > > >> -->
> > > > > >>
> > > > > >> H' (H^ H^)
> > > > > >>
> > > > > >
> > > > > > These things are too subtle for the greastest minds in the world
> > > > > > to notice since 1931. If you don't pay enormously more attention
> > > > > > there is no chance at all that you will ever understand what I
> > > > > > saying.
> > > > > >
> > > > > > You still are not paying close enough attention to see that
> > > > > > I quit talking about Ĥ quite a while ago. I did this so that
> > > > > > people would bother to try to understand why Ĥx still specifies
> > > > > > an infinitely recursive evaluation sequence even without any
> > > > > > infinite loop.
> > > > > >
> > > > > > An infinitely recursive evaluation sequence is an entirely different
> > > > > > thing than merely getting stuck in an infinite loop.
> > > > > 
> > > > > There is no intrinsic difference between recursion and iteration. Every 
> > > > > recursive program can be converted into iterative program and vice 
> > > > > versa. Conceptually recursion means executing the same code over and 
> > > > > over again. It does not matter if you get there by "jump" or "jump to 
> > > > > subroutine".
> > > > > 
> > > > > > The infinitely recursive evaluation sequence prevents [Ĥx][Ĥx]
> > > > > > from even being evaluated for halting. The whole halt/not halt
> > > > > > evaluation is short-circuited by BAD INPUT REJECT !!!
> > > > > 
> > > > > Not sure how you are planning to distinguish legitimate recursion from 
> > > > > illegitimate recursion. BTW, it does not refute the theorem, which says 
> > > > > you cannot dichotomize the space.
> > > > > 
> > > > > It seems you are going to issue a third value "this was about to go to 
> > > > > infinite recursion but I cut it short". The "counter-example" will 
> > > > > immediately halt, and the decider failed to recognize it.
> > > > > 
> > > > > > Definition of Turing Machine Ĥx (infinite loop removed)
> > > > > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
> > > > > > q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn
> > > > > >
> > > > 
> > > > No the detector rejects BAD INPUT as it rejects English poems. 
> > > > 
> > > > An infinitely recursive evaluation sequence must be rejected
> > > > before any halt decision even begins to be evaluated in the 
> > > > exact same way that the Liar Paradox must be rejected without 
> > > > ever evaluating whether or not its assertion is true. 
> > > > 
> > > > The Liar Paradox is a syntactically correct sentence. 
> > > > Ĥx is a syntactically correct TMD. 
> > > > 
> > > > Both are semantically incorrect because their pathological self-reference
> > > > prevents them from even being evaluated. 
> > > > 
> > > > This is a very subtle distinction that has taken me at least 6,000
> > > > hours since 2004. You may actually be bright enough to understand
> > > > what I am saying.
> > > 
> > > 
> > > a DECIDER that rejects bad input
> > > 
> > > and
> > > 
> > > a DECIDER that outputs YES or NO whether the input halts or not
> > > 
> > > 
> > > are 2 different things
> > > 
> > > 
> > > 
> > > 
> > > "THE HALTING PROBLEM" is about the latter.
> > 
> > Nope. 
> > 
> > The question is this:
> > Is the input a correct TMD that halts on its input? 
> > The no answer to this question includes all kinds of things.
> 
> 
> 
> CORRECTNESS is defined as HALTING(.)

You aren't ever going to get it you are simply not trying hard enough. 

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


#172141

Fromgrahamcooper7@gmail.com
Date2018-02-07 23:25 -0800
Message-ID<81aff2f7-8f84-4e24-913b-f50fbc8816e1@googlegroups.com>
In reply to#172139

Then, Gray steals the ANTI-MISSILE




On Thursday, February 8, 2018 at 5:16:56 PM UTC+10, peteolcott wrote:
>
> You aren't ever going to get it 







Haha!  your just a MILITARY ZOMBIE Pete ....


writing what SECRET AGENTS tell your mind to write....



*SPOOKY*

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


#172134

Fromgrahamcooper7@gmail.com
Date2018-02-07 21:13 -0800
Message-ID<09cb49d4-d6d8-4376-9581-5f25bed0fdef@googlegroups.com>
In reply to#172132
> The Liar Paradox is a syntactically correct sentence. 
> Ĥx is a syntactically correct TMD. 


Turing Machines have a simple SYNTAX.


(STATEa) ----OUT ARROW------>(STATEb)
   |
   |
   |
 OUT ARROW
   |
   | 
   v
(STATEc)



OUT ARROW ::-  0|1 0|1 L|R

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


#172138

Fromgrahamcooper7@gmail.com
Date2018-02-07 23:08 -0800
Message-ID<ad9ba538-fde6-47a7-ae8b-2e15cad549db@googlegroups.com>
In reply to#172132
On Thursday,  peteolcott wrote:
>
> 
> Both are semantically incorrect because their pathological self-reference
> prevents them from even being evaluated. 
> 



Imagine PETE designed an ANTI-MISSILE!


  <==< -------







PETE:  MY ANTI-MISSILE WORKS 100% ON ALL MISSILE TARGETS!



Then, Gray steals the ANTI-MISSILE design and modifies the target by 


[X,Y]-->[X,Y+1] 


 ------ >==>





Pete's MISSILE TARGETS GRAYS MISSILE with 100% ACCURACY!

Gray's MISSILE TARGETS PETES MISSILE with the SAME QUOTED 100% ACCURACY!




GRAY ------------------ >==>        <==< -----------------PETE!



PETE is trying SHOOT DOWN Grays Missile!

But GRAYS MISSILE IS EXACTLY THE SAME ACCURACY..... 

and AIMS 1 METER HIGHER!




IF GRAY HITS THE TARGET (1 METER ABOVE THE ANTI-MISSILE)

THEN GRAYS MISSILE DOESNT GET SHOT DOWN!





CONCLUSION:   Pete's ANTI-MISSILE cannot work 100% of the time!




SAME PROOF METHOD AS THE HALTING PROBLEM!




ANTI-MISSILES is an imperfect science

DISCRETE HALTING SOLUTION is an imperfect function


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


#172140

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-07 23:20 -0800
Message-ID<d38cdc92-75e8-4387-a9af-499ca28a900a@googlegroups.com>
In reply to#172138
On Thursday, February 8, 2018 at 1:08:37 AM UTC-6, graham...@gmail.com wrote:
> On Thursday,  peteolcott wrote:
> >
> > 
> > Both are semantically incorrect because their pathological self-reference
> > prevents them from even being evaluated. 
> > 
> 
> 
> 
> Imagine PETE designed an ANTI-MISSILE!
> 
> 
>   <==< -------
> 
> 
> 
> 
> 
> 
> 
> PETE:  MY ANTI-MISSILE WORKS 100% ON ALL MISSILE TARGETS!
> 
> 
> 
> Then, Gray steals the ANTI-MISSILE design and modifies the target by 
> 
> 
> [X,Y]-->[X,Y+1] 
> 
> 
>  ------ >==>
> 
> 
> 
> 
> 
> Pete's MISSILE TARGETS GRAYS MISSILE with 100% ACCURACY!
> 
> Gray's MISSILE TARGETS PETES MISSILE with the SAME QUOTED 100% ACCURACY!
> 
> 
> 
> 
> GRAY ------------------ >==>        <==< -----------------PETE!
> 
> 
> 
> PETE is trying SHOOT DOWN Grays Missile!
> 
> But GRAYS MISSILE IS EXACTLY THE SAME ACCURACY..... 
> 
> and AIMS 1 METER HIGHER!
> 
> 
> 
> 
> IF GRAY HITS THE TARGET (1 METER ABOVE THE ANTI-MISSILE)
> 
> THEN GRAYS MISSILE DOESNT GET SHOT DOWN!
> 
> 
> 
> 
> 
> CONCLUSION:   Pete's ANTI-MISSILE cannot work 100% of the time!
> 
> 
> 
> 
> SAME PROOF METHOD AS THE HALTING PROBLEM!
> 
> 
> 
> 
> ANTI-MISSILES is an imperfect science
> 
> DISCRETE HALTING SOLUTION is an imperfect function

There is no form of pathological self-reference error that
my system cannot determine and reject try and provide one. 

I have simultaneously correctly refuted many famous theorems
of math and computer science by detecting this one single error.

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


#172142

Fromgrahamcooper7@gmail.com
Date2018-02-07 23:29 -0800
Message-ID<31d9d1cd-de10-4fe0-901e-56ab86893da0@googlegroups.com>
In reply to#172140
On Thursday, February 8, 2018 at 5:20:23 PM UTC+10, peteolcott wrote:
> On Thursday, February 8, 2018 at 1:08:37 AM UTC-6, graham...@gmail.com wrote:
> > On Thursday,  peteolcott wrote:
> > >
> > > 
> > > Both are semantically incorrect because their pathological self-reference
> > > prevents them from even being evaluated. 
> > > 
> > 
> > 
> > 
> > Imagine PETE designed an ANTI-MISSILE!
> > 
> > 
> >   <==< -------
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > PETE:  MY ANTI-MISSILE WORKS 100% ON ALL MISSILE TARGETS!
> > 
> > 
> > 
> > Then, Gray steals the ANTI-MISSILE design and modifies the target by 
> > 
> > 
> > [X,Y]-->[X,Y+1] 
> > 
> > 
> >  ------ >==>
> > 
> > 
> > 
> > 
> > 
> > Pete's MISSILE TARGETS GRAYS MISSILE with 100% ACCURACY!
> > 
> > Gray's MISSILE TARGETS PETES MISSILE with the SAME QUOTED 100% ACCURACY!
> > 
> > 
> > 
> > 
> > GRAY ------------------ >==>        <==< -----------------PETE!
> > 
> > 
> > 
> > PETE is trying SHOOT DOWN Grays Missile!
> > 
> > But GRAYS MISSILE IS EXACTLY THE SAME ACCURACY..... 
> > 
> > and AIMS 1 METER HIGHER!
> > 
> > 
> > 
> > 
> > IF GRAY HITS THE TARGET (1 METER ABOVE THE ANTI-MISSILE)
> > 
> > THEN GRAYS MISSILE DOESNT GET SHOT DOWN!
> > 
> > 
> > 
> > 
> > 
> > CONCLUSION:   Pete's ANTI-MISSILE cannot work 100% of the time!
> > 
> > 
> > 
> > 
> > SAME PROOF METHOD AS THE HALTING PROBLEM!
> > 
> > 
> > 
> > 
> > ANTI-MISSILES is an imperfect science
> > 
> > DISCRETE HALTING SOLUTION is an imperfect function
> 
> There is no form of pathological self-reference error that
> my system cannot determine and reject try and provide one. 
> 
> I have simultaneously correctly refuted many famous theorems
> of math and computer science by detecting this one single error.





NOPE!


Halting Proof uses DIAGONALISATION to refute 1 ROW!


Godel, Cantor, Tarski ETC ETC refute the WHOLE FRIGGIN TABLE!

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


#172143

Fromgrahamcooper7@gmail.com
Date2018-02-07 23:34 -0800
Message-ID<5e4da228-cc41-4165-abfe-746ed096d0be@googlegroups.com>
In reply to#172140
On Thursday, February 8, 2018 at 5:20:23 PM UTC+10, peteolcott wrote:
>
> > 
> > ANTI-MISSILES is an imperfect science
> > 
> > DISCRETE HALTING SOLUTION is an imperfect function
> 
> There is no form of pathological self-reference error that
> my system cannot determine and reject try and provide one. 
> 

MTTX: IF MTT( question ) == TRUE PRINT FALSE

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


Page 13 of 16 — ← Prev page 1 … 11 12 [13] 14 15 16  Next page →

Back to top | Article view | sci.logic


csiph-web