Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #333681 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-05-05 12:02 -0500 |
| Last post | 2024-05-07 03:38 +0200 |
| Articles | 20 on this page of 409 — 11 participants |
Back to article view | Back to sci.logic
Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 12:02 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 13:22 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 13:43 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 17:13 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 14:10 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 17:13 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 16:30 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 17:56 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 17:56 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 19:27 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 20:26 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 22:11 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 22:36 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 23:57 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 21:33 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 23:08 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 23:14 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-06 06:33 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-06 09:57 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-06 22:01 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 17:03 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H --- typo olcott <polcott333@gmail.com> - 2024-05-05 17:05 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 18:44 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 19:35 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 20:47 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 21:34 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 23:15 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 21:42 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 23:03 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 23:01 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-06 06:34 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-06 10:16 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-06 22:08 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 19:53 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 21:36 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 22:29 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 23:47 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 21:36 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 23:05 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H --- olcott <polcott333@gmail.com> - 2024-05-05 23:11 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H --- Richard Damon <richard@damon-family.org> - 2024-05-06 06:33 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H --- olcott <polcott333@gmail.com> - 2024-05-06 09:52 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H --- Richard Damon <richard@damon-family.org> - 2024-05-06 22:11 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 14:40 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 17:13 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-05 16:31 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-05 19:29 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H immibis <news@immibis.com> - 2024-05-07 03:39 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-06 22:00 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-06 23:07 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-06 22:36 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-06 23:55 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-06 22:59 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-07 00:09 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-06 23:13 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-07 07:16 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-07 09:35 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-07 22:46 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ immibis <news@immibis.com> - 2024-05-09 03:33 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H +++ immibis <news@immibis.com> - 2024-05-09 03:32 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 20:44 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-06 13:28 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-06 22:13 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-06 21:36 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-06 23:17 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-06 22:39 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-06 23:55 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-06 22:57 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 00:08 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-06 23:11 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 07:17 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 09:40 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 22:26 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 21:33 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 22:48 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 22:16 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-08 07:38 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 12:31 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 18:42 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 18:30 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 22:29 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 21:39 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 22:51 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-07 22:29 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-07 23:03 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 07:39 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 14:36 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 21:27 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 20:45 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 22:35 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 20:46 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 22:36 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 20:47 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 22:36 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ joes <noreply@example.com> - 2024-05-09 12:34 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 07:39 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 08:21 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ wij <wyniijj5@gmail.com> - 2024-05-08 22:30 +0800
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 22:41 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 21:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 20:33 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-08 22:37 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ olcott <polcott333@gmail.com> - 2024-05-08 22:49 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H @@@ Richard Damon <richard@damon-family.org> - 2024-05-09 07:25 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 19:37 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 22:31 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === olcott <polcott333@gmail.com> - 2024-05-07 21:19 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H === Richard Damon <richard@damon-family.org> - 2024-05-07 22:32 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H === immibis <news@immibis.com> - 2024-05-09 03:35 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-07 10:40 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-07 18:31 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-07 12:02 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-07 22:42 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-07 22:39 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-07 20:54 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-07 14:05 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-07 22:40 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-07 16:23 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-08 11:07 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-08 08:07 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-08 20:48 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-08 21:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-08 14:23 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-08 21:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-09 08:43 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-09 07:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H --- Mutually honest dialogue olcott <polcott333@gmail.com> - 2024-05-09 14:15 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H --- Mutually honest dialogue Richard Damon <richard@damon-family.org> - 2024-05-09 22:31 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H --- Mutually honest dialogue olcott <polcott333@gmail.com> - 2024-05-09 22:23 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H --- Mutually honest dialogue Richard Damon <richard@damon-family.org> - 2024-05-10 10:18 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-07 22:43 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-08 08:01 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-08 16:13 +0100
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-08 14:05 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### immibis <news@immibis.com> - 2024-05-09 03:38 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-09 10:38 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-09 22:31 -0400
Richard tried to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-09 22:10 -0500
Re: Olcott doesn't understand logic Richard Damon <richard@damon-family.org> - 2024-05-10 10:18 -0400
Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-10 10:50 -0500
Re: Richard KEEPS TRYING to get away with this falsehood Richard Damon <richard@damon-family.org> - 2024-05-10 12:12 -0400
Re: Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-10 12:49 -0500
Olcott keeps on lying. Richard Damon <richard@damon-family.org> - 2024-05-10 16:09 -0400
Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-10 15:27 -0500
Re: Richard KEEPS TRYING to get away with this falsehood Richard Damon <richard@damon-family.org> - 2024-05-10 16:50 -0400
Re: Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-10 16:11 -0500
Olcott thinks something isn't iteself. Richard Damon <richard@damon-family.org> - 2024-05-10 17:19 -0400
Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-10 16:43 -0500
Olcott can't tell the difference between a machine and an infinte set of machines Richard Damon <richard@damon-family.org> - 2024-05-10 17:59 -0400
Richard KEEPS TRYING to get away with falsehood olcott <polcott333@gmail.com> - 2024-05-10 17:28 -0500
Olcott thinks One is Infinity Richard Damon <richard@damon-family.org> - 2024-05-10 18:39 -0400
Richard seems to be a liar. olcott <polcott333@gmail.com> - 2024-05-10 18:39 -0500
Olcott doesn't know the difference between an element an the set Richard Damon <richard@damon-family.org> - 2024-05-10 22:17 -0400
Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-10 21:21 -0500
Re: Is Richard a Liar? No, but Olcott is. Richard Damon <richard@damon-family.org> - 2024-05-10 22:39 -0400
Richard must be educated on what a termination analyzer is olcott <polcott333@gmail.com> - 2024-05-10 21:49 -0500
Olcott admits to creating defintion out of his *ss Richard Damon <richard@damon-family.org> - 2024-05-10 23:16 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-11 11:26 -0500
Re: Is Oclott a Liar? Richard Damon <richard@damon-family.org> - 2024-05-11 12:46 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-12 08:51 -0500
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 09:32 -0500
Re: Is Richard a Liar? Alan Mackenzie <acm@muc.de> - 2024-05-14 15:08 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 10:45 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-14 18:13 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 12:14 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-14 19:49 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 12:52 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-14 20:30 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 13:40 -0500
Re: Is Richard a Liar? joes <noreply@example.com> - 2024-05-14 19:01 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 14:34 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 10:10 -0500
Re: Is Richard a Liar? joes <noreply@example.com> - 2024-05-15 16:20 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 11:59 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-16 12:14 +0300
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 10:34 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-16 17:53 +0200
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Every D correctly simulated by H never reaches its final state and halts V2 olcott <polcott333@gmail.com> - 2024-05-17 11:27 -0500
Re: Every D correctly simulated by H never reaches its final state and halts V2 Richard Damon <richard@damon-family.org> - 2024-05-17 21:06 -0400
Re: Every D correctly simulated by H never reaches its final state and halts V2 Mikko <mikko.levanto@iki.fi> - 2024-05-18 10:48 +0300
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-17 19:27 +0300
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 13:18 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-18 12:18 +0300
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-14 21:36 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 14:42 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-14 22:05 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 15:13 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-15 08:21 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 09:02 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-15 16:50 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 11:27 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-15 20:19 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 13:39 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-15 21:13 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 15:10 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-16 08:41 +0200
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-16 12:27 +0300
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 10:17 -0500
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-17 19:32 +0300
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 13:24 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-18 11:39 +0300
Re: Is Richard a Liar? joes <noreply@example.com> - 2024-05-18 10:12 +0000
Re: Is Richard a Liar? immibis <news@immibis.com> - 2024-05-18 10:55 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-18 10:27 -0500
Re: Is Richard a Liar? Richard Damon <richard@damon-family.org> - 2024-05-18 11:31 -0400
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-16 12:36 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 09:54 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-16 17:12 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 11:04 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-16 20:55 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 14:32 -0500
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-17 09:41 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 10:31 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-17 18:24 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 12:18 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-17 21:02 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 14:34 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-17 21:06 -0400
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-18 10:58 +0300
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-18 10:45 +0200
Re: Is Richard a Liar? joes <noreply@example.com> - 2024-05-18 10:43 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-18 10:34 -0500
Re: Is Richard a Liar? Richard Damon <richard@damon-family.org> - 2024-05-18 11:40 -0400
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-18 14:13 +0200
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: Olcott is a Liar? Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
No Message-ID therefore construed as Liar olcott <polcott333@gmail.com> - 2024-05-17 23:05 -0500
Re: No Message-ID therefore construed as Liar Richard Damon <richard@damon-family.org> - 2024-05-18 07:24 -0400
Re: No Message-ID therefore construed as Liar olcott <polcott333@gmail.com> - 2024-05-18 07:53 -0500
Re: No Message-ID therefore construed as Liar. Message ID Provided, so OLCOTT is the LIAR. Richard Damon <richard@damon-family.org> - 2024-05-18 09:13 -0400
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-17 10:26 +0200
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 10:38 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-17 11:31 -0500
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-18 11:09 +0300
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 11:56 -0500
Re: Is Richard a Liar? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-15 20:26 +0200
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Is Richard a Liar? joes <noreply@example.com> - 2024-05-15 06:27 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 09:09 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 10:47 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 10:43 -0500
Re: Is Richard a Liar? joes <noreply@example.com> - 2024-05-15 16:26 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 12:04 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Is Richard a Liar? Mikko <mikko.levanto@iki.fi> - 2024-05-16 12:39 +0300
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 10:10 -0500
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:16 -0400
Re: Is Richard a Liar? No! Alan Mackenzie <acm@muc.de> - 2024-05-15 13:40 +0000
Re: Is Richard a Liar? No! olcott <polcott333@gmail.com> - 2024-05-15 09:16 -0500
Re: Is Richard a Liar? No! Alan Mackenzie <acm@muc.de> - 2024-05-15 14:54 +0000
Re: Is Richard a Liar? No! olcott <polcott333@gmail.com> - 2024-05-15 11:34 -0500
Re: Is Richard a Liar? No! Alan Mackenzie <acm@muc.de> - 2024-05-15 17:04 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 12:10 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Is Richard a Liar? No! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 11:57 -0500
Re: Is Richard a Liar? Alan Mackenzie <acm@muc.de> - 2024-05-15 18:04 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 13:33 -0500
Re: Is Richard a Liar? Alan Mackenzie <acm@muc.de> - 2024-05-15 19:29 +0000
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-15 15:18 -0500
Re: Is Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Is Richard a Liar? No! Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Is Richard a Liar? No! olcott <polcott333@gmail.com> - 2024-05-15 09:19 -0500
Re: Is Richard a Liar? No! (Glad you argree) Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Olcott is a Pathological Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Unconventional partial halt decider and grounding to a truthmaker olcott <polcott333@gmail.com> - 2024-05-16 09:48 -0500
Re: Unconventional partial halt decider and grounding to a truthmaker Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Unconventional partial halt decider and grounding to a truthmaker joes <noreply@example.com> - 2024-05-17 07:09 +0000
Re: Unconventional partial halt decider and grounding to a truthmaker Ben Bacarisse <ben@bsb.me.uk> - 2024-05-17 13:50 +0100
Re: Unconventional partial halt decider and grounding to a truthmaker olcott <polcott333@gmail.com> - 2024-05-17 10:28 -0500
Re: Unconventional partial halt decider and grounding to a truthmaker -- Reply to Ben's long standing objection olcott <polcott333@gmail.com> - 2024-05-17 13:42 -0500
Reply to Ben's long standing objection --- I finally have the words olcott <polcott333@gmail.com> - 2024-05-17 13:46 -0500
Re: Reply to Ben's long standing objection --- I finally have the words Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: Unconventional partial halt decider and grounding to a truthmaker olcott <polcott333@gmail.com> - 2024-05-17 12:01 -0500
Re: Unconventional partial halt decider and grounding to a truthmaker Mikko <mikko.levanto@iki.fi> - 2024-05-18 11:23 +0300
Re: Nature of undecidable halting --- Connecting truth-bearers to their truthmaker olcott <polcott333@gmail.com> - 2024-05-16 10:00 -0500
Re: Nature of undecidable halting --- Connecting truth-bearers to their truthmaker Richard Damon <richard@damon-family.org> - 2024-05-16 23:11 -0400
Re: Nature of undecidable halting ---Handling undecidable inputs olcott <polcott333@gmail.com> - 2024-05-17 11:49 -0500
Re: Nature of undecidable halting ---Handling undecidable inputs Richard Damon <richard@damon-family.org> - 2024-05-17 21:06 -0400
Re: Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-16 09:37 -0500
Re: Olcott is a patholgociat liar! Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: Richard KEEPS TRYING to get away with this falsehood immibis <news@immibis.com> - 2024-05-13 06:53 +0200
Re: Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-13 08:19 -0500
Re: Richard KEEPS TRYING to get away with this falsehood immibis <news@immibis.com> - 2024-05-13 23:49 +0200
Re: Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-13 17:51 -0500
Re: Richard KEEPS TRYING to get away with this falsehood immibis <news@immibis.com> - 2024-05-14 02:17 +0200
Re: Richard KEEPS TRYING to get away with this falsehood olcott <polcott333@gmail.com> - 2024-05-13 19:37 -0500
Re: Olcott KEEPS LYING about Richard not refuting his statemnt. Richard Damon <richard@damon-family.org> - 2024-05-13 21:51 -0400
Re: Olcott KEEPS TRYING to get away with this falsehood Richard Damon <richard@damon-family.org> - 2024-05-13 20:29 -0400
Re: Olcott KEEPS TRYING to get away with this falsehood Richard Damon <richard@damon-family.org> - 2024-05-13 20:30 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### Alan Mackenzie <acm@muc.de> - 2024-05-10 17:55 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-10 13:01 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Alan Mackenzie <acm@muc.de> - 2024-05-10 18:38 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-10 14:16 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-10 16:09 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### Alan Mackenzie <acm@muc.de> - 2024-05-11 09:48 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-11 10:02 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-11 11:36 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-11 11:48 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-11 12:58 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H +++ olcott <polcott333@gmail.com> - 2024-05-11 12:36 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H +++ Richard Damon <richard@damon-family.org> - 2024-05-11 19:25 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### Alan Mackenzie <acm@muc.de> - 2024-05-11 17:14 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-10 16:09 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-15 12:01 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-15 20:24 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-17 19:34 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-17 21:06 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-18 10:30 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-18 09:20 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Jeff Barnett <jbb@notatt.com> - 2024-05-19 00:48 -0600
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-19 09:03 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-19 13:17 -0400
Re: Every D(D) is correctly simulated by H olcott <polcott333@gmail.com> - 2024-05-19 13:13 -0500
Re: Every D(D) is correctly simulated by H Richard Damon <richard@damon-family.org> - 2024-05-19 15:09 -0400
Re: Every D(D) is correctly simulated by H olcott <polcott333@gmail.com> - 2024-05-19 14:29 -0500
Re: Every D(D) is correctly simulated by H Richard Damon <richard@damon-family.org> - 2024-05-19 15:49 -0400
Re: Every D(D) is correctly simulated by H olcott <polcott333@gmail.com> - 2024-05-19 15:34 -0500
Re: Every D(D) is correctly simulated by H Richard Damon <richard@damon-family.org> - 2024-05-19 19:30 -0400
Re: Every D(D) is correctly simulated by H olcott <polcott333@gmail.com> - 2024-05-19 15:59 -0500
Re: Every D(D) is correctly simulated by H Richard Damon <richard@damon-family.org> - 2024-05-19 19:31 -0400
Re: Every D(D) is correctly simulated by H olcott <polcott333@gmail.com> - 2024-05-20 13:33 -0500
Re: Every D(D) is correctly simulated by H Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-23 08:18 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-23 21:44 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-27 08:52 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-27 10:10 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-27 09:39 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-27 10:58 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-27 10:43 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-27 11:56 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-27 11:06 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-27 12:37 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-27 14:52 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-27 17:34 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-27 17:46 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-27 19:12 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-28 11:21 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-28 10:13 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-28 22:04 -0400
My use of the Socratic method defined: EXACTLY ONE-POINT-AT-A-TIME olcott <polcott333@gmail.com> - 2024-05-28 21:30 -0500
Re: My use of the Socratic method defined: EXACTLY ONE-POINT-AT-A-TIME Richard Damon <richard@damon-family.org> - 2024-05-28 23:38 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 12:10 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-30 08:40 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 17:11 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-28 11:17 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-28 10:10 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 12:14 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-30 08:16 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 16:57 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-30 10:05 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 17:27 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ### joes <noreply@example.com> - 2024-06-01 17:58 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-06-01 13:02 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-09 04:05 +0100
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-08 22:46 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-10 00:43 +0100
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-09 20:07 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-10 03:25 +0100
Re: Every D(D) simulated by H presents non-halting behavior to H ### olcott <polcott333@gmail.com> - 2024-05-09 22:08 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ### joes <noreply@example.com> - 2024-05-10 07:18 +0000
Re: Every D(D) simulated by H presents non-halting behavior to H ### Richard Damon <richard@damon-family.org> - 2024-05-10 10:18 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ---Airtight Mutual Accountability olcott <polcott333@gmail.com> - 2024-05-09 13:02 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ---Airtight Mutual Accountability Richard Damon <richard@damon-family.org> - 2024-05-09 22:31 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ---Airtight Mutual Accountability olcott <polcott333@gmail.com> - 2024-05-09 22:20 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ---Airtight Mutual Accountability Richard Damon <richard@damon-family.org> - 2024-05-10 10:18 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ### (watches state changes) olcott <polcott333@gmail.com> - 2024-05-09 23:46 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-08 14:08 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-08 21:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-07 22:36 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-07 21:40 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H Richard Damon <richard@damon-family.org> - 2024-05-07 22:52 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H <<< olcott <polcott333@gmail.com> - 2024-05-07 22:10 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H <<< Richard Damon <richard@damon-family.org> - 2024-05-08 07:39 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H <<< olcott <polcott333@gmail.com> - 2024-05-08 14:52 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H <<< Richard Damon <richard@damon-family.org> - 2024-05-08 21:27 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H <<< olcott <polcott333@gmail.com> - 2024-05-08 15:37 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H <<< Richard Damon <richard@damon-family.org> - 2024-05-08 21:24 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ... olcott <polcott333@gmail.com> - 2024-05-08 07:57 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ... olcott <polcott333@gmail.com> - 2024-05-08 14:16 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H ... Richard Damon <richard@damon-family.org> - 2024-05-08 21:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H ... "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-10 14:53 +0200
Re: Every D(D) simulated by H presents non-halting behavior to H ... Richard Damon <richard@damon-family.org> - 2024-05-08 21:28 -0400
Re: Every D(D) simulated by H presents non-halting behavior to H olcott <polcott333@gmail.com> - 2024-05-07 10:45 -0500
Re: Every D(D) simulated by H presents non-halting behavior to H immibis <news@immibis.com> - 2024-05-07 03:38 +0200
Page 2 of 21 — ← Prev page 1 [2] 3 4 … 21 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 17:03 -0500 |
| Message-ID | <v18vni$23glj$1@dont-email.me> |
| In reply to | #333704 |
On 5/5/2024 4:13 PM, Richard Damon wrote:
> On 5/5/24 3:10 PM, olcott wrote:
>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>> On 5/5/24 1:02 PM, olcott wrote:
>>>> The x86utm operating system: https://github.com/plolcott/x86utm enables
>>>> one C function to execute another C function in debug step mode.
>>>> Simulating Termination analyzer H simulates the x86 machine code of its
>>>> input (using libx86emu) in debug step mode until it correctly matches a
>>>> correct non-halting behavior pattern proving that its input will never
>>>> stop running unless aborted.
>>>
>>> Except that the pattern it uses is incorrect, since H(D,D) using this
>>> "pattern" says that D(D) will not halt, where, when main calls D(D),
>>> it does return/halt, so H is just incorrect.
>>>
>>>
>>>>
>>>> Can D correctly simulated by H terminate normally?
>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>> 01 int D(ptr x)
>>>> 02 {
>>>> 03 int Halt_Status = H(x, x);
>>>> 04 if (Halt_Status)
>>>> 05 HERE: goto HERE;
>>>> 06 return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 int main()
>>>> 10 {
>>>> 11 H(D,D);
>>>> 12 }
>>>>
>>>> *Execution Trace*
>>>> Line 11: main() invokes H(D,D);
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>
>>>> *Simulation invariant*
>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
>>> it would be trivial to show the error in the proof, but hasn't done
>>> it, showing that he doesn't actually have an answer to the
>>> refutation, and thus by just repeating a statment that is know to at
>>> least potentially have a problem as if it was just clearly true is
>>> just a pathological lie.
>>>
>>>>
>>>> The above execution trace proves that (for every H/D pair of the
>>>> infinite set of H/D pairs) each D(D) simulated by the H that this D(D)
>>>> calls cannot possibly reach past its own line 03.
>>>
>>> Except that the proof shows that you are not smart enough to think of
>>> some of the ways arround the problem (even though those methods were
>>> discussed a long time back)
>>>
>>
>> The above execution trace proves the behavior of each D simulated by
>> each H of the elements of the infinite set of H/D pairs where this D
>> calls that H.
>
> Nope, your problem is you stop simulating at the call to H and then
> resort to incorrect logic to try to figure out what happens next.
>
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
When H stops simulating D then the simulated H that D calls
also immediately stops because the executed H(D,D) that was
simulating D(D) was also simulating the H(D,D) that D(D)
calls as a part of its simulation of D(D).
> You are just stuck in the wrong ideas about H.
>
>>
>> If you are claiming that you have some top secret proof that shows
>> the above execution trace is incorrect I am taking this as the empty
>> claims of evidence of election fraud that no one has ever seen.
>>
>
> But not "Top Secret" as openly published here, and it was using ideas
> that have been discussed here in the past.
>
>
>
>> *I will perpetually hound you for this evidence*
>> *I will perpetually hound you for this evidence*
>> *I will perpetually hound you for this evidence*
>
> By LYING that it was not presented.
>
>
>>
>> This same method worked on an election denier, they deleted all
>> of their claims of election fraud and left.
>
> So, are you willing to put up or shut up?
>
> If I can show you how to write a valid C program H that can correctly
> simulates this D above (that calls my H), will you abandon your repeated
> claims that you can do this?
>
>>
>>>>
>>>> *Shown by ordinary software engineering* When the directly executed
>>>> H(D,D) aborts simulating its input then all of the nested simulations
>>>> (if any) immediately totally stop running and no simulated H ever
>>>> returns any value to any simulated D.
>>>>
>>>
>>> Right, but that doesn't change the behavor of the correctly and
>>> completely simulated input or the direct execution of the program
>>> descirbed.
>>>
>>>> From this we can definitely know that every D(D) of the infinite set
>>>> of H/D pairs where this D(D) is simulated by the H that this D(D) calls
>>>> that this D(D) presents non-halting behavior to this H.
>>>
>>> Nope. And the conclusion doesn't even follow from the incorrect premise.
>>>
>>>
>>>>
>>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>>
>>>
>>> Just LIES.
>>
>
--
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 | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 17:05 -0500 |
| Subject | Re: Every D(D) simulated by H presents non-halting behavior to H --- typo |
| Message-ID | <v18vr7$23glj$2@dont-email.me> |
| In reply to | #333710 |
On 5/5/2024 5:03 PM, olcott wrote:
> On 5/5/2024 4:13 PM, Richard Damon wrote:
>> On 5/5/24 3:10 PM, olcott wrote:
>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>> enables
>>>>> one C function to execute another C function in debug step mode.
>>>>> Simulating Termination analyzer H simulates the x86 machine code of
>>>>> its
>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>> matches a
>>>>> correct non-halting behavior pattern proving that its input will never
>>>>> stop running unless aborted.
>>>>
>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>> this "pattern" says that D(D) will not halt, where, when main calls
>>>> D(D), it does return/halt, so H is just incorrect.
>>>>
>>>>
>>>>>
>>>>> Can D correctly simulated by H terminate normally?
>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>> 01 int D(ptr x)
>>>>> 02 {
>>>>> 03 int Halt_Status = H(x, x);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 int main()
>>>>> 10 {
>>>>> 11 H(D,D);
>>>>> 12 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 11: main() invokes H(D,D);
>>>>>
>>>>> *keeps repeating* (unless aborted)
>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>>
>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
>>>> it would be trivial to show the error in the proof, but hasn't done
>>>> it, showing that he doesn't actually have an answer to the
>>>> refutation, and thus by just repeating a statment that is know to at
>>>> least potentially have a problem as if it was just clearly true is
>>>> just a pathological lie.
>>>>
>>>>>
>>>>> The above execution trace proves that (for every H/D pair of the
>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this D(D)
>>>>> calls cannot possibly reach past its own line 03.
>>>>
>>>> Except that the proof shows that you are not smart enough to think
>>>> of some of the ways arround the problem (even though those methods
>>>> were discussed a long time back)
>>>>
>>>
>>> The above execution trace proves the behavior of each D simulated by
>>> each H of the elements of the infinite set of H/D pairs where this D
>>> calls that H.
>>
>> Nope, your problem is you stop simulating at the call to H and then
>> resort to incorrect logic to try to figure out what happens next.
>>
>
> I have to usually tell you the exactly same thing several
> hundreds of times before you notice that I ever said it once.
>
> We are talking about the infinite set of H/D pairs where
> D is simulated by the same H that D calls.
>
> We are talking about the infinite set of H/D pairs where
> D is simulated by the same H that D calls.
>
> We are talking about the infinite set of H/D pairs where
> D is simulated by the same H that D calls.
>
> H that simulates the D that calls H(D,D) will simulate to
> 1 ∞ steps of D.
>
H that simulates the D that calls H(D,D) will simulate
1 to ∞ steps of D.
> When H stops simulating D then the simulated H that D calls
> also immediately stops because the executed H(D,D) that was
> simulating D(D) was also simulating the H(D,D) that D(D)
> calls as a part of its simulation of D(D).
>
>
>
>
>
>
>> You are just stuck in the wrong ideas about H.
>>
>>>
>>> If you are claiming that you have some top secret proof that shows
>>> the above execution trace is incorrect I am taking this as the empty
>>> claims of evidence of election fraud that no one has ever seen.
>>>
>>
>> But not "Top Secret" as openly published here, and it was using ideas
>> that have been discussed here in the past.
>>
>>
>>
>>> *I will perpetually hound you for this evidence*
>>> *I will perpetually hound you for this evidence*
>>> *I will perpetually hound you for this evidence*
>>
>> By LYING that it was not presented.
>>
>>
>>>
>>> This same method worked on an election denier, they deleted all
>>> of their claims of election fraud and left.
>>
>> So, are you willing to put up or shut up?
>>
>> If I can show you how to write a valid C program H that can correctly
>> simulates this D above (that calls my H), will you abandon your
>> repeated claims that you can do this?
>>
>>>
>>>>>
>>>>> *Shown by ordinary software engineering* When the directly executed
>>>>> H(D,D) aborts simulating its input then all of the nested simulations
>>>>> (if any) immediately totally stop running and no simulated H ever
>>>>> returns any value to any simulated D.
>>>>>
>>>>
>>>> Right, but that doesn't change the behavor of the correctly and
>>>> completely simulated input or the direct execution of the program
>>>> descirbed.
>>>>
>>>>> From this we can definitely know that every D(D) of the infinite set
>>>>> of H/D pairs where this D(D) is simulated by the H that this D(D)
>>>>> calls
>>>>> that this D(D) presents non-halting behavior to this H.
>>>>
>>>> Nope. And the conclusion doesn't even follow from the incorrect
>>>> premise.
>>>>
>>>>
>>>>>
>>>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>>>
>>>>
>>>> Just LIES.
>>>
>>
>
--
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-05-05 18:44 -0400 |
| Message-ID | <v19252$5asr$14@i2pn2.org> |
| In reply to | #333710 |
On 5/5/24 6:03 PM, olcott wrote:
> On 5/5/2024 4:13 PM, Richard Damon wrote:
>> On 5/5/24 3:10 PM, olcott wrote:
>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>> enables
>>>>> one C function to execute another C function in debug step mode.
>>>>> Simulating Termination analyzer H simulates the x86 machine code of
>>>>> its
>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>> matches a
>>>>> correct non-halting behavior pattern proving that its input will never
>>>>> stop running unless aborted.
>>>>
>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>> this "pattern" says that D(D) will not halt, where, when main calls
>>>> D(D), it does return/halt, so H is just incorrect.
>>>>
>>>>
>>>>>
>>>>> Can D correctly simulated by H terminate normally?
>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>> 01 int D(ptr x)
>>>>> 02 {
>>>>> 03 int Halt_Status = H(x, x);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 int main()
>>>>> 10 {
>>>>> 11 H(D,D);
>>>>> 12 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 11: main() invokes H(D,D);
>>>>>
>>>>> *keeps repeating* (unless aborted)
>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>>
>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
>>>> it would be trivial to show the error in the proof, but hasn't done
>>>> it, showing that he doesn't actually have an answer to the
>>>> refutation, and thus by just repeating a statment that is know to at
>>>> least potentially have a problem as if it was just clearly true is
>>>> just a pathological lie.
>>>>
>>>>>
>>>>> The above execution trace proves that (for every H/D pair of the
>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this D(D)
>>>>> calls cannot possibly reach past its own line 03.
>>>>
>>>> Except that the proof shows that you are not smart enough to think
>>>> of some of the ways arround the problem (even though those methods
>>>> were discussed a long time back)
>>>>
>>>
>>> The above execution trace proves the behavior of each D simulated by
>>> each H of the elements of the infinite set of H/D pairs where this D
>>> calls that H.
>>
>> Nope, your problem is you stop simulating at the call to H and then
>> resort to incorrect logic to try to figure out what happens next.
>>
>
> I have to usually tell you the exactly same thing several
> hundreds of times before you notice that I ever said it once.
>
> We are talking about the infinite set of H/D pairs where
> D is simulated by the same H that D calls.
>
> We are talking about the infinite set of H/D pairs where
> D is simulated by the same H that D calls.
>
> We are talking about the infinite set of H/D pairs where
> D is simulated by the same H that D calls.
>
> H that simulates the D that calls H(D,D) will simulate to
> 1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H does NOT
simulated that H, but instead simultes the machine that that machine
would be simulating.
The simulation of the D(D) that H(D,D) would be simulating is DIFFERENT
than simulating H simulting D(D), so your H is not doing what it claims
to be doing.
There ARE conditions underwhich those two simulation can have a
correspondence made, but do not, and can not, establish that for this
case, you just incorrectly assume it, since you just don't understand
what simulation actually means.
I have still proven, and you haven't even attempted to refute, your
claim that no H can simulated D beyond the call to H. This makes your
claims just disproven lies and the repeating of them evidence of you
being a pathological liar that doesn't know the meaning of truth.
>
> When H stops simulating D then the simulated H that D calls
> also immediately stops because the executed H(D,D) that was
> simulating D(D) was also simulating the H(D,D) that D(D)
> calls as a part of its simulation of D(D).
>
>
When H stops simulating D, then the SIMULATION of H that calls D stops.
The actual machine that is being simulated does not, as there is nothing
to stop it.
You just don't understand the fundamental nature of a Turing Machine.
The thing is, the "State Transition Table/Tape operation" listing of a
Turing Machine is NOT a piece of "SOFTWARE", but is the Hardware
Description Language of the special purpose machine that is that Turing
Machine. The input tape is the "Programming".
Note, that "Hardware" needs nothing supplied to it to run, except for
the input tape, so it can't be halted once started.
This makes the UTM, just a different, "Hardware" implementation that
takes a description of any other Turing Machine, and simulates it,
giving the exact same results as if we built that specialized
"hardware". Thus one set of "hardware" can do all problems, and turns
the Hardware Description Language of the sepecialized machine into
something now more like a "software" program (as it is given on the
input, not the hardware design of the machine).
So, All these "Machines" being given as input, have full behavior
defined by the instruction built into them, and are NOT dependent on the
actual simulation done by H, so its "aborting" its simulation does NOT
affect the behavior that H is being asked to decide on, it just makes
the rest of the behavior beyond H's visibility.
>
>
>
>
>> You are just stuck in the wrong ideas about H.
>>
>>>
>>> If you are claiming that you have some top secret proof that shows
>>> the above execution trace is incorrect I am taking this as the empty
>>> claims of evidence of election fraud that no one has ever seen.
>>>
>>
>> But not "Top Secret" as openly published here, and it was using ideas
>> that have been discussed here in the past.
>>
>>
>>
>>> *I will perpetually hound you for this evidence*
>>> *I will perpetually hound you for this evidence*
>>> *I will perpetually hound you for this evidence*
>>
>> By LYING that it was not presented.
>>
>>
>>>
>>> This same method worked on an election denier, they deleted all
>>> of their claims of election fraud and left.
>>
>> So, are you willing to put up or shut up?
>>
>> If I can show you how to write a valid C program H that can correctly
>> simulates this D above (that calls my H), will you abandon your
>> repeated claims that you can do this?
>>
>>>
>>>>>
>>>>> *Shown by ordinary software engineering* When the directly executed
>>>>> H(D,D) aborts simulating its input then all of the nested simulations
>>>>> (if any) immediately totally stop running and no simulated H ever
>>>>> returns any value to any simulated D.
>>>>>
>>>>
>>>> Right, but that doesn't change the behavor of the correctly and
>>>> completely simulated input or the direct execution of the program
>>>> descirbed.
>>>>
>>>>> From this we can definitely know that every D(D) of the infinite set
>>>>> of H/D pairs where this D(D) is simulated by the H that this D(D)
>>>>> calls
>>>>> that this D(D) presents non-halting behavior to this H.
>>>>
>>>> Nope. And the conclusion doesn't even follow from the incorrect
>>>> premise.
>>>>
>>>>
>>>>>
>>>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>>>
>>>>
>>>> Just LIES.
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 19:35 -0500 |
| Message-ID | <v198jn$253i2$1@dont-email.me> |
| In reply to | #333714 |
On 5/5/2024 5:44 PM, Richard Damon wrote:
> On 5/5/24 6:03 PM, olcott wrote:
>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>> On 5/5/24 3:10 PM, olcott wrote:
>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>> enables
>>>>>> one C function to execute another C function in debug step mode.
>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>> of its
>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>> matches a
>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>> never
>>>>>> stop running unless aborted.
>>>>>
>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>> this "pattern" says that D(D) will not halt, where, when main calls
>>>>> D(D), it does return/halt, so H is just incorrect.
>>>>>
>>>>>
>>>>>>
>>>>>> Can D correctly simulated by H terminate normally?
>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>> 01 int D(ptr x)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = H(x, x);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 int main()
>>>>>> 10 {
>>>>>> 11 H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 11: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborted)
>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach past its own line
>>>>>> 03.
>>>>>
>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
>>>>> it would be trivial to show the error in the proof, but hasn't done
>>>>> it, showing that he doesn't actually have an answer to the
>>>>> refutation, and thus by just repeating a statment that is know to
>>>>> at least potentially have a problem as if it was just clearly true
>>>>> is just a pathological lie.
>>>>>
>>>>>>
>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this
>>>>>> D(D)
>>>>>> calls cannot possibly reach past its own line 03.
>>>>>
>>>>> Except that the proof shows that you are not smart enough to think
>>>>> of some of the ways arround the problem (even though those methods
>>>>> were discussed a long time back)
>>>>>
>>>>
>>>> The above execution trace proves the behavior of each D simulated by
>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>> calls that H.
>>>
>>> Nope, your problem is you stop simulating at the call to H and then
>>> resort to incorrect logic to try to figure out what happens next.
>>>
>>
>> I have to usually tell you the exactly same thing several
>> hundreds of times before you notice that I ever said it once.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> H that simulates the D that calls H(D,D) will simulate to
>> 1 ∞ steps of D.
>
> Nope, when your H simulates the call to H(D,D) inside D, your H does NOT
> simulated that H, but instead simultes the machine that that machine
> would be simulating.
>
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
--
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-05-05 20:47 -0400 |
| Message-ID | <v199bk$5asr$15@i2pn2.org> |
| In reply to | #333716 |
On 5/5/24 8:35 PM, olcott wrote:
> On 5/5/2024 5:44 PM, Richard Damon wrote:
>> On 5/5/24 6:03 PM, olcott wrote:
>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>> enables
>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>>> of its
>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>> matches a
>>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>>> never
>>>>>>> stop running unless aborted.
>>>>>>
>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>> 01 int D(ptr x)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11 H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>
>>>>>>> *keeps repeating* (unless aborted)
>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>> line 03.
>>>>>>
>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>> that it would be trivial to show the error in the proof, but
>>>>>> hasn't done it, showing that he doesn't actually have an answer to
>>>>>> the refutation, and thus by just repeating a statment that is know
>>>>>> to at least potentially have a problem as if it was just clearly
>>>>>> true is just a pathological lie.
>>>>>>
>>>>>>>
>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this
>>>>>>> D(D)
>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>
>>>>>> Except that the proof shows that you are not smart enough to think
>>>>>> of some of the ways arround the problem (even though those methods
>>>>>> were discussed a long time back)
>>>>>>
>>>>>
>>>>> The above execution trace proves the behavior of each D simulated by
>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>> calls that H.
>>>>
>>>> Nope, your problem is you stop simulating at the call to H and then
>>>> resort to incorrect logic to try to figure out what happens next.
>>>>
>>>
>>> I have to usually tell you the exactly same thing several
>>> hundreds of times before you notice that I ever said it once.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> H that simulates the D that calls H(D,D) will simulate to
>>> 1 ∞ steps of D.
>>
>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>> NOT simulated that H, but instead simultes the machine that that
>> machine would be simulating.
>>
>
> I am not talking about my H
> I am talking about every element of the infinite set of
> H/D pairs where D is simulated by the same H that D calls.
> I will repeat this endlessly to your every post until you get it
So, what does an infinite set of programs and an infinte set of inputs do?
If you don't run each of those H's individually on its D, what else do
you mean to do?
I think you need to figure out how your computation model actua;lly works,
It seems to be just a bunch of gobbledygook to me.
It seems about as bad as WM and his dark numbers.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 21:34 -0500 |
| Message-ID | <v19fkb$2aufj$2@dont-email.me> |
| In reply to | #333722 |
On 5/5/2024 7:47 PM, Richard Damon wrote: > On 5/5/24 8:35 PM, olcott wrote: Your system clock is still off.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-05 23:15 -0400 |
| Message-ID | <v19i0h$5asr$20@i2pn2.org> |
| In reply to | #333724 |
On 5/5/24 10:34 PM, olcott wrote: > On 5/5/2024 7:47 PM, Richard Damon wrote: >> On 5/5/24 8:35 PM, olcott wrote: > > Your system clock is still off. > Nope. It is set precisely via NTTP. Note actual time stamps of these messages Most Recent of yours: Date: Sun, 5 May 2024 21:34:51 -0500 This would be GMT 02:34:51 Mine: Date: Sun, 5 May 2024 20:47:48 -0400 This would be GMT 00:47:48 Your first: Date: Sun, 5 May 2024 19:35:03 -0500 This would be GMT 00:35:03 Note, GMT times in order
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 21:42 -0500 |
| Message-ID | <v19g2g$2aufj$4@dont-email.me> |
| In reply to | #333722 |
On 5/5/2024 7:47 PM, Richard Damon wrote:
> On 5/5/24 8:35 PM, olcott wrote:
>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>> On 5/5/24 6:03 PM, olcott wrote:
>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>>> enables
>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>>>> of its
>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>> matches a
>>>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>>>> never
>>>>>>>> stop running unless aborted.
>>>>>>>
>>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>> 01 int D(ptr x)
>>>>>>>> 02 {
>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>> 04 if (Halt_Status)
>>>>>>>> 05 HERE: goto HERE;
>>>>>>>> 06 return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 int main()
>>>>>>>> 10 {
>>>>>>>> 11 H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>> line 03.
>>>>>>>
>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>> hasn't done it, showing that he doesn't actually have an answer
>>>>>>> to the refutation, and thus by just repeating a statment that is
>>>>>>> know to at least potentially have a problem as if it was just
>>>>>>> clearly true is just a pathological lie.
>>>>>>>
>>>>>>>>
>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>> this D(D)
>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>
>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>> think of some of the ways arround the problem (even though those
>>>>>>> methods were discussed a long time back)
>>>>>>>
>>>>>>
>>>>>> The above execution trace proves the behavior of each D simulated by
>>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>>> calls that H.
>>>>>
>>>>> Nope, your problem is you stop simulating at the call to H and then
>>>>> resort to incorrect logic to try to figure out what happens next.
>>>>>
>>>>
>>>> I have to usually tell you the exactly same thing several
>>>> hundreds of times before you notice that I ever said it once.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> H that simulates the D that calls H(D,D) will simulate to
>>>> 1 ∞ steps of D.
>>>
>>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>>> NOT simulated that H, but instead simultes the machine that that
>>> machine would be simulating.
>>>
>>
>> I am not talking about my H
>> I am talking about every element of the infinite set of
>> H/D pairs where D is simulated by the same H that D calls.
>> I will repeat this endlessly to your every post until you get it
>
> So, what does an infinite set of programs and an infinte set of inputs do?
>
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
> If you don't run each of those H's individually on its D, what else do
> you mean to do?
>
When we can directly see that every element of an infinite set
has a property of never reaching past its own line 03 then we
know that no D(D) ever reaches its own line 06 and halts.
From this we know that every input D(D) that calls H(D,D) and
is simulated by H specifies non halting behavior to H(D,D).
> I think you need to figure out how your computation model actua;lly works,
>
> It seems to be just a bunch of gobbledygook to me.
>
> It seems about as bad as WM and his dark numbers.
--
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-05-05 23:03 -0400 |
| Message-ID | <v19h9b$5asr$17@i2pn2.org> |
| In reply to | #333726 |
On 5/5/24 10:42 PM, olcott wrote:
> On 5/5/2024 7:47 PM, Richard Damon wrote:
>> On 5/5/24 8:35 PM, olcott wrote:
>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>> On 5/5/24 6:03 PM, olcott wrote:
>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>>>> enables
>>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine
>>>>>>>>> code of its
>>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>>> matches a
>>>>>>>>> correct non-halting behavior pattern proving that its input
>>>>>>>>> will never
>>>>>>>>> stop running unless aborted.
>>>>>>>>
>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>>> 01 int D(ptr x)
>>>>>>>>> 02 {
>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>> 06 return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 int main()
>>>>>>>>> 10 {
>>>>>>>>> 11 H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>> line 03.
>>>>>>>>
>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>>> hasn't done it, showing that he doesn't actually have an answer
>>>>>>>> to the refutation, and thus by just repeating a statment that is
>>>>>>>> know to at least potentially have a problem as if it was just
>>>>>>>> clearly true is just a pathological lie.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>>> this D(D)
>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>
>>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>>> think of some of the ways arround the problem (even though those
>>>>>>>> methods were discussed a long time back)
>>>>>>>>
>>>>>>>
>>>>>>> The above execution trace proves the behavior of each D simulated by
>>>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>>>> calls that H.
>>>>>>
>>>>>> Nope, your problem is you stop simulating at the call to H and
>>>>>> then resort to incorrect logic to try to figure out what happens
>>>>>> next.
>>>>>>
>>>>>
>>>>> I have to usually tell you the exactly same thing several
>>>>> hundreds of times before you notice that I ever said it once.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>> 1 ∞ steps of D.
>>>>
>>>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>>>> NOT simulated that H, but instead simultes the machine that that
>>>> machine would be simulating.
>>>>
>>>
>>> I am not talking about my H
>>> I am talking about every element of the infinite set of
>>> H/D pairs where D is simulated by the same H that D calls.
>>> I will repeat this endlessly to your every post until you get it
>>
>> So, what does an infinite set of programs and an infinte set of inputs
>> do?
>>
>
> I am talking about every element of the infinite set of
> H/D pairs where D is simulated by the same H that D calls.
>
> The 1st H simulates 1 steps of D
> The 2nd H simulates 2 steps of D
> The 3rd H simulates 3 steps of D
> ...
> The 5,000,000,000 H simulates 5,000,000,000 steps of D
> ...
> All the way up to H that simulates ∞ steps of D
>
> None of these D(D) simulated by the H that D(D) calls
> ever reach past their own line 03.
Then they aren't doing it right.
In particular, I suspect they aren't simulation the CALL H instruction
right.
Note, it DOESN'T go directly from "Call H" to a new layer of simulation
of D(D).
Not unless you have somehow redefined what simulation means and not
mentioned that.
This seems to be a common problem with you.
>
>> If you don't run each of those H's individually on its D, what else do
>> you mean to do?
>>
>
> When we can directly see that every element of an infinite set
> has a property of never reaching past its own line 03 then we
> know that no D(D) ever reaches its own line 06 and halts.
>
> From this we know that every input D(D) that calls H(D,D) and
> is simulated by H specifies non halting behavior to H(D,D).
Nope, I described how an H can exist that directly and correctly
simulated ALL o fthe instructions that is sees while simulating D(D)
while doing it RIGHT.
>
>
>> I think you need to figure out how your computation model actua;lly
>> works,
>>
>> It seems to be just a bunch of gobbledygook to me.
>>
>> It seems about as bad as WM and his dark numbers.
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 23:01 -0500 |
| Message-ID | <v19knj$2c1rk$1@dont-email.me> |
| In reply to | #333732 |
On 5/5/2024 10:03 PM, Richard Damon wrote:
> On 5/5/24 10:42 PM, olcott wrote:
>> On 5/5/2024 7:47 PM, Richard Damon wrote:
>>> On 5/5/24 8:35 PM, olcott wrote:
>>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>>> On 5/5/24 6:03 PM, olcott wrote:
>>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>>> The x86utm operating system:
>>>>>>>>>> https://github.com/plolcott/x86utm enables
>>>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine
>>>>>>>>>> code of its
>>>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>>>> matches a
>>>>>>>>>> correct non-halting behavior pattern proving that its input
>>>>>>>>>> will never
>>>>>>>>>> stop running unless aborted.
>>>>>>>>>
>>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D)
>>>>>>>>> using this "pattern" says that D(D) will not halt, where, when
>>>>>>>>> main calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>>>> 01 int D(ptr x)
>>>>>>>>>> 02 {
>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 int main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11 H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> *Execution Trace*
>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>
>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>> simulates D(D)
>>>>>>>>>>
>>>>>>>>>> *Simulation invariant*
>>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>>> line 03.
>>>>>>>>>
>>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>>>> hasn't done it, showing that he doesn't actually have an answer
>>>>>>>>> to the refutation, and thus by just repeating a statment that
>>>>>>>>> is know to at least potentially have a problem as if it was
>>>>>>>>> just clearly true is just a pathological lie.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>>>> this D(D)
>>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>>
>>>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>>>> think of some of the ways arround the problem (even though
>>>>>>>>> those methods were discussed a long time back)
>>>>>>>>>
>>>>>>>>
>>>>>>>> The above execution trace proves the behavior of each D
>>>>>>>> simulated by
>>>>>>>> each H of the elements of the infinite set of H/D pairs where
>>>>>>>> this D
>>>>>>>> calls that H.
>>>>>>>
>>>>>>> Nope, your problem is you stop simulating at the call to H and
>>>>>>> then resort to incorrect logic to try to figure out what happens
>>>>>>> next.
>>>>>>>
>>>>>>
>>>>>> I have to usually tell you the exactly same thing several
>>>>>> hundreds of times before you notice that I ever said it once.
>>>>>>
>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>> D is simulated by the same H that D calls.
>>>>>>
>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>> D is simulated by the same H that D calls.
>>>>>>
>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>> D is simulated by the same H that D calls.
>>>>>>
>>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>>> 1 ∞ steps of D.
>>>>>
>>>>> Nope, when your H simulates the call to H(D,D) inside D, your H
>>>>> does NOT simulated that H, but instead simultes the machine that
>>>>> that machine would be simulating.
>>>>>
>>>>
>>>> I am not talking about my H
>>>> I am talking about every element of the infinite set of
>>>> H/D pairs where D is simulated by the same H that D calls.
>>>> I will repeat this endlessly to your every post until you get it
>>>
>>> So, what does an infinite set of programs and an infinte set of
>>> inputs do?
>>>
>>
>> I am talking about every element of the infinite set of
>> H/D pairs where D is simulated by the same H that D calls.
>>
>> The 1st H simulates 1 steps of D
>> The 2nd H simulates 2 steps of D
>> The 3rd H simulates 3 steps of D
>> ...
>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>> ...
>> All the way up to H that simulates ∞ steps of D
>>
>> None of these D(D) simulated by the H that D(D) calls
>> ever reach past their own line 03.
>
> Then they aren't doing it right.
>
When HH(DD,DD) simulates its input and reaches the call
to repeat this process it goes ahead and repeats this
process simulating itself simulating DD. I don't show
the 251 pages of text of HH simulating itself. People
are totally overwhelmed with the halt a page of text
that I do show them.
The hypothetical H(D,D) that I am referring to works
just like the actual HH(DD,DD). When HH simulates HH
simulating DD there is an extra 250 pages of execution
trace that what I show and that is only by simulating
DD twice. 8 lines of DD simulated twice is actually
16000 lines of code.
Simulated once = 8 lines
Simulated twice = 16,000 lines
Simulated thrice = 16,000^2 lines
The above hypothetical H does simulate itself simulating D.
The 5 billion lines of D simulated would take
5,000,000,000 / 8 = 625,000,000 simulations this
251^625,000,000 pages of text to show the full execution trace.
> In particular, I suspect they aren't simulation the CALL H instruction
> right.
>
> Note, it DOESN'T go directly from "Call H" to a new layer of simulation
> of D(D).
>
I would have to display 251 pages of execution trace
of HH(DD,DD) simulating its input recursively once.
It takes 251^2 pages to simulate it recursively twice.
It takes 251^3 pages to simulate it recursively thrice.
The hypothetical H(D,D) that I am referring to does do this.
> Not unless you have somehow redefined what simulation means and not
> mentioned that.
>
> This seems to be a common problem with you.
>
>>
>>> If you don't run each of those H's individually on its D, what else
>>> do you mean to do?
>>>
>>
>> When we can directly see that every element of an infinite set
>> has a property of never reaching past its own line 03 then we
>> know that no D(D) ever reaches its own line 06 and halts.
>>
>> From this we know that every input D(D) that calls H(D,D) and
>> is simulated by H specifies non halting behavior to H(D,D).
>
> Nope, I described how an H can exist that directly and correctly
> simulated ALL o fthe instructions that is sees while simulating D(D)
> while doing it RIGHT.
>
>>
>>
>>> I think you need to figure out how your computation model actua;lly
>>> works,
>>>
>>> It seems to be just a bunch of gobbledygook to me.
>>>
>>> It seems about as bad as WM and his dark numbers.
>>
>
--
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-05-06 06:34 -0400 |
| Message-ID | <v1abmr$7eu1$4@i2pn2.org> |
| In reply to | #333740 |
On 5/6/24 12:01 AM, olcott wrote:
> On 5/5/2024 10:03 PM, Richard Damon wrote:
>> On 5/5/24 10:42 PM, olcott wrote:
>>> On 5/5/2024 7:47 PM, Richard Damon wrote:
>>>> On 5/5/24 8:35 PM, olcott wrote:
>>>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>>>> On 5/5/24 6:03 PM, olcott wrote:
>>>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>>>> The x86utm operating system:
>>>>>>>>>>> https://github.com/plolcott/x86utm enables
>>>>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine
>>>>>>>>>>> code of its
>>>>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>>>>> matches a
>>>>>>>>>>> correct non-halting behavior pattern proving that its input
>>>>>>>>>>> will never
>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>
>>>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D)
>>>>>>>>>> using this "pattern" says that D(D) will not halt, where, when
>>>>>>>>>> main calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>>>>> 01 int D(ptr x)
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>> 08
>>>>>>>>>>> 09 int main()
>>>>>>>>>>> 10 {
>>>>>>>>>>> 11 H(D,D);
>>>>>>>>>>> 12 }
>>>>>>>>>>>
>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>
>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>
>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>>>> line 03.
>>>>>>>>>>
>>>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>>>>> hasn't done it, showing that he doesn't actually have an
>>>>>>>>>> answer to the refutation, and thus by just repeating a
>>>>>>>>>> statment that is know to at least potentially have a problem
>>>>>>>>>> as if it was just clearly true is just a pathological lie.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>>>>> this D(D)
>>>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>>>
>>>>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>>>>> think of some of the ways arround the problem (even though
>>>>>>>>>> those methods were discussed a long time back)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The above execution trace proves the behavior of each D
>>>>>>>>> simulated by
>>>>>>>>> each H of the elements of the infinite set of H/D pairs where
>>>>>>>>> this D
>>>>>>>>> calls that H.
>>>>>>>>
>>>>>>>> Nope, your problem is you stop simulating at the call to H and
>>>>>>>> then resort to incorrect logic to try to figure out what happens
>>>>>>>> next.
>>>>>>>>
>>>>>>>
>>>>>>> I have to usually tell you the exactly same thing several
>>>>>>> hundreds of times before you notice that I ever said it once.
>>>>>>>
>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>> D is simulated by the same H that D calls.
>>>>>>>
>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>> D is simulated by the same H that D calls.
>>>>>>>
>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>> D is simulated by the same H that D calls.
>>>>>>>
>>>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>>>> 1 ∞ steps of D.
>>>>>>
>>>>>> Nope, when your H simulates the call to H(D,D) inside D, your H
>>>>>> does NOT simulated that H, but instead simultes the machine that
>>>>>> that machine would be simulating.
>>>>>>
>>>>>
>>>>> I am not talking about my H
>>>>> I am talking about every element of the infinite set of
>>>>> H/D pairs where D is simulated by the same H that D calls.
>>>>> I will repeat this endlessly to your every post until you get it
>>>>
>>>> So, what does an infinite set of programs and an infinte set of
>>>> inputs do?
>>>>
>>>
>>> I am talking about every element of the infinite set of
>>> H/D pairs where D is simulated by the same H that D calls.
>>>
>>> The 1st H simulates 1 steps of D
>>> The 2nd H simulates 2 steps of D
>>> The 3rd H simulates 3 steps of D
>>> ...
>>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>>> ...
>>> All the way up to H that simulates ∞ steps of D
>>>
>>> None of these D(D) simulated by the H that D(D) calls
>>> ever reach past their own line 03.
>>
>> Then they aren't doing it right.
>>
>
> When HH(DD,DD) simulates its input and reaches the call
> to repeat this process it goes ahead and repeats this
> process simulating itself simulating DD. I don't show
> the 251 pages of text of HH simulating itself. People
> are totally overwhelmed with the halt a page of text
> that I do show them.
>
> The hypothetical H(D,D) that I am referring to works
> just like the actual HH(DD,DD). When HH simulates HH
> simulating DD there is an extra 250 pages of execution
> trace that what I show and that is only by simulating
> DD twice. 8 lines of DD simulated twice is actually
> 16000 lines of code.
>
> Simulated once = 8 lines
> Simulated twice = 16,000 lines
> Simulated thrice = 16,000^2 lines
> The above hypothetical H does simulate itself simulating D.
>
> The 5 billion lines of D simulated would take
> 5,000,000,000 / 8 = 625,000,000 simulations this
> 251^625,000,000 pages of text to show the full execution trace.
>
>> In particular, I suspect they aren't simulation the CALL H instruction
>> right.
>>
>> Note, it DOESN'T go directly from "Call H" to a new layer of
>> simulation of D(D).
>>
>
> I would have to display 251 pages of execution trace
> of HH(DD,DD) simulating its input recursively once.
>
> It takes 251^2 pages to simulate it recursively twice.
> It takes 251^3 pages to simulate it recursively thrice.
> The hypothetical H(D,D) that I am referring to does do this.
And why does H use the infinite set of HH's?
>
>> Not unless you have somehow redefined what simulation means and not
>> mentioned that.
>>
>> This seems to be a common problem with you.
>>
>>>
>>>> If you don't run each of those H's individually on its D, what else
>>>> do you mean to do?
>>>>
>>>
>>> When we can directly see that every element of an infinite set
>>> has a property of never reaching past its own line 03 then we
>>> know that no D(D) ever reaches its own line 06 and halts.
>>>
>>> From this we know that every input D(D) that calls H(D,D) and
>>> is simulated by H specifies non halting behavior to H(D,D).
>>
>> Nope, I described how an H can exist that directly and correctly
>> simulated ALL o fthe instructions that is sees while simulating D(D)
>> while doing it RIGHT.
>>
>>>
>>>
>>>> I think you need to figure out how your computation model actua;lly
>>>> works,
>>>>
>>>> It seems to be just a bunch of gobbledygook to me.
>>>>
>>>> It seems about as bad as WM and his dark numbers.
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-06 10:16 -0500 |
| Message-ID | <v1as8p$2kk44$1@dont-email.me> |
| In reply to | #333747 |
On 5/6/2024 5:34 AM, Richard Damon wrote:
> On 5/6/24 12:01 AM, olcott wrote:
>> On 5/5/2024 10:03 PM, Richard Damon wrote:
>>> On 5/5/24 10:42 PM, olcott wrote:
>>>> On 5/5/2024 7:47 PM, Richard Damon wrote:
>>>>> On 5/5/24 8:35 PM, olcott wrote:
>>>>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>>>>> On 5/5/24 6:03 PM, olcott wrote:
>>>>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>>>>> The x86utm operating system:
>>>>>>>>>>>> https://github.com/plolcott/x86utm enables
>>>>>>>>>>>> one C function to execute another C function in debug step
>>>>>>>>>>>> mode.
>>>>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine
>>>>>>>>>>>> code of its
>>>>>>>>>>>> input (using libx86emu) in debug step mode until it
>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>> correct non-halting behavior pattern proving that its input
>>>>>>>>>>>> will never
>>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>>
>>>>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D)
>>>>>>>>>>> using this "pattern" says that D(D) will not halt, where,
>>>>>>>>>>> when main calls D(D), it does return/halt, so H is just
>>>>>>>>>>> incorrect.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>>>>>> 01 int D(ptr x)
>>>>>>>>>>>> 02 {
>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>> 07 }
>>>>>>>>>>>> 08
>>>>>>>>>>>> 09 int main()
>>>>>>>>>>>> 10 {
>>>>>>>>>>>> 11 H(D,D);
>>>>>>>>>>>> 12 }
>>>>>>>>>>>>
>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>
>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>
>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>> D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>> own line 03.
>>>>>>>>>>>
>>>>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even
>>>>>>>>>>> claimed that it would be trivial to show the error in the
>>>>>>>>>>> proof, but hasn't done it, showing that he doesn't actually
>>>>>>>>>>> have an answer to the refutation, and thus by just repeating
>>>>>>>>>>> a statment that is know to at least potentially have a
>>>>>>>>>>> problem as if it was just clearly true is just a pathological
>>>>>>>>>>> lie.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The above execution trace proves that (for every H/D pair of
>>>>>>>>>>>> the
>>>>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>>>>>> this D(D)
>>>>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>>>>
>>>>>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>>>>>> think of some of the ways arround the problem (even though
>>>>>>>>>>> those methods were discussed a long time back)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The above execution trace proves the behavior of each D
>>>>>>>>>> simulated by
>>>>>>>>>> each H of the elements of the infinite set of H/D pairs where
>>>>>>>>>> this D
>>>>>>>>>> calls that H.
>>>>>>>>>
>>>>>>>>> Nope, your problem is you stop simulating at the call to H and
>>>>>>>>> then resort to incorrect logic to try to figure out what
>>>>>>>>> happens next.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I have to usually tell you the exactly same thing several
>>>>>>>> hundreds of times before you notice that I ever said it once.
>>>>>>>>
>>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>>> D is simulated by the same H that D calls.
>>>>>>>>
>>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>>> D is simulated by the same H that D calls.
>>>>>>>>
>>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>>> D is simulated by the same H that D calls.
>>>>>>>>
>>>>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>>>>> 1 ∞ steps of D.
>>>>>>>
>>>>>>> Nope, when your H simulates the call to H(D,D) inside D, your H
>>>>>>> does NOT simulated that H, but instead simultes the machine that
>>>>>>> that machine would be simulating.
>>>>>>>
>>>>>>
>>>>>> I am not talking about my H
>>>>>> I am talking about every element of the infinite set of
>>>>>> H/D pairs where D is simulated by the same H that D calls.
>>>>>> I will repeat this endlessly to your every post until you get it
>>>>>
>>>>> So, what does an infinite set of programs and an infinte set of
>>>>> inputs do?
>>>>>
>>>>
>>>> I am talking about every element of the infinite set of
>>>> H/D pairs where D is simulated by the same H that D calls.
>>>>
>>>> The 1st H simulates 1 steps of D
>>>> The 2nd H simulates 2 steps of D
>>>> The 3rd H simulates 3 steps of D
>>>> ...
>>>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>>>> ...
>>>> All the way up to H that simulates ∞ steps of D
>>>>
>>>> None of these D(D) simulated by the H that D(D) calls
>>>> ever reach past their own line 03.
>>>
>>> Then they aren't doing it right.
>>>
>>
>> When HH(DD,DD) simulates its input and reaches the call
>> to repeat this process it goes ahead and repeats this
>> process simulating itself simulating DD. I don't show
>> the 251 pages of text of HH simulating itself. People
>> are totally overwhelmed with the halt a page of text
>> that I do show them.
>>
>> The hypothetical H(D,D) that I am referring to works
>> just like the actual HH(DD,DD). When HH simulates HH
>> simulating DD there is an extra 250 pages of execution
>> trace that what I show and that is only by simulating
>> DD twice. 8 lines of DD simulated twice is actually
>> 16000 lines of code.
>>
>> Simulated once = 8 lines
>> Simulated twice = 16,000 lines
>> Simulated thrice = 16,000^2 lines
>> The above hypothetical H does simulate itself simulating D.
>>
>> The 5 billion lines of D simulated would take
>> 5,000,000,000 / 8 = 625,000,000 simulations this
>> 251^625,000,000 pages of text to show the full execution trace.
>>
>>> In particular, I suspect they aren't simulation the CALL H
>>> instruction right.
>>>
>>> Note, it DOESN'T go directly from "Call H" to a new layer of
>>> simulation of D(D).
>>>
>>
>> I would have to display 251 pages of execution trace
>> of HH(DD,DD) simulating its input recursively once.
>>
>> It takes 251^2 pages to simulate it recursively twice.
>> It takes 251^3 pages to simulate it recursively thrice.
>> The hypothetical H(D,D) that I am referring to does do this.
>
> And why does H use the infinite set of HH's?
>
H does not use and HH's
My hypothetical H is physically implemented as HH.
I use the simpler name in my paper.
HH(DD,DD) empirically proves that there is no number of recursive
simulations where DD simulated by HH ever reaches past its own line 03.
At least now I see that you had genuine misunderstanding.
Because four other people had a very easy time with this
I did not see how anyone could actually misunderstand.
>>
>>> Not unless you have somehow redefined what simulation means and not
>>> mentioned that.
>>>
>>> This seems to be a common problem with you.
>>>
>>>>
>>>>> If you don't run each of those H's individually on its D, what else
>>>>> do you mean to do?
>>>>>
>>>>
>>>> When we can directly see that every element of an infinite set
>>>> has a property of never reaching past its own line 03 then we
>>>> know that no D(D) ever reaches its own line 06 and halts.
>>>>
>>>> From this we know that every input D(D) that calls H(D,D) and
>>>> is simulated by H specifies non halting behavior to H(D,D).
>>>
>>> Nope, I described how an H can exist that directly and correctly
>>> simulated ALL o fthe instructions that is sees while simulating D(D)
>>> while doing it RIGHT.
>>>
>>>>
>>>>
>>>>> I think you need to figure out how your computation model actua;lly
>>>>> works,
>>>>>
>>>>> It seems to be just a bunch of gobbledygook to me.
>>>>>
>>>>> It seems about as bad as WM and his dark numbers.
>>>>
>>>
>>
>
--
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-05-06 22:08 -0400 |
| Message-ID | <v1c2f0$9f72$4@i2pn2.org> |
| In reply to | #333750 |
On 5/6/24 11:16 AM, olcott wrote:
> On 5/6/2024 5:34 AM, Richard Damon wrote:
>> On 5/6/24 12:01 AM, olcott wrote:
>>> On 5/5/2024 10:03 PM, Richard Damon wrote:
>>>> On 5/5/24 10:42 PM, olcott wrote:
>>>>> On 5/5/2024 7:47 PM, Richard Damon wrote:
>>>>>> On 5/5/24 8:35 PM, olcott wrote:
>>>>>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>>>>>> On 5/5/24 6:03 PM, olcott wrote:
>>>>>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>>>>>> The x86utm operating system:
>>>>>>>>>>>>> https://github.com/plolcott/x86utm enables
>>>>>>>>>>>>> one C function to execute another C function in debug step
>>>>>>>>>>>>> mode.
>>>>>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine
>>>>>>>>>>>>> code of its
>>>>>>>>>>>>> input (using libx86emu) in debug step mode until it
>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>> correct non-halting behavior pattern proving that its input
>>>>>>>>>>>>> will never
>>>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D)
>>>>>>>>>>>> using this "pattern" says that D(D) will not halt, where,
>>>>>>>>>>>> when main calls D(D), it does return/halt, so H is just
>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>>>>>>> 01 int D(ptr x)
>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>> 08
>>>>>>>>>>>>> 09 int main()
>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>> 11 H(D,D);
>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>
>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>>> own line 03.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even
>>>>>>>>>>>> claimed that it would be trivial to show the error in the
>>>>>>>>>>>> proof, but hasn't done it, showing that he doesn't actually
>>>>>>>>>>>> have an answer to the refutation, and thus by just repeating
>>>>>>>>>>>> a statment that is know to at least potentially have a
>>>>>>>>>>>> problem as if it was just clearly true is just a
>>>>>>>>>>>> pathological lie.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above execution trace proves that (for every H/D pair
>>>>>>>>>>>>> of the
>>>>>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H
>>>>>>>>>>>>> that this D(D)
>>>>>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>>>>>>> think of some of the ways arround the problem (even though
>>>>>>>>>>>> those methods were discussed a long time back)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The above execution trace proves the behavior of each D
>>>>>>>>>>> simulated by
>>>>>>>>>>> each H of the elements of the infinite set of H/D pairs where
>>>>>>>>>>> this D
>>>>>>>>>>> calls that H.
>>>>>>>>>>
>>>>>>>>>> Nope, your problem is you stop simulating at the call to H and
>>>>>>>>>> then resort to incorrect logic to try to figure out what
>>>>>>>>>> happens next.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have to usually tell you the exactly same thing several
>>>>>>>>> hundreds of times before you notice that I ever said it once.
>>>>>>>>>
>>>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>>>> D is simulated by the same H that D calls.
>>>>>>>>>
>>>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>>>> D is simulated by the same H that D calls.
>>>>>>>>>
>>>>>>>>> We are talking about the infinite set of H/D pairs where
>>>>>>>>> D is simulated by the same H that D calls.
>>>>>>>>>
>>>>>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>>>>>> 1 ∞ steps of D.
>>>>>>>>
>>>>>>>> Nope, when your H simulates the call to H(D,D) inside D, your H
>>>>>>>> does NOT simulated that H, but instead simultes the machine that
>>>>>>>> that machine would be simulating.
>>>>>>>>
>>>>>>>
>>>>>>> I am not talking about my H
>>>>>>> I am talking about every element of the infinite set of
>>>>>>> H/D pairs where D is simulated by the same H that D calls.
>>>>>>> I will repeat this endlessly to your every post until you get it
>>>>>>
>>>>>> So, what does an infinite set of programs and an infinte set of
>>>>>> inputs do?
>>>>>>
>>>>>
>>>>> I am talking about every element of the infinite set of
>>>>> H/D pairs where D is simulated by the same H that D calls.
>>>>>
>>>>> The 1st H simulates 1 steps of D
>>>>> The 2nd H simulates 2 steps of D
>>>>> The 3rd H simulates 3 steps of D
>>>>> ...
>>>>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>>>>> ...
>>>>> All the way up to H that simulates ∞ steps of D
>>>>>
>>>>> None of these D(D) simulated by the H that D(D) calls
>>>>> ever reach past their own line 03.
>>>>
>>>> Then they aren't doing it right.
>>>>
>>>
>>> When HH(DD,DD) simulates its input and reaches the call
>>> to repeat this process it goes ahead and repeats this
>>> process simulating itself simulating DD. I don't show
>>> the 251 pages of text of HH simulating itself. People
>>> are totally overwhelmed with the halt a page of text
>>> that I do show them.
>>>
>>> The hypothetical H(D,D) that I am referring to works
>>> just like the actual HH(DD,DD). When HH simulates HH
>>> simulating DD there is an extra 250 pages of execution
>>> trace that what I show and that is only by simulating
>>> DD twice. 8 lines of DD simulated twice is actually
>>> 16000 lines of code.
>>>
>>> Simulated once = 8 lines
>>> Simulated twice = 16,000 lines
>>> Simulated thrice = 16,000^2 lines
>>> The above hypothetical H does simulate itself simulating D.
>>>
>>> The 5 billion lines of D simulated would take
>>> 5,000,000,000 / 8 = 625,000,000 simulations this
>>> 251^625,000,000 pages of text to show the full execution trace.
>>>
>>>> In particular, I suspect they aren't simulation the CALL H
>>>> instruction right.
>>>>
>>>> Note, it DOESN'T go directly from "Call H" to a new layer of
>>>> simulation of D(D).
>>>>
>>>
>>> I would have to display 251 pages of execution trace
>>> of HH(DD,DD) simulating its input recursively once.
>>>
>>> It takes 251^2 pages to simulate it recursively twice.
>>> It takes 251^3 pages to simulate it recursively thrice.
>>> The hypothetical H(D,D) that I am referring to does do this.
>>
>> And why does H use the infinite set of HH's?
>>
>
> H does not use and HH's
> My hypothetical H is physically implemented as HH.
> I use the simpler name in my paper.
So, how do you write a specific program that calls an infinite set of
proggrams?
Or is your terminatation analysis not about deciding on programs at all?
>
> HH(DD,DD) empirically proves that there is no number of recursive
> simulations where DD simulated by HH ever reaches past its own line 03.
Only for a TOY case where you limit what options are allowed.
Yes, you may be able to prove that ONE SPEICIF formulation of a
simulation decider is unable to reach the end of a specific template
that no one actually cares about.
Note, your D is NOT Linz's H^, or Sipser's D, as you omit an important
detail that makes them totally uninteresting inputs.
>
> At least now I see that you had genuine misunderstanding.
>
> Because four other people had a very easy time with this
> I did not see how anyone could actually misunderstand.
>
>>>
>>>> Not unless you have somehow redefined what simulation means and not
>>>> mentioned that.
>>>>
>>>> This seems to be a common problem with you.
>>>>
>>>>>
>>>>>> If you don't run each of those H's individually on its D, what
>>>>>> else do you mean to do?
>>>>>>
>>>>>
>>>>> When we can directly see that every element of an infinite set
>>>>> has a property of never reaching past its own line 03 then we
>>>>> know that no D(D) ever reaches its own line 06 and halts.
>>>>>
>>>>> From this we know that every input D(D) that calls H(D,D) and
>>>>> is simulated by H specifies non halting behavior to H(D,D).
>>>>
>>>> Nope, I described how an H can exist that directly and correctly
>>>> simulated ALL o fthe instructions that is sees while simulating D(D)
>>>> while doing it RIGHT.
>>>>
>>>>>
>>>>>
>>>>>> I think you need to figure out how your computation model
>>>>>> actua;lly works,
>>>>>>
>>>>>> It seems to be just a bunch of gobbledygook to me.
>>>>>>
>>>>>> It seems about as bad as WM and his dark numbers.
>>>>>
>>>>
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 19:53 -0500 |
| Message-ID | <v199lv$25d3h$1@dont-email.me> |
| In reply to | #333714 |
On 5/5/2024 5:44 PM, Richard Damon wrote:
> On 5/5/24 6:03 PM, olcott wrote:
>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>> On 5/5/24 3:10 PM, olcott wrote:
>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>> enables
>>>>>> one C function to execute another C function in debug step mode.
>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>> of its
>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>> matches a
>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>> never
>>>>>> stop running unless aborted.
>>>>>
>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>> this "pattern" says that D(D) will not halt, where, when main calls
>>>>> D(D), it does return/halt, so H is just incorrect.
>>>>>
>>>>>
>>>>>>
>>>>>> Can D correctly simulated by H terminate normally?
>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>> 01 int D(ptr x)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = H(x, x);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 int main()
>>>>>> 10 {
>>>>>> 11 H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 11: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborted)
>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach past its own line
>>>>>> 03.
>>>>>
>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
>>>>> it would be trivial to show the error in the proof, but hasn't done
>>>>> it, showing that he doesn't actually have an answer to the
>>>>> refutation, and thus by just repeating a statment that is know to
>>>>> at least potentially have a problem as if it was just clearly true
>>>>> is just a pathological lie.
>>>>>
>>>>>>
>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this
>>>>>> D(D)
>>>>>> calls cannot possibly reach past its own line 03.
>>>>>
>>>>> Except that the proof shows that you are not smart enough to think
>>>>> of some of the ways arround the problem (even though those methods
>>>>> were discussed a long time back)
>>>>>
>>>>
>>>> The above execution trace proves the behavior of each D simulated by
>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>> calls that H.
>>>
>>> Nope, your problem is you stop simulating at the call to H and then
>>> resort to incorrect logic to try to figure out what happens next.
>>>
>>
>> I have to usually tell you the exactly same thing several
>> hundreds of times before you notice that I ever said it once.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> H that simulates the D that calls H(D,D) will simulate to
>> 1 ∞ steps of D.
>
> Nope, when your H simulates the call to H(D,D) inside D, your H does NOT
> simulated that H, but instead simultes the machine that that machine
> would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
--
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-05-05 21:36 -0400 |
| Message-ID | <v19c7d$5asq$10@i2pn2.org> |
| In reply to | #333718 |
On 5/5/24 8:53 PM, olcott wrote:
> On 5/5/2024 5:44 PM, Richard Damon wrote:
>> On 5/5/24 6:03 PM, olcott wrote:
>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>> enables
>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>>> of its
>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>> matches a
>>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>>> never
>>>>>>> stop running unless aborted.
>>>>>>
>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>> 01 int D(ptr x)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11 H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>
>>>>>>> *keeps repeating* (unless aborted)
>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>> line 03.
>>>>>>
>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>> that it would be trivial to show the error in the proof, but
>>>>>> hasn't done it, showing that he doesn't actually have an answer to
>>>>>> the refutation, and thus by just repeating a statment that is know
>>>>>> to at least potentially have a problem as if it was just clearly
>>>>>> true is just a pathological lie.
>>>>>>
>>>>>>>
>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this
>>>>>>> D(D)
>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>
>>>>>> Except that the proof shows that you are not smart enough to think
>>>>>> of some of the ways arround the problem (even though those methods
>>>>>> were discussed a long time back)
>>>>>>
>>>>>
>>>>> The above execution trace proves the behavior of each D simulated by
>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>> calls that H.
>>>>
>>>> Nope, your problem is you stop simulating at the call to H and then
>>>> resort to incorrect logic to try to figure out what happens next.
>>>>
>>>
>>> I have to usually tell you the exactly same thing several
>>> hundreds of times before you notice that I ever said it once.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> H that simulates the D that calls H(D,D) will simulate to
>>> 1 ∞ steps of D.
>>
>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>> NOT simulated that H, but instead simultes the machine that that
>> machine would be simulating.
>
> I am not talking about my H
> I am talking about every element of the infinite set of
> H/D pairs where D is simulated by the same H that D calls.
>
> The 1st H simulates 1 steps of D
> The 2nd H simulates 2 steps of D
> The 3rd H simulates 3 steps of D
> ...
> The 5,000,000,000 H simulates 5,000,000,000 steps of D
> ...
> All the way up to H that simulates ∞ steps of D
>
> None of these D(D) simulated by the H that D(D) calls
> ever reach past their own line 03.
>
>
And none of these have anything thing to do with your H, what does it
have to do with it?
Question, do these H actually simulate the instructions of the H that D
calls, or not?
Why does my second example of how to build an H in the post you refuse
to answer no handle this case?
If these H are built by that template, there will be a point where the H
that simulates some number of steps of D and H will find it reaches the
point where H returns to D, which you say is impossible, thus your logic
is wrong.
Prove me wrong, as I have proved you wrong (and not be refuted).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 22:29 -0500 |
| Message-ID | <v19ips$2bkma$2@dont-email.me> |
| In reply to | #333728 |
On 5/5/2024 8:36 PM, Richard Damon wrote:
> On 5/5/24 8:53 PM, olcott wrote:
>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>> On 5/5/24 6:03 PM, olcott wrote:
>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>>> enables
>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>>>> of its
>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>> matches a
>>>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>>>> never
>>>>>>>> stop running unless aborted.
>>>>>>>
>>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>> 01 int D(ptr x)
>>>>>>>> 02 {
>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>> 04 if (Halt_Status)
>>>>>>>> 05 HERE: goto HERE;
>>>>>>>> 06 return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 int main()
>>>>>>>> 10 {
>>>>>>>> 11 H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>> line 03.
>>>>>>>
>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>> hasn't done it, showing that he doesn't actually have an answer
>>>>>>> to the refutation, and thus by just repeating a statment that is
>>>>>>> know to at least potentially have a problem as if it was just
>>>>>>> clearly true is just a pathological lie.
>>>>>>>
>>>>>>>>
>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>> this D(D)
>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>
>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>> think of some of the ways arround the problem (even though those
>>>>>>> methods were discussed a long time back)
>>>>>>>
>>>>>>
>>>>>> The above execution trace proves the behavior of each D simulated by
>>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>>> calls that H.
>>>>>
>>>>> Nope, your problem is you stop simulating at the call to H and then
>>>>> resort to incorrect logic to try to figure out what happens next.
>>>>>
>>>>
>>>> I have to usually tell you the exactly same thing several
>>>> hundreds of times before you notice that I ever said it once.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> H that simulates the D that calls H(D,D) will simulate to
>>>> 1 ∞ steps of D.
>>>
>>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>>> NOT simulated that H, but instead simultes the machine that that
>>> machine would be simulating.
>>
>> I am not talking about my H
>> I am talking about every element of the infinite set of
>> H/D pairs where D is simulated by the same H that D calls.
>>
>> The 1st H simulates 1 steps of D
>> The 2nd H simulates 2 steps of D
>> The 3rd H simulates 3 steps of D
>> ...
>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>> ...
>> All the way up to H that simulates ∞ steps of D
>>
>> None of these D(D) simulated by the H that D(D) calls
>> ever reach past their own line 03.
>>
>>
>
> And none of these have anything thing to do with your H, what does it
> have to do with it?
>
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> Question, do these H actually simulate the instructions of the H that D
> calls, or not?
>
> Why does my second example of how to build an H in the post you refuse
> to answer no handle this case?
>
> If these H are built by that template, there will be a point where the H
> that simulates some number of steps of D and H will find it reaches the
> point where H returns to D, which you say is impossible, thus your logic
> is wrong.
>
> Prove me wrong, as I have proved you wrong (and not be refuted).
--
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-05-05 23:47 -0400 |
| Message-ID | <v19jsi$5asq$12@i2pn2.org> |
| In reply to | #333731 |
On 5/5/24 11:29 PM, olcott wrote:
> On 5/5/2024 8:36 PM, Richard Damon wrote:
>> On 5/5/24 8:53 PM, olcott wrote:
>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>> On 5/5/24 6:03 PM, olcott wrote:
>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>>>> enables
>>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine
>>>>>>>>> code of its
>>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>>> matches a
>>>>>>>>> correct non-halting behavior pattern proving that its input
>>>>>>>>> will never
>>>>>>>>> stop running unless aborted.
>>>>>>>>
>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>>> 01 int D(ptr x)
>>>>>>>>> 02 {
>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>> 06 return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 int main()
>>>>>>>>> 10 {
>>>>>>>>> 11 H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>> line 03.
>>>>>>>>
>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>>> hasn't done it, showing that he doesn't actually have an answer
>>>>>>>> to the refutation, and thus by just repeating a statment that is
>>>>>>>> know to at least potentially have a problem as if it was just
>>>>>>>> clearly true is just a pathological lie.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>>> this D(D)
>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>
>>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>>> think of some of the ways arround the problem (even though those
>>>>>>>> methods were discussed a long time back)
>>>>>>>>
>>>>>>>
>>>>>>> The above execution trace proves the behavior of each D simulated by
>>>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>>>> calls that H.
>>>>>>
>>>>>> Nope, your problem is you stop simulating at the call to H and
>>>>>> then resort to incorrect logic to try to figure out what happens
>>>>>> next.
>>>>>>
>>>>>
>>>>> I have to usually tell you the exactly same thing several
>>>>> hundreds of times before you notice that I ever said it once.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>> 1 ∞ steps of D.
>>>>
>>>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>>>> NOT simulated that H, but instead simultes the machine that that
>>>> machine would be simulating.
>>>
>>> I am not talking about my H
>>> I am talking about every element of the infinite set of
>>> H/D pairs where D is simulated by the same H that D calls.
>>>
>>> The 1st H simulates 1 steps of D
>>> The 2nd H simulates 2 steps of D
>>> The 3rd H simulates 3 steps of D
>>> ...
>>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>>> ...
>>> All the way up to H that simulates ∞ steps of D
>>>
>>> None of these D(D) simulated by the H that D(D) calls
>>> ever reach past their own line 03.
>>>
>>>
>>
>> And none of these have anything thing to do with your H, what does it
>> have to do with it?
>>
>
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
> I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
So, if they are not H, then what do they have to do with what H should
return?
It seems when you are asked about cats, you are answering about 10 story
office buildings.
Your definition was "Simulation by H", if these pairs are NOT H, then
they have NOTHING to do with what that should be.
I think you just buried your logic in the hole you dug.
It seems you can't read English, as you didn't answer the question.
I guess you are just admiting that your whole logic is built on lies.
>
>> Question, do these H actually simulate the instructions of the H that
>> D calls, or not?
>>
>> Why does my second example of how to build an H in the post you refuse
>> to answer no handle this case?
>>
>> If these H are built by that template, there will be a point where the
>> H that simulates some number of steps of D and H will find it reaches
>> the point where H returns to D, which you say is impossible, thus your
>> logic is wrong.
>>
>> Prove me wrong, as I have proved you wrong (and not be refuted).
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 21:36 -0500 |
| Message-ID | <v19fmj$2aufj$3@dont-email.me> |
| In reply to | #333714 |
On 5/5/2024 5:44 PM, Richard Damon wrote:
> On 5/5/24 6:03 PM, olcott wrote:
>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>> On 5/5/24 3:10 PM, olcott wrote:
>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>> enables
>>>>>> one C function to execute another C function in debug step mode.
>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>> of its
>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>> matches a
>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>> never
>>>>>> stop running unless aborted.
>>>>>
>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>> this "pattern" says that D(D) will not halt, where, when main calls
>>>>> D(D), it does return/halt, so H is just incorrect.
>>>>>
>>>>>
>>>>>>
>>>>>> Can D correctly simulated by H terminate normally?
>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>> 01 int D(ptr x)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = H(x, x);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 int main()
>>>>>> 10 {
>>>>>> 11 H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 11: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborted)
>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach past its own line
>>>>>> 03.
>>>>>
>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
>>>>> it would be trivial to show the error in the proof, but hasn't done
>>>>> it, showing that he doesn't actually have an answer to the
>>>>> refutation, and thus by just repeating a statment that is know to
>>>>> at least potentially have a problem as if it was just clearly true
>>>>> is just a pathological lie.
>>>>>
>>>>>>
>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this
>>>>>> D(D)
>>>>>> calls cannot possibly reach past its own line 03.
>>>>>
>>>>> Except that the proof shows that you are not smart enough to think
>>>>> of some of the ways arround the problem (even though those methods
>>>>> were discussed a long time back)
>>>>>
>>>>
>>>> The above execution trace proves the behavior of each D simulated by
>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>> calls that H.
>>>
>>> Nope, your problem is you stop simulating at the call to H and then
>>> resort to incorrect logic to try to figure out what happens next.
>>>
>>
>> I have to usually tell you the exactly same thing several
>> hundreds of times before you notice that I ever said it once.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> We are talking about the infinite set of H/D pairs where
>> D is simulated by the same H that D calls.
>>
>> H that simulates the D that calls H(D,D) will simulate to
>> 1 ∞ steps of D.
>
> Nope, when your H simulates the call to H(D,D) inside D, your H does NOT
> simulated that H, but instead simultes the machine that that machine
> would be simulating.
>
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
--
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-05-05 23:05 -0400 |
| Message-ID | <v19hdf$5asr$18@i2pn2.org> |
| In reply to | #333725 |
On 5/5/24 10:36 PM, olcott wrote:
> On 5/5/2024 5:44 PM, Richard Damon wrote:
>> On 5/5/24 6:03 PM, olcott wrote:
>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>> enables
>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>>> of its
>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>> matches a
>>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>>> never
>>>>>>> stop running unless aborted.
>>>>>>
>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>> 01 int D(ptr x)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11 H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>
>>>>>>> *keeps repeating* (unless aborted)
>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>> line 03.
>>>>>>
>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>> that it would be trivial to show the error in the proof, but
>>>>>> hasn't done it, showing that he doesn't actually have an answer to
>>>>>> the refutation, and thus by just repeating a statment that is know
>>>>>> to at least potentially have a problem as if it was just clearly
>>>>>> true is just a pathological lie.
>>>>>>
>>>>>>>
>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that this
>>>>>>> D(D)
>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>
>>>>>> Except that the proof shows that you are not smart enough to think
>>>>>> of some of the ways arround the problem (even though those methods
>>>>>> were discussed a long time back)
>>>>>>
>>>>>
>>>>> The above execution trace proves the behavior of each D simulated by
>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>> calls that H.
>>>>
>>>> Nope, your problem is you stop simulating at the call to H and then
>>>> resort to incorrect logic to try to figure out what happens next.
>>>>
>>>
>>> I have to usually tell you the exactly same thing several
>>> hundreds of times before you notice that I ever said it once.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> We are talking about the infinite set of H/D pairs where
>>> D is simulated by the same H that D calls.
>>>
>>> H that simulates the D that calls H(D,D) will simulate to
>>> 1 ∞ steps of D.
>>
>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>> NOT simulated that H, but instead simultes the machine that that
>> machine would be simulating.
>>
>
>
> I am not talking about my H
> I am talking about every element of the infinite set of
> H/D pairs where D is simulated by the same H that D calls.
>
> The 1st H simulates 1 steps of D
> The 2nd H simulates 2 steps of D
> The 3rd H simulates 3 steps of D
> ...
> The 5,000,000,000 H simulates 5,000,000,000 steps of D
> ...
> All the way up to H that simulates ∞ steps of D
>
> None of these D(D) simulated by the H that D(D) calls
> ever reach past their own line 03.
>
But those H's aren't doing correct simulations, since by your
description they are not doing the call H instuction correctly.
What is your definition of a "Correct Simulation" of the call H instruction?
My example actually does a CORRECT simulation of the full code of D, and
reaches the final state, and doesn't fall prey to the error you coded in
your H.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 23:11 -0500 |
| Subject | Re: Every D(D) simulated by H presents non-halting behavior to H --- |
| Message-ID | <v19la6$2c3bq$1@dont-email.me> |
| In reply to | #333733 |
On 5/5/2024 10:05 PM, Richard Damon wrote:
> On 5/5/24 10:36 PM, olcott wrote:
>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>> On 5/5/24 6:03 PM, olcott wrote:
>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>>>>>>> enables
>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>> Simulating Termination analyzer H simulates the x86 machine code
>>>>>>>> of its
>>>>>>>> input (using libx86emu) in debug step mode until it correctly
>>>>>>>> matches a
>>>>>>>> correct non-halting behavior pattern proving that its input will
>>>>>>>> never
>>>>>>>> stop running unless aborted.
>>>>>>>
>>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using
>>>>>>> this "pattern" says that D(D) will not halt, where, when main
>>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>> 00 int H(ptr x, ptr x) // ptr is pointer to int function
>>>>>>>> 01 int D(ptr x)
>>>>>>>> 02 {
>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>> 04 if (Halt_Status)
>>>>>>>> 05 HERE: goto HERE;
>>>>>>>> 06 return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 int main()
>>>>>>>> 10 {
>>>>>>>> 11 H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>> line 03.
>>>>>>>
>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed
>>>>>>> that it would be trivial to show the error in the proof, but
>>>>>>> hasn't done it, showing that he doesn't actually have an answer
>>>>>>> to the refutation, and thus by just repeating a statment that is
>>>>>>> know to at least potentially have a problem as if it was just
>>>>>>> clearly true is just a pathological lie.
>>>>>>>
>>>>>>>>
>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that
>>>>>>>> this D(D)
>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>
>>>>>>> Except that the proof shows that you are not smart enough to
>>>>>>> think of some of the ways arround the problem (even though those
>>>>>>> methods were discussed a long time back)
>>>>>>>
>>>>>>
>>>>>> The above execution trace proves the behavior of each D simulated by
>>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>>> calls that H.
>>>>>
>>>>> Nope, your problem is you stop simulating at the call to H and then
>>>>> resort to incorrect logic to try to figure out what happens next.
>>>>>
>>>>
>>>> I have to usually tell you the exactly same thing several
>>>> hundreds of times before you notice that I ever said it once.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> We are talking about the infinite set of H/D pairs where
>>>> D is simulated by the same H that D calls.
>>>>
>>>> H that simulates the D that calls H(D,D) will simulate to
>>>> 1 ∞ steps of D.
>>>
>>> Nope, when your H simulates the call to H(D,D) inside D, your H does
>>> NOT simulated that H, but instead simultes the machine that that
>>> machine would be simulating.
>>>
>>
>>
>> I am not talking about my H
>> I am talking about every element of the infinite set of
>> H/D pairs where D is simulated by the same H that D calls.
>>
>> The 1st H simulates 1 steps of D
>> The 2nd H simulates 2 steps of D
>> The 3rd H simulates 3 steps of D
>> ...
>> The 5,000,000,000 H simulates 5,000,000,000 steps of D
>> ...
>> All the way up to H that simulates ∞ steps of D
>>
>> None of these D(D) simulated by the H that D(D) calls
>> ever reach past their own line 03.
>>
>
> But those H's aren't doing correct simulations, since by your
> description they are not doing the call H instuction correctly.
>
> What is your definition of a "Correct Simulation" of the call H
> instruction?
>
My hypothetical H(D,D) behaves the same way that my actual
HH(DD,DD) works it goes ahead and simulates itself simulating DD.
Hypothetically there is no limit to this. HH(DD,DD) could
simulate itself simulating DD a quadrillion times. If it did
this DD would still never get past its own line 03.
> My example actually does a CORRECT simulation of the full code of D, and
> reaches the final state, and doesn't fall prey to the error you coded in
> your H.
--
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 2 of 21 — ← Prev page 1 [2] 3 4 … 21 Next page →
Back to top | Article view | sci.logic
csiph-web