Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #170305 > unrolled thread
| Started by | Newberry <newberryxy@gmail.com> |
|---|---|
| First post | 2018-01-16 13:02 -0800 |
| Last post | 2018-02-14 00:44 -0600 |
| Articles | 20 on this page of 310 — 14 participants |
Back to article view | Back to sci.logic
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 →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | Newberry <newberryxy@gmail.com> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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