Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #106259 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-04 16:53 -0500 |
| Last post | 2024-06-05 20:39 +0200 |
| Articles | 20 on this page of 210 — 13 participants |
Back to article view | Back to comp.theory
At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-04 16:53 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-04 21:48 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-04 20:54 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-04 22:22 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-04 21:28 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-04 22:45 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-04 21:55 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-04 23:15 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-04 22:21 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 07:31 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 07:30 -0500
Re: At least 100 people kept denying the easily verified fact joes <noreply@example.com> - 2024-06-05 18:00 +0000
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 19:32 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 20:01 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 21:07 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 20:18 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 21:27 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 20:31 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 22:25 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 21:43 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 23:05 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 22:11 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 23:41 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 22:44 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-05 23:58 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 23:04 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 00:06 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 23:14 -0500
Re: At least 100 people kept denying the easily verified fact wij <wyniijj5@gmail.com> - 2024-06-06 12:32 +0800
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 07:11 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-06 08:06 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-06 21:56 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-06 22:04 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-06 23:29 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-06 22:53 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 11:14 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 10:22 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 11:32 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-06 23:29 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 08:09 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 11:14 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 10:29 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 11:46 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 10:56 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 12:25 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 11:46 -0500
Re: Last communication with Richard Rich Yard Daemon <news3@immibis.com> - 2024-06-07 18:51 +0200
Re: Last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 13:12 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 13:11 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 12:14 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 14:22 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 13:38 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 15:23 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 13:53 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 15:23 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-07 17:57 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 11:13 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 12:27 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 10:52 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard immibis <news@immibis.com> - 2024-06-07 18:00 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 12:28 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Alan Mackenzie <acm@muc.de> - 2024-06-07 17:50 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 13:02 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 14:24 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 13:41 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard wij <wyniijj5@gmail.com> - 2024-06-08 02:57 +0800
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard immibis <news@immibis.com> - 2024-06-07 21:22 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard joes <noreply@example.com> - 2024-06-07 20:45 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 17:22 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-08 10:01 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 08:07 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 09:40 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 08:52 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 10:34 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-09 10:34 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 07:51 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-09 18:32 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 11:18 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-10 10:00 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-10 10:06 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-11 10:18 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-11 22:22 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 14:31 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard wij <wyniijj5@gmail.com> - 2024-06-08 03:43 +0800
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 15:01 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard wij <wyniijj5@gmail.com> - 2024-06-08 12:18 +0800
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 07:20 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 14:41 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 08:16 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 15:38 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 08:50 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 16:01 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 09:06 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 16:19 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 09:25 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 16:36 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 09:59 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 11:09 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 10:44 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 10:40 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 10:39 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 09:47 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 09:05 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 10:46 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 08:36 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 09:50 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 15:50 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Alan Mackenzie <acm@muc.de> - 2024-06-07 19:57 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 15:04 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Alan Mackenzie <acm@muc.de> - 2024-06-07 20:16 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 17:03 -0500
Re: olcott is a moron immibis <news@immibis.com> - 2024-06-08 00:14 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 19:00 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard (we wish) Richard Damon <richard@damon-family.org> - 2024-06-07 16:17 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard (we wish) olcott <polcott333@gmail.com> - 2024-06-07 17:11 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard (we wish) Richard Damon <richard@damon-family.org> - 2024-06-07 18:18 -0400
Re: At least 100 people kept denying the easily verified fact -- closure joes <noreply@example.com> - 2024-06-07 22:22 +0000
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 17:35 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 19:00 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 18:07 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 19:18 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 18:38 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 20:43 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 19:47 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 20:58 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 20:22 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 21:39 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 20:45 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 22:06 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 21:21 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 22:37 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 21:47 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 22:56 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 22:23 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: At least 100 people kept denying the easily verified fact -- closure joes <noreply@example.com> - 2024-06-07 23:21 +0000
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 18:51 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 19:57 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 19:23 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 20:45 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 19:50 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 21:01 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 19:32 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 20:47 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 19:52 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 21:08 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 20:26 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 21:42 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 20:48 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 22:11 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 21:35 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 22:46 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-07 21:54 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-07 23:11 -0400
Re: At least 100 people kept denying the easily verified fact -- closure Mikko <mikko.levanto@iki.fi> - 2024-06-08 10:31 +0300
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-08 08:39 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-08 09:56 -0400
Re: At least 100 people kept denying the easily verified fact -- closure olcott <polcott333@gmail.com> - 2024-06-08 08:12 -0500
Re: At least 100 people kept denying the easily verified fact -- closure Richard Damon <richard@damon-family.org> - 2024-06-08 09:57 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard joes <noreply@example.com> - 2024-06-07 20:56 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 17:24 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 19:00 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 18:09 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 19:20 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 18:48 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 20:31 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 18:31 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 20:35 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 15:28 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 14:36 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 16:01 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Python <python@invalid.org> - 2024-06-07 23:06 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-07 17:25 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-07 17:12 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Python <python@invalid.org> - 2024-06-08 00:15 +0200
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-08 09:58 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-08 08:06 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-08 10:01 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Mikko <mikko.levanto@iki.fi> - 2024-06-09 12:33 +0300
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 09:04 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Andy Walker <anw@cuboid.co.uk> - 2024-06-09 15:16 +0100
Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 09:21 -0500
Re: Simplified proof that DDD correctly simulated by HHH does not halt Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard joes <noreply@example.com> - 2024-06-09 15:11 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 11:11 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 19:17 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-09 20:36 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 19:50 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-09 21:07 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard olcott <polcott333@gmail.com> - 2024-06-09 20:22 -0500
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard Richard Damon <richard@damon-family.org> - 2024-06-09 21:41 -0400
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard joes <noreply@example.com> - 2024-06-07 20:52 +0000
Re: At least 100 people kept denying the easily verified fact --- last communication with Richard immibis <news@immibis.com> - 2024-06-07 18:01 +0200
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-06 00:57 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 07:11 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-06 08:08 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-06 08:27 -0500
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: At least 100 people kept denying the easily verified fact ornott <news2@immibis.com> - 2024-06-06 18:48 +0200
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-06 11:56 -0500
Re: At least 100 people kept denying the easily verified fact prescott <news2@immibis.com> - 2024-06-06 20:03 +0200
Re: At least 100 people kept denying the easily verified fact Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: At least 100 people kept denying the easily verified fact "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 10:02 +0200
Re: At least 100 people kept denying the easily verified fact olcott <polcott333@gmail.com> - 2024-06-05 08:54 -0500
Re: At least 100 people kept denying the easily verified fact "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 20:39 +0200
Page 6 of 11 — ← Prev page 1 … 4 5 [6] 7 8 … 11 Next page →
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 10:40 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41qh5$3cg3s$4@i2pn2.org> |
| In reply to | #106689 |
On 6/8/24 10:06 AM, olcott wrote:
> On 6/8/2024 9:01 AM, Fred. Zwarts wrote:
>> Op 08.jun.2024 om 15:50 schreef olcott:
>>> On 6/8/2024 8:38 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 15:16 schreef olcott:
>>>>> On 6/8/2024 7:41 AM, Fred. Zwarts wrote:
>>>>>> Op 08.jun.2024 om 14:20 schreef olcott:
>>>>>>> On 6/7/2024 11:18 PM, wij wrote:
>>>>>>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>>>>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>>>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [ .... ]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>>>>>>> Less than a
>>>>>>>>>>>>>>>> few
>>>>>>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>>>>>>> instructions"
>>>>>>>>>>>>>>>> simulated (without ever specifying what you meant by N).
>>>>>>>>>>>>>>>> It seems that
>>>>>>>>>>>>>>>> the simulation of exactly one instruction would have met
>>>>>>>>>>>>>>>> your criterion.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>>>>>>
>>>>>>>>>>>>> More dishonest deflection.
>>>>>>>>>>>>> The point that I made and you try to deflect using the
>>>>>>>>>>>>> strawman
>>>>>>>>>>>>> deception as a fake rebuttal is the I just proved that DD
>>>>>>>>>>>>> is correctly
>>>>>>>>>>>>> simulated by HH and this is not the same behavior as the
>>>>>>>>>>>>> directly
>>>>>>>>>>>>> executed DD(DD).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>>>>>> ELSE HP is undecidable
>>>>>>>>>>>>
>>>>>>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>>>>>>
>>>>>>>>>>>> Surrender to my GUR, son.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If people are going to be dishonest about simple things
>>>>>>>>>>> such as the actual behavior of actual x86 code where
>>>>>>>>>>> they consistently deny verified facts
>>>>>>>>>>>
>>>>>>>>>>> then we certainly cannot trust these people with more
>>>>>>>>>>> difficult issues that require at least some slight degree
>>>>>>>>>>> of judgment call.
>>>>>>>>>>>
>>>>>>>>>>> When we can show that even in the halting problem HH
>>>>>>>>>>> is only required to report on the behavior of DD correctly
>>>>>>>>>>> simulated by HH these dishonest people merely use that
>>>>>>>>>>> as another deflection point for their dishonesty.
>>>>>>>>>>>
>>>>>>>>>>> The way around this that just worked is to stay diligently
>>>>>>>>>>> focused one one single point until the dishonest people
>>>>>>>>>>> finally admit that they have simply ignored all the proofs
>>>>>>>>>>> for three solid years.
>>>>>>>>>>>
>>>>>>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>>>>>>> >>
>>>>>>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>>>>>>> >
>>>>>>>>>>> > But, as I said, I won't acknowledge that you
>>>>>>>>>>> > are correct, because I am not willing to put
>>>>>>>>>>> > that effort into your worthless claim.
>>>>>>>>>>> >
>>>>>>>>>>>
>>>>>>>>>>> Here is the earliest version of the proof (that everyone
>>>>>>>>>>> has simply ignored for three solid years) that P correctly
>>>>>>>>>>> simulated by H would never stop running unless aborted.
>>>>>>>>>>>
>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The fact that the execution trace of P derived by the executed
>>>>>>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>>>>>>> proves that each instruction of P was simulated correctly and
>>>>>>>>>>> in the correct order this conclusively proves that P is
>>>>>>>>>>> correctly
>>>>>>>>>>> simulated by both of these instances of H.
>>>>>>>>>>>
>>>>>>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>>>>>>> assumption.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>
>>>>>>>>>>> _DD()
>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>
>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>
>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I recalled now. You knew what the Halting Problem is. But
>>>>>>>>>> soon, you started to insist
>>>>>>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>>>>>>> Wake up, your trick won't work.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> All the while that you insist on lying about
>>>>>>>>>
>>>>>>>>> the verified fact that DD correctly simulated by
>>>>>>>>> HH cannot possibly stop running without having its
>>>>>>>>> simulation aborted by HH.
>>>>>>>>>
>>>>>>>>> You won't get to talk to me about anything else such
>>>>>>>>> as why the above statement matters.
>>>>>>>>>
>>>>>>>>> If you want to choose to be a liar thus <is> the
>>>>>>>>> consequence that you get.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>> ELSE HP is undecidable
>>>>>>>>
>>>>>>>> What is your answer? (the last time I saw POOH, it does not
>>>>>>>> report anything)
>>>>>>>>
>>>>>>>
>>>>>>> I incorporate by reference
>>>>>>> (a) The x86 language
>>>>>>> (b) The notion of an x86 emulator
>>>>>>>
>>>>>>> (c) I provide this complete function
>>>>>>>
>>>>>>> void DDD(int (*x)())
>>>>>>> {
>>>>>>> HH(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00001de2] 55 push ebp
>>>>>>> [00001de3] 8bec mov ebp,esp
>>>>>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>>>>>> [00001de8] 50 push eax ; push DD
>>>>>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00001dec] 51 push ecx ; push DD
>>>>>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>>>>>> [00001df2] 83c408 add esp,+08
>>>>>>> [00001df5] 5d pop ebp
>>>>>>> [00001df6] c3 ret
>>>>>>> Size in bytes:(0021) [00001df6]
>>>>>>>
>>>>>>> Then I state that No DDD correctly emulated by any
>>>>>>> x86 emulator H can possibly reach its own [00001df6]
>>>>>>> instruction.
>>>>>>>
>>>>>>> To anyone having this mandatory prerequisite knowledge
>>>>>>> (perhaps not you) every x86 emulation of DDD by any
>>>>>>> x86 emulator H continually repeats the first seven lines
>>>>>>> of DDD until it crashes due to out-of-memory error.
>>>>>>>
>>>>>>
>>>>>> The only reason being that HH, although required to halt, does not
>>>>>> halt, but calls DDD recursively until it is aborted.
>>>>>
>>>>> Try rereading this again and again until to understand and remember
>>>>> all of its words unless you fully intend to stay in rebuttal mode
>>>>> against the verified facts. In that case I will quit replying to
>>>>> your messages.
>>>>>
>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>> If simulating halt decider H correctly simulates its input D
>>>>> until H correctly determines that its simulated D would never
>>>>> stop running unless aborted then
>>>>>
>>>>> H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>
>>>> Don't only cite Sipser, but try to understand the words. Try to
>>>> think! If he really agreed about D, he would come to the same
>>>> conclusion for H.
>>>>
>>>> If simulating halt decider H correctly simulates its input H
>>>> (as part of D)
>>>> until H correctly determines that its simulated H would never
>>>> stop running unless aborted then
>>>>
>>>> H can abort its simulation of H and correctly report that H
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>
>>> It is only that DD calls HH that makes the simulated HH not halt.
>>>
>>>
>>
>> With similar logic we can say that it is only HH that simulates DD
>> that makes the simulated DD not halt.
>>
>
> HH(DD,DD)==0 Please quit lying about this.
>
Then DD(DD) Halts, Please quit lying about that.
That shows that HH is NOT a Halt decider.
It might be a POOP decider, but no one (but you) cares about that.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 10:39 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41qf3$3cg3s$3@i2pn2.org> |
| In reply to | #106678 |
On 6/8/24 9:50 AM, olcott wrote:
> On 6/8/2024 8:38 AM, Fred. Zwarts wrote:
>> Op 08.jun.2024 om 15:16 schreef olcott:
>>> On 6/8/2024 7:41 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 14:20 schreef olcott:
>>>>> On 6/7/2024 11:18 PM, wij wrote:
>>>>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [ .... ]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>>>>> Less than a
>>>>>>>>>>>>>> few
>>>>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>>>>> instructions"
>>>>>>>>>>>>>> simulated (without ever specifying what you meant by N).
>>>>>>>>>>>>>> It seems that
>>>>>>>>>>>>>> the simulation of exactly one instruction would have met
>>>>>>>>>>>>>> your criterion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>>>
>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>
>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>>>>
>>>>>>>>>>> More dishonest deflection.
>>>>>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>>>>>> correctly
>>>>>>>>>>> simulated by HH and this is not the same behavior as the
>>>>>>>>>>> directly
>>>>>>>>>>> executed DD(DD).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>>>> ELSE HP is undecidable
>>>>>>>>>>
>>>>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>>>>
>>>>>>>>>> Surrender to my GUR, son.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If people are going to be dishonest about simple things
>>>>>>>>> such as the actual behavior of actual x86 code where
>>>>>>>>> they consistently deny verified facts
>>>>>>>>>
>>>>>>>>> then we certainly cannot trust these people with more
>>>>>>>>> difficult issues that require at least some slight degree
>>>>>>>>> of judgment call.
>>>>>>>>>
>>>>>>>>> When we can show that even in the halting problem HH
>>>>>>>>> is only required to report on the behavior of DD correctly
>>>>>>>>> simulated by HH these dishonest people merely use that
>>>>>>>>> as another deflection point for their dishonesty.
>>>>>>>>>
>>>>>>>>> The way around this that just worked is to stay diligently
>>>>>>>>> focused one one single point until the dishonest people
>>>>>>>>> finally admit that they have simply ignored all the proofs
>>>>>>>>> for three solid years.
>>>>>>>>>
>>>>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>>>>> >>
>>>>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>>>>> >
>>>>>>>>> > But, as I said, I won't acknowledge that you
>>>>>>>>> > are correct, because I am not willing to put
>>>>>>>>> > that effort into your worthless claim.
>>>>>>>>> >
>>>>>>>>>
>>>>>>>>> Here is the earliest version of the proof (that everyone
>>>>>>>>> has simply ignored for three solid years) that P correctly
>>>>>>>>> simulated by H would never stop running unless aborted.
>>>>>>>>>
>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The fact that the execution trace of P derived by the executed
>>>>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>>>>> proves that each instruction of P was simulated correctly and
>>>>>>>>> in the correct order this conclusively proves that P is correctly
>>>>>>>>> simulated by both of these instances of H.
>>>>>>>>>
>>>>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>>>>> assumption.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>
>>>>>>>>> _DD()
>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>
>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>
>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I recalled now. You knew what the Halting Problem is. But soon,
>>>>>>>> you started to insist
>>>>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>>>>> Wake up, your trick won't work.
>>>>>>>>
>>>>>>>
>>>>>>> All the while that you insist on lying about
>>>>>>>
>>>>>>> the verified fact that DD correctly simulated by
>>>>>>> HH cannot possibly stop running without having its
>>>>>>> simulation aborted by HH.
>>>>>>>
>>>>>>> You won't get to talk to me about anything else such
>>>>>>> as why the above statement matters.
>>>>>>>
>>>>>>> If you want to choose to be a liar thus <is> the
>>>>>>> consequence that you get.
>>>>>>>
>>>>>>
>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>> ELSE HP is undecidable
>>>>>>
>>>>>> What is your answer? (the last time I saw POOH, it does not report
>>>>>> anything)
>>>>>>
>>>>>
>>>>> I incorporate by reference
>>>>> (a) The x86 language
>>>>> (b) The notion of an x86 emulator
>>>>>
>>>>> (c) I provide this complete function
>>>>>
>>>>> void DDD(int (*x)())
>>>>> {
>>>>> HH(x, x);
>>>>> }
>>>>>
>>>>> _DDD()
>>>>> [00001de2] 55 push ebp
>>>>> [00001de3] 8bec mov ebp,esp
>>>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>>>> [00001de8] 50 push eax ; push DD
>>>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>>>> [00001dec] 51 push ecx ; push DD
>>>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>>>> [00001df2] 83c408 add esp,+08
>>>>> [00001df5] 5d pop ebp
>>>>> [00001df6] c3 ret
>>>>> Size in bytes:(0021) [00001df6]
>>>>>
>>>>> Then I state that No DDD correctly emulated by any
>>>>> x86 emulator H can possibly reach its own [00001df6]
>>>>> instruction.
>>>>>
>>>>> To anyone having this mandatory prerequisite knowledge
>>>>> (perhaps not you) every x86 emulation of DDD by any
>>>>> x86 emulator H continually repeats the first seven lines
>>>>> of DDD until it crashes due to out-of-memory error.
>>>>>
>>>>
>>>> The only reason being that HH, although required to halt, does not
>>>> halt, but calls DDD recursively until it is aborted.
>>>
>>> Try rereading this again and again until to understand and remember
>>> all of its words unless you fully intend to stay in rebuttal mode
>>> against the verified facts. In that case I will quit replying to
>>> your messages.
>>>
>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>> If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never
>>> stop running unless aborted then
>>>
>>> H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>
>> Don't only cite Sipser, but try to understand the words. Try to think!
>> If he really agreed about D, he would come to the same conclusion for H.
>>
>> If simulating halt decider H correctly simulates its input H
>> (as part of D)
>> until H correctly determines that its simulated H would never
>> stop running unless aborted then
>>
>> H can abort its simulation of H and correctly report that H
>> specifies a non-halting sequence of configurations.
>>
>
> It is only that DD calls HH that makes the simulated HH not halt.
>
>
But it is HH's requirement that it always returns a result, so if there
exists an input that breaks that requirement, the "fault" is on the
program that fails to meet its requirement, that is HH.
There is no problem with DD being non-halting, if that is a result of HH
returning an answer to it that causes it to loop. It just happens that
this only happens if HH answer that DD will halt, and thus it proves HH
to be wrong.
The problem is if DD is non-halting because HH was non-halting, then HH
failed to meet its requirements, so the behavior of DD is irrelevent, as
it did its job of showing HH didn't meet its requirements.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 09:47 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41ne5$3cg3t$15@i2pn2.org> |
| In reply to | #106665 |
On 6/8/24 9:16 AM, olcott wrote:
> On 6/8/2024 7:41 AM, Fred. Zwarts wrote:
>> Op 08.jun.2024 om 14:20 schreef olcott:
>>> On 6/7/2024 11:18 PM, wij wrote:
>>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>>
>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> [ .... ]
>>>>>>>>>>>>
>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>
>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>
>>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>>> Less than a
>>>>>>>>>>>> few
>>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>>> instructions"
>>>>>>>>>>>> simulated (without ever specifying what you meant by N). It
>>>>>>>>>>>> seems that
>>>>>>>>>>>> the simulation of exactly one instruction would have met
>>>>>>>>>>>> your criterion.
>>>>>>>>>>>>
>>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>>
>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>
>>>>>>>>>>> _DD()
>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>
>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>
>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>>
>>>>>>>>> More dishonest deflection.
>>>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>>>> correctly
>>>>>>>>> simulated by HH and this is not the same behavior as the directly
>>>>>>>>> executed DD(DD).
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>> ELSE HP is undecidable
>>>>>>>>
>>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>>
>>>>>>>> Surrender to my GUR, son.
>>>>>>>>
>>>>>>>
>>>>>>> If people are going to be dishonest about simple things
>>>>>>> such as the actual behavior of actual x86 code where
>>>>>>> they consistently deny verified facts
>>>>>>>
>>>>>>> then we certainly cannot trust these people with more
>>>>>>> difficult issues that require at least some slight degree
>>>>>>> of judgment call.
>>>>>>>
>>>>>>> When we can show that even in the halting problem HH
>>>>>>> is only required to report on the behavior of DD correctly
>>>>>>> simulated by HH these dishonest people merely use that
>>>>>>> as another deflection point for their dishonesty.
>>>>>>>
>>>>>>> The way around this that just worked is to stay diligently
>>>>>>> focused one one single point until the dishonest people
>>>>>>> finally admit that they have simply ignored all the proofs
>>>>>>> for three solid years.
>>>>>>>
>>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>>> >>
>>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>>> >
>>>>>>> > But, as I said, I won't acknowledge that you
>>>>>>> > are correct, because I am not willing to put
>>>>>>> > that effort into your worthless claim.
>>>>>>> >
>>>>>>>
>>>>>>> Here is the earliest version of the proof (that everyone
>>>>>>> has simply ignored for three solid years) that P correctly
>>>>>>> simulated by H would never stop running unless aborted.
>>>>>>>
>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>
>>>>>>>
>>>>>>> The fact that the execution trace of P derived by the executed
>>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>>> proves that each instruction of P was simulated correctly and
>>>>>>> in the correct order this conclusively proves that P is correctly
>>>>>>> simulated by both of these instances of H.
>>>>>>>
>>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>>> assumption.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>
>>>>>>> _DD()
>>>>>>> [00001e12] 55 push ebp
>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>> [00001e15] 51 push ecx
>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>
>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>> by HH and simulated in the correct order.
>>>>>>>
>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>> of the above definition of correct simulation.
>>>>>>>
>>>>>>
>>>>>> I recalled now. You knew what the Halting Problem is. But soon,
>>>>>> you started to insist
>>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>>> Wake up, your trick won't work.
>>>>>>
>>>>>
>>>>> All the while that you insist on lying about
>>>>>
>>>>> the verified fact that DD correctly simulated by
>>>>> HH cannot possibly stop running without having its
>>>>> simulation aborted by HH.
>>>>>
>>>>> You won't get to talk to me about anything else such
>>>>> as why the above statement matters.
>>>>>
>>>>> If you want to choose to be a liar thus <is> the
>>>>> consequence that you get.
>>>>>
>>>>
>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>> IF H(D,D)==1, THEN D(D) will return.
>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>> ELSE HP is undecidable
>>>>
>>>> What is your answer? (the last time I saw POOH, it does not report
>>>> anything)
>>>>
>>>
>>> I incorporate by reference
>>> (a) The x86 language
>>> (b) The notion of an x86 emulator
>>>
>>> (c) I provide this complete function
>>>
>>> void DDD(int (*x)())
>>> {
>>> HH(x, x);
>>> }
>>>
>>> _DDD()
>>> [00001de2] 55 push ebp
>>> [00001de3] 8bec mov ebp,esp
>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>> [00001de8] 50 push eax ; push DD
>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>> [00001dec] 51 push ecx ; push DD
>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>> [00001df2] 83c408 add esp,+08
>>> [00001df5] 5d pop ebp
>>> [00001df6] c3 ret
>>> Size in bytes:(0021) [00001df6]
>>>
>>> Then I state that No DDD correctly emulated by any
>>> x86 emulator H can possibly reach its own [00001df6]
>>> instruction.
>>>
>>> To anyone having this mandatory prerequisite knowledge
>>> (perhaps not you) every x86 emulation of DDD by any
>>> x86 emulator H continually repeats the first seven lines
>>> of DDD until it crashes due to out-of-memory error.
>>>
>>
>> The only reason being that HH, although required to halt, does not
>> halt, but calls DDD recursively until it is aborted.
>
> Try rereading this again and again until to understand and remember
> all of its words unless you fully intend to stay in rebuttal mode
> against the verified facts. In that case I will quit replying to
> your messages.
>
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> If simulating halt decider H correctly simulates its input D
> until H correctly determines that its simulated D would never
> stop running unless aborted then
>
> H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
Which uses a DIFFERENT defintion of "Correct Simulation" then you do, so
you can't apply it the way you try.
Professor Sipser means as a correct simulation, a simulation that never
stops until it reaches a final state. Your H doesn't meet that
requirement, so you can't use its own simulation, and since it also
about this particular input (not the template as applied to the current
simulator, since such a thing isn't representable as a Turing Machine)
you can't look at the simulaiion of the OTHER H that is simulating the
OTHER D built on that OTHER H that doesn't abort. If we do look at the
replacing of THIS H with a UTM to evaluate the "correct simulation of
this input" and keep the input still tied to the original H, then we see
that if this H chooses to abort, that the simulation will reach an end,
and thus you have no basis to claim the first part happened, so you have
no basis to do the second part, but did anyway, so it gets the answer wrong.
Just a case of the ends do not justify the means.
>
>> For everyone with a little bit of knowledge of the x86 language it is
>> clear that if HH would return (as required), then DDD would return as
>> well.
>> So, not only DDD, but also HH is a problem for the simulator, because
>> they keep creating new instances of each other.
>> That the direct execution of HH halts, but the simulation of HH does
>> not halt, is a clear indication that HH is not correctly simulated. In
>> that case it does not help to simulate only DDD correctly. The
>> simulation of HH should go at least to the point where HH returns to
>> DDD. But the simulator is unable to do that, because it aborts too
>> early, which is a problem of the simulator, not of DDD.
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-08 09:05 -0500 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41oei$2kanc$12@dont-email.me> |
| In reply to | #106676 |
On 6/8/2024 8:47 AM, Richard Damon wrote:
> On 6/8/24 9:16 AM, olcott wrote:
>> On 6/8/2024 7:41 AM, Fred. Zwarts wrote:
>>> Op 08.jun.2024 om 14:20 schreef olcott:
>>>> On 6/7/2024 11:18 PM, wij wrote:
>>>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>>>
>>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> [ .... ]
>>>>>>>>>>>>>
>>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>>>> Less than a
>>>>>>>>>>>>> few
>>>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>>>> instructions"
>>>>>>>>>>>>> simulated (without ever specifying what you meant by N).
>>>>>>>>>>>>> It seems that
>>>>>>>>>>>>> the simulation of exactly one instruction would have met
>>>>>>>>>>>>> your criterion.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>>>
>>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>>
>>>>>>>>>>>> _DD()
>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>
>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>
>>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>>>
>>>>>>>>>> More dishonest deflection.
>>>>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>>>>> correctly
>>>>>>>>>> simulated by HH and this is not the same behavior as the directly
>>>>>>>>>> executed DD(DD).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>>> ELSE HP is undecidable
>>>>>>>>>
>>>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>>>
>>>>>>>>> Surrender to my GUR, son.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If people are going to be dishonest about simple things
>>>>>>>> such as the actual behavior of actual x86 code where
>>>>>>>> they consistently deny verified facts
>>>>>>>>
>>>>>>>> then we certainly cannot trust these people with more
>>>>>>>> difficult issues that require at least some slight degree
>>>>>>>> of judgment call.
>>>>>>>>
>>>>>>>> When we can show that even in the halting problem HH
>>>>>>>> is only required to report on the behavior of DD correctly
>>>>>>>> simulated by HH these dishonest people merely use that
>>>>>>>> as another deflection point for their dishonesty.
>>>>>>>>
>>>>>>>> The way around this that just worked is to stay diligently
>>>>>>>> focused one one single point until the dishonest people
>>>>>>>> finally admit that they have simply ignored all the proofs
>>>>>>>> for three solid years.
>>>>>>>>
>>>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>>>> >>
>>>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>>>> >
>>>>>>>> > But, as I said, I won't acknowledge that you
>>>>>>>> > are correct, because I am not willing to put
>>>>>>>> > that effort into your worthless claim.
>>>>>>>> >
>>>>>>>>
>>>>>>>> Here is the earliest version of the proof (that everyone
>>>>>>>> has simply ignored for three solid years) that P correctly
>>>>>>>> simulated by H would never stop running unless aborted.
>>>>>>>>
>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>
>>>>>>>>
>>>>>>>> The fact that the execution trace of P derived by the executed
>>>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>>>> proves that each instruction of P was simulated correctly and
>>>>>>>> in the correct order this conclusively proves that P is correctly
>>>>>>>> simulated by both of these instances of H.
>>>>>>>>
>>>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>>>> assumption.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>
>>>>>>>> _DD()
>>>>>>>> [00001e12] 55 push ebp
>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>> [00001e15] 51 push ecx
>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>
>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>
>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>> of the above definition of correct simulation.
>>>>>>>>
>>>>>>>
>>>>>>> I recalled now. You knew what the Halting Problem is. But soon,
>>>>>>> you started to insist
>>>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>>>> Wake up, your trick won't work.
>>>>>>>
>>>>>>
>>>>>> All the while that you insist on lying about
>>>>>>
>>>>>> the verified fact that DD correctly simulated by
>>>>>> HH cannot possibly stop running without having its
>>>>>> simulation aborted by HH.
>>>>>>
>>>>>> You won't get to talk to me about anything else such
>>>>>> as why the above statement matters.
>>>>>>
>>>>>> If you want to choose to be a liar thus <is> the
>>>>>> consequence that you get.
>>>>>>
>>>>>
>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>> ELSE HP is undecidable
>>>>>
>>>>> What is your answer? (the last time I saw POOH, it does not report
>>>>> anything)
>>>>>
>>>>
>>>> I incorporate by reference
>>>> (a) The x86 language
>>>> (b) The notion of an x86 emulator
>>>>
>>>> (c) I provide this complete function
>>>>
>>>> void DDD(int (*x)())
>>>> {
>>>> HH(x, x);
>>>> }
>>>>
>>>> _DDD()
>>>> [00001de2] 55 push ebp
>>>> [00001de3] 8bec mov ebp,esp
>>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>>> [00001de8] 50 push eax ; push DD
>>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>>> [00001dec] 51 push ecx ; push DD
>>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>>> [00001df2] 83c408 add esp,+08
>>>> [00001df5] 5d pop ebp
>>>> [00001df6] c3 ret
>>>> Size in bytes:(0021) [00001df6]
>>>>
>>>> Then I state that No DDD correctly emulated by any
>>>> x86 emulator H can possibly reach its own [00001df6]
>>>> instruction.
>>>>
>>>> To anyone having this mandatory prerequisite knowledge
>>>> (perhaps not you) every x86 emulation of DDD by any
>>>> x86 emulator H continually repeats the first seven lines
>>>> of DDD until it crashes due to out-of-memory error.
>>>>
>>>
>>> The only reason being that HH, although required to halt, does not
>>> halt, but calls DDD recursively until it is aborted.
>>
>> Try rereading this again and again until to understand and remember
>> all of its words unless you fully intend to stay in rebuttal mode
>> against the verified facts. In that case I will quit replying to
>> your messages.
>>
>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>> If simulating halt decider H correctly simulates its input D
>> until H correctly determines that its simulated D would never
>> stop running unless aborted then
>>
>> H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>
> Which uses a DIFFERENT defintion of "Correct Simulation" then you do, so
> you can't apply it the way you try.
>
I prove that DD is correctly simulated by HH and
your "rebuttal" is refusal to look at this proof.
*Cease and desist calling my simulation incorrect*
On 6/5/2024 10:58 PM, Richard Damon wrote:
> On 6/5/24 11:44 PM, olcott wrote:
>>
>> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>
> But, as I said, I won't acknowledge that you
> are correct, because I am not willing to put
> that effort into your worthless claim.
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 10:46 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41qsg$3cg3s$6@i2pn2.org> |
| In reply to | #106688 |
On 6/8/24 10:05 AM, olcott wrote:
> On 6/8/2024 8:47 AM, Richard Damon wrote:
>> On 6/8/24 9:16 AM, olcott wrote:
>>> On 6/8/2024 7:41 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 14:20 schreef olcott:
>>>>> On 6/7/2024 11:18 PM, wij wrote:
>>>>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [ .... ]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>>>>> Less than a
>>>>>>>>>>>>>> few
>>>>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>>>>> instructions"
>>>>>>>>>>>>>> simulated (without ever specifying what you meant by N).
>>>>>>>>>>>>>> It seems that
>>>>>>>>>>>>>> the simulation of exactly one instruction would have met
>>>>>>>>>>>>>> your criterion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>>>
>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>>
>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>>>>
>>>>>>>>>>> More dishonest deflection.
>>>>>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>>>>>> correctly
>>>>>>>>>>> simulated by HH and this is not the same behavior as the
>>>>>>>>>>> directly
>>>>>>>>>>> executed DD(DD).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>>>> ELSE HP is undecidable
>>>>>>>>>>
>>>>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>>>>
>>>>>>>>>> Surrender to my GUR, son.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If people are going to be dishonest about simple things
>>>>>>>>> such as the actual behavior of actual x86 code where
>>>>>>>>> they consistently deny verified facts
>>>>>>>>>
>>>>>>>>> then we certainly cannot trust these people with more
>>>>>>>>> difficult issues that require at least some slight degree
>>>>>>>>> of judgment call.
>>>>>>>>>
>>>>>>>>> When we can show that even in the halting problem HH
>>>>>>>>> is only required to report on the behavior of DD correctly
>>>>>>>>> simulated by HH these dishonest people merely use that
>>>>>>>>> as another deflection point for their dishonesty.
>>>>>>>>>
>>>>>>>>> The way around this that just worked is to stay diligently
>>>>>>>>> focused one one single point until the dishonest people
>>>>>>>>> finally admit that they have simply ignored all the proofs
>>>>>>>>> for three solid years.
>>>>>>>>>
>>>>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>>>>> >>
>>>>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>>>>> >
>>>>>>>>> > But, as I said, I won't acknowledge that you
>>>>>>>>> > are correct, because I am not willing to put
>>>>>>>>> > that effort into your worthless claim.
>>>>>>>>> >
>>>>>>>>>
>>>>>>>>> Here is the earliest version of the proof (that everyone
>>>>>>>>> has simply ignored for three solid years) that P correctly
>>>>>>>>> simulated by H would never stop running unless aborted.
>>>>>>>>>
>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The fact that the execution trace of P derived by the executed
>>>>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>>>>> proves that each instruction of P was simulated correctly and
>>>>>>>>> in the correct order this conclusively proves that P is correctly
>>>>>>>>> simulated by both of these instances of H.
>>>>>>>>>
>>>>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>>>>> assumption.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>
>>>>>>>>> _DD()
>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>
>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>
>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I recalled now. You knew what the Halting Problem is. But soon,
>>>>>>>> you started to insist
>>>>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>>>>> Wake up, your trick won't work.
>>>>>>>>
>>>>>>>
>>>>>>> All the while that you insist on lying about
>>>>>>>
>>>>>>> the verified fact that DD correctly simulated by
>>>>>>> HH cannot possibly stop running without having its
>>>>>>> simulation aborted by HH.
>>>>>>>
>>>>>>> You won't get to talk to me about anything else such
>>>>>>> as why the above statement matters.
>>>>>>>
>>>>>>> If you want to choose to be a liar thus <is> the
>>>>>>> consequence that you get.
>>>>>>>
>>>>>>
>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>> ELSE HP is undecidable
>>>>>>
>>>>>> What is your answer? (the last time I saw POOH, it does not report
>>>>>> anything)
>>>>>>
>>>>>
>>>>> I incorporate by reference
>>>>> (a) The x86 language
>>>>> (b) The notion of an x86 emulator
>>>>>
>>>>> (c) I provide this complete function
>>>>>
>>>>> void DDD(int (*x)())
>>>>> {
>>>>> HH(x, x);
>>>>> }
>>>>>
>>>>> _DDD()
>>>>> [00001de2] 55 push ebp
>>>>> [00001de3] 8bec mov ebp,esp
>>>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>>>> [00001de8] 50 push eax ; push DD
>>>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>>>> [00001dec] 51 push ecx ; push DD
>>>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>>>> [00001df2] 83c408 add esp,+08
>>>>> [00001df5] 5d pop ebp
>>>>> [00001df6] c3 ret
>>>>> Size in bytes:(0021) [00001df6]
>>>>>
>>>>> Then I state that No DDD correctly emulated by any
>>>>> x86 emulator H can possibly reach its own [00001df6]
>>>>> instruction.
>>>>>
>>>>> To anyone having this mandatory prerequisite knowledge
>>>>> (perhaps not you) every x86 emulation of DDD by any
>>>>> x86 emulator H continually repeats the first seven lines
>>>>> of DDD until it crashes due to out-of-memory error.
>>>>>
>>>>
>>>> The only reason being that HH, although required to halt, does not
>>>> halt, but calls DDD recursively until it is aborted.
>>>
>>> Try rereading this again and again until to understand and remember
>>> all of its words unless you fully intend to stay in rebuttal mode
>>> against the verified facts. In that case I will quit replying to
>>> your messages.
>>>
>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>> If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never
>>> stop running unless aborted then
>>>
>>> H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>
>> Which uses a DIFFERENT defintion of "Correct Simulation" then you do,
>> so you can't apply it the way you try.
>>
>
> I prove that DD is correctly simulated by HH and
> your "rebuttal" is refusal to look at this proof.
> *Cease and desist calling my simulation incorrect*
No you don't, you CLAIM it to be true.
You have not shown a finite sequence of truth-perserving operations from
the truth-makers of the system to your claim.
And I suspect you can never do this.
>
> On 6/5/2024 10:58 PM, Richard Damon wrote:
> > On 6/5/24 11:44 PM, olcott wrote:
> >>
> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
> >
> > But, as I said, I won't acknowledge that you
> > are correct, because I am not willing to put
> > that effort into your worthless claim.
Note, my statement here is to neither affirm or deny your claim, I just
point out that you haven't PROVEN it, which is a true fact.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 09:03 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41kqk$3cg3t$6@i2pn2.org> |
| In reply to | #106640 |
On 6/8/24 8:20 AM, olcott wrote:
> On 6/7/2024 11:18 PM, wij wrote:
>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>> On 6/7/2024 2:43 PM, wij wrote:
>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>
>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>
>>>>>>>>>> [ .... ]
>>>>>>>>>>
>>>>>>>>>>> _DD()
>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>
>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>
>>>>>>>>>> That's a bit of sudden and substantial change, isn't it? Less
>>>>>>>>>> than a
>>>>>>>>>> few
>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>> instructions"
>>>>>>>>>> simulated (without ever specifying what you meant by N). It
>>>>>>>>>> seems that
>>>>>>>>>> the simulation of exactly one instruction would have met your
>>>>>>>>>> criterion.
>>>>>>>>>>
>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>
>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>
>>>>>>>>> _DD()
>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>
>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>
>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>
>>>>>>> More dishonest deflection.
>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>> correctly
>>>>>>> simulated by HH and this is not the same behavior as the directly
>>>>>>> executed DD(DD).
>>>>>>>
>>>>>>
>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>> ELSE HP is undecidable
>>>>>>
>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>
>>>>>> Surrender to my GUR, son.
>>>>>>
>>>>>
>>>>> If people are going to be dishonest about simple things
>>>>> such as the actual behavior of actual x86 code where
>>>>> they consistently deny verified facts
>>>>>
>>>>> then we certainly cannot trust these people with more
>>>>> difficult issues that require at least some slight degree
>>>>> of judgment call.
>>>>>
>>>>> When we can show that even in the halting problem HH
>>>>> is only required to report on the behavior of DD correctly
>>>>> simulated by HH these dishonest people merely use that
>>>>> as another deflection point for their dishonesty.
>>>>>
>>>>> The way around this that just worked is to stay diligently
>>>>> focused one one single point until the dishonest people
>>>>> finally admit that they have simply ignored all the proofs
>>>>> for three solid years.
>>>>>
>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>> >>
>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>> >
>>>>> > But, as I said, I won't acknowledge that you
>>>>> > are correct, because I am not willing to put
>>>>> > that effort into your worthless claim.
>>>>> >
>>>>>
>>>>> Here is the earliest version of the proof (that everyone
>>>>> has simply ignored for three solid years) that P correctly
>>>>> simulated by H would never stop running unless aborted.
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation
>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>
>>>>>
>>>>> The fact that the execution trace of P derived by the executed
>>>>> H and the simulated H exactly matches the machine code of P
>>>>> proves that each instruction of P was simulated correctly and
>>>>> in the correct order this conclusively proves that P is correctly
>>>>> simulated by both of these instances of H.
>>>>>
>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>> sure to ignore this proof so that they can maintain their false
>>>>> assumption.
>>>>>
>>>>>
>>>>>
>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>> stops running without having its simulation aborted by HH.
>>>>>
>>>>> _DD()
>>>>> [00001e12] 55 push ebp
>>>>> [00001e13] 8bec mov ebp,esp
>>>>> [00001e15] 51 push ecx
>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>> [00001e19] 50 push eax ; push DD
>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>> [00001e1d] 51 push ecx ; push DD
>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>
>>>>> A {correct simulation} means that each instruction of the
>>>>> above x86 machine language of DD is correctly simulated
>>>>> by HH and simulated in the correct order.
>>>>>
>>>>> Anyone claiming that HH should report on the behavior
>>>>> of the directly executed DD(DD) is requiring a violation
>>>>> of the above definition of correct simulation.
>>>>>
>>>>
>>>> I recalled now. You knew what the Halting Problem is. But soon, you
>>>> started to insist
>>>> POOH is correct by fabricating ...(lots of things)...
>>>> Wake up, your trick won't work.
>>>>
>>>
>>> All the while that you insist on lying about
>>>
>>> the verified fact that DD correctly simulated by
>>> HH cannot possibly stop running without having its
>>> simulation aborted by HH.
>>>
>>> You won't get to talk to me about anything else such
>>> as why the above statement matters.
>>>
>>> If you want to choose to be a liar thus <is> the
>>> consequence that you get.
>>>
>>
>> The Halting Problem asks for a program H (precisely a TM) that:
>> IF H(D,D)==1, THEN D(D) will return.
>> ELSE If H(D,D)==0, THEN D(D) will never return.
>> ELSE HP is undecidable
>>
>> What is your answer? (the last time I saw POOH, it does not report
>> anything)
>>
>
> I incorporate by reference
> (a) The x86 language
> (b) The notion of an x86 emulator
>
> (c) I provide this complete function
And what do you do with them?
>
> void DDD(int (*x)())
> {
> HH(x, x);
> }
>
> _DDD()
> [00001de2] 55 push ebp
> [00001de3] 8bec mov ebp,esp
> [00001de5] 8b4508 mov eax,[ebp+08]
> [00001de8] 50 push eax ; push DD
> [00001de9] 8b4d08 mov ecx,[ebp+08]
> [00001dec] 51 push ecx ; push DD
> [00001ded] e890f5ffff call 00001382 ; call HH
> [00001df2] 83c408 add esp,+08
> [00001df5] 5d pop ebp
> [00001df6] c3 ret
> Size in bytes:(0021) [00001df6]
>
> Then I state that No DDD correctly emulated by any
> x86 emulator H can possibly reach its own [00001df6]
> instruction.
Which isn't a truth preserving operations from the truth-makers to
something, Just a claim, so not a proof.
And proving a negative is hard.
>
> To anyone having this mandatory prerequisite knowledge
> (perhaps not you) every x86 emulation of DDD by any
> x86 emulator H continually repeats the first seven lines
> of DDD until it crashes due to out-of-memory error.
>
But only if HH NEVER aborts its simulation.
Remember, DD is built on the actaul decider that you are claiming to
give the correct answer.
So the one case you can show is non-halting, is also the same case that
doesn't answer.
You are just showing how ignorant you are of the thing you are talking
about.
You don't know how to write a proof.
You don't understand what deciders are and what is their input.
You don't understand that halt decider work on PROGRAMS, which are
complete, and not just templates.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-08 08:36 -0500 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41mp8$2kanc$5@dont-email.me> |
| In reply to | #106654 |
On 6/8/2024 8:03 AM, Richard Damon wrote:
> On 6/8/24 8:20 AM, olcott wrote:
>> On 6/7/2024 11:18 PM, wij wrote:
>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>
>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>> [ .... ]
>>>>>>>>>>>
>>>>>>>>>>>> _DD()
>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>
>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>
>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>> Less than a
>>>>>>>>>>> few
>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>> instructions"
>>>>>>>>>>> simulated (without ever specifying what you meant by N). It
>>>>>>>>>>> seems that
>>>>>>>>>>> the simulation of exactly one instruction would have met your
>>>>>>>>>>> criterion.
>>>>>>>>>>>
>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>
>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>
>>>>>>>>>> _DD()
>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>
>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>
>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>
>>>>>>>> More dishonest deflection.
>>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>>> correctly
>>>>>>>> simulated by HH and this is not the same behavior as the directly
>>>>>>>> executed DD(DD).
>>>>>>>>
>>>>>>>
>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>> ELSE HP is undecidable
>>>>>>>
>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>
>>>>>>> Surrender to my GUR, son.
>>>>>>>
>>>>>>
>>>>>> If people are going to be dishonest about simple things
>>>>>> such as the actual behavior of actual x86 code where
>>>>>> they consistently deny verified facts
>>>>>>
>>>>>> then we certainly cannot trust these people with more
>>>>>> difficult issues that require at least some slight degree
>>>>>> of judgment call.
>>>>>>
>>>>>> When we can show that even in the halting problem HH
>>>>>> is only required to report on the behavior of DD correctly
>>>>>> simulated by HH these dishonest people merely use that
>>>>>> as another deflection point for their dishonesty.
>>>>>>
>>>>>> The way around this that just worked is to stay diligently
>>>>>> focused one one single point until the dishonest people
>>>>>> finally admit that they have simply ignored all the proofs
>>>>>> for three solid years.
>>>>>>
>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>> >>
>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>> >
>>>>>> > But, as I said, I won't acknowledge that you
>>>>>> > are correct, because I am not willing to put
>>>>>> > that effort into your worthless claim.
>>>>>> >
>>>>>>
>>>>>> Here is the earliest version of the proof (that everyone
>>>>>> has simply ignored for three solid years) that P correctly
>>>>>> simulated by H would never stop running unless aborted.
>>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>
>>>>>>
>>>>>> The fact that the execution trace of P derived by the executed
>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>> proves that each instruction of P was simulated correctly and
>>>>>> in the correct order this conclusively proves that P is correctly
>>>>>> simulated by both of these instances of H.
>>>>>>
>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>> assumption.
>>>>>>
>>>>>>
>>>>>>
>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>> stops running without having its simulation aborted by HH.
>>>>>>
>>>>>> _DD()
>>>>>> [00001e12] 55 push ebp
>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>> [00001e15] 51 push ecx
>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>> [00001e19] 50 push eax ; push DD
>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>
>>>>>> A {correct simulation} means that each instruction of the
>>>>>> above x86 machine language of DD is correctly simulated
>>>>>> by HH and simulated in the correct order.
>>>>>>
>>>>>> Anyone claiming that HH should report on the behavior
>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>> of the above definition of correct simulation.
>>>>>>
>>>>>
>>>>> I recalled now. You knew what the Halting Problem is. But soon, you
>>>>> started to insist
>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>> Wake up, your trick won't work.
>>>>>
>>>>
>>>> All the while that you insist on lying about
>>>>
>>>> the verified fact that DD correctly simulated by
>>>> HH cannot possibly stop running without having its
>>>> simulation aborted by HH.
>>>>
>>>> You won't get to talk to me about anything else such
>>>> as why the above statement matters.
>>>>
>>>> If you want to choose to be a liar thus <is> the
>>>> consequence that you get.
>>>>
>>>
>>> The Halting Problem asks for a program H (precisely a TM) that:
>>> IF H(D,D)==1, THEN D(D) will return.
>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>> ELSE HP is undecidable
>>>
>>> What is your answer? (the last time I saw POOH, it does not report
>>> anything)
>>>
>>
>> I incorporate by reference
>> (a) The x86 language
>> (b) The notion of an x86 emulator
>>
>> (c) I provide this complete function
>
> And what do you do with them?
>
>>
>> void DDD(int (*x)())
>> {
>> HH(x, x);
>> }
>>
>> _DDD()
>> [00001de2] 55 push ebp
>> [00001de3] 8bec mov ebp,esp
>> [00001de5] 8b4508 mov eax,[ebp+08]
>> [00001de8] 50 push eax ; push DD
>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>> [00001dec] 51 push ecx ; push DD
>> [00001ded] e890f5ffff call 00001382 ; call HH
>> [00001df2] 83c408 add esp,+08
>> [00001df5] 5d pop ebp
>> [00001df6] c3 ret
>> Size in bytes:(0021) [00001df6]
>>
>> Then I state that No DDD correctly emulated by any
>> x86 emulator H can possibly reach its own [00001df6]
>> instruction.
>
> Which isn't a truth preserving operations from the truth-makers to
> something, Just a claim, so not a proof.
>
> And proving a negative is hard.
>
>>
>> To anyone having this mandatory prerequisite knowledge
>> (perhaps not you) every x86 emulation of DDD by any
>> x86 emulator H continually repeats the first seven lines
>> of DDD until it crashes due to out-of-memory error.
>>
>
> But only if HH NEVER aborts its simulation.
>
When HH sees what we see that DDD correctly simulated by HH
can never reach its own machine address in any finite number
of steps of correct simulation and HH sees this by recognizing
the non-halting behavior pattern in a finite sequence of steps
then HH is correct to abort its simulation and reject DDD
as non-halting.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 09:50 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v41nk2$3cg3t$16@i2pn2.org> |
| In reply to | #106670 |
On 6/8/24 9:36 AM, olcott wrote:
> On 6/8/2024 8:03 AM, Richard Damon wrote:
>> On 6/8/24 8:20 AM, olcott wrote:
>>> On 6/7/2024 11:18 PM, wij wrote:
>>>> On Fri, 2024-06-07 at 15:01 -0500, olcott wrote:
>>>>> On 6/7/2024 2:43 PM, wij wrote:
>>>>>> On Fri, 2024-06-07 at 14:31 -0500, olcott wrote:
>>>>>>> On 6/7/2024 1:57 PM, wij wrote:
>>>>>>>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>>>>>>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>>>>>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>>>>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>>>
>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> [ .... ]
>>>>>>>>>>>>
>>>>>>>>>>>>> _DD()
>>>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>>
>>>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>>
>>>>>>>>>>>> That's a bit of sudden and substantial change, isn't it?
>>>>>>>>>>>> Less than a
>>>>>>>>>>>> few
>>>>>>>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>>>>>>>> instructions"
>>>>>>>>>>>> simulated (without ever specifying what you meant by N). It
>>>>>>>>>>>> seems that
>>>>>>>>>>>> the simulation of exactly one instruction would have met
>>>>>>>>>>>> your criterion.
>>>>>>>>>>>>
>>>>>>>>>>>> That now seems to have changed.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because I am a relatively terrible writer I must constantly
>>>>>>>>>>> improve my words on the basis of reviews.
>>>>>>>>>>>
>>>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>>>>
>>>>>>>>>>> _DD()
>>>>>>>>>>> [00001e12] 55 push ebp
>>>>>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>>>>>> [00001e15] 51 push ecx
>>>>>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>>>>>
>>>>>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>>>>>> by HH and simulated in the correct order.
>>>>>>>>>>>
>>>>>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>>>>>> of the above definition of correct simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And thus you admit that HH is not a Halt Decider,
>>>>>>>>>
>>>>>>>>> More dishonest deflection.
>>>>>>>>> The point that I made and you try to deflect using the strawman
>>>>>>>>> deception as a fake rebuttal is the I just proved that DD is
>>>>>>>>> correctly
>>>>>>>>> simulated by HH and this is not the same behavior as the directly
>>>>>>>>> executed DD(DD).
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>>>>>> IF H(D,D)==1, THEN D(D) will return.
>>>>>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>>>>>> ELSE HP is undecidable
>>>>>>>>
>>>>>>>> You keep solving POOH !!! and made lots of lies.
>>>>>>>>
>>>>>>>> Surrender to my GUR, son.
>>>>>>>>
>>>>>>>
>>>>>>> If people are going to be dishonest about simple things
>>>>>>> such as the actual behavior of actual x86 code where
>>>>>>> they consistently deny verified facts
>>>>>>>
>>>>>>> then we certainly cannot trust these people with more
>>>>>>> difficult issues that require at least some slight degree
>>>>>>> of judgment call.
>>>>>>>
>>>>>>> When we can show that even in the halting problem HH
>>>>>>> is only required to report on the behavior of DD correctly
>>>>>>> simulated by HH these dishonest people merely use that
>>>>>>> as another deflection point for their dishonesty.
>>>>>>>
>>>>>>> The way around this that just worked is to stay diligently
>>>>>>> focused one one single point until the dishonest people
>>>>>>> finally admit that they have simply ignored all the proofs
>>>>>>> for three solid years.
>>>>>>>
>>>>>>> On 6/5/2024 10:58 PM, Richard Damon wrote:
>>>>>>> > On 6/5/24 11:44 PM, olcott wrote:
>>>>>>> >>
>>>>>>> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
>>>>>>> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
>>>>>>> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
>>>>>>> >
>>>>>>> > But, as I said, I won't acknowledge that you
>>>>>>> > are correct, because I am not willing to put
>>>>>>> > that effort into your worthless claim.
>>>>>>> >
>>>>>>>
>>>>>>> Here is the earliest version of the proof (that everyone
>>>>>>> has simply ignored for three solid years) that P correctly
>>>>>>> simulated by H would never stop running unless aborted.
>>>>>>>
>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>
>>>>>>>
>>>>>>> The fact that the execution trace of P derived by the executed
>>>>>>> H and the simulated H exactly matches the machine code of P
>>>>>>> proves that each instruction of P was simulated correctly and
>>>>>>> in the correct order this conclusively proves that P is correctly
>>>>>>> simulated by both of these instances of H.
>>>>>>>
>>>>>>> It has proved this since 2021-09-26 and everyone has made
>>>>>>> sure to ignore this proof so that they can maintain their false
>>>>>>> assumption.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>
>>>>>>> _DD()
>>>>>>> [00001e12] 55 push ebp
>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>> [00001e15] 51 push ecx
>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>>
>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>> by HH and simulated in the correct order.
>>>>>>>
>>>>>>> Anyone claiming that HH should report on the behavior
>>>>>>> of the directly executed DD(DD) is requiring a violation
>>>>>>> of the above definition of correct simulation.
>>>>>>>
>>>>>>
>>>>>> I recalled now. You knew what the Halting Problem is. But soon,
>>>>>> you started to insist
>>>>>> POOH is correct by fabricating ...(lots of things)...
>>>>>> Wake up, your trick won't work.
>>>>>>
>>>>>
>>>>> All the while that you insist on lying about
>>>>>
>>>>> the verified fact that DD correctly simulated by
>>>>> HH cannot possibly stop running without having its
>>>>> simulation aborted by HH.
>>>>>
>>>>> You won't get to talk to me about anything else such
>>>>> as why the above statement matters.
>>>>>
>>>>> If you want to choose to be a liar thus <is> the
>>>>> consequence that you get.
>>>>>
>>>>
>>>> The Halting Problem asks for a program H (precisely a TM) that:
>>>> IF H(D,D)==1, THEN D(D) will return.
>>>> ELSE If H(D,D)==0, THEN D(D) will never return.
>>>> ELSE HP is undecidable
>>>>
>>>> What is your answer? (the last time I saw POOH, it does not report
>>>> anything)
>>>>
>>>
>>> I incorporate by reference
>>> (a) The x86 language
>>> (b) The notion of an x86 emulator
>>>
>>> (c) I provide this complete function
>>
>> And what do you do with them?
>>
>>>
>>> void DDD(int (*x)())
>>> {
>>> HH(x, x);
>>> }
>>>
>>> _DDD()
>>> [00001de2] 55 push ebp
>>> [00001de3] 8bec mov ebp,esp
>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>> [00001de8] 50 push eax ; push DD
>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>> [00001dec] 51 push ecx ; push DD
>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>> [00001df2] 83c408 add esp,+08
>>> [00001df5] 5d pop ebp
>>> [00001df6] c3 ret
>>> Size in bytes:(0021) [00001df6]
>>>
>>> Then I state that No DDD correctly emulated by any
>>> x86 emulator H can possibly reach its own [00001df6]
>>> instruction.
>>
>> Which isn't a truth preserving operations from the truth-makers to
>> something, Just a claim, so not a proof.
>>
>> And proving a negative is hard.
>>
>>>
>>> To anyone having this mandatory prerequisite knowledge
>>> (perhaps not you) every x86 emulation of DDD by any
>>> x86 emulator H continually repeats the first seven lines
>>> of DDD until it crashes due to out-of-memory error.
>>>
>>
>> But only if HH NEVER aborts its simulation.
>>
>
> When HH sees what we see that DDD correctly simulated by HH
> can never reach its own machine address in any finite number
> of steps of correct simulation and HH sees this by recognizing
> the non-halting behavior pattern in a finite sequence of steps
> then HH is correct to abort its simulation and reject DDD
> as non-halting.
>
Except you don't think far enough.
It is only non-halting behavior *IF* H doesn't abort. Once you
contemplate H aborting, you have lost your evidence of non-halting behavior.
The question you are supposed to be answering is the objective one about
the actual behavior of the input when run.
If you have lied (to yourself even) about it being about what H itself
can see, you are deceived and not doing what you are supposed to do.
This just seems natural to you, because you don't understand what Truth
actually is.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-07 15:50 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v3voas$39ri5$21@i2pn2.org> |
| In reply to | #106537 |
On 6/7/24 3:31 PM, olcott wrote:
> On 6/7/2024 1:57 PM, wij wrote:
>> On Fri, 2024-06-07 at 13:41 -0500, olcott wrote:
>>> On 6/7/2024 1:24 PM, Richard Damon wrote:
>>>> On 6/7/24 2:02 PM, olcott wrote:
>>>>> On 6/7/2024 12:50 PM, Alan Mackenzie wrote:
>>>>>> [ Followup-To: set ]
>>>>>>
>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>
>>>>>> [ .... ]
>>>>>>
>>>>>>> _DD()
>>>>>>> [00001e12] 55 push ebp
>>>>>>> [00001e13] 8bec mov ebp,esp
>>>>>>> [00001e15] 51 push ecx
>>>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>>>> [00001e19] 50 push eax ; push DD
>>>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00001e1d] 51 push ecx ; push DD
>>>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>>
>>>>>>> A {correct simulation} means that each instruction of the
>>>>>>> above x86 machine language of DD is correctly simulated
>>>>>>> by HH and simulated in the correct order.
>>>>>>
>>>>>> That's a bit of sudden and substantial change, isn't it? Less than a
>>>>>> few
>>>>>> days ago, you were defining a correct simulation as "1 to N
>>>>>> instructions"
>>>>>> simulated (without ever specifying what you meant by N). It seems
>>>>>> that
>>>>>> the simulation of exactly one instruction would have met your
>>>>>> criterion.
>>>>>>
>>>>>> That now seems to have changed.
>>>>>>
>>>>>
>>>>> Because I am a relatively terrible writer I must constantly
>>>>> improve my words on the basis of reviews.
>>>>>
>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>> stops running without having its simulation aborted by HH.
>>>>>
>>>>> _DD()
>>>>> [00001e12] 55 push ebp
>>>>> [00001e13] 8bec mov ebp,esp
>>>>> [00001e15] 51 push ecx
>>>>> [00001e16] 8b4508 mov eax,[ebp+08]
>>>>> [00001e19] 50 push eax ; push DD
>>>>> [00001e1a] 8b4d08 mov ecx,[ebp+08]
>>>>> [00001e1d] 51 push ecx ; push DD
>>>>> [00001e1e] e85ff5ffff call 00001382 ; call HH
>>>>>
>>>>> A {correct simulation} means that each instruction of the
>>>>> above x86 machine language of DD is correctly simulated
>>>>> by HH and simulated in the correct order.
>>>>>
>>>>> Anyone claiming that HH should report on the behavior
>>>>> of the directly executed DD(DD) is requiring a violation
>>>>> of the above definition of correct simulation.
>>>>>
>>>>
>>>> And thus you admit that HH is not a Halt Decider,
>>>
>>> More dishonest deflection.
>>> The point that I made and you try to deflect using the strawman
>>> deception as a fake rebuttal is the I just proved that DD is correctly
>>> simulated by HH and this is not the same behavior as the directly
>>> executed DD(DD).
>>>
>>
>> The Halting Problem asks for a program H (precisely a TM) that:
>> IF H(D,D)==1, THEN D(D) will return.
>> ELSE If H(D,D)==0, THEN D(D) will never return.
>> ELSE HP is undecidable
>>
>> You keep solving POOH !!! and made lots of lies.
>>
>> Surrender to my GUR, son.
>>
>
> If people are going to be dishonest about simple things
> such as the actual behavior of actual x86 code where
> they consistently deny verified facts
But what have people disagreed about on the actual code.
DO you deny that the actual x86 code when run will halt since your
HH(DD,DD) will return 0 to let it be a decider?
>
> then we certainly cannot trust these people with more
> difficult issues that require at least some slight degree
> of judgment call.
But nothing should require a "judgement call".
>
> When we can show that even in the halting problem HH
> is only required to report on the behavior of DD correctly
> simulated by HH these dishonest people merely use that
> as another deflection point for their dishonesty.
But that is just a LIE, because that isn't the quesiton of the Halting
problem, only of your POOP.
The Halting problem SPECIFICALLY asks the question if the machine
described by the input, that is the direct execution of DD(DD), will
halt or not when run.
Please show your reference that it can be ANYTHING like what you are
claiming, that is just your own pathological lie because you can not
face realitiy.
Since you lie about that, why should anyone believe your statements
about other things.
>
> The way around this that just worked is to stay diligently
> focused one one single point until the dishonest people
> finally admit that they have simply ignored all the proofs
> for three solid years.
>
> On 6/5/2024 10:58 PM, Richard Damon wrote:
> > On 6/5/24 11:44 PM, olcott wrote:
> >>
> >> THIS IS ALL THAT YOU WILL EVER GET TO TALK
> >> TO ME ABOUT UNTIL YOU ACKNOWLEDGE THAT
> >> I AM CORRECT OR YOU PROVE THAT I AM INCORRECT
> >
> > But, as I said, I won't acknowledge that you
> > are correct, because I am not willing to put
> > that effort into your worthless claim.
> >
>
> Here is the earliest version of the proof (that everyone
> has simply ignored for three solid years) that P correctly
> simulated by H would never stop running unless aborted.
Which isn't a proof, but does show a possible origin for your strawman
of why you thought you could change the question.
>
> Halting problem undecidability and infinitely nested simulation
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
> The fact that the execution trace of P derived by the executed
> H and the simulated H exactly matches the machine code of P
> proves that each instruction of P was simulated correctly and
> in the correct order this conclusively proves that P is correctly
> simulated by both of these instances of H.
It shows they were simulated correct for as far as they went.
The simulation of the CALL H is just WRONG,
Either you need to show the actual x86 instructions of HH being simulated,
or the simulation needs to show the equivalent return of HH, which since
you claim it correctly returns 0 would be that.
Any simulation that shows that HH will never return is just wrong, or is
ending with invalid or unsound logic from a correct partial simulation
(which is what sort of happens). Your logic "forgets" that if HH decides
to abort its simulation, then ALL copies of HH will do that an thus not
get stuck in the loop.
So HH either needs to get stuck in that loop by not deciding, and thus
fails to be the needed decider, or it uses incorrect logic to get the
wrong answer.
Which choice will be fixed by the algorithm that HH uses.
>
> It has proved this since 2021-09-26 and everyone has made
> sure to ignore this proof so that they can maintain their false
> assumption.
>
It has shown that you mind was on wrong things since then.
>
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
WHO CARES?
It has been proven that answer doesn't tell us what we need to know, and
is just your strawman.
>
> _DD()
> [00001e12] 55 push ebp
> [00001e13] 8bec mov ebp,esp
> [00001e15] 51 push ecx
> [00001e16] 8b4508 mov eax,[ebp+08]
> [00001e19] 50 push eax ; push DD
> [00001e1a] 8b4d08 mov ecx,[ebp+08]
> [00001e1d] 51 push ecx ; push DD
> [00001e1e] e85ff5ffff call 00001382 ; call HH
>
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
>
> Anyone claiming that HH should report on the behavior
> of the directly executed DD(DD) is requiring a violation
> of the above definition of correct simulation.
>
Which is just an admititon that you are not working on the halting
problem, since that IS based on the behavior of directly executed DD(DD)
and not any form of simulation at all.
So, you are just admitting that all your work is just deceptions and lies.
[toc] | [prev] | [next] | [standalone]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2024-06-07 19:57 +0000 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v3vont$a5e$3@news.muc.de> |
| In reply to | #106537 |
[ Followup-To: set ] In comp.theory olcott <polcott333@gmail.com> wrote: [ .... ] > If people are going to be dishonest about simple things such as the > actual behavior of actual x86 code where they consistently deny > verified facts .... You should stop swearing. "Verified facts" has a meaning, and that meaning isn't "false things Peter Olcott would like to be true". You've been dishonest about verified facts right from the beginning. For example, the Halting Theorem is a conclusively proven verified fact. Your refusing to accept that has just led to an enormous waste of people's time, most notably your own. > .... then we certainly cannot trust these people with more difficult > issues that require at least some slight degree of judgment call. I trust "these people". I do not, and cannot, trust you. > When we can show that even in the halting problem HH > is only required to report on the behavior of DD correctly > simulated by HH these dishonest people merely use that > as another deflection point for their dishonesty. The above is a distortion of the truth. The dishonesty here is not "theirs". > The way around this that just worked is to stay diligently > focused one one single point until the dishonest people > finally admit that they have simply ignored all the proofs > for three solid years. Otherwise known as spamming the newsgroup. The word "proof" also has a meaning, and that meaning isn't "false statements repeated ad nauseam by Peter Olcott". You should stop misusing that word. It means something you don't understand. [ .... ] > -- > Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-07 15:04 -0500 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v3vp3j$27d15$2@dont-email.me> |
| In reply to | #106541 |
On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
> [ Followup-To: set ]
>
> In comp.theory olcott <polcott333@gmail.com> wrote:
>
> [ .... ]
>
>> If people are going to be dishonest about simple things such as the
>> actual behavior of actual x86 code where they consistently deny
>> verified facts ....
>
> You should stop swearing. "Verified facts" has a meaning,
Everyone knows that the following is a verified fact and
they dishonestly deflect.
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.
_DD()
[00001e12] 55 push ebp
[00001e13] 8bec mov ebp,esp
[00001e15] 51 push ecx
[00001e16] 8b4508 mov eax,[ebp+08]
[00001e19] 50 push eax ; push DD
[00001e1a] 8b4d08 mov ecx,[ebp+08]
[00001e1d] 51 push ecx ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
Anyone claiming that HH should report on the behavior
of the directly executed DD(DD) is requiring a violation
of the above definition of correct simulation.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2024-06-07 20:16 +0000 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v3vpqe$a5e$4@news.muc.de> |
| In reply to | #106544 |
olcott <polcott333@gmail.com> wrote:
> On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
>> In comp.theory olcott <polcott333@gmail.com> wrote:
>> [ .... ]
>>> If people are going to be dishonest about simple things such as the
>>> actual behavior of actual x86 code where they consistently deny
>>> verified facts ....
>> You should stop swearing. "Verified facts" has a meaning,
> Everyone knows that the following is a verified fact and
> they dishonestly deflect.
That is untrue. There is at least one person who doesn't know "it's a
verified fact" (me).
What's more it is a lie. You know full well that "the following" has NOT
been verified by anybody. If I am wrong, point out who has done this
verifying, when, how, and what their conclusions were.
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
> _DD()
> [00001e12] 55 push ebp
> [00001e13] 8bec mov ebp,esp
> [00001e15] 51 push ecx
> [00001e16] 8b4508 mov eax,[ebp+08]
> [00001e19] 50 push eax ; push DD
> [00001e1a] 8b4d08 mov ecx,[ebp+08]
> [00001e1d] 51 push ecx ; push DD
> [00001e1e] e85ff5ffff call 00001382 ; call HH
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
> Anyone claiming that HH should report on the behavior
> of the directly executed DD(DD) is requiring a violation
> of the above definition of correct simulation.
> --
> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
> hits a target no one else can see." Arthur Schopenhauer
--
Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-07 17:03 -0500 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v4003n$287qb$2@dont-email.me> |
| In reply to | #106545 |
On 6/7/2024 3:16 PM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>
>>> [ .... ]
>
>>>> If people are going to be dishonest about simple things such as the
>>>> actual behavior of actual x86 code where they consistently deny
>>>> verified facts ....
>
>>> You should stop swearing. "Verified facts" has a meaning,
>
>> Everyone knows that the following is a verified fact and
>> they dishonestly deflect.
>
> That is untrue. There is at least one person who doesn't know "it's a
> verified fact" (me).
>
I should have said more accurately that everyone that understands
this knows it is a verified fact.
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.
_DD()
[00001e12] 55 push ebp
[00001e13] 8bec mov ebp,esp
[00001e15] 51 push ecx
[00001e16] 8b4508 mov eax,[ebp+08]
[00001e19] 50 push eax ; push DD
[00001e1a] 8b4d08 mov ecx,[ebp+08]
[00001e1d] 51 push ecx ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
Anyone claiming that HH should report on the behavior
of the directly executed DD(DD) is requiring a violation
of the above definition of correct simulation.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | immibis <news@immibis.com> |
|---|---|
| Date | 2024-06-08 00:14 +0200 |
| Subject | Re: olcott is a moron |
| Message-ID | <v400nf$27tu1$1@dont-email.me> |
| In reply to | #106557 |
On 8/06/24 00:03, olcott wrote: > I should have said more accurately that everyone that understands > this knows it is a verified fact. > > Try to show how this DD correctly simulated by any HH ever > stops running without having its simulation aborted by HH. This isn't even a fact. It's a command. It can't be true or false because it is a command. It's like saying the number 12 is a verified fact.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-07 19:00 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard |
| Message-ID | <v403f2$39ri6$16@i2pn2.org> |
| In reply to | #106557 |
On 6/7/24 6:03 PM, olcott wrote:
> On 6/7/2024 3:16 PM, Alan Mackenzie wrote:
>> olcott <polcott333@gmail.com> wrote:
>>> On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>
>>>> [ .... ]
>>
>>>>> If people are going to be dishonest about simple things such as the
>>>>> actual behavior of actual x86 code where they consistently deny
>>>>> verified facts ....
>>
>>>> You should stop swearing. "Verified facts" has a meaning,
>>
>>> Everyone knows that the following is a verified fact and
>>> they dishonestly deflect.
>>
>> That is untrue. There is at least one person who doesn't know "it's a
>> verified fact" (me).
>>
>
> I should have said more accurately that everyone that understands
> this knows it is a verified fact.
And that statement is just a lie, as your claim has not be "verified" by
anyone but your own claims.
>
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
And why do we care?
>
> _DD()
> [00001e12] 55 push ebp
> [00001e13] 8bec mov ebp,esp
> [00001e15] 51 push ecx
> [00001e16] 8b4508 mov eax,[ebp+08]
> [00001e19] 50 push eax ; push DD
> [00001e1a] 8b4d08 mov ecx,[ebp+08]
> [00001e1d] 51 push ecx ; push DD
> [00001e1e] e85ff5ffff call 00001382 ; call HH
>
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
>
> Anyone claiming that HH should report on the behavior
> of the directly executed DD(DD) is requiring a violation
> of the above definition of correct simulation.
>
And thus you admit that your H isn't a Halt Decider, as a Halt Decider
MUST report on the behavior of the directly executed machine described
by its input, in this case DD(DD)
That, or we can say that your definition of "Correct Simulation" is in
conflict with the requirements on HH (except that the actual problem
never limits to "by the decider" even when we expand it to include the
concept of simulation.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-07 16:17 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard (we wish) |
| Message-ID | <v3vpsg$39ri6$12@i2pn2.org> |
| In reply to | #106544 |
On 6/7/24 4:04 PM, olcott wrote:
> On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
>> [ Followup-To: set ]
>>
>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>
>> [ .... ]
>>
>>> If people are going to be dishonest about simple things such as the
>>> actual behavior of actual x86 code where they consistently deny
>>> verified facts ....
>>
>> You should stop swearing. "Verified facts" has a meaning,
>
> Everyone knows that the following is a verified fact and
> they dishonestly deflect.
It MIGHT be a fact, but it hasn't been "Verified" as in a formal process
that certifies a statement to be true, or that it has been actually
formally proven.
Pointing out that it is MEANINGLESS is not a "dishonest" deflectin.
>
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
>
> _DD()
> [00001e12] 55 push ebp
> [00001e13] 8bec mov ebp,esp
> [00001e15] 51 push ecx
> [00001e16] 8b4508 mov eax,[ebp+08]
> [00001e19] 50 push eax ; push DD
> [00001e1a] 8b4d08 mov ecx,[ebp+08]
> [00001e1d] 51 push ecx ; push DD
> [00001e1e] e85ff5ffff call 00001382 ; call HH
>
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
>
> Anyone claiming that HH should report on the behavior
> of the directly executed DD(DD) is requiring a violation
> of the above definition of correct simulation.
>
>
Which is just an admittion that you HH isn't even claiming to be a Halt
Decider, as a Halt Decider *IS* required to report on the behavior of
the directly executed DD(DD) from the definition of the problem.
So. I guess we can wrap all this up as you are just admitting that
nothing you have been talking about has actually be based on the actual
Halting Problem, and you have been just spamming the group with attempts
to prove your POOP, which disguising it as sort of like the Halting Problem.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-07 17:11 -0500 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard (we wish) |
| Message-ID | <v400hl$287qb$3@dont-email.me> |
| In reply to | #106546 |
On 6/7/2024 3:17 PM, Richard Damon wrote:
> On 6/7/24 4:04 PM, olcott wrote:
>> On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
>>> [ Followup-To: set ]
>>>
>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>
>>> [ .... ]
>>>
>>>> If people are going to be dishonest about simple things such as the
>>>> actual behavior of actual x86 code where they consistently deny
>>>> verified facts ....
>>>
>>> You should stop swearing. "Verified facts" has a meaning,
>>
>> Everyone knows that the following is a verified fact and
>> they dishonestly deflect.
>
> It MIGHT be a fact, but it hasn't been "Verified" as in a formal process
> that certifies a statement to be true, or that it has been actually
> formally proven.
>
That is great you said that right before I was going to quit
looking at any of your replies. I enjoy talking to you yet not
at the expense of you undermining my life's work.
That it is literally impossible to prove that the following
is false conclusively proves that it is true and the proof
really need not be wrapped in any tuxedo.
We can get on to other key points only after we have closure
on this {foundation of simulating halt deciders} point.
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.
_DD()
[00001e12] 55 push ebp
[00001e13] 8bec mov ebp,esp
[00001e15] 51 push ecx
[00001e16] 8b4508 mov eax,[ebp+08]
[00001e19] 50 push eax ; push DD
[00001e1a] 8b4d08 mov ecx,[ebp+08]
[00001e1d] 51 push ecx ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
Anyone claiming that HH should report on the behavior
of the directly executed DD(DD) is requiring a violation
of the above definition of correct simulation.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-07 18:18 -0400 |
| Subject | Re: At least 100 people kept denying the easily verified fact --- last communication with Richard (we wish) |
| Message-ID | <v4010i$39ri5$23@i2pn2.org> |
| In reply to | #106558 |
On 6/7/24 6:11 PM, olcott wrote:
> On 6/7/2024 3:17 PM, Richard Damon wrote:
>> On 6/7/24 4:04 PM, olcott wrote:
>>> On 6/7/2024 2:57 PM, Alan Mackenzie wrote:
>>>> [ Followup-To: set ]
>>>>
>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>
>>>> [ .... ]
>>>>
>>>>> If people are going to be dishonest about simple things such as the
>>>>> actual behavior of actual x86 code where they consistently deny
>>>>> verified facts ....
>>>>
>>>> You should stop swearing. "Verified facts" has a meaning,
>>>
>>> Everyone knows that the following is a verified fact and
>>> they dishonestly deflect.
>>
>> It MIGHT be a fact, but it hasn't been "Verified" as in a formal
>> process that certifies a statement to be true, or that it has been
>> actually formally proven.
>>
>
> That is great you said that right before I was going to quit
> looking at any of your replies. I enjoy talking to you yet not
> at the expense of you undermining my life's work.
>
> That it is literally impossible to prove that the following
> is false conclusively proves that it is true and the proof
> really need not be wrapped in any tuxedo.
Nope. Just shows you don't understand the meaning of True.
And you are apperently stuck out in the open in your birthday clothes as
it is revealed that you don't understand how logic works.
>
> We can get on to other key points only after we have closure
> on this {foundation of simulating halt deciders} point.
>
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
Again, WHY?
Partial simulation does not prove non-halting.
>
> _DD()
> [00001e12] 55 push ebp
> [00001e13] 8bec mov ebp,esp
> [00001e15] 51 push ecx
> [00001e16] 8b4508 mov eax,[ebp+08]
> [00001e19] 50 push eax ; push DD
> [00001e1a] 8b4d08 mov ecx,[ebp+08]
> [00001e1d] 51 push ecx ; push DD
> [00001e1e] e85ff5ffff call 00001382 ; call HH
>
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
>
> Anyone claiming that HH should report on the behavior
> of the directly executed DD(DD) is requiring a violation
> of the above definition of correct simulation.
>
>
So, you are just admitting that you aren't working on the halting
problem as that DOES require looking at the behavior of the directly
executed DD(DD).
So, you have admitted your defeat.
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-07 22:22 +0000 |
| Subject | Re: At least 100 people kept denying the easily verified fact -- closure |
| Message-ID | <v4016m$3avmq$1@i2pn2.org> |
| In reply to | #106558 |
Am Fri, 07 Jun 2024 17:11:00 -0500 schrieb olcott:
> That it is literally impossible to prove that the following is false
> conclusively proves that it is true and the proof really need not be
> wrapped in any tuxedo.
If you consider it unfalsifiable, why do you care?
> We can get on to other key points only after we have closure on this
> {foundation of simulating halt deciders} point.
What do you need closure for? You only want agreement.
--
joes
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-07 17:35 -0500 |
| Subject | Re: At least 100 people kept denying the easily verified fact -- closure |
| Message-ID | <v401vc$28q9r$2@dont-email.me> |
| In reply to | #106565 |
On 6/7/2024 5:22 PM, joes wrote:
> Am Fri, 07 Jun 2024 17:11:00 -0500 schrieb olcott:
>> That it is literally impossible to prove that the following is false
>> conclusively proves that it is true and the proof really need not be
>> wrapped in any tuxedo.
> If you consider it unfalsifiable, why do you care?
>
The entire body of truth is unfalsifiable.
https://en.wikipedia.org/wiki/Falsifiability
That "cats" <are> "animals" is unfalsifiable because
it is inherently true.
You are conflating empirical with analytical truth.
Scientific principles do not exactly apply to math.
>> We can get on to other key points only after we have closure on this
>> {foundation of simulating halt deciders} point.
> What do you need closure for? You only want agreement.
>
I must get closure on each of the four points of
my proof so that I know that my words can possibly
be understood. Without this publication is hopeless.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 6 of 11 — ← Prev page 1 … 4 5 [6] 7 8 … 11 Next page →
Back to top | Article view | comp.theory
csiph-web