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 8 of 21 — ← Prev page 1 … 6 7 [8] 9 10 … 21 Next page →
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-10 12:12 -0400 |
| Subject | Re: Richard KEEPS TRYING to get away with this falsehood |
| Message-ID | <v1lh1g$kf52$4@i2pn2.org> |
| In reply to | #333880 |
On 5/10/24 11:50 AM, olcott wrote:
> On 5/10/2024 9:18 AM, Richard Damon wrote:
>> On 5/9/24 11:10 PM, olcott wrote:
>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify which
>>>>>>>>>>>>>>>>> set of pairs
>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words don't
>>>>>>>>>>>>>>>>> mean anything.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is simulated
>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps
>>>>>>>>>>>>>>>> of D
>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations where H
>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set theories
>>>>>>>>>>>>>>> like ZFC there
>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This template defines an infinite set of finite string H/D
>>>>>>>>>>>>> pairs where each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>
>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞ simulated
>>>>>>>>>>>>> steps of D and involve zero to ∞ recursive simulations of H
>>>>>>>>>>>>> simulating itself simulating D(D). Every time Lines 1,2,3
>>>>>>>>>>>>> are simulated again defines
>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>
>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>
>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>
>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>
>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>
>>>>>>>>>>>> Is this the definition of the infinite set of H? We can
>>>>>>>>>>>> think of many more simulations that only these.
>>>>>>>>>>>
>>>>>>>>>>> This template defines an infinite set of finite string H/D
>>>>>>>>>>> pairs where
>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this same
>>>>>>>>>>> H(D,D).
>>>>>>>>>>>
>>>>>>>>>>> No-one can possibly show one element of this set where D(D)
>>>>>>>>>>> reaches
>>>>>>>>>>> past its own line 03.
>>>>>>>>>>
>>>>>>>>>> If H is a decider of any kind then the D build from it reaches
>>>>>>>>>> its line
>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H reaches
>>>>>>>>>> that line
>>>>>>>>>> is another question.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>
>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>> recursion works. You can run the code and see that I am correct.
>>>>>>>>>
>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>
>>>>>>>> HH is completely broken - it uses a global variable which is
>>>>>>>> allows HH to detect whether it is the outer HH or a nested
>>>>>>>> (simulated) HH. As a result, the nested HH behaves completely
>>>>>>>> differently to the outer HH - I mean /completely/ differently:
>>>>>>>> it goes through a totally separate "I am called in nested mode"
>>>>>>>> code path!
>>>>>>>>
>>>>>>>
>>>>>>> The encoding of HH is not the pure function that it needs to be to
>>>>>>> be a computable function.
>>>>>>>
>>>>>>> *Maybe you can settle this*
>>>>>>>
>>>>>>> The disagreement is entirely over an enormously much simpler thing.
>>>>>>> The disagreement is that Richard says that a D simulated by H could
>>>>>>> reach past its own line 03 and halt.
>>>>>>
>>>>>> Here's the proof:
>>>>>>
>>>>>> 1. A simulation always produces an identical execution trace to
>>>>>> the direct execution.
>>>>>
>>>>> *When pathological self-reference is involved this is counter-factual*
>>>>> That no one can possibly show the steps of how D simulated by H
>>>>> possibly
>>>>> reach line 06 of H proves this.
>>>>
>>>>
>>>>
>>>>>
>>>>> Richard tried to get away with D never simulated by H as an example
>>>>> of D simulated by H:
>>>>
>>>> Nope, you are looking at the WRONG message, and I have told you this
>>>> multiple times.
>>>
>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>> *When you interpret*
>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>> > On 5/1/24 11:51 AM, olcott wrote:
>>> *Every D simulated by H that cannot possibly*
>>> *stop running unless aborted by H*
>>>
>>> as *D NEVER simulated by H*
>>>
>>> you have shown a reckless disregard for the truth
>>> that would win a defamation case.
>>>
>>
>> My H simulated 0 steps of D, of which was ALL of the steps it
>> simulated correctly.
>
> *THAT DOES NOT MEET THE SPEC*
You haven't GIVEN a defined SPEC.
The only definition within Computation Theory, which is the space you
started in, and claim to get to, doesn't have "aborted" simulations, so
you don't have a defintion of what simulatioin actually means, other
than doing something that tells you something about the behavior of what
is simulated.
My H does that, by aborting its "simulation" in shows that THIS H did
not simulate its input to a final state.
Just the same result that you partial set of H's showed.
> *THAT DOES NOT MEET THE SPEC*
> *THAT DOES NOT MEET THE SPEC*
> *THAT DOES NOT MEET THE SPEC*
>
> *Every D simulated by H that cannot possibly*
> *stop running unless aborted by H*
>
> *Every D simulated by H that cannot possibly*
> *stop running unless aborted by H*
>
> *Every D simulated by H that cannot possibly*
> *stop running unless aborted by H*
>
> *Every D simulated by H that cannot possibly*
> *stop running unless aborted by H*
>
> *Every D simulated by H that cannot possibly*
> *stop running unless aborted by H*
>
>
Right, and simulating zero steps correctly and them aborting means H
simulated ALL of its steps correctly when it aborted. Simulating ALL
steps simulated is a corrrect simulation by your definition.
You added LATER, the requirement of 1 to N steps, so, your arguement is
just a LIE.
Remember, when I ask you for definitions, you refused to try to do it.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 12:49 -0500 |
| Subject | Re: Richard KEEPS TRYING to get away with this falsehood |
| Message-ID | <v1lmo1$1g1mj$1@dont-email.me> |
| In reply to | #333881 |
On 5/10/2024 11:12 AM, Richard Damon wrote:
> On 5/10/24 11:50 AM, olcott wrote:
>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>> On 5/9/24 11:10 PM, olcott wrote:
>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify which
>>>>>>>>>>>>>>>>>> set of pairs
>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words don't
>>>>>>>>>>>>>>>>>> mean anything.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is simulated
>>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps
>>>>>>>>>>>>>>>>> of D
>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations where H
>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set theories
>>>>>>>>>>>>>>>> like ZFC there
>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This template defines an infinite set of finite string H/D
>>>>>>>>>>>>>> pairs where each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D). Every
>>>>>>>>>>>>>> time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>
>>>>>>>>>>>>> Is this the definition of the infinite set of H? We can
>>>>>>>>>>>>> think of many more simulations that only these.
>>>>>>>>>>>>
>>>>>>>>>>>> This template defines an infinite set of finite string H/D
>>>>>>>>>>>> pairs where
>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this same
>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>
>>>>>>>>>>>> No-one can possibly show one element of this set where D(D)
>>>>>>>>>>>> reaches
>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>
>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>> reaches its line
>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H reaches
>>>>>>>>>>> that line
>>>>>>>>>>> is another question.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>
>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>> recursion works. You can run the code and see that I am correct.
>>>>>>>>>>
>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>
>>>>>>>>> HH is completely broken - it uses a global variable which is
>>>>>>>>> allows HH to detect whether it is the outer HH or a nested
>>>>>>>>> (simulated) HH. As a result, the nested HH behaves completely
>>>>>>>>> differently to the outer HH - I mean /completely/ differently:
>>>>>>>>> it goes through a totally separate "I am called in nested mode"
>>>>>>>>> code path!
>>>>>>>>>
>>>>>>>>
>>>>>>>> The encoding of HH is not the pure function that it needs to be to
>>>>>>>> be a computable function.
>>>>>>>>
>>>>>>>> *Maybe you can settle this*
>>>>>>>>
>>>>>>>> The disagreement is entirely over an enormously much simpler thing.
>>>>>>>> The disagreement is that Richard says that a D simulated by H could
>>>>>>>> reach past its own line 03 and halt.
>>>>>>>
>>>>>>> Here's the proof:
>>>>>>>
>>>>>>> 1. A simulation always produces an identical execution trace to
>>>>>>> the direct execution.
>>>>>>
>>>>>> *When pathological self-reference is involved this is
>>>>>> counter-factual*
>>>>>> That no one can possibly show the steps of how D simulated by H
>>>>>> possibly
>>>>>> reach line 06 of H proves this.
>>>>>
>>>>>
>>>>>
>>>>>>
>>>>>> Richard tried to get away with D never simulated by H as an example
>>>>>> of D simulated by H:
>>>>>
>>>>> Nope, you are looking at the WRONG message, and I have told you
>>>>> this multiple times.
>>>>
>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>> *When you interpret*
>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>> *Every D simulated by H that cannot possibly*
>>>> *stop running unless aborted by H*
>>>>
>>>> as *D NEVER simulated by H*
>>>>
>>>> you have shown a reckless disregard for the truth
>>>> that would win a defamation case.
>>>>
>>>
>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>> simulated correctly.
>>
>> *THAT DOES NOT MEET THE SPEC*
>
> You haven't GIVEN a defined SPEC.
>
> The only definition within Computation Theory, which is the space you
> started in, and claim to get to, doesn't have "aborted" simulations, so
> you don't have a defintion of what simulatioin actually means, other
> than doing something that tells you something about the behavior of what
> is simulated.
>
> My H does that, by aborting its "simulation" in shows that THIS H did
> not simulate its input to a final state.
>
> Just the same result that you partial set of H's showed.
>
>> *THAT DOES NOT MEET THE SPEC*
>> *THAT DOES NOT MEET THE SPEC*
>> *THAT DOES NOT MEET THE SPEC*
>>
>> *Every D simulated by H that cannot possibly*
>> *stop running unless aborted by H*
>>
>> *Every D simulated by H that cannot possibly*
>> *stop running unless aborted by H*
>>
>> *Every D simulated by H that cannot possibly*
>> *stop running unless aborted by H*
>>
>> *Every D simulated by H that cannot possibly*
>> *stop running unless aborted by H*
>>
>> *Every D simulated by H that cannot possibly*
>> *stop running unless aborted by H*
>>
>>
>
> Right, and simulating zero steps correctly and them aborting means H
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
> simulated ALL of its steps correctly when it aborted. Simulating ALL
> steps simulated is a corrrect simulation by your definition.
>
> You added LATER, the requirement of 1 to N steps, so, your arguement is
> just a LIE.
>
> Remember, when I ask you for definitions, you refused to try to do 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-10 16:09 -0400 |
| Subject | Olcott keeps on lying. |
| Message-ID | <v1luu1$lbo5$3@i2pn2.org> |
| In reply to | #333882 |
On 5/10/24 1:49 PM, olcott wrote:
> On 5/10/2024 11:12 AM, Richard Damon wrote:
>> On 5/10/24 11:50 AM, olcott wrote:
>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify
>>>>>>>>>>>>>>>>>>> which set of pairs
>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words don't
>>>>>>>>>>>>>>>>>>> mean anything.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is simulated
>>>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞
>>>>>>>>>>>>>>>>>> steps of D
>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations where H
>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set theories
>>>>>>>>>>>>>>>>> like ZFC there
>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>> H/D pairs where each D(D) that is simulated by H(D,D)
>>>>>>>>>>>>>>> also calls this same H(D,D).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D). Every
>>>>>>>>>>>>>>> time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We can
>>>>>>>>>>>>>> think of many more simulations that only these.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This template defines an infinite set of finite string H/D
>>>>>>>>>>>>> pairs where
>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this same
>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>
>>>>>>>>>>>>> No-one can possibly show one element of this set where D(D)
>>>>>>>>>>>>> reaches
>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>
>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>> reaches its line
>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H reaches
>>>>>>>>>>>> that line
>>>>>>>>>>>> is another question.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>
>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>> recursion works. You can run the code and see that I am correct.
>>>>>>>>>>>
>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>
>>>>>>>>>> HH is completely broken - it uses a global variable which is
>>>>>>>>>> allows HH to detect whether it is the outer HH or a nested
>>>>>>>>>> (simulated) HH. As a result, the nested HH behaves completely
>>>>>>>>>> differently to the outer HH - I mean /completely/ differently:
>>>>>>>>>> it goes through a totally separate "I am called in nested
>>>>>>>>>> mode" code path!
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The encoding of HH is not the pure function that it needs to be to
>>>>>>>>> be a computable function.
>>>>>>>>>
>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>
>>>>>>>>> The disagreement is entirely over an enormously much simpler
>>>>>>>>> thing.
>>>>>>>>> The disagreement is that Richard says that a D simulated by H
>>>>>>>>> could
>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>
>>>>>>>> Here's the proof:
>>>>>>>>
>>>>>>>> 1. A simulation always produces an identical execution trace to
>>>>>>>> the direct execution.
>>>>>>>
>>>>>>> *When pathological self-reference is involved this is
>>>>>>> counter-factual*
>>>>>>> That no one can possibly show the steps of how D simulated by H
>>>>>>> possibly
>>>>>>> reach line 06 of H proves this.
>>>>>>
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> Richard tried to get away with D never simulated by H as an example
>>>>>>> of D simulated by H:
>>>>>>
>>>>>> Nope, you are looking at the WRONG message, and I have told you
>>>>>> this multiple times.
>>>>>
>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>> *When you interpret*
>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>> *Every D simulated by H that cannot possibly*
>>>>> *stop running unless aborted by H*
>>>>>
>>>>> as *D NEVER simulated by H*
>>>>>
>>>>> you have shown a reckless disregard for the truth
>>>>> that would win a defamation case.
>>>>>
>>>>
>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>> simulated correctly.
>>>
>>> *THAT DOES NOT MEET THE SPEC*
>>
>> You haven't GIVEN a defined SPEC.
>>
>> The only definition within Computation Theory, which is the space you
>> started in, and claim to get to, doesn't have "aborted" simulations,
>> so you don't have a defintion of what simulatioin actually means,
>> other than doing something that tells you something about the behavior
>> of what is simulated.
>>
>> My H does that, by aborting its "simulation" in shows that THIS H did
>> not simulate its input to a final state.
>>
>> Just the same result that you partial set of H's showed.
>>
>>> *THAT DOES NOT MEET THE SPEC*
>>> *THAT DOES NOT MEET THE SPEC*
>>> *THAT DOES NOT MEET THE SPEC*
>>>
>>> *Every D simulated by H that cannot possibly*
>>> *stop running unless aborted by H*
>>>
>>> *Every D simulated by H that cannot possibly*
>>> *stop running unless aborted by H*
>>>
>>> *Every D simulated by H that cannot possibly*
>>> *stop running unless aborted by H*
>>>
>>> *Every D simulated by H that cannot possibly*
>>> *stop running unless aborted by H*
>>>
>>> *Every D simulated by H that cannot possibly*
>>> *stop running unless aborted by H*
>>>
>>>
>>
>> Right, and simulating zero steps correctly and them aborting means H
>
> *cannot possibly stop running unless aborted is not met*
Aborted after 0 steps which is all that that H does.
Your term is MEANINGLESS as a given H either does or does not abort a
that point, so if H is a given program it is meaningless.
If H is an "infinite set" of machines, then main can not call such an
infinte set.
So, you question is based on a self-contradictory definition that was
never actually defined.
Which is H, a single program or an infinte set?
Define this or admit you logic is not defined.
> *cannot possibly stop running unless aborted is not met*
> *cannot possibly stop running unless aborted is not met*
> *cannot possibly stop running unless aborted is not met*
> *cannot possibly stop running unless aborted is not met*
>
>> simulated ALL of its steps correctly when it aborted. Simulating ALL
>> steps simulated is a corrrect simulation by your definition.
>>
>> You added LATER, the requirement of 1 to N steps, so, your arguement
>> is just a LIE.
>>
>> Remember, when I ask you for definitions, you refused to try to do it.
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 15:27 -0500 |
| Subject | Richard KEEPS TRYING to get away with this falsehood |
| Message-ID | <v1lvuo$1i47i$1@dont-email.me> |
| In reply to | #333890 |
On 5/10/2024 3:09 PM, Richard Damon wrote:
> On 5/10/24 1:49 PM, olcott wrote:
>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>> On 5/10/24 11:50 AM, olcott wrote:
>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify
>>>>>>>>>>>>>>>>>>>> which set of pairs
>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words
>>>>>>>>>>>>>>>>>>>> don't mean anything.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞
>>>>>>>>>>>>>>>>>>> steps of D
>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations
>>>>>>>>>>>>>>>>>>> where H
>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>>> H/D pairs where each D(D) that is simulated by H(D,D)
>>>>>>>>>>>>>>>> also calls this same H(D,D).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D).
>>>>>>>>>>>>>>>> Every time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We can
>>>>>>>>>>>>>>> think of many more simulations that only these.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This template defines an infinite set of finite string H/D
>>>>>>>>>>>>>> pairs where
>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this same
>>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No-one can possibly show one element of this set where
>>>>>>>>>>>>>> D(D) reaches
>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>>> reaches its line
>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>
>>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>>> recursion works. You can run the code and see that I am
>>>>>>>>>>>> correct.
>>>>>>>>>>>>
>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>
>>>>>>>>>>> HH is completely broken - it uses a global variable which is
>>>>>>>>>>> allows HH to detect whether it is the outer HH or a nested
>>>>>>>>>>> (simulated) HH. As a result, the nested HH behaves completely
>>>>>>>>>>> differently to the outer HH - I mean /completely/
>>>>>>>>>>> differently: it goes through a totally separate "I am called
>>>>>>>>>>> in nested mode" code path!
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The encoding of HH is not the pure function that it needs to
>>>>>>>>>> be to
>>>>>>>>>> be a computable function.
>>>>>>>>>>
>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>
>>>>>>>>>> The disagreement is entirely over an enormously much simpler
>>>>>>>>>> thing.
>>>>>>>>>> The disagreement is that Richard says that a D simulated by H
>>>>>>>>>> could
>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>
>>>>>>>>> Here's the proof:
>>>>>>>>>
>>>>>>>>> 1. A simulation always produces an identical execution trace to
>>>>>>>>> the direct execution.
>>>>>>>>
>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>> counter-factual*
>>>>>>>> That no one can possibly show the steps of how D simulated by H
>>>>>>>> possibly
>>>>>>>> reach line 06 of H proves this.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Richard tried to get away with D never simulated by H as an example
>>>>>>>> of D simulated by H:
>>>>>>>
>>>>>>> Nope, you are looking at the WRONG message, and I have told you
>>>>>>> this multiple times.
>>>>>>
>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>> *When you interpret*
>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>> *Every D simulated by H that cannot possibly*
>>>>>> *stop running unless aborted by H*
>>>>>>
>>>>>> as *D NEVER simulated by H*
>>>>>>
>>>>>> you have shown a reckless disregard for the truth
>>>>>> that would win a defamation case.
>>>>>>
>>>>>
>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>> simulated correctly.
>>>>
>>>> *THAT DOES NOT MEET THE SPEC*
>>>
>>> You haven't GIVEN a defined SPEC.
>>>
>>> The only definition within Computation Theory, which is the space you
>>> started in, and claim to get to, doesn't have "aborted" simulations,
>>> so you don't have a defintion of what simulatioin actually means,
>>> other than doing something that tells you something about the
>>> behavior of what is simulated.
>>>
>>> My H does that, by aborting its "simulation" in shows that THIS H did
>>> not simulate its input to a final state.
>>>
>>> Just the same result that you partial set of H's showed.
>>>
>>>> *THAT DOES NOT MEET THE SPEC*
>>>> *THAT DOES NOT MEET THE SPEC*
>>>> *THAT DOES NOT MEET THE SPEC*
>>>>
>>>> *Every D simulated by H that cannot possibly*
>>>> *stop running unless aborted by H*
>>>>
>>>> *Every D simulated by H that cannot possibly*
>>>> *stop running unless aborted by H*
>>>>
>>>> *Every D simulated by H that cannot possibly*
>>>> *stop running unless aborted by H*
>>>>
>>>> *Every D simulated by H that cannot possibly*
>>>> *stop running unless aborted by H*
>>>>
>>>> *Every D simulated by H that cannot possibly*
>>>> *stop running unless aborted by H*
>>>>
>>>>
>>>
>>> Right, and simulating zero steps correctly and them aborting means H
>>
>> *cannot possibly stop running unless aborted is not met*
>
> Aborted after 0 steps which is all that that H does.
>
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
--
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-10 16:50 -0400 |
| Subject | Re: Richard KEEPS TRYING to get away with this falsehood |
| Message-ID | <v1m1bf$lbo5$4@i2pn2.org> |
| In reply to | #333891 |
On 5/10/24 4:27 PM, olcott wrote:
> On 5/10/2024 3:09 PM, Richard Damon wrote:
>> On 5/10/24 1:49 PM, olcott wrote:
>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify
>>>>>>>>>>>>>>>>>>>>> which set of pairs
>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words
>>>>>>>>>>>>>>>>>>>>> don't mean anything.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞
>>>>>>>>>>>>>>>>>>>> steps of D
>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations
>>>>>>>>>>>>>>>>>>>> where H
>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>>>> H/D pairs where each D(D) that is simulated by H(D,D)
>>>>>>>>>>>>>>>>> also calls this same H(D,D).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D).
>>>>>>>>>>>>>>>>> Every time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We can
>>>>>>>>>>>>>>>> think of many more simulations that only these.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>> H/D pairs where
>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this
>>>>>>>>>>>>>>> same H(D,D).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No-one can possibly show one element of this set where
>>>>>>>>>>>>>>> D(D) reaches
>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>>>> reaches its line
>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>
>>>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>>>> recursion works. You can run the code and see that I am
>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>
>>>>>>>>>>>> HH is completely broken - it uses a global variable which is
>>>>>>>>>>>> allows HH to detect whether it is the outer HH or a nested
>>>>>>>>>>>> (simulated) HH. As a result, the nested HH behaves
>>>>>>>>>>>> completely differently to the outer HH - I mean /completely/
>>>>>>>>>>>> differently: it goes through a totally separate "I am called
>>>>>>>>>>>> in nested mode" code path!
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The encoding of HH is not the pure function that it needs to
>>>>>>>>>>> be to
>>>>>>>>>>> be a computable function.
>>>>>>>>>>>
>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>
>>>>>>>>>>> The disagreement is entirely over an enormously much simpler
>>>>>>>>>>> thing.
>>>>>>>>>>> The disagreement is that Richard says that a D simulated by H
>>>>>>>>>>> could
>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>
>>>>>>>>>> Here's the proof:
>>>>>>>>>>
>>>>>>>>>> 1. A simulation always produces an identical execution trace
>>>>>>>>>> to the direct execution.
>>>>>>>>>
>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>> counter-factual*
>>>>>>>>> That no one can possibly show the steps of how D simulated by H
>>>>>>>>> possibly
>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Richard tried to get away with D never simulated by H as an
>>>>>>>>> example
>>>>>>>>> of D simulated by H:
>>>>>>>>
>>>>>>>> Nope, you are looking at the WRONG message, and I have told you
>>>>>>>> this multiple times.
>>>>>>>
>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>> *When you interpret*
>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>> *stop running unless aborted by H*
>>>>>>>
>>>>>>> as *D NEVER simulated by H*
>>>>>>>
>>>>>>> you have shown a reckless disregard for the truth
>>>>>>> that would win a defamation case.
>>>>>>>
>>>>>>
>>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>>> simulated correctly.
>>>>>
>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>
>>>> You haven't GIVEN a defined SPEC.
>>>>
>>>> The only definition within Computation Theory, which is the space
>>>> you started in, and claim to get to, doesn't have "aborted"
>>>> simulations, so you don't have a defintion of what simulatioin
>>>> actually means, other than doing something that tells you something
>>>> about the behavior of what is simulated.
>>>>
>>>> My H does that, by aborting its "simulation" in shows that THIS H
>>>> did not simulate its input to a final state.
>>>>
>>>> Just the same result that you partial set of H's showed.
>>>>
>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>
>>>>> *Every D simulated by H that cannot possibly*
>>>>> *stop running unless aborted by H*
>>>>>
>>>>> *Every D simulated by H that cannot possibly*
>>>>> *stop running unless aborted by H*
>>>>>
>>>>> *Every D simulated by H that cannot possibly*
>>>>> *stop running unless aborted by H*
>>>>>
>>>>> *Every D simulated by H that cannot possibly*
>>>>> *stop running unless aborted by H*
>>>>>
>>>>> *Every D simulated by H that cannot possibly*
>>>>> *stop running unless aborted by H*
>>>>>
>>>>>
>>>>
>>>> Right, and simulating zero steps correctly and them aborting means H
>>>
>>> *cannot possibly stop running unless aborted is not met*
>>
>> Aborted after 0 steps which is all that that H does.
>>
>
> *cannot possibly stop running unless aborted is not met*
> *BY cannot possibly start running*
>
> *cannot possibly stop running unless aborted is not met*
> *BY cannot possibly start running*
>
> *cannot possibly stop running unless aborted is not met*
> *BY cannot possibly start running*
>
> *cannot possibly stop running unless aborted is not met*
> *BY cannot possibly start running*
>
You can start and then immediately stop an not make any progress.
A bit like your "first point after 0".
You just don't understand how logic works.
And your definition is also illogical, as H either DOES or DOES NOT
abort its simulation.
How do you expect people to believe you understand "software
engineering" when you make such basic errors.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 16:11 -0500 |
| Subject | Re: Richard KEEPS TRYING to get away with this falsehood |
| Message-ID | <v1m2hc$1ijhr$1@dont-email.me> |
| In reply to | #333892 |
On 5/10/2024 3:50 PM, Richard Damon wrote:
> On 5/10/24 4:27 PM, olcott wrote:
>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>> On 5/10/24 1:49 PM, olcott wrote:
>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify
>>>>>>>>>>>>>>>>>>>>>> which set of pairs
>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words
>>>>>>>>>>>>>>>>>>>>>> don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞
>>>>>>>>>>>>>>>>>>>>> steps of D
>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations
>>>>>>>>>>>>>>>>>>>>> where H
>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>>>>> H/D pairs where each D(D) that is simulated by H(D,D)
>>>>>>>>>>>>>>>>>> also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D).
>>>>>>>>>>>>>>>>>> Every time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We can
>>>>>>>>>>>>>>>>> think of many more simulations that only these.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>>> H/D pairs where
>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this
>>>>>>>>>>>>>>>> same H(D,D).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No-one can possibly show one element of this set where
>>>>>>>>>>>>>>>> D(D) reaches
>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>>>>> reaches its line
>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>>>>> recursion works. You can run the code and see that I am
>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>
>>>>>>>>>>>>> HH is completely broken - it uses a global variable which
>>>>>>>>>>>>> is allows HH to detect whether it is the outer HH or a
>>>>>>>>>>>>> nested (simulated) HH. As a result, the nested HH behaves
>>>>>>>>>>>>> completely differently to the outer HH - I mean
>>>>>>>>>>>>> /completely/ differently: it goes through a totally
>>>>>>>>>>>>> separate "I am called in nested mode" code path!
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The encoding of HH is not the pure function that it needs to
>>>>>>>>>>>> be to
>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>
>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>
>>>>>>>>>>>> The disagreement is entirely over an enormously much simpler
>>>>>>>>>>>> thing.
>>>>>>>>>>>> The disagreement is that Richard says that a D simulated by
>>>>>>>>>>>> H could
>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>
>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>
>>>>>>>>>>> 1. A simulation always produces an identical execution trace
>>>>>>>>>>> to the direct execution.
>>>>>>>>>>
>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>> counter-factual*
>>>>>>>>>> That no one can possibly show the steps of how D simulated by
>>>>>>>>>> H possibly
>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Richard tried to get away with D never simulated by H as an
>>>>>>>>>> example
>>>>>>>>>> of D simulated by H:
>>>>>>>>>
>>>>>>>>> Nope, you are looking at the WRONG message, and I have told you
>>>>>>>>> this multiple times.
>>>>>>>>
>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>> *When you interpret*
>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>> *stop running unless aborted by H*
>>>>>>>>
>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>
>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>> that would win a defamation case.
>>>>>>>>
>>>>>>>
>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>>>> simulated correctly.
>>>>>>
>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>
>>>>> You haven't GIVEN a defined SPEC.
>>>>>
>>>>> The only definition within Computation Theory, which is the space
>>>>> you started in, and claim to get to, doesn't have "aborted"
>>>>> simulations, so you don't have a defintion of what simulatioin
>>>>> actually means, other than doing something that tells you something
>>>>> about the behavior of what is simulated.
>>>>>
>>>>> My H does that, by aborting its "simulation" in shows that THIS H
>>>>> did not simulate its input to a final state.
>>>>>
>>>>> Just the same result that you partial set of H's showed.
>>>>>
>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>
>>>>>> *Every D simulated by H that cannot possibly*
>>>>>> *stop running unless aborted by H*
>>>>>>
>>>>>> *Every D simulated by H that cannot possibly*
>>>>>> *stop running unless aborted by H*
>>>>>>
>>>>>> *Every D simulated by H that cannot possibly*
>>>>>> *stop running unless aborted by H*
>>>>>>
>>>>>> *Every D simulated by H that cannot possibly*
>>>>>> *stop running unless aborted by H*
>>>>>>
>>>>>> *Every D simulated by H that cannot possibly*
>>>>>> *stop running unless aborted by H*
>>>>>>
>>>>>>
>>>>>
>>>>> Right, and simulating zero steps correctly and them aborting means H
>>>>
>>>> *cannot possibly stop running unless aborted is not met*
>>>
>>> Aborted after 0 steps which is all that that H does.
>>>
>>
>> *cannot possibly stop running unless aborted is not met*
>> *BY cannot possibly start running*
>
>>
>> *cannot possibly stop running unless aborted is not met*
>> *BY cannot possibly start running*
>>
>> *cannot possibly stop running unless aborted is not met*
>> *BY cannot possibly start running*
>>
>> *cannot possibly stop running unless aborted is not met*
>> *BY cannot possibly start running*
>>
>
> You can start and then immediately stop an not make any progress.
>
> A bit like your "first point after 0".
>
> You just don't understand how logic works.
>
> And your definition is also illogical, as H either DOES or DOES NOT
> abort its simulation.
>
*WRONG DICHOTOMY STRAW-MAN DECEPTION*
"...cannot possibly stop running unless aborted"
*stops running if not aborted or keeps running if not aborted*
*WRONG DICHOTOMY STRAW-MAN DECEPTION*
"...cannot possibly stop running unless aborted"
*stops running if not aborted or keeps running if not aborted*
*WRONG DICHOTOMY STRAW-MAN DECEPTION*
"...cannot possibly stop running unless aborted"
*stops running if not aborted or keeps running if not aborted*
--
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-10 17:19 -0400 |
| Subject | Olcott thinks something isn't iteself. |
| Message-ID | <v1m31m$lbo4$1@i2pn2.org> |
| In reply to | #333893 |
On 5/10/24 5:11 PM, olcott wrote:
> On 5/10/2024 3:50 PM, Richard Damon wrote:
>> On 5/10/24 4:27 PM, olcott wrote:
>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify
>>>>>>>>>>>>>>>>>>>>>>> which set of pairs
>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words
>>>>>>>>>>>>>>>>>>>>>>> don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞
>>>>>>>>>>>>>>>>>>>>>> steps of D
>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations
>>>>>>>>>>>>>>>>>>>>>> where H
>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is simulated by
>>>>>>>>>>>>>>>>>>> H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D).
>>>>>>>>>>>>>>>>>>> Every time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated by H
>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H
>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated by H
>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated by H
>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We
>>>>>>>>>>>>>>>>>> can think of many more simulations that only these.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>>>> H/D pairs where
>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this
>>>>>>>>>>>>>>>>> same H(D,D).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set where
>>>>>>>>>>>>>>>>> D(D) reaches
>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>>>>>> reaches its line
>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>>>>>> recursion works. You can run the code and see that I am
>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> HH is completely broken - it uses a global variable which
>>>>>>>>>>>>>> is allows HH to detect whether it is the outer HH or a
>>>>>>>>>>>>>> nested (simulated) HH. As a result, the nested HH behaves
>>>>>>>>>>>>>> completely differently to the outer HH - I mean
>>>>>>>>>>>>>> /completely/ differently: it goes through a totally
>>>>>>>>>>>>>> separate "I am called in nested mode" code path!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The encoding of HH is not the pure function that it needs
>>>>>>>>>>>>> to be to
>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>
>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>> The disagreement is that Richard says that a D simulated by
>>>>>>>>>>>>> H could
>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>
>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>
>>>>>>>>>>>> 1. A simulation always produces an identical execution trace
>>>>>>>>>>>> to the direct execution.
>>>>>>>>>>>
>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>> counter-factual*
>>>>>>>>>>> That no one can possibly show the steps of how D simulated by
>>>>>>>>>>> H possibly
>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Richard tried to get away with D never simulated by H as an
>>>>>>>>>>> example
>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>
>>>>>>>>>> Nope, you are looking at the WRONG message, and I have told
>>>>>>>>>> you this multiple times.
>>>>>>>>>
>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>> *When you interpret*
>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>
>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>
>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>> that would win a defamation case.
>>>>>>>>>
>>>>>>>>
>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>>>>> simulated correctly.
>>>>>>>
>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>
>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>
>>>>>> The only definition within Computation Theory, which is the space
>>>>>> you started in, and claim to get to, doesn't have "aborted"
>>>>>> simulations, so you don't have a defintion of what simulatioin
>>>>>> actually means, other than doing something that tells you
>>>>>> something about the behavior of what is simulated.
>>>>>>
>>>>>> My H does that, by aborting its "simulation" in shows that THIS H
>>>>>> did not simulate its input to a final state.
>>>>>>
>>>>>> Just the same result that you partial set of H's showed.
>>>>>>
>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>
>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>> *stop running unless aborted by H*
>>>>>>>
>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>> *stop running unless aborted by H*
>>>>>>>
>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>> *stop running unless aborted by H*
>>>>>>>
>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>> *stop running unless aborted by H*
>>>>>>>
>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>> *stop running unless aborted by H*
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, and simulating zero steps correctly and them aborting means H
>>>>>
>>>>> *cannot possibly stop running unless aborted is not met*
>>>>
>>>> Aborted after 0 steps which is all that that H does.
>>>>
>>>
>>> *cannot possibly stop running unless aborted is not met*
>>> *BY cannot possibly start running*
>>
>>>
>>> *cannot possibly stop running unless aborted is not met*
>>> *BY cannot possibly start running*
>>>
>>> *cannot possibly stop running unless aborted is not met*
>>> *BY cannot possibly start running*
>>>
>>> *cannot possibly stop running unless aborted is not met*
>>> *BY cannot possibly start running*
>>>
>>
>> You can start and then immediately stop an not make any progress.
>>
>> A bit like your "first point after 0".
>>
>> You just don't understand how logic works.
>>
>> And your definition is also illogical, as H either DOES or DOES NOT
>> abort its simulation.
>>
>
> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
But there is no Dichotomy, as there is just H, an not something to
compare it to.
The other thing you compare it to is not H.
> "...cannot possibly stop running unless aborted"
> *stops running if not aborted or keeps running if not aborted*
But *THE* H does one or the other.
There does not exist an H that this applies to.
If H aborts its simulation then there does not exist a "not stop
running" case for that machine.
Yoor phrase is just a self-inconstant lie.
>
> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
> "...cannot possibly stop running unless aborted"
> *stops running if not aborted or keeps running if not aborted*
>
> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
> "...cannot possibly stop running unless aborted"
> *stops running if not aborted or keeps running if not aborted*
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 16:43 -0500 |
| Subject | Richard KEEPS TRYING to get away with this falsehood |
| Message-ID | <v1m4et$1iv85$1@dont-email.me> |
| In reply to | #333894 |
On 5/10/2024 4:19 PM, Richard Damon wrote:
> On 5/10/24 5:11 PM, olcott wrote:
>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>> On 5/10/24 4:27 PM, olcott wrote:
>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should specify
>>>>>>>>>>>>>>>>>>>>>>>> which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words
>>>>>>>>>>>>>>>>>>>>>>>> don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>> steps of D
>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive simulations
>>>>>>>>>>>>>>>>>>>>>>> where H
>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is simulated
>>>>>>>>>>>>>>>>>>>> by H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D).
>>>>>>>>>>>>>>>>>>>> Every time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated
>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated
>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated
>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated
>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated
>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We
>>>>>>>>>>>>>>>>>>> can think of many more simulations that only these.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite string
>>>>>>>>>>>>>>>>>> H/D pairs where
>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this
>>>>>>>>>>>>>>>>>> same H(D,D).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set where
>>>>>>>>>>>>>>>>>> D(D) reaches
>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>>>>>>> reaches its line
>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>>>>>>> recursion works. You can run the code and see that I am
>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable which
>>>>>>>>>>>>>>> is allows HH to detect whether it is the outer HH or a
>>>>>>>>>>>>>>> nested (simulated) HH. As a result, the nested HH behaves
>>>>>>>>>>>>>>> completely differently to the outer HH - I mean
>>>>>>>>>>>>>>> /completely/ differently: it goes through a totally
>>>>>>>>>>>>>>> separate "I am called in nested mode" code path!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The encoding of HH is not the pure function that it needs
>>>>>>>>>>>>>> to be to
>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>> The disagreement is that Richard says that a D simulated
>>>>>>>>>>>>>> by H could
>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>
>>>>>>>>>>>>> 1. A simulation always produces an identical execution
>>>>>>>>>>>>> trace to the direct execution.
>>>>>>>>>>>>
>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>> That no one can possibly show the steps of how D simulated
>>>>>>>>>>>> by H possibly
>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Richard tried to get away with D never simulated by H as an
>>>>>>>>>>>> example
>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>
>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have told
>>>>>>>>>>> you this multiple times.
>>>>>>>>>>
>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>> *When you interpret*
>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>
>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>
>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>>>>>> simulated correctly.
>>>>>>>>
>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>
>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>
>>>>>>> The only definition within Computation Theory, which is the space
>>>>>>> you started in, and claim to get to, doesn't have "aborted"
>>>>>>> simulations, so you don't have a defintion of what simulatioin
>>>>>>> actually means, other than doing something that tells you
>>>>>>> something about the behavior of what is simulated.
>>>>>>>
>>>>>>> My H does that, by aborting its "simulation" in shows that THIS H
>>>>>>> did not simulate its input to a final state.
>>>>>>>
>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>
>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>
>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>> *stop running unless aborted by H*
>>>>>>>>
>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>> *stop running unless aborted by H*
>>>>>>>>
>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>> *stop running unless aborted by H*
>>>>>>>>
>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>> *stop running unless aborted by H*
>>>>>>>>
>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>> *stop running unless aborted by H*
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, and simulating zero steps correctly and them aborting means H
>>>>>>
>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>
>>>>> Aborted after 0 steps which is all that that H does.
>>>>>
>>>>
>>>> *cannot possibly stop running unless aborted is not met*
>>>> *BY cannot possibly start running*
>>>
>>>>
>>>> *cannot possibly stop running unless aborted is not met*
>>>> *BY cannot possibly start running*
>>>>
>>>> *cannot possibly stop running unless aborted is not met*
>>>> *BY cannot possibly start running*
>>>>
>>>> *cannot possibly stop running unless aborted is not met*
>>>> *BY cannot possibly start running*
>>>>
>>>
>>> You can start and then immediately stop an not make any progress.
>>>
>>> A bit like your "first point after 0".
>>>
>>> You just don't understand how logic works.
>>>
>>> And your definition is also illogical, as H either DOES or DOES NOT
>>> abort its simulation.
>>>
>>
>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>
> But there is no Dichotomy, as there is just H, an not something to
> compare it to.
>
> The other thing you compare it to is not H.
>
>> "...cannot possibly stop running unless aborted"
>> *stops running if not aborted or keeps running if not aborted*
>
> But *THE* H does one or the other.
>
Is your employer aware that your memory is this bad?
Are you in management where slick double-talk can hide this?
*I have repeated time and again that I have always been referring*
*to the specific infinite set of H/D pairs specified below*
*I have repeated time and again that I have always been referring*
*to the specific infinite set of H/D pairs specified below*
*I have repeated time and again that I have always been referring*
*to the specific infinite set of H/D pairs specified below*
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 }
Any H/D pair matching the above template where D(D) is simulated
by the same H(D,D) that it calls cannot possibly reach past its own
line 03. Simple software engineering verified fact.
--
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-10 17:59 -0400 |
| Subject | Olcott can't tell the difference between a machine and an infinte set of machines |
| Message-ID | <v1m5co$lbo4$2@i2pn2.org> |
| In reply to | #333895 |
On 5/10/24 5:43 PM, olcott wrote:
> On 5/10/2024 4:19 PM, Richard Damon wrote:
>> On 5/10/24 5:11 PM, olcott wrote:
>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your words
>>>>>>>>>>>>>>>>>>>>>>>>> don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to
>>>>>>>>>>>>>>>>>>>>>>>> ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is simulated
>>>>>>>>>>>>>>>>>>>>> by H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞
>>>>>>>>>>>>>>>>>>>>> recursive simulations of H simulating itself
>>>>>>>>>>>>>>>>>>>>> simulating D(D). Every time Lines 1,2,3 are
>>>>>>>>>>>>>>>>>>>>> simulated again defines
>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is simulated
>>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated
>>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated
>>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are simulated
>>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are simulated by
>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at line 02
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are simulated by
>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at line 03
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are simulated
>>>>>>>>>>>>>>>>>>>>> by H
>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at line 01
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We
>>>>>>>>>>>>>>>>>>>> can think of many more simulations that only these.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls this
>>>>>>>>>>>>>>>>>>> same H(D,D).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set
>>>>>>>>>>>>>>>>>>> where D(D) reaches
>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from it
>>>>>>>>>>>>>>>>>> reaches its line
>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how infinite
>>>>>>>>>>>>>>>>> recursion works. You can run the code and see that I am
>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable
>>>>>>>>>>>>>>>> which is allows HH to detect whether it is the outer HH
>>>>>>>>>>>>>>>> or a nested (simulated) HH. As a result, the nested HH
>>>>>>>>>>>>>>>> behaves completely differently to the outer HH - I mean
>>>>>>>>>>>>>>>> /completely/ differently: it goes through a totally
>>>>>>>>>>>>>>>> separate "I am called in nested mode" code path!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it needs
>>>>>>>>>>>>>>> to be to
>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>>> The disagreement is that Richard says that a D simulated
>>>>>>>>>>>>>>> by H could
>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 1. A simulation always produces an identical execution
>>>>>>>>>>>>>> trace to the direct execution.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>> That no one can possibly show the steps of how D simulated
>>>>>>>>>>>>> by H possibly
>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Richard tried to get away with D never simulated by H as an
>>>>>>>>>>>>> example
>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have told
>>>>>>>>>>>> you this multiple times.
>>>>>>>>>>>
>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>> *When you interpret*
>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>
>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>
>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>>>>>>> simulated correctly.
>>>>>>>>>
>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>
>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>
>>>>>>>> The only definition within Computation Theory, which is the
>>>>>>>> space you started in, and claim to get to, doesn't have
>>>>>>>> "aborted" simulations, so you don't have a defintion of what
>>>>>>>> simulatioin actually means, other than doing something that
>>>>>>>> tells you something about the behavior of what is simulated.
>>>>>>>>
>>>>>>>> My H does that, by aborting its "simulation" in shows that THIS
>>>>>>>> H did not simulate its input to a final state.
>>>>>>>>
>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>
>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>
>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>
>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>
>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>
>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>
>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, and simulating zero steps correctly and them aborting
>>>>>>>> means H
>>>>>>>
>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>
>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>
>>>>>
>>>>> *cannot possibly stop running unless aborted is not met*
>>>>> *BY cannot possibly start running*
>>>>
>>>>>
>>>>> *cannot possibly stop running unless aborted is not met*
>>>>> *BY cannot possibly start running*
>>>>>
>>>>> *cannot possibly stop running unless aborted is not met*
>>>>> *BY cannot possibly start running*
>>>>>
>>>>> *cannot possibly stop running unless aborted is not met*
>>>>> *BY cannot possibly start running*
>>>>>
>>>>
>>>> You can start and then immediately stop an not make any progress.
>>>>
>>>> A bit like your "first point after 0".
>>>>
>>>> You just don't understand how logic works.
>>>>
>>>> And your definition is also illogical, as H either DOES or DOES NOT
>>>> abort its simulation.
>>>>
>>>
>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>
>> But there is no Dichotomy, as there is just H, an not something to
>> compare it to.
>>
>> The other thing you compare it to is not H.
>>
>>> "...cannot possibly stop running unless aborted"
>>> *stops running if not aborted or keeps running if not aborted*
>>
>> But *THE* H does one or the other.
>>
>
> Is your employer aware that your memory is this bad?
> Are you in management where slick double-talk can hide this?
Well, since you don't have an employer, I guess we can tell who performs
better.
>
> *I have repeated time and again that I have always been referring*
> *to the specific infinite set of H/D pairs specified below*
And how does MAIN call an "Infinite set" of functions?
And how is that an exact implementation of the Linz Proof, were H and H^
are specific (but arbitrary) machines?
Or Sipsers proof, where again H is a single specific (but arbitary)
machine and D is a single specific one made from it?
>
> *I have repeated time and again that I have always been referring*
> *to the specific infinite set of H/D pairs specified below*
>
> *I have repeated time and again that I have always been referring*
> *to the specific infinite set of H/D pairs specified below*
>
> 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 }
>
> Any H/D pair matching the above template where D(D) is simulated
> by the same H(D,D) that it calls cannot possibly reach past its own
> line 03. Simple software engineering verified fact.
>
Which has been proven to be a LIE.
And, you clearly don't belive that I didn't prove it, as you refuse to
commit to the put up or shut up challange, so your repeating the claim
is just an admonition that your logic is based on lying.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 17:28 -0500 |
| Subject | Richard KEEPS TRYING to get away with falsehood |
| Message-ID | <v1m71h$1jnpi$1@dont-email.me> |
| In reply to | #333896 |
On 5/10/2024 4:59 PM, Richard Damon wrote:
> On 5/10/24 5:43 PM, olcott wrote:
>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>> On 5/10/24 5:11 PM, olcott wrote:
>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your
>>>>>>>>>>>>>>>>>>>>>>>>>> words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to
>>>>>>>>>>>>>>>>>>>>>>>>> ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is simulated
>>>>>>>>>>>>>>>>>>>>>> by H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞
>>>>>>>>>>>>>>>>>>>>>> recursive simulations of H simulating itself
>>>>>>>>>>>>>>>>>>>>>> simulating D(D). Every time Lines 1,2,3 are
>>>>>>>>>>>>>>>>>>>>>> simulated again defines
>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at line 01
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>> line 02
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>> line 03
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at
>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H? We
>>>>>>>>>>>>>>>>>>>>> can think of many more simulations that only these.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls
>>>>>>>>>>>>>>>>>>>> this same H(D,D).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set
>>>>>>>>>>>>>>>>>>>> where D(D) reaches
>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from
>>>>>>>>>>>>>>>>>>> it reaches its line
>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how
>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see that I
>>>>>>>>>>>>>>>>>> am correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable
>>>>>>>>>>>>>>>>> which is allows HH to detect whether it is the outer HH
>>>>>>>>>>>>>>>>> or a nested (simulated) HH. As a result, the nested HH
>>>>>>>>>>>>>>>>> behaves completely differently to the outer HH - I mean
>>>>>>>>>>>>>>>>> /completely/ differently: it goes through a totally
>>>>>>>>>>>>>>>>> separate "I am called in nested mode" code path!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it
>>>>>>>>>>>>>>>> needs to be to
>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D simulated
>>>>>>>>>>>>>>>> by H could
>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1. A simulation always produces an identical execution
>>>>>>>>>>>>>>> trace to the direct execution.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>>> That no one can possibly show the steps of how D simulated
>>>>>>>>>>>>>> by H possibly
>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Richard tried to get away with D never simulated by H as
>>>>>>>>>>>>>> an example
>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have told
>>>>>>>>>>>>> you this multiple times.
>>>>>>>>>>>>
>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>
>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>
>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps it
>>>>>>>>>>> simulated correctly.
>>>>>>>>>>
>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>
>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>
>>>>>>>>> The only definition within Computation Theory, which is the
>>>>>>>>> space you started in, and claim to get to, doesn't have
>>>>>>>>> "aborted" simulations, so you don't have a defintion of what
>>>>>>>>> simulatioin actually means, other than doing something that
>>>>>>>>> tells you something about the behavior of what is simulated.
>>>>>>>>>
>>>>>>>>> My H does that, by aborting its "simulation" in shows that THIS
>>>>>>>>> H did not simulate its input to a final state.
>>>>>>>>>
>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>
>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>
>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>
>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>
>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>
>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>
>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, and simulating zero steps correctly and them aborting
>>>>>>>>> means H
>>>>>>>>
>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>
>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>
>>>>>>
>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>> *BY cannot possibly start running*
>>>>>
>>>>>>
>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>> *BY cannot possibly start running*
>>>>>>
>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>> *BY cannot possibly start running*
>>>>>>
>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>> *BY cannot possibly start running*
>>>>>>
>>>>>
>>>>> You can start and then immediately stop an not make any progress.
>>>>>
>>>>> A bit like your "first point after 0".
>>>>>
>>>>> You just don't understand how logic works.
>>>>>
>>>>> And your definition is also illogical, as H either DOES or DOES NOT
>>>>> abort its simulation.
>>>>>
>>>>
>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>
>>> But there is no Dichotomy, as there is just H, an not something to
>>> compare it to.
>>>
>>> The other thing you compare it to is not H.
>>>
>>>> "...cannot possibly stop running unless aborted"
>>>> *stops running if not aborted or keeps running if not aborted*
>>>
>>> But *THE* H does one or the other.
>>>
>>
>> Is your employer aware that your memory is this bad?
>> Are you in management where slick double-talk can hide this?
>
> Well, since you don't have an employer, I guess we can tell who performs
> better.
>
>>
>> *I have repeated time and again that I have always been referring*
>> *to the specific infinite set of H/D pairs specified below*
>
> And how does MAIN call an "Infinite set" of functions?
>
> And how is that an exact implementation of the Linz Proof, were H and H^
> are specific (but arbitrary) machines?
>
A "specific" and "arbitrary" machine is like a
very tiny little enormously huge thing.
We can have specific elements of an infinite set such
that every element of this set has common properties.
The Linz H specifies all of the elements of an infinite
set of implementations of this Linz template:
*Original Linz Turing Machine H*
H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
H.q0 ⟨M⟩ w ⊢* H.qn // M applied to w does not halt
--
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-10 18:39 -0400 |
| Subject | Olcott thinks One is Infinity |
| Message-ID | <v1m7mh$lbo5$5@i2pn2.org> |
| In reply to | #333897 |
On 5/10/24 6:28 PM, olcott wrote:
> On 5/10/2024 4:59 PM, Richard Damon wrote:
>> On 5/10/24 5:43 PM, olcott wrote:
>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your
>>>>>>>>>>>>>>>>>>>>>>>>>>> words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1
>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is
>>>>>>>>>>>>>>>>>>>>>>> simulated by H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to ∞
>>>>>>>>>>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞
>>>>>>>>>>>>>>>>>>>>>>> recursive simulations of H simulating itself
>>>>>>>>>>>>>>>>>>>>>>> simulating D(D). Every time Lines 1,2,3 are
>>>>>>>>>>>>>>>>>>>>>>> simulated again defines
>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>> line 02
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>> line 03
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H?
>>>>>>>>>>>>>>>>>>>>>> We can think of many more simulations that only
>>>>>>>>>>>>>>>>>>>>>> these.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls
>>>>>>>>>>>>>>>>>>>>> this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set
>>>>>>>>>>>>>>>>>>>>> where D(D) reaches
>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from
>>>>>>>>>>>>>>>>>>>> it reaches its line
>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by H
>>>>>>>>>>>>>>>>>>>> reaches that line
>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how
>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see that I
>>>>>>>>>>>>>>>>>>> am correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable
>>>>>>>>>>>>>>>>>> which is allows HH to detect whether it is the outer
>>>>>>>>>>>>>>>>>> HH or a nested (simulated) HH. As a result, the nested
>>>>>>>>>>>>>>>>>> HH behaves completely differently to the outer HH - I
>>>>>>>>>>>>>>>>>> mean /completely/ differently: it goes through a
>>>>>>>>>>>>>>>>>> totally separate "I am called in nested mode" code path!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it
>>>>>>>>>>>>>>>>> needs to be to
>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1. A simulation always produces an identical execution
>>>>>>>>>>>>>>>> trace to the direct execution.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by H as
>>>>>>>>>>>>>>> an example
>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have
>>>>>>>>>>>>>> told you this multiple times.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps
>>>>>>>>>>>> it simulated correctly.
>>>>>>>>>>>
>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>
>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>
>>>>>>>>>> The only definition within Computation Theory, which is the
>>>>>>>>>> space you started in, and claim to get to, doesn't have
>>>>>>>>>> "aborted" simulations, so you don't have a defintion of what
>>>>>>>>>> simulatioin actually means, other than doing something that
>>>>>>>>>> tells you something about the behavior of what is simulated.
>>>>>>>>>>
>>>>>>>>>> My H does that, by aborting its "simulation" in shows that
>>>>>>>>>> THIS H did not simulate its input to a final state.
>>>>>>>>>>
>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>
>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>
>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>
>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>
>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>
>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>
>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, and simulating zero steps correctly and them aborting
>>>>>>>>>> means H
>>>>>>>>>
>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>
>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>
>>>>>>>
>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>> *BY cannot possibly start running*
>>>>>>
>>>>>>>
>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>> *BY cannot possibly start running*
>>>>>>>
>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>> *BY cannot possibly start running*
>>>>>>>
>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>> *BY cannot possibly start running*
>>>>>>>
>>>>>>
>>>>>> You can start and then immediately stop an not make any progress.
>>>>>>
>>>>>> A bit like your "first point after 0".
>>>>>>
>>>>>> You just don't understand how logic works.
>>>>>>
>>>>>> And your definition is also illogical, as H either DOES or DOES
>>>>>> NOT abort its simulation.
>>>>>>
>>>>>
>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>
>>>> But there is no Dichotomy, as there is just H, an not something to
>>>> compare it to.
>>>>
>>>> The other thing you compare it to is not H.
>>>>
>>>>> "...cannot possibly stop running unless aborted"
>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>
>>>> But *THE* H does one or the other.
>>>>
>>>
>>> Is your employer aware that your memory is this bad?
>>> Are you in management where slick double-talk can hide this?
>>
>> Well, since you don't have an employer, I guess we can tell who
>> performs better.
>>
>>>
>>> *I have repeated time and again that I have always been referring*
>>> *to the specific infinite set of H/D pairs specified below*
>>
>> And how does MAIN call an "Infinite set" of functions?
>>
>> And how is that an exact implementation of the Linz Proof, were H and
>> H^ are specific (but arbitrary) machines?
>>
>
> A "specific" and "arbitrary" machine is like a
> very tiny little enormously huge thing.
>
> We can have specific elements of an infinite set such
> that every element of this set has common properties.
But the element is different then the set.
Your logic is just like Nieve set theory, broken.
>
> The Linz H specifies all of the elements of an infinite
> set of implementations of this Linz template:
Nope, Linz H is a specific machine selected out of a set of machines
that meets the requirements.
The set that turns out to be empty (not infinite).
>
> *Original Linz Turing Machine H*
> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
> H.q0 ⟨M⟩ w ⊢* H.qn // M applied to w does not halt
>
>
Right, the SPECIFICATION for the machine allows for any arbitrary
machine to be chosen from the set.
But the H in the proof *IS* a specific machine built to that specification.
And H^ is a specific machine built from that specific machine.
You just don't undertand that simple fact, because you don't understand
what the definitions of the basic terms are.
You seem to think that ONE == INFINITY.
Poor stupid Olcott.
Doesn't understand the meaning of the words of Categorical logic, or set
theory.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 18:39 -0500 |
| Subject | Richard seems to be a liar. |
| Message-ID | <v1mb8f$1kgpl$1@dont-email.me> |
| In reply to | #333898 |
On 5/10/2024 5:39 PM, Richard Damon wrote:
> On 5/10/24 6:28 PM, olcott wrote:
>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>> On 5/10/24 5:43 PM, olcott wrote:
>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>> words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1
>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical set
>>>>>>>>>>>>>>>>>>>>>>>>>> theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to
>>>>>>>>>>>>>>>>>>>>>>>> ∞ simulated steps of D and involve zero to ∞
>>>>>>>>>>>>>>>>>>>>>>>> recursive simulations of H simulating itself
>>>>>>>>>>>>>>>>>>>>>>>> simulating D(D). Every time Lines 1,2,3 are
>>>>>>>>>>>>>>>>>>>>>>>> simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>> line 02
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>> line 03
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H?
>>>>>>>>>>>>>>>>>>>>>>> We can think of many more simulations that only
>>>>>>>>>>>>>>>>>>>>>>> these.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls
>>>>>>>>>>>>>>>>>>>>>> this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set
>>>>>>>>>>>>>>>>>>>>>> where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build from
>>>>>>>>>>>>>>>>>>>>> it reaches its line
>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by
>>>>>>>>>>>>>>>>>>>>> H reaches that line
>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how
>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see that I
>>>>>>>>>>>>>>>>>>>> am correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational code.
>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable
>>>>>>>>>>>>>>>>>>> which is allows HH to detect whether it is the outer
>>>>>>>>>>>>>>>>>>> HH or a nested (simulated) HH. As a result, the
>>>>>>>>>>>>>>>>>>> nested HH behaves completely differently to the outer
>>>>>>>>>>>>>>>>>>> HH - I mean /completely/ differently: it goes through
>>>>>>>>>>>>>>>>>>> a totally separate "I am called in nested mode" code
>>>>>>>>>>>>>>>>>>> path!
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it
>>>>>>>>>>>>>>>>>> needs to be to
>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical execution
>>>>>>>>>>>>>>>>> trace to the direct execution.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by H as
>>>>>>>>>>>>>>>> an example
>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have
>>>>>>>>>>>>>>> told you this multiple times.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps
>>>>>>>>>>>>> it simulated correctly.
>>>>>>>>>>>>
>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>
>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>
>>>>>>>>>>> The only definition within Computation Theory, which is the
>>>>>>>>>>> space you started in, and claim to get to, doesn't have
>>>>>>>>>>> "aborted" simulations, so you don't have a defintion of what
>>>>>>>>>>> simulatioin actually means, other than doing something that
>>>>>>>>>>> tells you something about the behavior of what is simulated.
>>>>>>>>>>>
>>>>>>>>>>> My H does that, by aborting its "simulation" in shows that
>>>>>>>>>>> THIS H did not simulate its input to a final state.
>>>>>>>>>>>
>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>
>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>
>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>
>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>
>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>
>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>
>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, and simulating zero steps correctly and them aborting
>>>>>>>>>>> means H
>>>>>>>>>>
>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>
>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>> *BY cannot possibly start running*
>>>>>>>
>>>>>>>>
>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>> *BY cannot possibly start running*
>>>>>>>>
>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>> *BY cannot possibly start running*
>>>>>>>>
>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>> *BY cannot possibly start running*
>>>>>>>>
>>>>>>>
>>>>>>> You can start and then immediately stop an not make any progress.
>>>>>>>
>>>>>>> A bit like your "first point after 0".
>>>>>>>
>>>>>>> You just don't understand how logic works.
>>>>>>>
>>>>>>> And your definition is also illogical, as H either DOES or DOES
>>>>>>> NOT abort its simulation.
>>>>>>>
>>>>>>
>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>
>>>>> But there is no Dichotomy, as there is just H, an not something to
>>>>> compare it to.
>>>>>
>>>>> The other thing you compare it to is not H.
>>>>>
>>>>>> "...cannot possibly stop running unless aborted"
>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>
>>>>> But *THE* H does one or the other.
>>>>>
>>>>
>>>> Is your employer aware that your memory is this bad?
>>>> Are you in management where slick double-talk can hide this?
>>>
>>> Well, since you don't have an employer, I guess we can tell who
>>> performs better.
>>>
>>>>
>>>> *I have repeated time and again that I have always been referring*
>>>> *to the specific infinite set of H/D pairs specified below*
>>>
>>> And how does MAIN call an "Infinite set" of functions?
>>>
>>> And how is that an exact implementation of the Linz Proof, were H and
>>> H^ are specific (but arbitrary) machines?
>>>
>>
>> A "specific" and "arbitrary" machine is like a
>> very tiny little enormously huge thing.
>>
>> We can have specific elements of an infinite set such
>> that every element of this set has common properties.
>
> But the element is different then the set.
>
One element of any type of set theory set is different
THAN (not then) the whole set, WELL DUH !!!
Every element of natural numbers > 5 shares that common
property of > 5.
*Richard can get this and lies about it*
*Richard can get this and lies about it*
*Richard can get this and lies about it*
*Richard can get this and lies about it*
Every D simulated by H shares the property that it is
simulated by H.
Every D NEVER simulated by H forms a set that is disjoint
from the above set.
--
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-10 22:17 -0400 |
| Subject | Olcott doesn't know the difference between an element an the set |
| Message-ID | <v1mkf8$lbo5$7@i2pn2.org> |
| In reply to | #333899 |
On 5/10/24 7:39 PM, olcott wrote:
> On 5/10/2024 5:39 PM, Richard Damon wrote:
>> On 5/10/24 6:28 PM, olcott wrote:
>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical
>>>>>>>>>>>>>>>>>>>>>>>>>>> set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where each D(D) that is
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H(D,D) also calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one to
>>>>>>>>>>>>>>>>>>>>>>>>> ∞ simulated steps of D and involve zero to ∞
>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulations of H simulating itself
>>>>>>>>>>>>>>>>>>>>>>>>> simulating D(D). Every time Lines 1,2,3 are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>> line 02
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>> line 03
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of H?
>>>>>>>>>>>>>>>>>>>>>>>> We can think of many more simulations that only
>>>>>>>>>>>>>>>>>>>>>>>> these.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls
>>>>>>>>>>>>>>>>>>>>>>> this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set
>>>>>>>>>>>>>>>>>>>>>>> where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build
>>>>>>>>>>>>>>>>>>>>>> from it reaches its line
>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D by
>>>>>>>>>>>>>>>>>>>>>> H reaches that line
>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how
>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see that
>>>>>>>>>>>>>>>>>>>>> I am correct.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational
>>>>>>>>>>>>>>>>>>>>> code.
>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable
>>>>>>>>>>>>>>>>>>>> which is allows HH to detect whether it is the outer
>>>>>>>>>>>>>>>>>>>> HH or a nested (simulated) HH. As a result, the
>>>>>>>>>>>>>>>>>>>> nested HH behaves completely differently to the
>>>>>>>>>>>>>>>>>>>> outer HH - I mean /completely/ differently: it goes
>>>>>>>>>>>>>>>>>>>> through a totally separate "I am called in nested
>>>>>>>>>>>>>>>>>>>> mode" code path!
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it
>>>>>>>>>>>>>>>>>>> needs to be to
>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical execution
>>>>>>>>>>>>>>>>>> trace to the direct execution.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by H
>>>>>>>>>>>>>>>>> as an example
>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have
>>>>>>>>>>>>>>>> told you this multiple times.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the steps
>>>>>>>>>>>>>> it simulated correctly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>
>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>
>>>>>>>>>>>> The only definition within Computation Theory, which is the
>>>>>>>>>>>> space you started in, and claim to get to, doesn't have
>>>>>>>>>>>> "aborted" simulations, so you don't have a defintion of what
>>>>>>>>>>>> simulatioin actually means, other than doing something that
>>>>>>>>>>>> tells you something about the behavior of what is simulated.
>>>>>>>>>>>>
>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows that
>>>>>>>>>>>> THIS H did not simulate its input to a final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>
>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and simulating zero steps correctly and them aborting
>>>>>>>>>>>> means H
>>>>>>>>>>>
>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>
>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>
>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>
>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>
>>>>>>>>
>>>>>>>> You can start and then immediately stop an not make any progress.
>>>>>>>>
>>>>>>>> A bit like your "first point after 0".
>>>>>>>>
>>>>>>>> You just don't understand how logic works.
>>>>>>>>
>>>>>>>> And your definition is also illogical, as H either DOES or DOES
>>>>>>>> NOT abort its simulation.
>>>>>>>>
>>>>>>>
>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>
>>>>>> But there is no Dichotomy, as there is just H, an not something to
>>>>>> compare it to.
>>>>>>
>>>>>> The other thing you compare it to is not H.
>>>>>>
>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>
>>>>>> But *THE* H does one or the other.
>>>>>>
>>>>>
>>>>> Is your employer aware that your memory is this bad?
>>>>> Are you in management where slick double-talk can hide this?
>>>>
>>>> Well, since you don't have an employer, I guess we can tell who
>>>> performs better.
>>>>
>>>>>
>>>>> *I have repeated time and again that I have always been referring*
>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>
>>>> And how does MAIN call an "Infinite set" of functions?
>>>>
>>>> And how is that an exact implementation of the Linz Proof, were H
>>>> and H^ are specific (but arbitrary) machines?
>>>>
>>>
>>> A "specific" and "arbitrary" machine is like a
>>> very tiny little enormously huge thing.
>>>
>>> We can have specific elements of an infinite set such
>>> that every element of this set has common properties.
>>
>> But the element is different then the set.
>>
>
> One element of any type of set theory set is different
> THAN (not then) the whole set, WELL DUH !!!
Right, so why do you lie that H is the SET, and not one element at a time.
>
> Every element of natural numbers > 5 shares that common
> property of > 5.
>
Right, but the set of natural numbers n > 5 doesn't have the property
that the SET (as a set) is greater than 5, since that property is not a
property of the set.
Just like HALTING is a property of Program, not "sets of programs" so
your POOP is just illogical.
> *Richard can get this and lies about it*
> *Richard can get this and lies about it*
> *Richard can get this and lies about it*
> *Richard can get this and lies about it*
>
> Every D simulated by H shares the property that it is
> simulated by H.
Nope, because "being simulated by" is not a property of the machine
iteself, but of the decider looking at it.
>
> Every D NEVER simulated by H forms a set that is disjoint
> from the above set.
>
But simulating zero steps correctly *IS* simulating ALL steps simulated
correctly if you stop before getting to step 1.
You just don't understand the nature of universal qualifiers.
Or the actual general meaning of "simulation"
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 21:21 -0500 |
| Subject | Is Richard a Liar? |
| Message-ID | <v1mkmm$1q5ee$1@dont-email.me> |
| In reply to | #333903 |
On 5/10/2024 9:17 PM, Richard Damon wrote:
> On 5/10/24 7:39 PM, olcott wrote:
>> On 5/10/2024 5:39 PM, Richard Damon wrote:
>>> On 5/10/24 6:28 PM, olcott wrote:
>>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1 to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical
>>>>>>>>>>>>>>>>>>>>>>>>>>>> set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where each D(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by H(D,D) also calls this same
>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one
>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of D and involve zero to
>>>>>>>>>>>>>>>>>>>>>>>>>> ∞ recursive simulations of H simulating itself
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating D(D). Every time Lines 1,2,3 are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>>> line 02
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>>> line 03
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>> H? We can think of many more simulations that
>>>>>>>>>>>>>>>>>>>>>>>>> only these.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also calls
>>>>>>>>>>>>>>>>>>>>>>>> this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this set
>>>>>>>>>>>>>>>>>>>>>>>> where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build
>>>>>>>>>>>>>>>>>>>>>>> from it reaches its line
>>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D
>>>>>>>>>>>>>>>>>>>>>>> by H reaches that line
>>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how
>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see that
>>>>>>>>>>>>>>>>>>>>>> I am correct.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational
>>>>>>>>>>>>>>>>>>>>>> code.
>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global variable
>>>>>>>>>>>>>>>>>>>>> which is allows HH to detect whether it is the
>>>>>>>>>>>>>>>>>>>>> outer HH or a nested (simulated) HH. As a result,
>>>>>>>>>>>>>>>>>>>>> the nested HH behaves completely differently to the
>>>>>>>>>>>>>>>>>>>>> outer HH - I mean /completely/ differently: it goes
>>>>>>>>>>>>>>>>>>>>> through a totally separate "I am called in nested
>>>>>>>>>>>>>>>>>>>>> mode" code path!
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it
>>>>>>>>>>>>>>>>>>>> needs to be to
>>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously much
>>>>>>>>>>>>>>>>>>>> simpler thing.
>>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical
>>>>>>>>>>>>>>>>>>> execution trace to the direct execution.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by H
>>>>>>>>>>>>>>>>>> as an example
>>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have
>>>>>>>>>>>>>>>>> told you this multiple times.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the
>>>>>>>>>>>>>>> steps it simulated correctly.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>
>>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The only definition within Computation Theory, which is the
>>>>>>>>>>>>> space you started in, and claim to get to, doesn't have
>>>>>>>>>>>>> "aborted" simulations, so you don't have a defintion of
>>>>>>>>>>>>> what simulatioin actually means, other than doing something
>>>>>>>>>>>>> that tells you something about the behavior of what is
>>>>>>>>>>>>> simulated.
>>>>>>>>>>>>>
>>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows that
>>>>>>>>>>>>> THIS H did not simulate its input to a final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and simulating zero steps correctly and them
>>>>>>>>>>>>> aborting means H
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>
>>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>
>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>
>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You can start and then immediately stop an not make any progress.
>>>>>>>>>
>>>>>>>>> A bit like your "first point after 0".
>>>>>>>>>
>>>>>>>>> You just don't understand how logic works.
>>>>>>>>>
>>>>>>>>> And your definition is also illogical, as H either DOES or DOES
>>>>>>>>> NOT abort its simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>>
>>>>>>> But there is no Dichotomy, as there is just H, an not something
>>>>>>> to compare it to.
>>>>>>>
>>>>>>> The other thing you compare it to is not H.
>>>>>>>
>>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>>
>>>>>>> But *THE* H does one or the other.
>>>>>>>
>>>>>>
>>>>>> Is your employer aware that your memory is this bad?
>>>>>> Are you in management where slick double-talk can hide this?
>>>>>
>>>>> Well, since you don't have an employer, I guess we can tell who
>>>>> performs better.
>>>>>
>>>>>>
>>>>>> *I have repeated time and again that I have always been referring*
>>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>>
>>>>> And how does MAIN call an "Infinite set" of functions?
>>>>>
>>>>> And how is that an exact implementation of the Linz Proof, were H
>>>>> and H^ are specific (but arbitrary) machines?
>>>>>
>>>>
>>>> A "specific" and "arbitrary" machine is like a
>>>> very tiny little enormously huge thing.
>>>>
>>>> We can have specific elements of an infinite set such
>>>> that every element of this set has common properties.
>>>
>>> But the element is different then the set.
>>>
>>
>> One element of any type of set theory set is different
>> THAN (not then) the whole set, WELL DUH !!!
>
> Right, so why do you lie that H is the SET, and not one element at a time.
>
>>
>> Every element of natural numbers > 5 shares that common
>> property of > 5.
>>
> Right, but the set of natural numbers n > 5 doesn't have the property
> that the SET (as a set) is greater than 5, since that property is not a
> property of the set.
>
> Just like HALTING is a property of Program, not "sets of programs" so
> your POOP is just illogical.
>
>> *Richard can get this and lies about it*
>> *Richard can get this and lies about it*
>> *Richard can get this and lies about it*
>> *Richard can get this and lies about it*
>>
>> Every D simulated by H shares the property that it is
>> simulated by H.
>
> Nope, because "being simulated by" is not a property of the machine
> iteself, but of the decider looking at it.
>
>
>>
>> Every D NEVER simulated by H forms a set that is disjoint
>> from the above set.
>>
>
> But simulating zero steps correctly *IS* simulating ALL steps simulated
> correctly if you stop before getting to step 1.
>
> You just don't understand the nature of universal qualifiers.
>
> Or the actual general meaning of "simulation"
>
Vacuously true is a bogus concept.
--
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-10 22:39 -0400 |
| Subject | Re: Is Richard a Liar? No, but Olcott is. |
| Message-ID | <v1mlpq$lbo4$4@i2pn2.org> |
| In reply to | #333905 |
On 5/10/24 10:21 PM, olcott wrote:
> On 5/10/2024 9:17 PM, Richard Damon wrote:
>> On 5/10/24 7:39 PM, olcott wrote:
>>> On 5/10/2024 5:39 PM, Richard Damon wrote:
>>>> On 5/10/24 6:28 PM, olcott wrote:
>>>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This involves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1 to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where each D(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by H(D,D) also calls this same
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one
>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of D and involve zero to
>>>>>>>>>>>>>>>>>>>>>>>>>>> ∞ recursive simulations of H simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>> itself simulating D(D). Every time Lines
>>>>>>>>>>>>>>>>>>>>>>>>>>> 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation at
>>>>>>>>>>>>>>>>>>>>>>>>>>> line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 02
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 03
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>> H? We can think of many more simulations that
>>>>>>>>>>>>>>>>>>>>>>>>>> only these.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of finite
>>>>>>>>>>>>>>>>>>>>>>>>> string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this
>>>>>>>>>>>>>>>>>>>>>>>>> set where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build
>>>>>>>>>>>>>>>>>>>>>>>> from it reaches its line
>>>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D
>>>>>>>>>>>>>>>>>>>>>>>> by H reaches that line
>>>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about how
>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see
>>>>>>>>>>>>>>>>>>>>>>> that I am correct.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully operational
>>>>>>>>>>>>>>>>>>>>>>> code.
>>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global
>>>>>>>>>>>>>>>>>>>>>> variable which is allows HH to detect whether it
>>>>>>>>>>>>>>>>>>>>>> is the outer HH or a nested (simulated) HH. As a
>>>>>>>>>>>>>>>>>>>>>> result, the nested HH behaves completely
>>>>>>>>>>>>>>>>>>>>>> differently to the outer HH - I mean /completely/
>>>>>>>>>>>>>>>>>>>>>> differently: it goes through a totally separate "I
>>>>>>>>>>>>>>>>>>>>>> am called in nested mode" code path!
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that it
>>>>>>>>>>>>>>>>>>>>> needs to be to
>>>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously
>>>>>>>>>>>>>>>>>>>>> much simpler thing.
>>>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical
>>>>>>>>>>>>>>>>>>>> execution trace to the direct execution.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this is
>>>>>>>>>>>>>>>>>>> counter-factual*
>>>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by H
>>>>>>>>>>>>>>>>>>> as an example
>>>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I have
>>>>>>>>>>>>>>>>>> told you this multiple times.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the
>>>>>>>>>>>>>>>> steps it simulated correctly.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The only definition within Computation Theory, which is
>>>>>>>>>>>>>> the space you started in, and claim to get to, doesn't
>>>>>>>>>>>>>> have "aborted" simulations, so you don't have a defintion
>>>>>>>>>>>>>> of what simulatioin actually means, other than doing
>>>>>>>>>>>>>> something that tells you something about the behavior of
>>>>>>>>>>>>>> what is simulated.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows that
>>>>>>>>>>>>>> THIS H did not simulate its input to a final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and simulating zero steps correctly and them
>>>>>>>>>>>>>> aborting means H
>>>>>>>>>>>>>
>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>
>>>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>
>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>
>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You can start and then immediately stop an not make any progress.
>>>>>>>>>>
>>>>>>>>>> A bit like your "first point after 0".
>>>>>>>>>>
>>>>>>>>>> You just don't understand how logic works.
>>>>>>>>>>
>>>>>>>>>> And your definition is also illogical, as H either DOES or
>>>>>>>>>> DOES NOT abort its simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>>>
>>>>>>>> But there is no Dichotomy, as there is just H, an not something
>>>>>>>> to compare it to.
>>>>>>>>
>>>>>>>> The other thing you compare it to is not H.
>>>>>>>>
>>>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>>>
>>>>>>>> But *THE* H does one or the other.
>>>>>>>>
>>>>>>>
>>>>>>> Is your employer aware that your memory is this bad?
>>>>>>> Are you in management where slick double-talk can hide this?
>>>>>>
>>>>>> Well, since you don't have an employer, I guess we can tell who
>>>>>> performs better.
>>>>>>
>>>>>>>
>>>>>>> *I have repeated time and again that I have always been referring*
>>>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>>>
>>>>>> And how does MAIN call an "Infinite set" of functions?
>>>>>>
>>>>>> And how is that an exact implementation of the Linz Proof, were H
>>>>>> and H^ are specific (but arbitrary) machines?
>>>>>>
>>>>>
>>>>> A "specific" and "arbitrary" machine is like a
>>>>> very tiny little enormously huge thing.
>>>>>
>>>>> We can have specific elements of an infinite set such
>>>>> that every element of this set has common properties.
>>>>
>>>> But the element is different then the set.
>>>>
>>>
>>> One element of any type of set theory set is different
>>> THAN (not then) the whole set, WELL DUH !!!
>>
>> Right, so why do you lie that H is the SET, and not one element at a
>> time.
>>
>>>
>>> Every element of natural numbers > 5 shares that common
>>> property of > 5.
>>>
>> Right, but the set of natural numbers n > 5 doesn't have the property
>> that the SET (as a set) is greater than 5, since that property is not
>> a property of the set.
>>
>> Just like HALTING is a property of Program, not "sets of programs" so
>> your POOP is just illogical.
>>
>>> *Richard can get this and lies about it*
>>> *Richard can get this and lies about it*
>>> *Richard can get this and lies about it*
>>> *Richard can get this and lies about it*
>>>
>>> Every D simulated by H shares the property that it is
>>> simulated by H.
>>
>> Nope, because "being simulated by" is not a property of the machine
>> iteself, but of the decider looking at it.
>>
>>
>>>
>>> Every D NEVER simulated by H forms a set that is disjoint
>>> from the above set.
>>>
>>
>> But simulating zero steps correctly *IS* simulating ALL steps
>> simulated correctly if you stop before getting to step 1.
>>
>> You just don't understand the nature of universal qualifiers.
>>
>> Or the actual general meaning of "simulation"
>>
>
> Vacuously true is a bogus concept.
>
Nope. As I said, you don't understand that actual definition of
"Simulation".
You have already rejected the meaning it has in Computation Theory, as
you allow (in fact require it to be allowed) to be aborted, which it is
not in the Theory (as the only use of "Simulation" is in the description
of a UTM that ALWAYS simualates until it reaches ano end.
The more general definition does NOT require the "step by steo exact"
that you seem to assume (yes, that is ONE definiton used in some parts
of computer science), but since you REFUSED to actually provide an
actual definition you can't retroactively apply a definition you did not
app;ly,
That just makes you a LIAR.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-10 21:49 -0500 |
| Subject | Richard must be educated on what a termination analyzer is |
| Message-ID | <v1mmba$1qip9$1@dont-email.me> |
| In reply to | #333910 |
On 5/10/2024 9:39 PM, Richard Damon wrote:
> On 5/10/24 10:21 PM, olcott wrote:
>> On 5/10/2024 9:17 PM, Richard Damon wrote:
>>> On 5/10/24 7:39 PM, olcott wrote:
>>>> On 5/10/2024 5:39 PM, Richard Damon wrote:
>>>>> On 5/10/24 6:28 PM, olcott wrote:
>>>>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> involves 1 to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where each D(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by H(D,D) also calls this same
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of D and involve zero
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ recursive simulations of H simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>> itself simulating D(D). Every time Lines
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 03
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>> H? We can think of many more simulations that
>>>>>>>>>>>>>>>>>>>>>>>>>>> only these.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>>>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this
>>>>>>>>>>>>>>>>>>>>>>>>>> set where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build
>>>>>>>>>>>>>>>>>>>>>>>>> from it reaches its line
>>>>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>> by H reaches that line
>>>>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about
>>>>>>>>>>>>>>>>>>>>>>>> how infinite
>>>>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see
>>>>>>>>>>>>>>>>>>>>>>>> that I am correct.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully
>>>>>>>>>>>>>>>>>>>>>>>> operational code.
>>>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global
>>>>>>>>>>>>>>>>>>>>>>> variable which is allows HH to detect whether it
>>>>>>>>>>>>>>>>>>>>>>> is the outer HH or a nested (simulated) HH. As a
>>>>>>>>>>>>>>>>>>>>>>> result, the nested HH behaves completely
>>>>>>>>>>>>>>>>>>>>>>> differently to the outer HH - I mean /completely/
>>>>>>>>>>>>>>>>>>>>>>> differently: it goes through a totally separate
>>>>>>>>>>>>>>>>>>>>>>> "I am called in nested mode" code path!
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that
>>>>>>>>>>>>>>>>>>>>>> it needs to be to
>>>>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously
>>>>>>>>>>>>>>>>>>>>>> much simpler thing.
>>>>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical
>>>>>>>>>>>>>>>>>>>>> execution trace to the direct execution.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this
>>>>>>>>>>>>>>>>>>>> is counter-factual*
>>>>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by
>>>>>>>>>>>>>>>>>>>> H as an example
>>>>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I
>>>>>>>>>>>>>>>>>>> have told you this multiple times.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the
>>>>>>>>>>>>>>>>> steps it simulated correctly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The only definition within Computation Theory, which is
>>>>>>>>>>>>>>> the space you started in, and claim to get to, doesn't
>>>>>>>>>>>>>>> have "aborted" simulations, so you don't have a defintion
>>>>>>>>>>>>>>> of what simulatioin actually means, other than doing
>>>>>>>>>>>>>>> something that tells you something about the behavior of
>>>>>>>>>>>>>>> what is simulated.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows
>>>>>>>>>>>>>>> that THIS H did not simulate its input to a final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and simulating zero steps correctly and them
>>>>>>>>>>>>>>> aborting means H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You can start and then immediately stop an not make any
>>>>>>>>>>> progress.
>>>>>>>>>>>
>>>>>>>>>>> A bit like your "first point after 0".
>>>>>>>>>>>
>>>>>>>>>>> You just don't understand how logic works.
>>>>>>>>>>>
>>>>>>>>>>> And your definition is also illogical, as H either DOES or
>>>>>>>>>>> DOES NOT abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>>>>
>>>>>>>>> But there is no Dichotomy, as there is just H, an not something
>>>>>>>>> to compare it to.
>>>>>>>>>
>>>>>>>>> The other thing you compare it to is not H.
>>>>>>>>>
>>>>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>>>>
>>>>>>>>> But *THE* H does one or the other.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Is your employer aware that your memory is this bad?
>>>>>>>> Are you in management where slick double-talk can hide this?
>>>>>>>
>>>>>>> Well, since you don't have an employer, I guess we can tell who
>>>>>>> performs better.
>>>>>>>
>>>>>>>>
>>>>>>>> *I have repeated time and again that I have always been referring*
>>>>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>>>>
>>>>>>> And how does MAIN call an "Infinite set" of functions?
>>>>>>>
>>>>>>> And how is that an exact implementation of the Linz Proof, were H
>>>>>>> and H^ are specific (but arbitrary) machines?
>>>>>>>
>>>>>>
>>>>>> A "specific" and "arbitrary" machine is like a
>>>>>> very tiny little enormously huge thing.
>>>>>>
>>>>>> We can have specific elements of an infinite set such
>>>>>> that every element of this set has common properties.
>>>>>
>>>>> But the element is different then the set.
>>>>>
>>>>
>>>> One element of any type of set theory set is different
>>>> THAN (not then) the whole set, WELL DUH !!!
>>>
>>> Right, so why do you lie that H is the SET, and not one element at a
>>> time.
>>>
>>>>
>>>> Every element of natural numbers > 5 shares that common
>>>> property of > 5.
>>>>
>>> Right, but the set of natural numbers n > 5 doesn't have the property
>>> that the SET (as a set) is greater than 5, since that property is not
>>> a property of the set.
>>>
>>> Just like HALTING is a property of Program, not "sets of programs" so
>>> your POOP is just illogical.
>>>
>>>> *Richard can get this and lies about it*
>>>> *Richard can get this and lies about it*
>>>> *Richard can get this and lies about it*
>>>> *Richard can get this and lies about it*
>>>>
>>>> Every D simulated by H shares the property that it is
>>>> simulated by H.
>>>
>>> Nope, because "being simulated by" is not a property of the machine
>>> iteself, but of the decider looking at it.
>>>
>>>
>>>>
>>>> Every D NEVER simulated by H forms a set that is disjoint
>>>> from the above set.
>>>>
>>>
>>> But simulating zero steps correctly *IS* simulating ALL steps
>>> simulated correctly if you stop before getting to step 1.
>>>
>>> You just don't understand the nature of universal qualifiers.
>>>
>>> Or the actual general meaning of "simulation"
>>>
>>
>> Vacuously true is a bogus concept.
>>
>
> Nope. As I said, you don't understand that actual definition of
> "Simulation".
>
> You have already rejected the meaning it has in Computation Theory, as
> you allow (in fact require it to be allowed) to be aborted, which it is
> not in the Theory (as the only use of "Simulation" is in the description
> of a UTM that ALWAYS simualates until it reaches ano end.
>
> The more general definition does NOT require the "step by steo exact"
> that you seem to assume (yes, that is ONE definiton used in some parts
> of computer science), but since you REFUSED to actually provide an
> actual definition you can't retroactively apply a definition you did not
> app;ly,
>
> That just makes you a LIAR.
--
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-10 23:16 -0400 |
| Subject | Olcott admits to creating defintion out of his *ss |
| Message-ID | <v1mnua$lbo5$10@i2pn2.org> |
| In reply to | #333912 |
Apparently, Olcott thinks a "Term of Art" means something he can create. That isn't the right meaning for "Art" here On 5/10/24 10:52 PM, olcott wrote: > On 5/10/2024 9:39 PM, Richard Damon wrote: >> Then you can point to published definitons that match yours? >> > > Now that I know that when people say that a term is undefined > they never meant that it is actually undefined I can fix this.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-11 11:26 -0500 |
| Subject | Re: Is Richard a Liar? |
| Message-ID | <v1o67n$24f4c$1@dont-email.me> |
| In reply to | #333905 |
On 5/11/2024 3:27 AM, Mikko wrote:
> On 2024-05-11 02:21:10 +0000, olcott said:
>
>> On 5/10/2024 9:17 PM, Richard Damon wrote:
>>> On 5/10/24 7:39 PM, olcott wrote:
>>>> On 5/10/2024 5:39 PM, Richard Damon wrote:
>>>>> On 5/10/24 6:28 PM, olcott wrote:
>>>>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you should
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> involves 1 to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In typical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where each D(D) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated by H(D,D) also calls this same
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the one
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of D and involve zero
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ recursive simulations of H simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>> itself simulating D(D). Every time Lines
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 03
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>> H? We can think of many more simulations that
>>>>>>>>>>>>>>>>>>>>>>>>>>> only these.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>>>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this
>>>>>>>>>>>>>>>>>>>>>>>>>> set where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build
>>>>>>>>>>>>>>>>>>>>>>>>> from it reaches its line
>>>>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>> by H reaches that line
>>>>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about
>>>>>>>>>>>>>>>>>>>>>>>> how infinite
>>>>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see
>>>>>>>>>>>>>>>>>>>>>>>> that I am correct.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully
>>>>>>>>>>>>>>>>>>>>>>>> operational code.
>>>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global
>>>>>>>>>>>>>>>>>>>>>>> variable which is allows HH to detect whether it
>>>>>>>>>>>>>>>>>>>>>>> is the outer HH or a nested (simulated) HH. As a
>>>>>>>>>>>>>>>>>>>>>>> result, the nested HH behaves completely
>>>>>>>>>>>>>>>>>>>>>>> differently to the outer HH - I mean /completely/
>>>>>>>>>>>>>>>>>>>>>>> differently: it goes through a totally separate
>>>>>>>>>>>>>>>>>>>>>>> "I am called in nested mode" code path!
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that
>>>>>>>>>>>>>>>>>>>>>> it needs to be to
>>>>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously
>>>>>>>>>>>>>>>>>>>>>> much simpler thing.
>>>>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical
>>>>>>>>>>>>>>>>>>>>> execution trace to the direct execution.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this
>>>>>>>>>>>>>>>>>>>> is counter-factual*
>>>>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by
>>>>>>>>>>>>>>>>>>>> H as an example
>>>>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I
>>>>>>>>>>>>>>>>>>> have told you this multiple times.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the
>>>>>>>>>>>>>>>>> steps it simulated correctly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The only definition within Computation Theory, which is
>>>>>>>>>>>>>>> the space you started in, and claim to get to, doesn't
>>>>>>>>>>>>>>> have "aborted" simulations, so you don't have a defintion
>>>>>>>>>>>>>>> of what simulatioin actually means, other than doing
>>>>>>>>>>>>>>> something that tells you something about the behavior of
>>>>>>>>>>>>>>> what is simulated.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows
>>>>>>>>>>>>>>> that THIS H did not simulate its input to a final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and simulating zero steps correctly and them
>>>>>>>>>>>>>>> aborting means H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You can start and then immediately stop an not make any
>>>>>>>>>>> progress.
>>>>>>>>>>>
>>>>>>>>>>> A bit like your "first point after 0".
>>>>>>>>>>>
>>>>>>>>>>> You just don't understand how logic works.
>>>>>>>>>>>
>>>>>>>>>>> And your definition is also illogical, as H either DOES or
>>>>>>>>>>> DOES NOT abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>>>>
>>>>>>>>> But there is no Dichotomy, as there is just H, an not something
>>>>>>>>> to compare it to.
>>>>>>>>>
>>>>>>>>> The other thing you compare it to is not H.
>>>>>>>>>
>>>>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>>>>
>>>>>>>>> But *THE* H does one or the other.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Is your employer aware that your memory is this bad?
>>>>>>>> Are you in management where slick double-talk can hide this?
>>>>>>>
>>>>>>> Well, since you don't have an employer, I guess we can tell who
>>>>>>> performs better.
>>>>>>>
>>>>>>>>
>>>>>>>> *I have repeated time and again that I have always been referring*
>>>>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>>>>
>>>>>>> And how does MAIN call an "Infinite set" of functions?
>>>>>>>
>>>>>>> And how is that an exact implementation of the Linz Proof, were H
>>>>>>> and H^ are specific (but arbitrary) machines?
>>>>>>>
>>>>>>
>>>>>> A "specific" and "arbitrary" machine is like a
>>>>>> very tiny little enormously huge thing.
>>>>>>
>>>>>> We can have specific elements of an infinite set such
>>>>>> that every element of this set has common properties.
>>>>>
>>>>> But the element is different then the set.
>>>>>
>>>>
>>>> One element of any type of set theory set is different
>>>> THAN (not then) the whole set, WELL DUH !!!
>>>
>>> Right, so why do you lie that H is the SET, and not one element at a
>>> time.
>>>
>>>>
>>>> Every element of natural numbers > 5 shares that common
>>>> property of > 5.
>>>>
>>> Right, but the set of natural numbers n > 5 doesn't have the property
>>> that the SET (as a set) is greater than 5, since that property is not
>>> a property of the set.
>>>
>>> Just like HALTING is a property of Program, not "sets of programs" so
>>> your POOP is just illogical.
>>>
>>>> *Richard can get this and lies about it*
>>>> *Richard can get this and lies about it*
>>>> *Richard can get this and lies about it*
>>>> *Richard can get this and lies about it*
>>>>
>>>> Every D simulated by H shares the property that it is
>>>> simulated by H.
>>>
>>> Nope, because "being simulated by" is not a property of the machine
>>> iteself, but of the decider looking at it.
>>>
>>>
>>>>
>>>> Every D NEVER simulated by H forms a set that is disjoint
>>>> from the above set.
>>>>
>>>
>>> But simulating zero steps correctly *IS* simulating ALL steps
>>> simulated correctly if you stop before getting to step 1.
>>>
>>> You just don't understand the nature of universal qualifiers.
>>>
>>> Or the actual general meaning of "simulation"
>>>
>>
>> Vacuously true is a bogus concept.
>
> If something is vacuously true then it is provably true, so if you
> see "vacuously true" in a positive sentence you may read it as if
> it were "provably true". The word "vacuously" means that the proof
> is very short.
>
> If something is not vacuously true then it may be otherwise true,
> so saning "not vacuously true" does not say very much.
>
We have a simpler way to prove Richard is WRONG
I have used the conventional term-of-the-art {Termination Analyzer}
in the title of my paper since 2023/06/19
*Termination Analyzer H is Not Fooled by Pathological Input D*
I am working on providing an academic quality definition of this
term. The conventional term-of-the-art {Termination Analyzer}
would not allow ignoring the input.
--
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-11 12:46 -0400 |
| Subject | Re: Is Oclott a Liar? |
| Message-ID | <v1o7ca$nmui$8@i2pn2.org> |
| In reply to | #333945 |
On 5/11/24 12:26 PM, olcott wrote:
> On 5/11/2024 3:27 AM, Mikko wrote:
>> On 2024-05-11 02:21:10 +0000, olcott said:
>>
>>> On 5/10/2024 9:17 PM, Richard Damon wrote:
>>>> On 5/10/24 7:39 PM, olcott wrote:
>>>>> On 5/10/2024 5:39 PM, Richard Damon wrote:
>>>>>> On 5/10/24 6:28 PM, olcott wrote:
>>>>>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>>>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) is simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> involves 1 to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typical set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where each D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is simulated by H(D,D) also calls this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one to ∞ simulated steps of D and involve
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero to ∞ recursive simulations of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating itself simulating D(D). Every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 03
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H? We can think of many more simulations
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that only these.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this
>>>>>>>>>>>>>>>>>>>>>>>>>>> set where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D build
>>>>>>>>>>>>>>>>>>>>>>>>>> from it reaches its line
>>>>>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>> D by H reaches that line
>>>>>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about
>>>>>>>>>>>>>>>>>>>>>>>>> how infinite
>>>>>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see
>>>>>>>>>>>>>>>>>>>>>>>>> that I am correct.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully
>>>>>>>>>>>>>>>>>>>>>>>>> operational code.
>>>>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global
>>>>>>>>>>>>>>>>>>>>>>>> variable which is allows HH to detect whether it
>>>>>>>>>>>>>>>>>>>>>>>> is the outer HH or a nested (simulated) HH. As a
>>>>>>>>>>>>>>>>>>>>>>>> result, the nested HH behaves completely
>>>>>>>>>>>>>>>>>>>>>>>> differently to the outer HH - I mean
>>>>>>>>>>>>>>>>>>>>>>>> /completely/ differently: it goes through a
>>>>>>>>>>>>>>>>>>>>>>>> totally separate "I am called in nested mode"
>>>>>>>>>>>>>>>>>>>>>>>> code path!
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that
>>>>>>>>>>>>>>>>>>>>>>> it needs to be to
>>>>>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously
>>>>>>>>>>>>>>>>>>>>>>> much simpler thing.
>>>>>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical
>>>>>>>>>>>>>>>>>>>>>> execution trace to the direct execution.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this
>>>>>>>>>>>>>>>>>>>>> is counter-factual*
>>>>>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated by
>>>>>>>>>>>>>>>>>>>>> H as an example
>>>>>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I
>>>>>>>>>>>>>>>>>>>> have told you this multiple times.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the
>>>>>>>>>>>>>>>>>> steps it simulated correctly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The only definition within Computation Theory, which is
>>>>>>>>>>>>>>>> the space you started in, and claim to get to, doesn't
>>>>>>>>>>>>>>>> have "aborted" simulations, so you don't have a
>>>>>>>>>>>>>>>> defintion of what simulatioin actually means, other than
>>>>>>>>>>>>>>>> doing something that tells you something about the
>>>>>>>>>>>>>>>> behavior of what is simulated.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows
>>>>>>>>>>>>>>>> that THIS H did not simulate its input to a final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, and simulating zero steps correctly and them
>>>>>>>>>>>>>>>> aborting means H
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You can start and then immediately stop an not make any
>>>>>>>>>>>> progress.
>>>>>>>>>>>>
>>>>>>>>>>>> A bit like your "first point after 0".
>>>>>>>>>>>>
>>>>>>>>>>>> You just don't understand how logic works.
>>>>>>>>>>>>
>>>>>>>>>>>> And your definition is also illogical, as H either DOES or
>>>>>>>>>>>> DOES NOT abort its simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>>>>>
>>>>>>>>>> But there is no Dichotomy, as there is just H, an not
>>>>>>>>>> something to compare it to.
>>>>>>>>>>
>>>>>>>>>> The other thing you compare it to is not H.
>>>>>>>>>>
>>>>>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>>>>>
>>>>>>>>>> But *THE* H does one or the other.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Is your employer aware that your memory is this bad?
>>>>>>>>> Are you in management where slick double-talk can hide this?
>>>>>>>>
>>>>>>>> Well, since you don't have an employer, I guess we can tell who
>>>>>>>> performs better.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *I have repeated time and again that I have always been referring*
>>>>>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>>>>>
>>>>>>>> And how does MAIN call an "Infinite set" of functions?
>>>>>>>>
>>>>>>>> And how is that an exact implementation of the Linz Proof, were
>>>>>>>> H and H^ are specific (but arbitrary) machines?
>>>>>>>>
>>>>>>>
>>>>>>> A "specific" and "arbitrary" machine is like a
>>>>>>> very tiny little enormously huge thing.
>>>>>>>
>>>>>>> We can have specific elements of an infinite set such
>>>>>>> that every element of this set has common properties.
>>>>>>
>>>>>> But the element is different then the set.
>>>>>>
>>>>>
>>>>> One element of any type of set theory set is different
>>>>> THAN (not then) the whole set, WELL DUH !!!
>>>>
>>>> Right, so why do you lie that H is the SET, and not one element at a
>>>> time.
>>>>
>>>>>
>>>>> Every element of natural numbers > 5 shares that common
>>>>> property of > 5.
>>>>>
>>>> Right, but the set of natural numbers n > 5 doesn't have the
>>>> property that the SET (as a set) is greater than 5, since that
>>>> property is not a property of the set.
>>>>
>>>> Just like HALTING is a property of Program, not "sets of programs"
>>>> so your POOP is just illogical.
>>>>
>>>>> *Richard can get this and lies about it*
>>>>> *Richard can get this and lies about it*
>>>>> *Richard can get this and lies about it*
>>>>> *Richard can get this and lies about it*
>>>>>
>>>>> Every D simulated by H shares the property that it is
>>>>> simulated by H.
>>>>
>>>> Nope, because "being simulated by" is not a property of the machine
>>>> iteself, but of the decider looking at it.
>>>>
>>>>
>>>>>
>>>>> Every D NEVER simulated by H forms a set that is disjoint
>>>>> from the above set.
>>>>>
>>>>
>>>> But simulating zero steps correctly *IS* simulating ALL steps
>>>> simulated correctly if you stop before getting to step 1.
>>>>
>>>> You just don't understand the nature of universal qualifiers.
>>>>
>>>> Or the actual general meaning of "simulation"
>>>>
>>>
>>> Vacuously true is a bogus concept.
>>
>> If something is vacuously true then it is provably true, so if you
>> see "vacuously true" in a positive sentence you may read it as if
>> it were "provably true". The word "vacuously" means that the proof
>> is very short.
>>
>> If something is not vacuously true then it may be otherwise true,
>> so saning "not vacuously true" does not say very much.
>>
>
> We have a simpler way to prove Richard is WRONG
> I have used the conventional term-of-the-art {Termination Analyzer}
> in the title of my paper since 2023/06/19
> *Termination Analyzer H is Not Fooled by Pathological Input D*
No, you havd used a FALSE definition that you claim is the
term-of-the-art definition, one that apparently is just beyound your
ability to understand.
>
> I am working on providing an academic quality definition of this
> term. The conventional term-of-the-art {Termination Analyzer}
> would not allow ignoring the input.
>
Which just shows you don't understand my arguement, because the point is
that YOUR H doesn't correctly look at the actual input given, but claims
that it can answer about THIS D that CALLS THIS H, by looking at a
DIFFERNT D that calls a DIFFERENT H.
If that is allowed, then H doesn't need to know what its input is, as
you logic claims it can process some other input then the one it was given.
It is a statement just like your Dead Cows walking in the pasture.
If YOUR H is allowed to treat D as something other than what this D is,
then you have dropped the requirement that H answer about the input it
was given, and your logic is based on lies.
That you don't understand this, just shows how much lies are the
foundation of your logic. You only accept your own lies, but reject the
lies of others, thus you logic system is inconsistant.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-12 08:51 -0500 |
| Subject | Re: Is Richard a Liar? |
| Message-ID | <v1qhg6$2on4q$1@dont-email.me> |
| In reply to | #333945 |
On 5/12/2024 4:19 AM, Mikko wrote:
> On 2024-05-11 16:26:30 +0000, olcott said:
>
>> On 5/11/2024 3:27 AM, Mikko wrote:
>>> On 2024-05-11 02:21:10 +0000, olcott said:
>>>
>>>> On 5/10/2024 9:17 PM, Richard Damon wrote:
>>>>> On 5/10/24 7:39 PM, olcott wrote:
>>>>>> On 5/10/2024 5:39 PM, Richard Damon wrote:
>>>>>>> On 5/10/24 6:28 PM, olcott wrote:
>>>>>>>> On 5/10/2024 4:59 PM, Richard Damon wrote:
>>>>>>>>> On 5/10/24 5:43 PM, olcott wrote:
>>>>>>>>>> On 5/10/2024 4:19 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/10/24 5:11 PM, olcott wrote:
>>>>>>>>>>>> On 5/10/2024 3:50 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/10/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/10/2024 3:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/10/24 1:49 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/10/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/10/24 11:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/10/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/9/24 11:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/9/2024 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/9/24 11:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 8:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/05/24 21:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 10:13 AM, Mike Terry wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 08/05/2024 14:01, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/8/2024 3:59 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-07 19:05:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 07.mei.2024 om 17:40 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2024 6:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/24 3:30 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-06 18:28:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-05-05 17:02:25 +0000, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you say "every H/D pair" you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should specify which set of pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about. As you don't,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your words don't mean anything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H/D pair in the universe where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) is simulated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same H(D,D) that D(D) calls. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> involves 1 to ∞ steps of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and also includes zero to ∞ recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "In the universe" is not a set. In
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typical set theories like ZFC there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no universal set.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where each D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is simulated by H(D,D) also calls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> These H/D pairs can be enumerated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one to ∞ simulated steps of D and involve
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero to ∞ recursive simulations of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating itself simulating D(D). Every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time Lines 1,2,3 are simulated again defines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one more level of recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1st element of H/D pairs 1 step of D is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4th element of H/D pairs 4 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the first recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5th element of H/D pairs 5 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> next step of the first recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation at line 02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6th element of H/D pairs 6 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> last step of the first recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation at line 03
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 7th element of H/D pairs 7 steps of D are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this begins the second recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation at line 01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is this the definition of the infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H? We can think of many more simulations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that only these.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This template defines an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string H/D pairs where
>>>>>>>>>>>>>>>>>>>>>>>>>>>> each D(D) that is simulated by H(D,D) also
>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls this same H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No-one can possibly show one element of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> set where D(D) reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>> past its own line 03.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is a decider of any kind then the D
>>>>>>>>>>>>>>>>>>>>>>>>>>> build from it reaches its line
>>>>>>>>>>>>>>>>>>>>>>>>>>> 4 as numberd above. Whether the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> D by H reaches that line
>>>>>>>>>>>>>>>>>>>>>>>>>>> is another question.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *My fully operational code proves otherwise*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I seems like you guys don't have a clue about
>>>>>>>>>>>>>>>>>>>>>>>>>> how infinite
>>>>>>>>>>>>>>>>>>>>>>>>>> recursion works. You can run the code and see
>>>>>>>>>>>>>>>>>>>>>>>>>> that I am correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have one concrete instance as fully
>>>>>>>>>>>>>>>>>>>>>>>>>> operational code.
>>>>>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>> line 555 u32 HH(ptr P, ptr I) its input in on
>>>>>>>>>>>>>>>>>>>>>>>>>> line 932 int DD(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> HH is completely broken - it uses a global
>>>>>>>>>>>>>>>>>>>>>>>>> variable which is allows HH to detect whether
>>>>>>>>>>>>>>>>>>>>>>>>> it is the outer HH or a nested (simulated) HH.
>>>>>>>>>>>>>>>>>>>>>>>>> As a result, the nested HH behaves completely
>>>>>>>>>>>>>>>>>>>>>>>>> differently to the outer HH - I mean
>>>>>>>>>>>>>>>>>>>>>>>>> /completely/ differently: it goes through a
>>>>>>>>>>>>>>>>>>>>>>>>> totally separate "I am called in nested mode"
>>>>>>>>>>>>>>>>>>>>>>>>> code path!
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The encoding of HH is not the pure function that
>>>>>>>>>>>>>>>>>>>>>>>> it needs to be to
>>>>>>>>>>>>>>>>>>>>>>>> be a computable function.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Maybe you can settle this*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The disagreement is entirely over an enormously
>>>>>>>>>>>>>>>>>>>>>>>> much simpler thing.
>>>>>>>>>>>>>>>>>>>>>>>> The disagreement is that Richard says that a D
>>>>>>>>>>>>>>>>>>>>>>>> simulated by H could
>>>>>>>>>>>>>>>>>>>>>>>> reach past its own line 03 and halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Here's the proof:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 1. A simulation always produces an identical
>>>>>>>>>>>>>>>>>>>>>>> execution trace to the direct execution.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *When pathological self-reference is involved this
>>>>>>>>>>>>>>>>>>>>>> is counter-factual*
>>>>>>>>>>>>>>>>>>>>>> That no one can possibly show the steps of how D
>>>>>>>>>>>>>>>>>>>>>> simulated by H possibly
>>>>>>>>>>>>>>>>>>>>>> reach line 06 of H proves this.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Richard tried to get away with D never simulated
>>>>>>>>>>>>>>>>>>>>>> by H as an example
>>>>>>>>>>>>>>>>>>>>>> of D simulated by H:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, you are looking at the WRONG message, and I
>>>>>>>>>>>>>>>>>>>>> have told you this multiple times.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Message-ID: <v0ummt$2qov3$2@i2pn2.org>
>>>>>>>>>>>>>>>>>>>> *When you interpret*
>>>>>>>>>>>>>>>>>>>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> > On 5/1/24 11:51 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> as *D NEVER simulated by H*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> you have shown a reckless disregard for the truth
>>>>>>>>>>>>>>>>>>>> that would win a defamation case.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> My H simulated 0 steps of D, of which was ALL of the
>>>>>>>>>>>>>>>>>>> steps it simulated correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You haven't GIVEN a defined SPEC.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The only definition within Computation Theory, which is
>>>>>>>>>>>>>>>>> the space you started in, and claim to get to, doesn't
>>>>>>>>>>>>>>>>> have "aborted" simulations, so you don't have a
>>>>>>>>>>>>>>>>> defintion of what simulatioin actually means, other
>>>>>>>>>>>>>>>>> than doing something that tells you something about the
>>>>>>>>>>>>>>>>> behavior of what is simulated.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My H does that, by aborting its "simulation" in shows
>>>>>>>>>>>>>>>>> that THIS H did not simulate its input to a final state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Just the same result that you partial set of H's showed.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>>> *THAT DOES NOT MEET THE SPEC*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Every D simulated by H that cannot possibly*
>>>>>>>>>>>>>>>>>> *stop running unless aborted by H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, and simulating zero steps correctly and them
>>>>>>>>>>>>>>>>> aborting means H
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborted after 0 steps which is all that that H does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *cannot possibly stop running unless aborted is not met*
>>>>>>>>>>>>>> *BY cannot possibly start running*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You can start and then immediately stop an not make any
>>>>>>>>>>>>> progress.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A bit like your "first point after 0".
>>>>>>>>>>>>>
>>>>>>>>>>>>> You just don't understand how logic works.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And your definition is also illogical, as H either DOES or
>>>>>>>>>>>>> DOES NOT abort its simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *WRONG DICHOTOMY STRAW-MAN DECEPTION*
>>>>>>>>>>>
>>>>>>>>>>> But there is no Dichotomy, as there is just H, an not
>>>>>>>>>>> something to compare it to.
>>>>>>>>>>>
>>>>>>>>>>> The other thing you compare it to is not H.
>>>>>>>>>>>
>>>>>>>>>>>> "...cannot possibly stop running unless aborted"
>>>>>>>>>>>> *stops running if not aborted or keeps running if not aborted*
>>>>>>>>>>>
>>>>>>>>>>> But *THE* H does one or the other.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Is your employer aware that your memory is this bad?
>>>>>>>>>> Are you in management where slick double-talk can hide this?
>>>>>>>>>
>>>>>>>>> Well, since you don't have an employer, I guess we can tell who
>>>>>>>>> performs better.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *I have repeated time and again that I have always been
>>>>>>>>>> referring*
>>>>>>>>>> *to the specific infinite set of H/D pairs specified below*
>>>>>>>>>
>>>>>>>>> And how does MAIN call an "Infinite set" of functions?
>>>>>>>>>
>>>>>>>>> And how is that an exact implementation of the Linz Proof, were
>>>>>>>>> H and H^ are specific (but arbitrary) machines?
>>>>>>>>>
>>>>>>>>
>>>>>>>> A "specific" and "arbitrary" machine is like a
>>>>>>>> very tiny little enormously huge thing.
>>>>>>>>
>>>>>>>> We can have specific elements of an infinite set such
>>>>>>>> that every element of this set has common properties.
>>>>>>>
>>>>>>> But the element is different then the set.
>>>>>>>
>>>>>>
>>>>>> One element of any type of set theory set is different
>>>>>> THAN (not then) the whole set, WELL DUH !!!
>>>>>
>>>>> Right, so why do you lie that H is the SET, and not one element at
>>>>> a time.
>>>>>
>>>>>>
>>>>>> Every element of natural numbers > 5 shares that common
>>>>>> property of > 5.
>>>>>>
>>>>> Right, but the set of natural numbers n > 5 doesn't have the
>>>>> property that the SET (as a set) is greater than 5, since that
>>>>> property is not a property of the set.
>>>>>
>>>>> Just like HALTING is a property of Program, not "sets of programs"
>>>>> so your POOP is just illogical.
>>>>>
>>>>>> *Richard can get this and lies about it*
>>>>>> *Richard can get this and lies about it*
>>>>>> *Richard can get this and lies about it*
>>>>>> *Richard can get this and lies about it*
>>>>>>
>>>>>> Every D simulated by H shares the property that it is
>>>>>> simulated by H.
>>>>>
>>>>> Nope, because "being simulated by" is not a property of the machine
>>>>> iteself, but of the decider looking at it.
>>>>>
>>>>>
>>>>>>
>>>>>> Every D NEVER simulated by H forms a set that is disjoint
>>>>>> from the above set.
>>>>>>
>>>>>
>>>>> But simulating zero steps correctly *IS* simulating ALL steps
>>>>> simulated correctly if you stop before getting to step 1.
>>>>>
>>>>> You just don't understand the nature of universal qualifiers.
>>>>>
>>>>> Or the actual general meaning of "simulation"
>>>>>
>>>>
>>>> Vacuously true is a bogus concept.
>>>
>>> If something is vacuously true then it is provably true, so if you
>>> see "vacuously true" in a positive sentence you may read it as if
>>> it were "provably true". The word "vacuously" means that the proof
>>> is very short.
>>>
>>> If something is not vacuously true then it may be otherwise true,
>>> so saning "not vacuously true" does not say very much.
>>>
>>
>> We have a simpler way to prove Richard is WRONG
>> I have used the conventional term-of-the-art {Termination Analyzer}
>> in the title of my paper since 2023/06/19
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>
> It is not a conventional term or the art if you use it in a meaning
> that is not its conventional meaning.
A simulating termination analyzer <is> exactly a conventional
{termination analyzer}. Termination analyzers are not restricted
to any specific method. They are not allowed to ignore their
input as Richard is trying to get away with.
> You have used the term
> "termination analyzer" in sentences that would be false nor non-sense
> if the conventional meaning would apply.
>
I don't think that I have. Some of the ideas that I present
are too difficult for people to understand. For example they
stubbornly refuse to understand that pathological inputs
behave differently than non-pathological inputs.
They refuse to "understand" this when understanding this is a
simple execution trace that any high school student that is
good with the C language could perform.
>> I am working on providing an academic quality definition of this
>> term.
>
> The definition in Wikipedia is good enough.
>
--
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 8 of 21 — ← Prev page 1 … 6 7 [8] 9 10 … 21 Next page →
Back to top | Article view | sci.logic
csiph-web