Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #59471 > unrolled thread
| Started by | olcott <polcott2@gmail.com> |
|---|---|
| First post | 2022-11-11 09:28 -0600 |
| Last post | 2022-11-12 11:14 -0500 |
| Articles | 20 on this page of 164 — 12 participants |
Back to article view | Back to comp.theory
Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 09:28 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 10:57 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-11 18:36 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 13:43 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 13:16 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 14:30 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 13:39 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 16:07 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 15:15 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 16:44 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-11 21:54 +0000
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 16:44 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 18:25 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-11 23:55 +0000
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 17:59 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 19:24 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 18:46 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 21:15 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 20:35 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 21:45 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 20:48 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 21:56 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 22:00 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:02 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 08:43 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:06 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 15:12 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:52 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 10:20 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 11:47 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 22:17 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:08 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 08:55 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:02 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 14:09 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:32 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 14:41 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:52 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 15:03 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:26 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 15:38 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:59 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 10:06 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 11:21 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 09:50 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 11:26 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 11:00 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 12:59 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 12:16 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 13:24 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 18:42 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 14:00 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 19:26 +0000
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-12 13:37 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 14:54 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-12 12:45 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 13:57 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-12 13:04 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 14:21 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 13:36 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 15:01 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-12 14:07 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 15:26 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-12 14:35 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 16:28 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 15:59 -0600
Olcottaholics anonymous Ben Bacarisse <ben.usenet@bsb.me.uk> - 2022-11-12 21:25 +0000
E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-12 16:04 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-12 17:26 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-12 16:33 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-12 17:55 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-12 17:38 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-12 19:02 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-12 19:31 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-12 21:30 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-12 22:00 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-12 23:38 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-12 23:04 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 08:00 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-13 09:39 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 14:34 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-13 13:49 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 15:38 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 14:51 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <news.x.richarddamon@xoxy.net> - 2022-11-13 16:02 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 15:16 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 16:59 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 16:08 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-13 22:25 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally Dennis Bush <dbush.mobile@gmail.com> - 2022-11-13 14:33 -0800
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 16:42 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 18:14 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 17:26 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-13 23:52 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-13 18:00 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 19:33 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 19:29 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-14 19:27 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-14 13:44 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-14 21:53 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-14 21:53 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-15 17:45 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-15 12:00 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-16 20:04 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-17 17:14 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-17 11:25 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 17:36 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 19:36 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 18:07 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-13 23:30 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 19:37 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally "Fred. Zwarts" <F.Zwarts@KVI.nl> - 2022-11-14 11:02 +0100
Re: E correctly simulated by H would never reach its last instruction and terminate normally wij <wyniijj5@gmail.com> - 2022-11-14 03:44 -0800
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2022-11-14 16:17 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally André G. Isaak <agisaak@gm.invalid> - 2022-11-14 11:34 -0700
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-14 13:20 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-14 21:53 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <none-ya@beez-waxes.com> - 2022-11-14 20:00 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-14 21:52 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 18:04 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 17:20 -0600
Re: E correctly simulated by H would never reach its last instruction and terminate normally Richard Damon <Richard@Damon-Family.org> - 2022-11-13 19:43 -0500
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-13 05:40 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-13 04:17 +0000
Re: E correctly simulated by H would never reach its last instruction and terminate normally olcott <polcott2@gmail.com> - 2022-11-13 12:35 -0600
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 18:19 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 13:33 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 09:51 -0600
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 14:50 +0000
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 16:37 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 18:20 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 17:39 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 18:48 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 18:05 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 19:29 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 18:51 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 21:25 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 20:36 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 21:51 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 20:57 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-11 22:25 -0500
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 21:36 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:11 -0500
Re: Simulating halt decider applied to a simpler input Jeff Barnett <jbb@notatt.com> - 2022-11-11 12:56 -0700
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 14:19 -0600
Re: Simulating halt decider applied to a simpler input Jeff Barnett <jbb@notatt.com> - 2022-11-11 18:43 -0700
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 21:06 -0600
Re: Simulating halt decider applied to a simpler input olcott <none-ya@beez-waxes.com> - 2022-11-11 20:21 -0600
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-11 23:35 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:15 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 14:31 +0000
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 08:35 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 09:58 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 15:16 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:41 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 15:52 +0000
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 11:09 -0500
Re: Simulating halt decider applied to a simpler input Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-11-12 16:42 +0000
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 11:04 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 12:07 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 09:27 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 10:46 -0500
Re: Simulating halt decider applied to a simpler input olcott <polcott2@gmail.com> - 2022-11-12 10:02 -0600
Re: Simulating halt decider applied to a simpler input Richard Damon <Richard@Damon-Family.org> - 2022-11-12 11:14 -0500
Page 5 of 9 — ← Prev page 1 2 3 4 [5] 6 7 8 9 Next page →
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-11-13 14:34 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <6FbcL.8759$ITE9.1469@fx40.iad> |
| In reply to | #59601 |
On 11/13/22 10:39 AM, olcott wrote:
> On 11/13/2022 7:00 AM, Richard Damon wrote:
>> On 11/13/22 12:04 AM, olcott wrote:
>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic. It's
>>>>>>>>>>>>>> been 176 days
>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>> expert knowledge of the C programming language is required.
>>>>>>>>>>>>> H simulates its input using an x86 emulator.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>>>>>>>>> simulated by H would never reach its own last instruction
>>>>>>>>>>>>> and terminate normally after 1 to ∞ steps of correct
>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is an easily verified fact that E correctly simulated by
>>>>>>>>>>>>> H would never reach its own last instruction and terminate
>>>>>>>>>>>>> normally after 1 to ∞ steps of correct simulation. E
>>>>>>>>>>>>> remains stuck in recursive simulation until aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is an
>>>>>>>>>>>> illogical statement.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>> corrected on the point many times. When H correctly simulates
>>>>>>>>>>> 1 to N steps of D, then one to N steps of D are correctly
>>>>>>>>>>> simulated.
>>>>>>>>>>>
>>>>>>>>>>> When someone asks if I have any money then any amount of
>>>>>>>>>>> money > 0 counts. It is not a lie for me to say yes when I
>>>>>>>>>>> have less than an infinite amount of money.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, how does a SINGLE H simulate this precise input for from 1
>>>>>>>>>> to an infinte number of steps,
>>>>>>>>>>
>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>> positive integers > 5 is an element of the infinite set of
>>>>>>>>> integers > 3 ?
>>>>>>>>>
>>>>>>>>> Once H correctly matches an infinite behavior pattern after N
>>>>>>>>> steps of correct simulation then H knows that D correctly
>>>>>>>>> simulated by H will never reach its final state and terminate
>>>>>>>>> normally in N to to ∞ steps of correct simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because you can prove it.
>>>>>>>>
>>>>>>>> Again you try to do proof by example, showing that you just
>>>>>>>> don't understand what you are doing.
>>>>>>>>
>>>>>>>> Maybe some day you will be enlightened into what you have been
>>>>>>>> doing wrong.
>>>>>>>>
>>>>>>>> H can't prove the behavor of the D it is simulating because it
>>>>>>>> needs to take into account that H(D,D) WILL return if H takes
>>>>>>>> the steps it needs
>>>>>>> void E(void (*x)())
>>>>>>> {
>>>>>>> H(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> The simulated E never reaches its own final state whether or not
>>>>>>> H ever aborts its simulation of E, thus E simulated by H is by
>>>>>>> definition not halting.
>>>>>>>
>>>>>>
>>>>>> You say "Whether or not" which means you do not have a deinition
>>>>>> for H, because when you define H you need to define its behavior
>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>> H correctly determines the halt status of D for every H/D pair such
>>>>> that
>>>>> the H element of this H/D pair correctly simulates 1 to to ∞ steps
>>>>> of D.
>>>>>
>>>>>
>>>>
>>>> How does that apply?
>>>>
>>>> H needs a SPECIFIC sequence of instructions.
>>>>
>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>> Address_of_H:1383
>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> You and I both can see that D correctly simulated by every H of the
>>> set of H/E pairs will never reach its final state and terminate
>>> normally.
>>> Why lie about this?
>>>
>>
>> Nope, we know you are stupid and a liar because the call H must
>> eventually result in a return of 0 since this run just shopwed that
>> H(P,P) returns 0.
>>
>> You have been told this many times and you ignore it.
>
> You told me that P simulated by H that never aborts its simulation never
> stops running, thus from this we can correctly infer that no P that has
> has had 1 to to ∞ steps correctly simulated by any H ever reaches its
> own final state and terminates normally.
>
> Why do you use the strawman deception to lie?
>
Right, but this H DOES abort its simulation, so that doesn't matter.
Note, we aren't concerned about the fact that no H can correctly
simulate its input to a final state, we are concerned if THIS P, when
executed or correctly simulated, will Halt, and it does.
Since this H doesn't do that, and none of your other H's were given THIS
P, none of your cases mean anything.
In fact, since this H doesn't do a correct simulaiton at all, you
statement is just an illogic, WORSE than the liars paradox.
Note, YOU are using a Strawman, since the actual problem never mentions
simulation, and particularly not "BY H:, that is your STUPID STRAWMAN to
try to add those terms. Doesn't matter your justifcation, it isn't in
the problem, so adding it IS a strawman.
The actual question of the Halting Problem is:
H(P,d) needs to tell us if P(d) will Halt.
H(D,D) says no, D(D) Halt, so H is wrong, and your denial just shows you
totally don't understand anything about the problem and are just proven
to be a persistent liar.
[toc] | [prev] | [next] | [standalone]
| From | olcott <none-ya@beez-waxes.com> |
|---|---|
| Date | 2022-11-13 13:49 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkrhnq$1cku$1@gioia.aioe.org> |
| In reply to | #59603 |
On 11/13/2022 1:34 PM, Richard Damon wrote:
> On 11/13/22 10:39 AM, olcott wrote:
>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>> On 11/13/22 12:04 AM, olcott wrote:
>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic. It's
>>>>>>>>>>>>>>> been 176 days
>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>>> expert knowledge of the C programming language is
>>>>>>>>>>>>>> required. H simulates its input using an x86 emulator.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>>>>>>>>>> simulated by H would never reach its own last instruction
>>>>>>>>>>>>>> and terminate normally after 1 to ∞ steps of correct
>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is an easily verified fact that E correctly simulated
>>>>>>>>>>>>>> by H would never reach its own last instruction and
>>>>>>>>>>>>>> terminate normally after 1 to ∞ steps of correct
>>>>>>>>>>>>>> simulation. E remains stuck in recursive simulation until
>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is an
>>>>>>>>>>>>> illogical statement.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>>> corrected on the point many times. When H correctly
>>>>>>>>>>>> simulates 1 to N steps of D, then one to N steps of D are
>>>>>>>>>>>> correctly simulated.
>>>>>>>>>>>>
>>>>>>>>>>>> When someone asks if I have any money then any amount of
>>>>>>>>>>>> money > 0 counts. It is not a lie for me to say yes when I
>>>>>>>>>>>> have less than an infinite amount of money.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for from
>>>>>>>>>>> 1 to an infinte number of steps,
>>>>>>>>>>>
>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>> positive integers > 5 is an element of the infinite set of
>>>>>>>>>> integers > 3 ?
>>>>>>>>>>
>>>>>>>>>> Once H correctly matches an infinite behavior pattern after N
>>>>>>>>>> steps of correct simulation then H knows that D correctly
>>>>>>>>>> simulated by H will never reach its final state and terminate
>>>>>>>>>> normally in N to to ∞ steps of correct simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because you can prove it.
>>>>>>>>>
>>>>>>>>> Again you try to do proof by example, showing that you just
>>>>>>>>> don't understand what you are doing.
>>>>>>>>>
>>>>>>>>> Maybe some day you will be enlightened into what you have been
>>>>>>>>> doing wrong.
>>>>>>>>>
>>>>>>>>> H can't prove the behavor of the D it is simulating because it
>>>>>>>>> needs to take into account that H(D,D) WILL return if H takes
>>>>>>>>> the steps it needs
>>>>>>>> void E(void (*x)())
>>>>>>>> {
>>>>>>>> H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> The simulated E never reaches its own final state whether or not
>>>>>>>> H ever aborts its simulation of E, thus E simulated by H is by
>>>>>>>> definition not halting.
>>>>>>>>
>>>>>>>
>>>>>>> You say "Whether or not" which means you do not have a deinition
>>>>>>> for H, because when you define H you need to define its behavior
>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>> H correctly determines the halt status of D for every H/D pair
>>>>>> such that
>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞ steps
>>>>>> of D.
>>>>>>
>>>>>>
>>>>>
>>>>> How does that apply?
>>>>>
>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>
>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>> Address_of_H:1383
>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>
>>>> You and I both can see that D correctly simulated by every H of the
>>>> set of H/E pairs will never reach its final state and terminate
>>>> normally.
>>>> Why lie about this?
>>>>
>>>
>>> Nope, we know you are stupid and a liar because the call H must
>>> eventually result in a return of 0 since this run just shopwed that
>>> H(P,P) returns 0.
>>>
>>> You have been told this many times and you ignore it.
>>
>> You told me that P simulated by H that never aborts its simulation
>> never stops running, thus from this we can correctly infer that no P
>> that has has had 1 to to ∞ steps correctly simulated by any H ever
>> reaches its own final state and terminates normally.
>>
>> Why do you use the strawman deception to lie?
>>
>
> Right, but this H DOES abort its simulation, so that doesn't matter.
>
In other words you are saying that infinite loops specify a sequence of
configurations that terminate normally after a finite number of steps of
correct simulation.
void Infinite_Loop()
{
HERE: goto HERE;
}
It is an easily verified fact that Infinite_Loop correctly simulated by
H would never reach its own last instruction and terminate normally
after 1 to ∞ steps of correct simulation.
void E(void (*x)())
{
H(x, x);
}
It is an easily verified fact that E correctly simulated by H would
never reach its own last instruction and terminate normally after 1 to ∞
steps of correct simulation. E remains stuck in recursive simulation
until aborted.
When H returns 0 to main() it correctly predicts that E correctly
simulated by H would never reach its own last instruction (final state)
and terminate normally after 1 to ∞ of correct simulation.
--
Copyright 2022 Pete 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 | 2022-11-13 15:38 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <eBccL.8760$ITE9.1742@fx40.iad> |
| In reply to | #59604 |
On 11/13/22 2:49 PM, olcott wrote:
> On 11/13/2022 1:34 PM, Richard Damon wrote:
>> On 11/13/22 10:39 AM, olcott wrote:
>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic. It's
>>>>>>>>>>>>>>>> been 176 days
>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>>>> expert knowledge of the C programming language is
>>>>>>>>>>>>>>> required. H simulates its input using an x86 emulator.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>> correctly simulated by H would never reach its own last
>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞ steps of
>>>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is an easily verified fact that E correctly simulated
>>>>>>>>>>>>>>> by H would never reach its own last instruction and
>>>>>>>>>>>>>>> terminate normally after 1 to ∞ steps of correct
>>>>>>>>>>>>>>> simulation. E remains stuck in recursive simulation until
>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is an
>>>>>>>>>>>>>> illogical statement.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>>>> corrected on the point many times. When H correctly
>>>>>>>>>>>>> simulates 1 to N steps of D, then one to N steps of D are
>>>>>>>>>>>>> correctly simulated.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When someone asks if I have any money then any amount of
>>>>>>>>>>>>> money > 0 counts. It is not a lie for me to say yes when I
>>>>>>>>>>>>> have less than an infinite amount of money.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for from
>>>>>>>>>>>> 1 to an infinte number of steps,
>>>>>>>>>>>>
>>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>>> positive integers > 5 is an element of the infinite set of
>>>>>>>>>>> integers > 3 ?
>>>>>>>>>>>
>>>>>>>>>>> Once H correctly matches an infinite behavior pattern after N
>>>>>>>>>>> steps of correct simulation then H knows that D correctly
>>>>>>>>>>> simulated by H will never reach its final state and terminate
>>>>>>>>>>> normally in N to to ∞ steps of correct simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because you can prove it.
>>>>>>>>>>
>>>>>>>>>> Again you try to do proof by example, showing that you just
>>>>>>>>>> don't understand what you are doing.
>>>>>>>>>>
>>>>>>>>>> Maybe some day you will be enlightened into what you have been
>>>>>>>>>> doing wrong.
>>>>>>>>>>
>>>>>>>>>> H can't prove the behavor of the D it is simulating because it
>>>>>>>>>> needs to take into account that H(D,D) WILL return if H takes
>>>>>>>>>> the steps it needs
>>>>>>>>> void E(void (*x)())
>>>>>>>>> {
>>>>>>>>> H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> The simulated E never reaches its own final state whether or
>>>>>>>>> not H ever aborts its simulation of E, thus E simulated by H is
>>>>>>>>> by definition not halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You say "Whether or not" which means you do not have a deinition
>>>>>>>> for H, because when you define H you need to define its behavior
>>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>>> H correctly determines the halt status of D for every H/D pair
>>>>>>> such that
>>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞
>>>>>>> steps of D.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> How does that apply?
>>>>>>
>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>
>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>> Address_of_H:1383
>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>
>>>>> You and I both can see that D correctly simulated by every H of the
>>>>> set of H/E pairs will never reach its final state and terminate
>>>>> normally.
>>>>> Why lie about this?
>>>>>
>>>>
>>>> Nope, we know you are stupid and a liar because the call H must
>>>> eventually result in a return of 0 since this run just shopwed that
>>>> H(P,P) returns 0.
>>>>
>>>> You have been told this many times and you ignore it.
>>>
>>> You told me that P simulated by H that never aborts its simulation
>>> never stops running, thus from this we can correctly infer that no P
>>> that has has had 1 to to ∞ steps correctly simulated by any H ever
>>> reaches its own final state and terminates normally.
>>>
>>> Why do you use the strawman deception to lie?
>>>
>>
>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>
> In other words you are saying that infinite loops specify a sequence of
> configurations that terminate normally after a finite number of steps of
> correct simulation.
Nope, but the fact that you think that is what I said shows that you
don't understand the material.
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> It is an easily verified fact that Infinite_Loop correctly simulated by
> H would never reach its own last instruction and terminate normally
> after 1 to ∞ steps of correct simulation.
No one denied that, so this is just more of your Red Herring.
>
> void E(void (*x)())
> {
> H(x, x);
> }
>
> It is an easily verified fact that E correctly simulated by H would
> never reach its own last instruction and terminate normally after 1 to ∞
> steps of correct simulation. E remains stuck in recursive simulation
> until aborted.
But that isn't the question, since the H you claim is correct doesn't
correctly simulate the input since it aborts it.
The H that this E is built on DOESN'T correctly simulate its input (but
it think it does) but just aborts it as soon as it sees the call to H in
it, and returns 0.
You are looking at the wrong program, as you seem to think that H
somehow correctly simulates its input.
It seems you just don't understand what a program is, maybe all the
credentials you have presented are just as fake as your arguements.
You seem to have fallen for the lies you have been spreading, and have
gaslighted yourself.
H just CLAIMES to simulate until it has correctly determined the answer,
but in fact it gives up and guesses non-halting once it sees the input
is doing something too complicated for it and CLAIMING (incorrectly)
that it has "proven" that it has the right answer.
You just don't seem to understand what is needed to actually prove
something, and thus have fallen for the lies of the Evil Peter Olcott
who makes up his on ideas because he refused to learn what is actually true.
I will admit, he can be somewhat persuasive in his arguments, until you
ask him for sources, at which point he does the normal sharlaton
response of it is just obvious.
Note, "Just Obvious" is the source of most logical fallacies, which he
is an EXPERT at using.
>
> When H returns 0 to main() it correctly predicts that E correctly
> simulated by H would never reach its own last instruction (final state)
> and terminate normally after 1 to ∞ of correct simulation.
>
So H is convicting Joe of the crime that H did itself.
The E that H was given calls this H that has been defined to return 0 to
H(E,E) (since that is the H that you are claiming to be correct about).
Instead H looks at some IMPOSTER E that is calling an IMPOSTER H that
behaves differently.
Obviously, to you, all functions by the same name are the same, and you
have no problem intentionally reusing names, proving that you are a
deceptive shister who shouldn't be trusted with anything,
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-11-13 14:51 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkrlcc$1hd6l$1@dont-email.me> |
| In reply to | #59605 |
On 11/13/2022 2:38 PM, Richard Damon wrote:
> On 11/13/22 2:49 PM, olcott wrote:
>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>> On 11/13/22 10:39 AM, olcott wrote:
>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic. It's
>>>>>>>>>>>>>>>>> been 176 days
>>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>>>>> expert knowledge of the C programming language is
>>>>>>>>>>>>>>>> required. H simulates its input using an x86 emulator.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>>> correctly simulated by H would never reach its own last
>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞ steps of
>>>>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly simulated
>>>>>>>>>>>>>>>> by H would never reach its own last instruction and
>>>>>>>>>>>>>>>> terminate normally after 1 to ∞ steps of correct
>>>>>>>>>>>>>>>> simulation. E remains stuck in recursive simulation
>>>>>>>>>>>>>>>> until aborted.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is an
>>>>>>>>>>>>>>> illogical statement.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>>>>> corrected on the point many times. When H correctly
>>>>>>>>>>>>>> simulates 1 to N steps of D, then one to N steps of D are
>>>>>>>>>>>>>> correctly simulated.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When someone asks if I have any money then any amount of
>>>>>>>>>>>>>> money > 0 counts. It is not a lie for me to say yes when I
>>>>>>>>>>>>>> have less than an infinite amount of money.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for
>>>>>>>>>>>>> from 1 to an infinte number of steps,
>>>>>>>>>>>>>
>>>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>>>> positive integers > 5 is an element of the infinite set of
>>>>>>>>>>>> integers > 3 ?
>>>>>>>>>>>>
>>>>>>>>>>>> Once H correctly matches an infinite behavior pattern after
>>>>>>>>>>>> N steps of correct simulation then H knows that D correctly
>>>>>>>>>>>> simulated by H will never reach its final state and
>>>>>>>>>>>> terminate normally in N to to ∞ steps of correct simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because you can prove it.
>>>>>>>>>>>
>>>>>>>>>>> Again you try to do proof by example, showing that you just
>>>>>>>>>>> don't understand what you are doing.
>>>>>>>>>>>
>>>>>>>>>>> Maybe some day you will be enlightened into what you have
>>>>>>>>>>> been doing wrong.
>>>>>>>>>>>
>>>>>>>>>>> H can't prove the behavor of the D it is simulating because
>>>>>>>>>>> it needs to take into account that H(D,D) WILL return if H
>>>>>>>>>>> takes the steps it needs
>>>>>>>>>> void E(void (*x)())
>>>>>>>>>> {
>>>>>>>>>> H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> The simulated E never reaches its own final state whether or
>>>>>>>>>> not H ever aborts its simulation of E, thus E simulated by H
>>>>>>>>>> is by definition not halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You say "Whether or not" which means you do not have a
>>>>>>>>> deinition for H, because when you define H you need to define
>>>>>>>>> its behavior
>>>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>>>> H correctly determines the halt status of D for every H/D pair
>>>>>>>> such that
>>>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞
>>>>>>>> steps of D.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> How does that apply?
>>>>>>>
>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>
>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>> Address_of_H:1383
>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>
>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>> the set of H/E pairs will never reach its final state and
>>>>>> terminate normally.
>>>>>> Why lie about this?
>>>>>>
>>>>>
>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>> eventually result in a return of 0 since this run just shopwed that
>>>>> H(P,P) returns 0.
>>>>>
>>>>> You have been told this many times and you ignore it.
>>>>
>>>> You told me that P simulated by H that never aborts its simulation
>>>> never stops running, thus from this we can correctly infer that no P
>>>> that has has had 1 to to ∞ steps correctly simulated by any H ever
>>>> reaches its own final state and terminates normally.
>>>>
>>>> Why do you use the strawman deception to lie?
>>>>
>>>
>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>
>> In other words you are saying that infinite loops specify a sequence
>> of configurations that terminate normally after a finite number of
>> steps of correct simulation.
>
> Nope, but the fact that you think that is what I said shows that you
> don't understand the material.
>
>>
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> }
>>
>> It is an easily verified fact that Infinite_Loop correctly simulated
>> by H would never reach its own last instruction and terminate normally
>> after 1 to ∞ steps of correct simulation.
>
> No one denied that, so this is just more of your Red Herring.
>
>>
>> void E(void (*x)())
>> {
>> H(x, x);
>> }
>>
>> It is an easily verified fact that E correctly simulated by H would
>> never reach its own last instruction and terminate normally after 1 to
>> ∞ steps of correct simulation. E remains stuck in recursive simulation
>> until aborted.
>
> But that isn't the question, since the H you claim is correct doesn't
> correctly simulate the input since it aborts it.
>
> The H that this E is built on DOESN'T correctly simulate its input
_E()
[000019d2] 55 push ebp
[000019d3] 8bec mov ebp,esp
[000019d5] 8b4508 mov eax,[ebp+08]
[000019d8] 50 push eax
[000019d9] 8b4d08 mov ecx,[ebp+08]
[000019dc] 51 push ecx
[000019dd] e8b0f9ffff call 00001392
[000019e2] 83c408 add esp,+08
[000019e5] 5d pop ebp
[000019e6] c3 ret
Size in bytes:(0021) [000019e6]
H: Begin Simulation Execution Trace Stored at:112b28
Address_of_H:1392
[000019d2][00112b14][00112b18] 55 push ebp
[000019d3][00112b14][00112b18] 8bec mov ebp,esp
[000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
[000019d8][00112b10][000019d2] 50 push eax // push E
[000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
[000019dc][00112b0c][000019d2] 51 push ecx // push E
[000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped
Since I already proved that H does correctly simulate E in that every
line of the execution trace of E simulated by H exactly matches a
corresponding line that the x86 source-code of E specifies, why do you
lie about this?
The first seven lines of E are proven to be correctly simulated by H and
also prove that E correctly simulated by every H that can possibly exist
would never reach its own final state and terminate normally.
--
Copyright 2022 Pete 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 <news.x.richarddamon@xoxy.net> |
|---|---|
| Date | 2022-11-13 16:02 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkrm1b$1h0mj$1@dont-email.me> |
| In reply to | #59606 |
On 11/13/22 3:51 PM, olcott wrote:
> On 11/13/2022 2:38 PM, Richard Damon wrote:
>> On 11/13/22 2:49 PM, olcott wrote:
>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic. It's
>>>>>>>>>>>>>>>>>> been 176 days
>>>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>>>>>> expert knowledge of the C programming language is
>>>>>>>>>>>>>>>>> required. H simulates its input using an x86 emulator.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its own last
>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>>>>>> of correct simulation. E remains stuck in recursive
>>>>>>>>>>>>>>>>> simulation until aborted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is an
>>>>>>>>>>>>>>>> illogical statement.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>>>>>> corrected on the point many times. When H correctly
>>>>>>>>>>>>>>> simulates 1 to N steps of D, then one to N steps of D are
>>>>>>>>>>>>>>> correctly simulated.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When someone asks if I have any money then any amount of
>>>>>>>>>>>>>>> money > 0 counts. It is not a lie for me to say yes when
>>>>>>>>>>>>>>> I have less than an infinite amount of money.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for
>>>>>>>>>>>>>> from 1 to an infinte number of steps,
>>>>>>>>>>>>>>
>>>>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>>>>> positive integers > 5 is an element of the infinite set of
>>>>>>>>>>>>> integers > 3 ?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Once H correctly matches an infinite behavior pattern after
>>>>>>>>>>>>> N steps of correct simulation then H knows that D correctly
>>>>>>>>>>>>> simulated by H will never reach its final state and
>>>>>>>>>>>>> terminate normally in N to to ∞ steps of correct simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because you can prove it.
>>>>>>>>>>>>
>>>>>>>>>>>> Again you try to do proof by example, showing that you just
>>>>>>>>>>>> don't understand what you are doing.
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe some day you will be enlightened into what you have
>>>>>>>>>>>> been doing wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> H can't prove the behavor of the D it is simulating because
>>>>>>>>>>>> it needs to take into account that H(D,D) WILL return if H
>>>>>>>>>>>> takes the steps it needs
>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>> H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> The simulated E never reaches its own final state whether or
>>>>>>>>>>> not H ever aborts its simulation of E, thus E simulated by H
>>>>>>>>>>> is by definition not halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You say "Whether or not" which means you do not have a
>>>>>>>>>> deinition for H, because when you define H you need to define
>>>>>>>>>> its behavior
>>>>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>>>>> H correctly determines the halt status of D for every H/D pair
>>>>>>>>> such that
>>>>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞
>>>>>>>>> steps of D.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> How does that apply?
>>>>>>>>
>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>
>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>>> Address_of_H:1383
>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>
>>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>>> the set of H/E pairs will never reach its final state and
>>>>>>> terminate normally.
>>>>>>> Why lie about this?
>>>>>>>
>>>>>>
>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>> that H(P,P) returns 0.
>>>>>>
>>>>>> You have been told this many times and you ignore it.
>>>>>
>>>>> You told me that P simulated by H that never aborts its simulation
>>>>> never stops running, thus from this we can correctly infer that no
>>>>> P that has has had 1 to to ∞ steps correctly simulated by any H
>>>>> ever reaches its own final state and terminates normally.
>>>>>
>>>>> Why do you use the strawman deception to lie?
>>>>>
>>>>
>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>
>>> In other words you are saying that infinite loops specify a sequence
>>> of configurations that terminate normally after a finite number of
>>> steps of correct simulation.
>>
>> Nope, but the fact that you think that is what I said shows that you
>> don't understand the material.
>>
>>>
>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }
>>>
>>> It is an easily verified fact that Infinite_Loop correctly simulated
>>> by H would never reach its own last instruction and terminate
>>> normally after 1 to ∞ steps of correct simulation.
>>
>> No one denied that, so this is just more of your Red Herring.
>>
>>>
>>> void E(void (*x)())
>>> {
>>> H(x, x);
>>> }
>>>
>>> It is an easily verified fact that E correctly simulated by H would
>>> never reach its own last instruction and terminate normally after 1
>>> to ∞ steps of correct simulation. E remains stuck in recursive
>>> simulation until aborted.
>>
>> But that isn't the question, since the H you claim is correct doesn't
>> correctly simulate the input since it aborts it.
>>
>> The H that this E is built on DOESN'T correctly simulate its input
>
> _E()
> [000019d2] 55 push ebp
> [000019d3] 8bec mov ebp,esp
> [000019d5] 8b4508 mov eax,[ebp+08]
> [000019d8] 50 push eax
> [000019d9] 8b4d08 mov ecx,[ebp+08]
> [000019dc] 51 push ecx
> [000019dd] e8b0f9ffff call 00001392
> [000019e2] 83c408 add esp,+08
> [000019e5] 5d pop ebp
> [000019e6] c3 ret
> Size in bytes:(0021) [000019e6]
>
> H: Begin Simulation Execution Trace Stored at:112b28
> Address_of_H:1392
> [000019d2][00112b14][00112b18] 55 push ebp
> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
> [000019d8][00112b10][000019d2] 50 push eax // push E
> [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
> [000019dc][00112b0c][000019d2] 51 push ecx // push E
> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
> H: Infinitely Recursive Simulation Detected Simulation Stopped
>
> Since I already proved that H does correctly simulate E in that every
> line of the execution trace of E simulated by H exactly matches a
> corresponding line that the x86 source-code of E specifies, why do you
> lie about this?
>
No, H does a correct PARTIAL simulation of its input.
When you mention that a correct simulation not reaching the end implies
non-halting, that means it needs to be a COMPLETE siulation, so your
statement is just a LIE.
You are being INTENTIONALLY deceptive with shifting definition.
> The first seven lines of E are proven to be correctly simulated by H and
> also prove that E correctly simulated by every H that can possibly exist
> would never reach its own final state and terminate normally.
>
>
And the "Simulation" of the "CALL" instruction is INCORRECT.
One error means NOT CORRECT.
So, YOU LIE.
This lie is also show to be INTENTIONAL.
You are just demonstrationg your utter STUPIDITY and IGNORANCE of the topic.
You are just proving that you are INCOMPETENT to talk about anything
related to this,
Yoy have thus destroyed your reputation and totally wasted your last 18
years of your life,
Sorry, you are a FAILURE.
YOU WILL BURN IN HELL by the scrptures you have quoted.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-11-13 15:16 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkrmrm$1hd6l$2@dont-email.me> |
| In reply to | #59607 |
On 11/13/2022 3:02 PM, Richard Damon wrote:
> On 11/13/22 3:51 PM, olcott wrote:
>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>> On 11/13/22 2:49 PM, olcott wrote:
>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic.
>>>>>>>>>>>>>>>>>>> It's been 176 days
>>>>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>>>>>>> expert knowledge of the C programming language is
>>>>>>>>>>>>>>>>>> required. H simulates its input using an x86 emulator.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its own
>>>>>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
>>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
>>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>>>>>>> of correct simulation. E remains stuck in recursive
>>>>>>>>>>>>>>>>>> simulation until aborted.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is an
>>>>>>>>>>>>>>>>> illogical statement.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>>>>>>> corrected on the point many times. When H correctly
>>>>>>>>>>>>>>>> simulates 1 to N steps of D, then one to N steps of D
>>>>>>>>>>>>>>>> are correctly simulated.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When someone asks if I have any money then any amount of
>>>>>>>>>>>>>>>> money > 0 counts. It is not a lie for me to say yes when
>>>>>>>>>>>>>>>> I have less than an infinite amount of money.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for
>>>>>>>>>>>>>>> from 1 to an infinte number of steps,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>>>>>> positive integers > 5 is an element of the infinite set of
>>>>>>>>>>>>>> integers > 3 ?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Once H correctly matches an infinite behavior pattern
>>>>>>>>>>>>>> after N steps of correct simulation then H knows that D
>>>>>>>>>>>>>> correctly simulated by H will never reach its final state
>>>>>>>>>>>>>> and terminate normally in N to to ∞ steps of correct
>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because you can prove it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again you try to do proof by example, showing that you just
>>>>>>>>>>>>> don't understand what you are doing.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe some day you will be enlightened into what you have
>>>>>>>>>>>>> been doing wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H can't prove the behavor of the D it is simulating because
>>>>>>>>>>>>> it needs to take into account that H(D,D) WILL return if H
>>>>>>>>>>>>> takes the steps it needs
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> The simulated E never reaches its own final state whether or
>>>>>>>>>>>> not H ever aborts its simulation of E, thus E simulated by H
>>>>>>>>>>>> is by definition not halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You say "Whether or not" which means you do not have a
>>>>>>>>>>> deinition for H, because when you define H you need to define
>>>>>>>>>>> its behavior
>>>>>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>>>>>> H correctly determines the halt status of D for every H/D pair
>>>>>>>>>> such that
>>>>>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞
>>>>>>>>>> steps of D.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> How does that apply?
>>>>>>>>>
>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>
>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>>>> Address_of_H:1383
>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>
>>>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>>>> the set of H/E pairs will never reach its final state and
>>>>>>>> terminate normally.
>>>>>>>> Why lie about this?
>>>>>>>>
>>>>>>>
>>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>>> that H(P,P) returns 0.
>>>>>>>
>>>>>>> You have been told this many times and you ignore it.
>>>>>>
>>>>>> You told me that P simulated by H that never aborts its simulation
>>>>>> never stops running, thus from this we can correctly infer that no
>>>>>> P that has has had 1 to to ∞ steps correctly simulated by any H
>>>>>> ever reaches its own final state and terminates normally.
>>>>>>
>>>>>> Why do you use the strawman deception to lie?
>>>>>>
>>>>>
>>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>>
>>>> In other words you are saying that infinite loops specify a sequence
>>>> of configurations that terminate normally after a finite number of
>>>> steps of correct simulation.
>>>
>>> Nope, but the fact that you think that is what I said shows that you
>>> don't understand the material.
>>>
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> It is an easily verified fact that Infinite_Loop correctly simulated
>>>> by H would never reach its own last instruction and terminate
>>>> normally after 1 to ∞ steps of correct simulation.
>>>
>>> No one denied that, so this is just more of your Red Herring.
>>>
>>>>
>>>> void E(void (*x)())
>>>> {
>>>> H(x, x);
>>>> }
>>>>
>>>> It is an easily verified fact that E correctly simulated by H would
>>>> never reach its own last instruction and terminate normally after 1
>>>> to ∞ steps of correct simulation. E remains stuck in recursive
>>>> simulation until aborted.
>>>
>>> But that isn't the question, since the H you claim is correct doesn't
>>> correctly simulate the input since it aborts it.
>>>
>>> The H that this E is built on DOESN'T correctly simulate its input
>>
>> _E()
>> [000019d2] 55 push ebp
>> [000019d3] 8bec mov ebp,esp
>> [000019d5] 8b4508 mov eax,[ebp+08]
>> [000019d8] 50 push eax
>> [000019d9] 8b4d08 mov ecx,[ebp+08]
>> [000019dc] 51 push ecx
>> [000019dd] e8b0f9ffff call 00001392
>> [000019e2] 83c408 add esp,+08
>> [000019e5] 5d pop ebp
>> [000019e6] c3 ret
>> Size in bytes:(0021) [000019e6]
>>
>> H: Begin Simulation Execution Trace Stored at:112b28
>> Address_of_H:1392
>> [000019d2][00112b14][00112b18] 55 push ebp
>> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
>> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
>> [000019d8][00112b10][000019d2] 50 push eax // push E
>> [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
>> [000019dc][00112b0c][000019d2] 51 push ecx // push E
>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> Since I already proved that H does correctly simulate E in that every
>> line of the execution trace of E simulated by H exactly matches a
>> corresponding line that the x86 source-code of E specifies, why do you
>> lie about this?
>>
> No, H does a correct PARTIAL simulation of its input.
>
> When you mention that a correct simulation not reaching the end implies
> non-halting, that means it needs to be a COMPLETE siulation, so your
> statement is just a LIE.
>
> You are being INTENTIONALLY deceptive with shifting definition.
>
>
>> The first seven lines of E are proven to be correctly simulated by H
>> and also prove that E correctly simulated by every H that can possibly
>> exist would never reach its own final state and terminate normally.
>>
>>
>
> And the "Simulation" of the "CALL" instruction is INCORRECT.
>
The seventh line of E simulated by H is the seventh line of the x86
source-code of E.
The simulation can only be incorrect when the execution trace of the
simulated E diverges from what the x86 source-code of E specifies, thus
you lie again. Why do you insist on lying about easily verified facts?
--
Copyright 2022 Pete 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 | 2022-11-13 16:59 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <wNdcL.3069$rB56.1965@fx08.iad> |
| In reply to | #59608 |
On 11/13/22 4:16 PM, olcott wrote:
> On 11/13/2022 3:02 PM, Richard Damon wrote:
>> On 11/13/22 3:51 PM, olcott wrote:
>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic.
>>>>>>>>>>>>>>>>>>>> It's been 176 days
>>>>>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that only
>>>>>>>>>>>>>>>>>>> expert knowledge of the C programming language is
>>>>>>>>>>>>>>>>>>> required. H simulates its input using an x86 emulator.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its own
>>>>>>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
>>>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
>>>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>>>>>>>> of correct simulation. E remains stuck in recursive
>>>>>>>>>>>>>>>>>>> simulation until aborted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is
>>>>>>>>>>>>>>>>>> an illogical statement.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You must really have brain damage because you have been
>>>>>>>>>>>>>>>>> corrected on the point many times. When H correctly
>>>>>>>>>>>>>>>>> simulates 1 to N steps of D, then one to N steps of D
>>>>>>>>>>>>>>>>> are correctly simulated.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When someone asks if I have any money then any amount
>>>>>>>>>>>>>>>>> of money > 0 counts. It is not a lie for me to say yes
>>>>>>>>>>>>>>>>> when I have less than an infinite amount of money.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for
>>>>>>>>>>>>>>>> from 1 to an infinte number of steps,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>>>>>>> positive integers > 5 is an element of the infinite set
>>>>>>>>>>>>>>> of integers > 3 ?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Once H correctly matches an infinite behavior pattern
>>>>>>>>>>>>>>> after N steps of correct simulation then H knows that D
>>>>>>>>>>>>>>> correctly simulated by H will never reach its final state
>>>>>>>>>>>>>>> and terminate normally in N to to ∞ steps of correct
>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because you can prove it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Again you try to do proof by example, showing that you
>>>>>>>>>>>>>> just don't understand what you are doing.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe some day you will be enlightened into what you have
>>>>>>>>>>>>>> been doing wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H can't prove the behavor of the D it is simulating
>>>>>>>>>>>>>> because it needs to take into account that H(D,D) WILL
>>>>>>>>>>>>>> return if H takes the steps it needs
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> The simulated E never reaches its own final state whether
>>>>>>>>>>>>> or not H ever aborts its simulation of E, thus E simulated
>>>>>>>>>>>>> by H is by definition not halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You say "Whether or not" which means you do not have a
>>>>>>>>>>>> deinition for H, because when you define H you need to
>>>>>>>>>>>> define its behavior
>>>>>>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>>>>>>> H correctly determines the halt status of D for every H/D
>>>>>>>>>>> pair such that
>>>>>>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞
>>>>>>>>>>> steps of D.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> How does that apply?
>>>>>>>>>>
>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>
>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>>>>> Address_of_H:1383
>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>
>>>>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>>>>> the set of H/E pairs will never reach its final state and
>>>>>>>>> terminate normally.
>>>>>>>>> Why lie about this?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>>>> that H(P,P) returns 0.
>>>>>>>>
>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>
>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>> simulation never stops running, thus from this we can correctly
>>>>>>> infer that no P that has has had 1 to to ∞ steps correctly
>>>>>>> simulated by any H ever reaches its own final state and
>>>>>>> terminates normally.
>>>>>>>
>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>
>>>>>>
>>>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>>>
>>>>> In other words you are saying that infinite loops specify a
>>>>> sequence of configurations that terminate normally after a finite
>>>>> number of steps of correct simulation.
>>>>
>>>> Nope, but the fact that you think that is what I said shows that you
>>>> don't understand the material.
>>>>
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>> simulated by H would never reach its own last instruction and
>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>
>>>> No one denied that, so this is just more of your Red Herring.
>>>>
>>>>>
>>>>> void E(void (*x)())
>>>>> {
>>>>> H(x, x);
>>>>> }
>>>>>
>>>>> It is an easily verified fact that E correctly simulated by H would
>>>>> never reach its own last instruction and terminate normally after 1
>>>>> to ∞ steps of correct simulation. E remains stuck in recursive
>>>>> simulation until aborted.
>>>>
>>>> But that isn't the question, since the H you claim is correct
>>>> doesn't correctly simulate the input since it aborts it.
>>>>
>>>> The H that this E is built on DOESN'T correctly simulate its input
>>>
>>> _E()
>>> [000019d2] 55 push ebp
>>> [000019d3] 8bec mov ebp,esp
>>> [000019d5] 8b4508 mov eax,[ebp+08]
>>> [000019d8] 50 push eax
>>> [000019d9] 8b4d08 mov ecx,[ebp+08]
>>> [000019dc] 51 push ecx
>>> [000019dd] e8b0f9ffff call 00001392
>>> [000019e2] 83c408 add esp,+08
>>> [000019e5] 5d pop ebp
>>> [000019e6] c3 ret
>>> Size in bytes:(0021) [000019e6]
>>>
>>> H: Begin Simulation Execution Trace Stored at:112b28
>>> Address_of_H:1392
>>> [000019d2][00112b14][00112b18] 55 push ebp
>>> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
>>> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
>>> [000019d8][00112b10][000019d2] 50 push eax // push E
>>> [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
>>> [000019dc][00112b0c][000019d2] 51 push ecx // push E
>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> Since I already proved that H does correctly simulate E in that every
>>> line of the execution trace of E simulated by H exactly matches a
>>> corresponding line that the x86 source-code of E specifies, why do
>>> you lie about this?
>>>
>> No, H does a correct PARTIAL simulation of its input.
>>
>> When you mention that a correct simulation not reaching the end
>> implies non-halting, that means it needs to be a COMPLETE siulation,
>> so your statement is just a LIE.
>>
>> You are being INTENTIONALLY deceptive with shifting definition.
>>
>>
>>> The first seven lines of E are proven to be correctly simulated by H
>>> and also prove that E correctly simulated by every H that can
>>> possibly exist would never reach its own final state and terminate
>>> normally.
>>>
>>>
>>
>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>
> The seventh line of E simulated by H is the seventh line of the x86
> source-code of E.
>
> The simulation can only be incorrect when the execution trace of the
> simulated E diverges from what the x86 source-code of E specifies, thus
> you lie again. Why do you insist on lying about easily verified facts?
>
>
And it does. How depends on which set of definitons you use.
We can look at it one of two ways.
THe first, is that since you are assserting that the failure of this
trace to reach a final state shows that the program is non-halting, then
the fact that in the actual program a "Call H" instruction continues
into the function H, while in the simulation stops its simulation there.
Thus it disagrees with the actual behaivor. You only possible answer is
to instead depend on logic about this call to H, which means all you
references to correctly simulating E is just a red herring as it is the
correct analysis of a call to H(E,E) that matters.
This gets to the second view, we KNOW from the fact that you are showing
a reasoning that H(E,E) can be correct to return 0, to show that H(E,E)
must actually return 0.
Thus a "Correct Simulation" of a "Call H" with parameters E and E, must
result in seeing a return 0. Since you logic says it never return, that
must be a INCORRECT simulation result.
Thus you are stuck with either your arguement that H doing a correct
simulation show the result must actually be a incorrect statement, or it
is shown that H just doesn't do a correct simulation.
This is just another examply of you changeing the meaning of words in
the middle of your statement.
If you want to claim that H is doing a correct simulation that shows tha
the input is non-halting, then either that simulation is incorrect, or
the statement that its "Correct Simulation" proves anyting is just a lie.
FAIL.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-11-13 16:08 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkrpsj$1hne2$1@dont-email.me> |
| In reply to | #59609 |
On 11/13/2022 3:59 PM, Richard Damon wrote:
> On 11/13/22 4:16 PM, olcott wrote:
>> On 11/13/2022 3:02 PM, Richard Damon wrote:
>>> On 11/13/22 3:51 PM, olcott wrote:
>>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an Olcottaholic.
>>>>>>>>>>>>>>>>>>>>> It's been 176 days
>>>>>>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that
>>>>>>>>>>>>>>>>>>>> only expert knowledge of the C programming language
>>>>>>>>>>>>>>>>>>>> is required. H simulates its input using an x86
>>>>>>>>>>>>>>>>>>>> emulator.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its own
>>>>>>>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
>>>>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
>>>>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>>>>>> steps of correct simulation. E remains stuck in
>>>>>>>>>>>>>>>>>>>> recursive simulation until aborted.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that is
>>>>>>>>>>>>>>>>>>> an illogical statement.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You must really have brain damage because you have
>>>>>>>>>>>>>>>>>> been corrected on the point many times. When H
>>>>>>>>>>>>>>>>>> correctly simulates 1 to N steps of D, then one to N
>>>>>>>>>>>>>>>>>> steps of D are correctly simulated.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When someone asks if I have any money then any amount
>>>>>>>>>>>>>>>>>> of money > 0 counts. It is not a lie for me to say yes
>>>>>>>>>>>>>>>>>> when I have less than an infinite amount of money.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input for
>>>>>>>>>>>>>>>>> from 1 to an infinte number of steps,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> How do we know that every element of the infinite set of
>>>>>>>>>>>>>>>> positive integers > 5 is an element of the infinite set
>>>>>>>>>>>>>>>> of integers > 3 ?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Once H correctly matches an infinite behavior pattern
>>>>>>>>>>>>>>>> after N steps of correct simulation then H knows that D
>>>>>>>>>>>>>>>> correctly simulated by H will never reach its final
>>>>>>>>>>>>>>>> state and terminate normally in N to to ∞ steps of
>>>>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because you can prove it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again you try to do proof by example, showing that you
>>>>>>>>>>>>>>> just don't understand what you are doing.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Maybe some day you will be enlightened into what you have
>>>>>>>>>>>>>>> been doing wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H can't prove the behavor of the D it is simulating
>>>>>>>>>>>>>>> because it needs to take into account that H(D,D) WILL
>>>>>>>>>>>>>>> return if H takes the steps it needs
>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The simulated E never reaches its own final state whether
>>>>>>>>>>>>>> or not H ever aborts its simulation of E, thus E simulated
>>>>>>>>>>>>>> by H is by definition not halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You say "Whether or not" which means you do not have a
>>>>>>>>>>>>> deinition for H, because when you define H you need to
>>>>>>>>>>>>> define its behavior
>>>>>>>>>>>> In the same way that we know that every integer > 5 is also > 3
>>>>>>>>>>>> H correctly determines the halt status of D for every H/D
>>>>>>>>>>>> pair such that
>>>>>>>>>>>> the H element of this H/D pair correctly simulates 1 to to ∞
>>>>>>>>>>>> steps of D.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> How does that apply?
>>>>>>>>>>>
>>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>>
>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>>>>>> Address_of_H:1383
>>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax // push P
>>>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [0000199e][0015d4b1][00001993] 51 push ecx // push P
>>>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> You and I both can see that D correctly simulated by every H
>>>>>>>>>> of the set of H/E pairs will never reach its final state and
>>>>>>>>>> terminate normally.
>>>>>>>>>> Why lie about this?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>>>>> that H(P,P) returns 0.
>>>>>>>>>
>>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>>
>>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>>> simulation never stops running, thus from this we can correctly
>>>>>>>> infer that no P that has has had 1 to to ∞ steps correctly
>>>>>>>> simulated by any H ever reaches its own final state and
>>>>>>>> terminates normally.
>>>>>>>>
>>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>>
>>>>>>>
>>>>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>>>>
>>>>>> In other words you are saying that infinite loops specify a
>>>>>> sequence of configurations that terminate normally after a finite
>>>>>> number of steps of correct simulation.
>>>>>
>>>>> Nope, but the fact that you think that is what I said shows that
>>>>> you don't understand the material.
>>>>>
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>> simulated by H would never reach its own last instruction and
>>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>>
>>>>> No one denied that, so this is just more of your Red Herring.
>>>>>
>>>>>>
>>>>>> void E(void (*x)())
>>>>>> {
>>>>>> H(x, x);
>>>>>> }
>>>>>>
>>>>>> It is an easily verified fact that E correctly simulated by H
>>>>>> would never reach its own last instruction and terminate normally
>>>>>> after 1 to ∞ steps of correct simulation. E remains stuck in
>>>>>> recursive simulation until aborted.
>>>>>
>>>>> But that isn't the question, since the H you claim is correct
>>>>> doesn't correctly simulate the input since it aborts it.
>>>>>
>>>>> The H that this E is built on DOESN'T correctly simulate its input
>>>>
>>>> _E()
>>>> [000019d2] 55 push ebp
>>>> [000019d3] 8bec mov ebp,esp
>>>> [000019d5] 8b4508 mov eax,[ebp+08]
>>>> [000019d8] 50 push eax
>>>> [000019d9] 8b4d08 mov ecx,[ebp+08]
>>>> [000019dc] 51 push ecx
>>>> [000019dd] e8b0f9ffff call 00001392
>>>> [000019e2] 83c408 add esp,+08
>>>> [000019e5] 5d pop ebp
>>>> [000019e6] c3 ret
>>>> Size in bytes:(0021) [000019e6]
>>>>
>>>> H: Begin Simulation Execution Trace Stored at:112b28
>>>> Address_of_H:1392
>>>> [000019d2][00112b14][00112b18] 55 push ebp
>>>> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
>>>> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
>>>> [000019d8][00112b10][000019d2] 50 push eax // push E
>>>> [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
>>>> [000019dc][00112b0c][000019d2] 51 push ecx // push E
>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>
>>>> Since I already proved that H does correctly simulate E in that
>>>> every line of the execution trace of E simulated by H exactly
>>>> matches a corresponding line that the x86 source-code of E
>>>> specifies, why do you lie about this?
>>>>
>>> No, H does a correct PARTIAL simulation of its input.
>>>
>>> When you mention that a correct simulation not reaching the end
>>> implies non-halting, that means it needs to be a COMPLETE siulation,
>>> so your statement is just a LIE.
>>>
>>> You are being INTENTIONALLY deceptive with shifting definition.
>>>
>>>
>>>> The first seven lines of E are proven to be correctly simulated by H
>>>> and also prove that E correctly simulated by every H that can
>>>> possibly exist would never reach its own final state and terminate
>>>> normally.
>>>>
>>>>
>>>
>>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>>
>> The seventh line of E simulated by H is the seventh line of the x86
>> source-code of E.
>>
>> The simulation can only be incorrect when the execution trace of the
>> simulated E diverges from what the x86 source-code of E specifies,
>> thus you lie again. Why do you insist on lying about easily verified
>> facts?
>>
>>
> And it does. How depends on which set of definitons you use.
>
> We can look at it one of two ways.
>
> THe first, is that since you are assserting that the failure of this
> trace to reach a final state shows that the program is non-halting, then
> the fact that in the actual program a "Call H" instruction continues
> into the function H, while in the simulation stops its simulation there.
>
int main() { H(D,D); } D simulated by H never stops running unless
aborted and never halts: (reaches its own final state and terminates
normally) whether aborted or not. Halt Deciders only report on the
behavior of their inputs thus no strawman deception about the behavior
of a non-input is any rebuttal at all.
--
Copyright 2022 Pete 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 | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-11-13 22:25 +0000 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <20221113222540.00006aa2@reddwarf.jmc.corp> |
| In reply to | #59610 |
On Sun, 13 Nov 2022 16:08:18 -0600
olcott <polcott2@gmail.com> wrote:
> On 11/13/2022 3:59 PM, Richard Damon wrote:
> > On 11/13/22 4:16 PM, olcott wrote:
> >> On 11/13/2022 3:02 PM, Richard Damon wrote:
> >>> On 11/13/22 3:51 PM, olcott wrote:
> >>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
> >>>>> On 11/13/22 2:49 PM, olcott wrote:
> >>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
> >>>>>>> On 11/13/22 10:39 AM, olcott wrote:
> >>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
> >>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
> >>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
> >>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
> >>>>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
> >>>>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
> >>>>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an
> >>>>>>>>>>>>>>>>>>>>> Olcottaholic. It's been 176 days
> >>>>>>>>>>>>>>>>>>>>> since my last post.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that
> >>>>>>>>>>>>>>>>>>>> only expert knowledge of the C programming
> >>>>>>>>>>>>>>>>>>>> language is required. H simulates its input
> >>>>>>>>>>>>>>>>>>>> using an x86 emulator.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
> >>>>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its
> >>>>>>>>>>>>>>>>>>>> own last instruction and terminate normally
> >>>>>>>>>>>>>>>>>>>> after 1 to ∞ steps of correct simulation.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void E(void (*x)())
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> H(x, x);
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
> >>>>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
> >>>>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞
> >>>>>>>>>>>>>>>>>>>> steps of correct simulation. E remains stuck in
> >>>>>>>>>>>>>>>>>>>> recursive simulation until aborted.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that
> >>>>>>>>>>>>>>>>>>> is an illogical statement.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You must really have brain damage because you have
> >>>>>>>>>>>>>>>>>> been corrected on the point many times. When H
> >>>>>>>>>>>>>>>>>> correctly simulates 1 to N steps of D, then one to
> >>>>>>>>>>>>>>>>>> N steps of D are correctly simulated.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> When someone asks if I have any money then any
> >>>>>>>>>>>>>>>>>> amount of money > 0 counts. It is not a lie for me
> >>>>>>>>>>>>>>>>>> to say yes when I have less than an infinite
> >>>>>>>>>>>>>>>>>> amount of money.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input
> >>>>>>>>>>>>>>>>> for from 1 to an infinte number of steps,
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> How do we know that every element of the infinite
> >>>>>>>>>>>>>>>> set of positive integers > 5 is an element of the
> >>>>>>>>>>>>>>>> infinite set of integers > 3 ?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Once H correctly matches an infinite behavior
> >>>>>>>>>>>>>>>> pattern after N steps of correct simulation then H
> >>>>>>>>>>>>>>>> knows that D correctly simulated by H will never
> >>>>>>>>>>>>>>>> reach its final state and terminate normally in N to
> >>>>>>>>>>>>>>>> to ∞ steps of correct simulation.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Because you can prove it.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Again you try to do proof by example, showing that
> >>>>>>>>>>>>>>> you just don't understand what you are doing.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Maybe some day you will be enlightened into what you
> >>>>>>>>>>>>>>> have been doing wrong.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H can't prove the behavor of the D it is simulating
> >>>>>>>>>>>>>>> because it needs to take into account that H(D,D)
> >>>>>>>>>>>>>>> WILL return if H takes the steps it needs
> >>>>>>>>>>>>>> void E(void (*x)())
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> H(x, x);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The simulated E never reaches its own final state
> >>>>>>>>>>>>>> whether or not H ever aborts its simulation of E, thus
> >>>>>>>>>>>>>> E simulated by H is by definition not halting.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You say "Whether or not" which means you do not have a
> >>>>>>>>>>>>> deinition for H, because when you define H you need to
> >>>>>>>>>>>>> define its behavior
> >>>>>>>>>>>> In the same way that we know that every integer > 5 is
> >>>>>>>>>>>> also > 3 H correctly determines the halt status of D for
> >>>>>>>>>>>> every H/D pair such that
> >>>>>>>>>>>> the H element of this H/D pair correctly simulates 1 to
> >>>>>>>>>>>> to ∞ steps of D.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> How does that apply?
> >>>>>>>>>>>
> >>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
> >>>>>>>>>>>
> >>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
> >>>>>>>>>> Address_of_H:1383
> >>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
> >>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
> >>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
> >>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax //
> >>>>>>>>>> push P [0000199b][0015d4b5][00001993] 8b4d08 mov
> >>>>>>>>>> ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51
> >>>>>>>>>> push ecx // push P [0000199f][0015d4ad][000019a4]
> >>>>>>>>>> e8dff9ffff call 00001383 // call H H: Infinitely Recursive
> >>>>>>>>>> Simulation Detected Simulation Stopped
> >>>>>>>>>>
> >>>>>>>>>> You and I both can see that D correctly simulated by every
> >>>>>>>>>> H of the set of H/E pairs will never reach its final state
> >>>>>>>>>> and terminate normally.
> >>>>>>>>>> Why lie about this?
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> Nope, we know you are stupid and a liar because the call H
> >>>>>>>>> must eventually result in a return of 0 since this run just
> >>>>>>>>> shopwed that H(P,P) returns 0.
> >>>>>>>>>
> >>>>>>>>> You have been told this many times and you ignore it.
> >>>>>>>>
> >>>>>>>> You told me that P simulated by H that never aborts its
> >>>>>>>> simulation never stops running, thus from this we can
> >>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
> >>>>>>>> correctly simulated by any H ever reaches its own final
> >>>>>>>> state and terminates normally.
> >>>>>>>>
> >>>>>>>> Why do you use the strawman deception to lie?
> >>>>>>>>
> >>>>>>>
> >>>>>>> Right, but this H DOES abort its simulation, so that doesn't
> >>>>>>> matter.
> >>>>>> In other words you are saying that infinite loops specify a
> >>>>>> sequence of configurations that terminate normally after a
> >>>>>> finite number of steps of correct simulation.
> >>>>>
> >>>>> Nope, but the fact that you think that is what I said shows
> >>>>> that you don't understand the material.
> >>>>>
> >>>>>>
> >>>>>> void Infinite_Loop()
> >>>>>> {
> >>>>>> HERE: goto HERE;
> >>>>>> }
> >>>>>>
> >>>>>> It is an easily verified fact that Infinite_Loop correctly
> >>>>>> simulated by H would never reach its own last instruction and
> >>>>>> terminate normally after 1 to ∞ steps of correct simulation.
> >>>>>
> >>>>> No one denied that, so this is just more of your Red Herring.
> >>>>>
> >>>>>>
> >>>>>> void E(void (*x)())
> >>>>>> {
> >>>>>> H(x, x);
> >>>>>> }
> >>>>>>
> >>>>>> It is an easily verified fact that E correctly simulated by H
> >>>>>> would never reach its own last instruction and terminate
> >>>>>> normally after 1 to ∞ steps of correct simulation. E remains
> >>>>>> stuck in recursive simulation until aborted.
> >>>>>
> >>>>> But that isn't the question, since the H you claim is correct
> >>>>> doesn't correctly simulate the input since it aborts it.
> >>>>>
> >>>>> The H that this E is built on DOESN'T correctly simulate its
> >>>>> input
> >>>>
> >>>> _E()
> >>>> [000019d2] 55 push ebp
> >>>> [000019d3] 8bec mov ebp,esp
> >>>> [000019d5] 8b4508 mov eax,[ebp+08]
> >>>> [000019d8] 50 push eax
> >>>> [000019d9] 8b4d08 mov ecx,[ebp+08]
> >>>> [000019dc] 51 push ecx
> >>>> [000019dd] e8b0f9ffff call 00001392
> >>>> [000019e2] 83c408 add esp,+08
> >>>> [000019e5] 5d pop ebp
> >>>> [000019e6] c3 ret
> >>>> Size in bytes:(0021) [000019e6]
> >>>>
> >>>> H: Begin Simulation Execution Trace Stored at:112b28
> >>>> Address_of_H:1392
> >>>> [000019d2][00112b14][00112b18] 55 push ebp
> >>>> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
> >>>> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
> >>>> [000019d8][00112b10][000019d2] 50 push eax //
> >>>> push E [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
> >>>> [000019dc][00112b0c][000019d2] 51 push ecx //
> >>>> push E [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392
> >>>> // call H H: Infinitely Recursive Simulation Detected
> >>>> Simulation Stopped
> >>>>
> >>>> Since I already proved that H does correctly simulate E in that
> >>>> every line of the execution trace of E simulated by H exactly
> >>>> matches a corresponding line that the x86 source-code of E
> >>>> specifies, why do you lie about this?
> >>>>
> >>> No, H does a correct PARTIAL simulation of its input.
> >>>
> >>> When you mention that a correct simulation not reaching the end
> >>> implies non-halting, that means it needs to be a COMPLETE
> >>> siulation, so your statement is just a LIE.
> >>>
> >>> You are being INTENTIONALLY deceptive with shifting definition.
> >>>
> >>>
> >>>> The first seven lines of E are proven to be correctly simulated
> >>>> by H and also prove that E correctly simulated by every H that
> >>>> can possibly exist would never reach its own final state and
> >>>> terminate normally.
> >>>>
> >>>>
> >>>
> >>> And the "Simulation" of the "CALL" instruction is INCORRECT.
> >>>
> >> The seventh line of E simulated by H is the seventh line of the
> >> x86 source-code of E.
> >>
> >> The simulation can only be incorrect when the execution trace of
> >> the simulated E diverges from what the x86 source-code of E
> >> specifies, thus you lie again. Why do you insist on lying about
> >> easily verified facts?
> >>
> >>
> > And it does. How depends on which set of definitons you use.
> >
> > We can look at it one of two ways.
> >
> > THe first, is that since you are assserting that the failure of
> > this trace to reach a final state shows that the program is
> > non-halting, then the fact that in the actual program a "Call H"
> > instruction continues into the function H, while in the simulation
> > stops its simulation there.
>
> int main() { H(D,D); } D simulated by H never stops running unless
> aborted and never halts: (reaches its own final state and terminates
> normally) whether aborted or not. Halt Deciders only report on the
> behavior of their inputs thus no strawman deception about the
> behavior of a non-input is any rebuttal at all.
>
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
Olcott: no, you're wrong
Damon: no, you're wrong
...
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | Dennis Bush <dbush.mobile@gmail.com> |
|---|---|
| Date | 2022-11-13 14:33 -0800 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <25967716-40c6-47f7-beb4-f8ac4d41fb0en@googlegroups.com> |
| In reply to | #59611 |
On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
> On Sun, 13 Nov 2022 16:08:18 -0600
> olcott <polc...@gmail.com> wrote:
>
> > On 11/13/2022 3:59 PM, Richard Damon wrote:
> > > On 11/13/22 4:16 PM, olcott wrote:
> > >> On 11/13/2022 3:02 PM, Richard Damon wrote:
> > >>> On 11/13/22 3:51 PM, olcott wrote:
> > >>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
> > >>>>> On 11/13/22 2:49 PM, olcott wrote:
> > >>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
> > >>>>>>> On 11/13/22 10:39 AM, olcott wrote:
> > >>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
> > >>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
> > >>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
> > >>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
> > >>>>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
> > >>>>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
> > >>>>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
> > >>>>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
> > >>>>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
> > >>>>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
> > >>>>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
> > >>>>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
> > >>>>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
> > >>>>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an
> > >>>>>>>>>>>>>>>>>>>>> Olcottaholic. It's been 176 days
> > >>>>>>>>>>>>>>>>>>>>> since my last post.
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that
> > >>>>>>>>>>>>>>>>>>>> only expert knowledge of the C programming
> > >>>>>>>>>>>>>>>>>>>> language is required. H simulates its input
> > >>>>>>>>>>>>>>>>>>>> using an x86 emulator.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> > >>>>>>>>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> > >>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
> > >>>>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its
> > >>>>>>>>>>>>>>>>>>>> own last instruction and terminate normally
> > >>>>>>>>>>>>>>>>>>>> after 1 to ∞ steps of correct simulation.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> void E(void (*x)())
> > >>>>>>>>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>> H(x, x);
> > >>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
> > >>>>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
> > >>>>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞
> > >>>>>>>>>>>>>>>>>>>> steps of correct simulation. E remains stuck in
> > >>>>>>>>>>>>>>>>>>>> recursive simulation until aborted.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that
> > >>>>>>>>>>>>>>>>>>> is an illogical statement.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> You must really have brain damage because you have
> > >>>>>>>>>>>>>>>>>> been corrected on the point many times. When H
> > >>>>>>>>>>>>>>>>>> correctly simulates 1 to N steps of D, then one to
> > >>>>>>>>>>>>>>>>>> N steps of D are correctly simulated.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> When someone asks if I have any money then any
> > >>>>>>>>>>>>>>>>>> amount of money > 0 counts. It is not a lie for me
> > >>>>>>>>>>>>>>>>>> to say yes when I have less than an infinite
> > >>>>>>>>>>>>>>>>>> amount of money.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input
> > >>>>>>>>>>>>>>>>> for from 1 to an infinte number of steps,
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> How do we know that every element of the infinite
> > >>>>>>>>>>>>>>>> set of positive integers > 5 is an element of the
> > >>>>>>>>>>>>>>>> infinite set of integers > 3 ?
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Once H correctly matches an infinite behavior
> > >>>>>>>>>>>>>>>> pattern after N steps of correct simulation then H
> > >>>>>>>>>>>>>>>> knows that D correctly simulated by H will never
> > >>>>>>>>>>>>>>>> reach its final state and terminate normally in N to
> > >>>>>>>>>>>>>>>> to ∞ steps of correct simulation.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Because you can prove it.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Again you try to do proof by example, showing that
> > >>>>>>>>>>>>>>> you just don't understand what you are doing.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Maybe some day you will be enlightened into what you
> > >>>>>>>>>>>>>>> have been doing wrong.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> H can't prove the behavor of the D it is simulating
> > >>>>>>>>>>>>>>> because it needs to take into account that H(D,D)
> > >>>>>>>>>>>>>>> WILL return if H takes the steps it needs
> > >>>>>>>>>>>>>> void E(void (*x)())
> > >>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>> H(x, x);
> > >>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> The simulated E never reaches its own final state
> > >>>>>>>>>>>>>> whether or not H ever aborts its simulation of E, thus
> > >>>>>>>>>>>>>> E simulated by H is by definition not halting.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> You say "Whether or not" which means you do not have a
> > >>>>>>>>>>>>> deinition for H, because when you define H you need to
> > >>>>>>>>>>>>> define its behavior
> > >>>>>>>>>>>> In the same way that we know that every integer > 5 is
> > >>>>>>>>>>>> also > 3 H correctly determines the halt status of D for
> > >>>>>>>>>>>> every H/D pair such that
> > >>>>>>>>>>>> the H element of this H/D pair correctly simulates 1 to
> > >>>>>>>>>>>> to ∞ steps of D.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> How does that apply?
> > >>>>>>>>>>>
> > >>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
> > >>>>>>>>>>>
> > >>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
> > >>>>>>>>>> Address_of_H:1383
> > >>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
> > >>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
> > >>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
> > >>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
> > >>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax //
> > >>>>>>>>>> push P [0000199b][0015d4b5][00001993] 8b4d08 mov
> > >>>>>>>>>> ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51
> > >>>>>>>>>> push ecx // push P [0000199f][0015d4ad][000019a4]
> > >>>>>>>>>> e8dff9ffff call 00001383 // call H H: Infinitely Recursive
> > >>>>>>>>>> Simulation Detected Simulation Stopped
> > >>>>>>>>>>
> > >>>>>>>>>> You and I both can see that D correctly simulated by every
> > >>>>>>>>>> H of the set of H/E pairs will never reach its final state
> > >>>>>>>>>> and terminate normally.
> > >>>>>>>>>> Why lie about this?
> > >>>>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>> Nope, we know you are stupid and a liar because the call H
> > >>>>>>>>> must eventually result in a return of 0 since this run just
> > >>>>>>>>> shopwed that H(P,P) returns 0.
> > >>>>>>>>>
> > >>>>>>>>> You have been told this many times and you ignore it.
> > >>>>>>>>
> > >>>>>>>> You told me that P simulated by H that never aborts its
> > >>>>>>>> simulation never stops running, thus from this we can
> > >>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
> > >>>>>>>> correctly simulated by any H ever reaches its own final
> > >>>>>>>> state and terminates normally.
> > >>>>>>>>
> > >>>>>>>> Why do you use the strawman deception to lie?
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>> Right, but this H DOES abort its simulation, so that doesn't
> > >>>>>>> matter.
> > >>>>>> In other words you are saying that infinite loops specify a
> > >>>>>> sequence of configurations that terminate normally after a
> > >>>>>> finite number of steps of correct simulation.
> > >>>>>
> > >>>>> Nope, but the fact that you think that is what I said shows
> > >>>>> that you don't understand the material.
> > >>>>>
> > >>>>>>
> > >>>>>> void Infinite_Loop()
> > >>>>>> {
> > >>>>>> HERE: goto HERE;
> > >>>>>> }
> > >>>>>>
> > >>>>>> It is an easily verified fact that Infinite_Loop correctly
> > >>>>>> simulated by H would never reach its own last instruction and
> > >>>>>> terminate normally after 1 to ∞ steps of correct simulation.
> > >>>>>
> > >>>>> No one denied that, so this is just more of your Red Herring.
> > >>>>>
> > >>>>>>
> > >>>>>> void E(void (*x)())
> > >>>>>> {
> > >>>>>> H(x, x);
> > >>>>>> }
> > >>>>>>
> > >>>>>> It is an easily verified fact that E correctly simulated by H
> > >>>>>> would never reach its own last instruction and terminate
> > >>>>>> normally after 1 to ∞ steps of correct simulation. E remains
> > >>>>>> stuck in recursive simulation until aborted.
> > >>>>>
> > >>>>> But that isn't the question, since the H you claim is correct
> > >>>>> doesn't correctly simulate the input since it aborts it.
> > >>>>>
> > >>>>> The H that this E is built on DOESN'T correctly simulate its
> > >>>>> input
> > >>>>
> > >>>> _E()
> > >>>> [000019d2] 55 push ebp
> > >>>> [000019d3] 8bec mov ebp,esp
> > >>>> [000019d5] 8b4508 mov eax,[ebp+08]
> > >>>> [000019d8] 50 push eax
> > >>>> [000019d9] 8b4d08 mov ecx,[ebp+08]
> > >>>> [000019dc] 51 push ecx
> > >>>> [000019dd] e8b0f9ffff call 00001392
> > >>>> [000019e2] 83c408 add esp,+08
> > >>>> [000019e5] 5d pop ebp
> > >>>> [000019e6] c3 ret
> > >>>> Size in bytes:(0021) [000019e6]
> > >>>>
> > >>>> H: Begin Simulation Execution Trace Stored at:112b28
> > >>>> Address_of_H:1392
> > >>>> [000019d2][00112b14][00112b18] 55 push ebp
> > >>>> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
> > >>>> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
> > >>>> [000019d8][00112b10][000019d2] 50 push eax //
> > >>>> push E [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
> > >>>> [000019dc][00112b0c][000019d2] 51 push ecx //
> > >>>> push E [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392
> > >>>> // call H H: Infinitely Recursive Simulation Detected
> > >>>> Simulation Stopped
> > >>>>
> > >>>> Since I already proved that H does correctly simulate E in that
> > >>>> every line of the execution trace of E simulated by H exactly
> > >>>> matches a corresponding line that the x86 source-code of E
> > >>>> specifies, why do you lie about this?
> > >>>>
> > >>> No, H does a correct PARTIAL simulation of its input.
> > >>>
> > >>> When you mention that a correct simulation not reaching the end
> > >>> implies non-halting, that means it needs to be a COMPLETE
> > >>> siulation, so your statement is just a LIE.
> > >>>
> > >>> You are being INTENTIONALLY deceptive with shifting definition.
> > >>>
> > >>>
> > >>>> The first seven lines of E are proven to be correctly simulated
> > >>>> by H and also prove that E correctly simulated by every H that
> > >>>> can possibly exist would never reach its own final state and
> > >>>> terminate normally.
> > >>>>
> > >>>>
> > >>>
> > >>> And the "Simulation" of the "CALL" instruction is INCORRECT.
> > >>>
> > >> The seventh line of E simulated by H is the seventh line of the
> > >> x86 source-code of E.
> > >>
> > >> The simulation can only be incorrect when the execution trace of
> > >> the simulated E diverges from what the x86 source-code of E
> > >> specifies, thus you lie again. Why do you insist on lying about
> > >> easily verified facts?
> > >>
> > >>
> > > And it does. How depends on which set of definitons you use.
> > >
> > > We can look at it one of two ways.
> > >
> > > THe first, is that since you are assserting that the failure of
> > > this trace to reach a final state shows that the program is
> > > non-halting, then the fact that in the actual program a "Call H"
> > > instruction continues into the function H, while in the simulation
> > > stops its simulation there.
> >
> > int main() { H(D,D); } D simulated by H never stops running unless
> > aborted and never halts: (reaches its own final state and terminates
> > normally) whether aborted or not. Halt Deciders only report on the
> > behavior of their inputs thus no strawman deception about the
> > behavior of a non-input is any rebuttal at all.
> >
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
Actually, it's more like:
Damon: X is wrong because Y
Olcott: but X is right! Also A.
Damon: X is still wrong because Y, and A is wrong because B.
Olcott: (stomps feet) but A is right!! Also F.
Damon: X is still wrong because Y, and A is still wrong because B, and F is wrong because G.
Olcott: (throws self on floor, kicking and pounding): but I'm RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-11-13 16:42 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkrrtk$1huru$1@dont-email.me> |
| In reply to | #59612 |
On 11/13/2022 4:33 PM, Dennis Bush wrote:
> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
>> On Sun, 13 Nov 2022 16:08:18 -0600
>> olcott <polc...@gmail.com> wrote:
>>
>>> On 11/13/2022 3:59 PM, Richard Damon wrote:
>>>> On 11/13/22 4:16 PM, olcott wrote:
>>>>> On 11/13/2022 3:02 PM, Richard Damon wrote:
>>>>>> On 11/13/22 3:51 PM, olcott wrote:
>>>>>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>>>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/12/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/12/22 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/12/22 6:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Hello. My name is Ben and I am an
>>>>>>>>>>>>>>>>>>>>>>>> Olcottaholic. It's been 176 days
>>>>>>>>>>>>>>>>>>>>>>>> since my last post.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Stay strong, Richard. ;-)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I made the essence of my work simple enough that
>>>>>>>>>>>>>>>>>>>>>>> only expert knowledge of the C programming
>>>>>>>>>>>>>>>>>>>>>>> language is required. H simulates its input
>>>>>>>>>>>>>>>>>>>>>>> using an x86 emulator.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H would never reach its
>>>>>>>>>>>>>>>>>>>>>>> own last instruction and terminate normally
>>>>>>>>>>>>>>>>>>>>>>> after 1 to ∞ steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that E correctly
>>>>>>>>>>>>>>>>>>>>>>> simulated by H would never reach its own last
>>>>>>>>>>>>>>>>>>>>>>> instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation. E remains stuck in
>>>>>>>>>>>>>>>>>>>>>>> recursive simulation until aborted.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Since E can NOT be correctly simulated by H, that
>>>>>>>>>>>>>>>>>>>>>> is an illogical statement.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You must really have brain damage because you have
>>>>>>>>>>>>>>>>>>>>> been corrected on the point many times. When H
>>>>>>>>>>>>>>>>>>>>> correctly simulates 1 to N steps of D, then one to
>>>>>>>>>>>>>>>>>>>>> N steps of D are correctly simulated.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When someone asks if I have any money then any
>>>>>>>>>>>>>>>>>>>>> amount of money > 0 counts. It is not a lie for me
>>>>>>>>>>>>>>>>>>>>> to say yes when I have less than an infinite
>>>>>>>>>>>>>>>>>>>>> amount of money.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, how does a SINGLE H simulate this precise input
>>>>>>>>>>>>>>>>>>>> for from 1 to an infinte number of steps,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> How do we know that every element of the infinite
>>>>>>>>>>>>>>>>>>> set of positive integers > 5 is an element of the
>>>>>>>>>>>>>>>>>>> infinite set of integers > 3 ?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Once H correctly matches an infinite behavior
>>>>>>>>>>>>>>>>>>> pattern after N steps of correct simulation then H
>>>>>>>>>>>>>>>>>>> knows that D correctly simulated by H will never
>>>>>>>>>>>>>>>>>>> reach its final state and terminate normally in N to
>>>>>>>>>>>>>>>>>>> to ∞ steps of correct simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because you can prove it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Again you try to do proof by example, showing that
>>>>>>>>>>>>>>>>>> you just don't understand what you are doing.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Maybe some day you will be enlightened into what you
>>>>>>>>>>>>>>>>>> have been doing wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H can't prove the behavor of the D it is simulating
>>>>>>>>>>>>>>>>>> because it needs to take into account that H(D,D)
>>>>>>>>>>>>>>>>>> WILL return if H takes the steps it needs
>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> H(x, x);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The simulated E never reaches its own final state
>>>>>>>>>>>>>>>>> whether or not H ever aborts its simulation of E, thus
>>>>>>>>>>>>>>>>> E simulated by H is by definition not halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You say "Whether or not" which means you do not have a
>>>>>>>>>>>>>>>> deinition for H, because when you define H you need to
>>>>>>>>>>>>>>>> define its behavior
>>>>>>>>>>>>>>> In the same way that we know that every integer > 5 is
>>>>>>>>>>>>>>> also > 3 H correctly determines the halt status of D for
>>>>>>>>>>>>>>> every H/D pair such that
>>>>>>>>>>>>>>> the H element of this H/D pair correctly simulates 1 to
>>>>>>>>>>>>>>> to ∞ steps of D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How does that apply?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>>>>>>>>> Address_of_H:1383
>>>>>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax //
>>>>>>>>>>>>> push P [0000199b][0015d4b5][00001993] 8b4d08 mov
>>>>>>>>>>>>> ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51
>>>>>>>>>>>>> push ecx // push P [0000199f][0015d4ad][000019a4]
>>>>>>>>>>>>> e8dff9ffff call 00001383 // call H H: Infinitely Recursive
>>>>>>>>>>>>> Simulation Detected Simulation Stopped
>>>>>>>>>>>>>
>>>>>>>>>>>>> You and I both can see that D correctly simulated by every
>>>>>>>>>>>>> H of the set of H/E pairs will never reach its final state
>>>>>>>>>>>>> and terminate normally.
>>>>>>>>>>>>> Why lie about this?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, we know you are stupid and a liar because the call H
>>>>>>>>>>>> must eventually result in a return of 0 since this run just
>>>>>>>>>>>> shopwed that H(P,P) returns 0.
>>>>>>>>>>>>
>>>>>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>>>>>
>>>>>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>>>>>> simulation never stops running, thus from this we can
>>>>>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
>>>>>>>>>>> correctly simulated by any H ever reaches its own final
>>>>>>>>>>> state and terminates normally.
>>>>>>>>>>>
>>>>>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, but this H DOES abort its simulation, so that doesn't
>>>>>>>>>> matter.
>>>>>>>>> In other words you are saying that infinite loops specify a
>>>>>>>>> sequence of configurations that terminate normally after a
>>>>>>>>> finite number of steps of correct simulation.
>>>>>>>>
>>>>>>>> Nope, but the fact that you think that is what I said shows
>>>>>>>> that you don't understand the material.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> void Infinite_Loop()
>>>>>>>>> {
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>>>>> simulated by H would never reach its own last instruction and
>>>>>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>>>>>
>>>>>>>> No one denied that, so this is just more of your Red Herring.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> void E(void (*x)())
>>>>>>>>> {
>>>>>>>>> H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> It is an easily verified fact that E correctly simulated by H
>>>>>>>>> would never reach its own last instruction and terminate
>>>>>>>>> normally after 1 to ∞ steps of correct simulation. E remains
>>>>>>>>> stuck in recursive simulation until aborted.
>>>>>>>>
>>>>>>>> But that isn't the question, since the H you claim is correct
>>>>>>>> doesn't correctly simulate the input since it aborts it.
>>>>>>>>
>>>>>>>> The H that this E is built on DOESN'T correctly simulate its
>>>>>>>> input
>>>>>>>
>>>>>>> _E()
>>>>>>> [000019d2] 55 push ebp
>>>>>>> [000019d3] 8bec mov ebp,esp
>>>>>>> [000019d5] 8b4508 mov eax,[ebp+08]
>>>>>>> [000019d8] 50 push eax
>>>>>>> [000019d9] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [000019dc] 51 push ecx
>>>>>>> [000019dd] e8b0f9ffff call 00001392
>>>>>>> [000019e2] 83c408 add esp,+08
>>>>>>> [000019e5] 5d pop ebp
>>>>>>> [000019e6] c3 ret
>>>>>>> Size in bytes:(0021) [000019e6]
>>>>>>>
>>>>>>> H: Begin Simulation Execution Trace Stored at:112b28
>>>>>>> Address_of_H:1392
>>>>>>> [000019d2][00112b14][00112b18] 55 push ebp
>>>>>>> [000019d3][00112b14][00112b18] 8bec mov ebp,esp
>>>>>>> [000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
>>>>>>> [000019d8][00112b10][000019d2] 50 push eax //
>>>>>>> push E [000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
>>>>>>> [000019dc][00112b0c][000019d2] 51 push ecx //
>>>>>>> push E [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392
>>>>>>> // call H H: Infinitely Recursive Simulation Detected
>>>>>>> Simulation Stopped
>>>>>>>
>>>>>>> Since I already proved that H does correctly simulate E in that
>>>>>>> every line of the execution trace of E simulated by H exactly
>>>>>>> matches a corresponding line that the x86 source-code of E
>>>>>>> specifies, why do you lie about this?
>>>>>>>
>>>>>> No, H does a correct PARTIAL simulation of its input.
>>>>>>
>>>>>> When you mention that a correct simulation not reaching the end
>>>>>> implies non-halting, that means it needs to be a COMPLETE
>>>>>> siulation, so your statement is just a LIE.
>>>>>>
>>>>>> You are being INTENTIONALLY deceptive with shifting definition.
>>>>>>
>>>>>>
>>>>>>> The first seven lines of E are proven to be correctly simulated
>>>>>>> by H and also prove that E correctly simulated by every H that
>>>>>>> can possibly exist would never reach its own final state and
>>>>>>> terminate normally.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>>>>>
>>>>> The seventh line of E simulated by H is the seventh line of the
>>>>> x86 source-code of E.
>>>>>
>>>>> The simulation can only be incorrect when the execution trace of
>>>>> the simulated E diverges from what the x86 source-code of E
>>>>> specifies, thus you lie again. Why do you insist on lying about
>>>>> easily verified facts?
>>>>>
>>>>>
>>>> And it does. How depends on which set of definitons you use.
>>>>
>>>> We can look at it one of two ways.
>>>>
>>>> THe first, is that since you are assserting that the failure of
>>>> this trace to reach a final state shows that the program is
>>>> non-halting, then the fact that in the actual program a "Call H"
>>>> instruction continues into the function H, while in the simulation
>>>> stops its simulation there.
>>>
>>> int main() { H(D,D); } D simulated by H never stops running unless
>>> aborted and never halts: (reaches its own final state and terminates
>>> normally) whether aborted or not. Halt Deciders only report on the
>>> behavior of their inputs thus no strawman deception about the
>>> behavior of a non-input is any rebuttal at all.
>>>
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>
> Actually, it's more like:
>
> Damon: X is wrong because Y
> Olcott: but X is right! Also A.
> Damon: X is still wrong because Y, and A is wrong because B.
> Olcott: (stomps feet) but A is right!! Also F.
> Damon: X is still wrong because Y, and A is still wrong because B, and F is wrong because G.
> Olcott: (throws self on floor, kicking and pounding): but I'm RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>
>
In the mean time since your last visit:
MIT Professor Michael Sipser (author of the best selling book on the
theory of computation) has agreed that the following verbatim paragraph
is correct (he has not agreed to anything else):
If simulating halt decider H correctly simulates its input
D until H correctly determines that its simulated D would
never stop running unless aborted then H can abort its
simulation of D and correctly report that D specifies a
non-halting sequence of configurations.
--
Copyright 2022 Pete 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 | 2022-11-13 18:14 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <4TecL.56548$NeJ8.23202@fx09.iad> |
| In reply to | #59613 |
On 11/13/22 5:42 PM, olcott wrote: > On 11/13/2022 4:33 PM, Dennis Bush wrote: >> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote: >>> On Sun, 13 Nov 2022 16:08:18 -0600 >>> Damon: no, you're wrong >>> Olcott: no, you're wrong >>> Damon: no, you're wrong >> >> Actually, it's more like: >> >> Damon: X is wrong because Y >> Olcott: but X is right! Also A. >> Damon: X is still wrong because Y, and A is wrong because B. >> Olcott: (stomps feet) but A is right!! Also F. >> Damon: X is still wrong because Y, and A is still wrong because B, and >> F is wrong because G. >> Olcott: (throws self on floor, kicking and pounding): but I'm >> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!! >> >> > > In the mean time since your last visit: > > MIT Professor Michael Sipser (author of the best selling book on the > theory of computation) has agreed that the following verbatim paragraph > is correct (he has not agreed to anything else): > > If simulating halt decider H correctly simulates its input > D until H correctly determines that its simulated D would > never stop running unless aborted then H can abort its > simulation of D and correctly report that D specifies a > non-halting sequence of configurations. > And his definition of that is that you need to show that a correct AND COMPLETE simulation of THIS input would never halt. Thus, you don't get to change the H that D calls, and need to correctly and completely simualate the D and the H it calls to show the result. You don't do that.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-11-13 17:26 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tkruf0$1huru$3@dont-email.me> |
| In reply to | #59616 |
On 11/13/2022 5:14 PM, Richard Damon wrote: > On 11/13/22 5:42 PM, olcott wrote: >> On 11/13/2022 4:33 PM, Dennis Bush wrote: >>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote: >>>> On Sun, 13 Nov 2022 16:08:18 -0600 >>>> Damon: no, you're wrong >>>> Olcott: no, you're wrong >>>> Damon: no, you're wrong >>> >>> Actually, it's more like: >>> >>> Damon: X is wrong because Y >>> Olcott: but X is right! Also A. >>> Damon: X is still wrong because Y, and A is wrong because B. >>> Olcott: (stomps feet) but A is right!! Also F. >>> Damon: X is still wrong because Y, and A is still wrong because B, >>> and F is wrong because G. >>> Olcott: (throws self on floor, kicking and pounding): but I'm >>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!! >>> >>> >> >> In the mean time since your last visit: >> >> MIT Professor Michael Sipser (author of the best selling book on the >> theory of computation) has agreed that the following verbatim >> paragraph is correct (he has not agreed to anything else): >> >> If simulating halt decider H correctly simulates its input >> D until H correctly determines that its simulated D would >> never stop running unless aborted then H can abort its >> simulation of D and correctly report that D specifies a >> non-halting sequence of configurations. >> > > And his definition of that is that you need to show that a correct AND > COMPLETE simulation of THIS input would never halt. > You have already agreed that a correct and complete simulation of P by H never stops running. Why do you lie about things that you already agreed to? > Thus, you don't get to change the H that D calls, and need to correctly > and completely simualate the D and the H it calls to show the result. > > You don't do that. You already know that there is no need for the simulation to be correct and complete. We (and H) can infer the behavior of the correct and complete simulation of D by H on the basis of the correct partial simulation of D by H. Why do you insist on lying about this? -- Copyright 2022 Pete 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 | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-11-13 23:52 +0000 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <20221113235243.00006871@reddwarf.jmc.corp> |
| In reply to | #59618 |
On Sun, 13 Nov 2022 17:26:23 -0600 olcott <polcott2@gmail.com> wrote: > On 11/13/2022 5:14 PM, Richard Damon wrote: > > On 11/13/22 5:42 PM, olcott wrote: > >> On 11/13/2022 4:33 PM, Dennis Bush wrote: > >>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble > >>> wrote: > >>>> On Sun, 13 Nov 2022 16:08:18 -0600 > >>>> Damon: no, you're wrong > >>>> Olcott: no, you're wrong > >>>> Damon: no, you're wrong > >>> > >>> Actually, it's more like: > >>> > >>> Damon: X is wrong because Y > >>> Olcott: but X is right! Also A. > >>> Damon: X is still wrong because Y, and A is wrong because B. > >>> Olcott: (stomps feet) but A is right!! Also F. > >>> Damon: X is still wrong because Y, and A is still wrong because > >>> B, and F is wrong because G. > >>> Olcott: (throws self on floor, kicking and pounding): but I'm > >>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!! > >>> > >>> > >> > >> In the mean time since your last visit: > >> > >> MIT Professor Michael Sipser (author of the best selling book on > >> the theory of computation) has agreed that the following verbatim > >> paragraph is correct (he has not agreed to anything else): > >> > >> If simulating halt decider H correctly simulates its input > >> D until H correctly determines that its simulated D would > >> never stop running unless aborted then H can abort its > >> simulation of D and correctly report that D specifies a > >> non-halting sequence of configurations. > >> > > > > And his definition of that is that you need to show that a correct > > AND COMPLETE simulation of THIS input would never halt. > > > > You have already agreed that a correct and complete simulation of P > by H never stops running. Why do you lie about things that you > already agreed to? > > > Thus, you don't get to change the H that D calls, and need to > > correctly and completely simualate the D and the H it calls to show > > the result. > > > > You don't do that. > > You already know that there is no need for the simulation to be > correct and complete. We (and H) can infer the behavior of the > correct and complete simulation of D by H on the basis of the correct > partial simulation of D by H. > > Why do you insist on lying about this? I agree: if a partial simulation can infer the correct behaviour of a full simulation then there is no need to run a full simulation; if this wasn't the case then it would be impossible for a SHD to reach a decision of non-halting in finite time. /Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <none-ya@beez-waxes.com> |
|---|---|
| Date | 2022-11-13 18:00 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tks0e1$17th$1@gioia.aioe.org> |
| In reply to | #59621 |
On 11/13/2022 5:52 PM, Mr Flibble wrote: > On Sun, 13 Nov 2022 17:26:23 -0600 > olcott <polcott2@gmail.com> wrote: > >> On 11/13/2022 5:14 PM, Richard Damon wrote: >>> On 11/13/22 5:42 PM, olcott wrote: >>>> On 11/13/2022 4:33 PM, Dennis Bush wrote: >>>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble >>>>> wrote: >>>>>> On Sun, 13 Nov 2022 16:08:18 -0600 >>>>>> Damon: no, you're wrong >>>>>> Olcott: no, you're wrong >>>>>> Damon: no, you're wrong >>>>> >>>>> Actually, it's more like: >>>>> >>>>> Damon: X is wrong because Y >>>>> Olcott: but X is right! Also A. >>>>> Damon: X is still wrong because Y, and A is wrong because B. >>>>> Olcott: (stomps feet) but A is right!! Also F. >>>>> Damon: X is still wrong because Y, and A is still wrong because >>>>> B, and F is wrong because G. >>>>> Olcott: (throws self on floor, kicking and pounding): but I'm >>>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!! >>>>> >>>>> >>>> >>>> In the mean time since your last visit: >>>> >>>> MIT Professor Michael Sipser (author of the best selling book on >>>> the theory of computation) has agreed that the following verbatim >>>> paragraph is correct (he has not agreed to anything else): >>>> >>>> If simulating halt decider H correctly simulates its input >>>> D until H correctly determines that its simulated D would >>>> never stop running unless aborted then H can abort its >>>> simulation of D and correctly report that D specifies a >>>> non-halting sequence of configurations. >>>> >>> >>> And his definition of that is that you need to show that a correct >>> AND COMPLETE simulation of THIS input would never halt. >>> >> >> You have already agreed that a correct and complete simulation of P >> by H never stops running. Why do you lie about things that you >> already agreed to? >> >>> Thus, you don't get to change the H that D calls, and need to >>> correctly and completely simualate the D and the H it calls to show >>> the result. >>> >>> You don't do that. >> >> You already know that there is no need for the simulation to be >> correct and complete. We (and H) can infer the behavior of the >> correct and complete simulation of D by H on the basis of the correct >> partial simulation of D by H. >> >> Why do you insist on lying about this? > > I agree: if a partial simulation can infer the correct behaviour of a > full simulation then there is no need to run a full simulation; if this > wasn't the case then it would be impossible for a SHD to reach a > decision of non-halting in finite time. > > /Flibble > Richard seems to simply be a liar. His goal (like Ben's) is rebuttal at all costs. -- Copyright 2022 Pete 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 | 2022-11-13 19:33 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <51gcL.36832$I1C9.15351@fx42.iad> |
| In reply to | #59622 |
On 11/13/22 7:00 PM, olcott wrote: > On 11/13/2022 5:52 PM, Mr Flibble wrote: >> On Sun, 13 Nov 2022 17:26:23 -0600 >> olcott <polcott2@gmail.com> wrote: >> >>> On 11/13/2022 5:14 PM, Richard Damon wrote: >>>> On 11/13/22 5:42 PM, olcott wrote: >>>>> On 11/13/2022 4:33 PM, Dennis Bush wrote: >>>>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble >>>>>> wrote: >>>>>>> On Sun, 13 Nov 2022 16:08:18 -0600 >>>>>>> Damon: no, you're wrong >>>>>>> Olcott: no, you're wrong >>>>>>> Damon: no, you're wrong >>>>>> >>>>>> Actually, it's more like: >>>>>> >>>>>> Damon: X is wrong because Y >>>>>> Olcott: but X is right! Also A. >>>>>> Damon: X is still wrong because Y, and A is wrong because B. >>>>>> Olcott: (stomps feet) but A is right!! Also F. >>>>>> Damon: X is still wrong because Y, and A is still wrong because >>>>>> B, and F is wrong because G. >>>>>> Olcott: (throws self on floor, kicking and pounding): but I'm >>>>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!! >>>>>> >>>>> >>>>> In the mean time since your last visit: >>>>> >>>>> MIT Professor Michael Sipser (author of the best selling book on >>>>> the theory of computation) has agreed that the following verbatim >>>>> paragraph is correct (he has not agreed to anything else): >>>>> >>>>> If simulating halt decider H correctly simulates its input >>>>> D until H correctly determines that its simulated D would >>>>> never stop running unless aborted then H can abort its >>>>> simulation of D and correctly report that D specifies a >>>>> non-halting sequence of configurations. >>>> >>>> And his definition of that is that you need to show that a correct >>>> AND COMPLETE simulation of THIS input would never halt. >>> >>> You have already agreed that a correct and complete simulation of P >>> by H never stops running. Why do you lie about things that you >>> already agreed to? >>> >>>> Thus, you don't get to change the H that D calls, and need to >>>> correctly and completely simualate the D and the H it calls to show >>>> the result. >>>> >>>> You don't do that. >>> >>> You already know that there is no need for the simulation to be >>> correct and complete. We (and H) can infer the behavior of the >>> correct and complete simulation of D by H on the basis of the correct >>> partial simulation of D by H. >>> >>> Why do you insist on lying about this? >> I agree: if a partial simulation can infer the correct behaviour of a >> full simulation then there is no need to run a full simulation; if this >> wasn't the case then it would be impossible for a SHD to reach a >> decision of non-halting in finite time. >> >> /Flibble >> > > Richard seems to simply be a liar. > His goal (like Ben's) is rebuttal at all costs. > If I was, then you could show an actual reffernce to something that shows I am wrong, rather than just you making claims that I am. Note, I reference fundamenta principles (you call learned-by-rote) that are KNOW TO BE TRUE, while you just put forward unsupported claims. The inability of you to actually provide a FACTUAL based rebutal to what I say, says that it si YOU who isn't on solid ground. That will be evident to anyone who looks that these discussions. Sorry Peter, but you have distroyed any reputaiton you might have earned in the past, and have wasted the last 18 years of your life.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-11-13 19:29 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <AZfcL.36831$I1C9.7561@fx42.iad> |
| In reply to | #59618 |
On 11/13/22 6:26 PM, olcott wrote: > On 11/13/2022 5:14 PM, Richard Damon wrote: >> On 11/13/22 5:42 PM, olcott wrote: >>> On 11/13/2022 4:33 PM, Dennis Bush wrote: >>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote: >>>>> On Sun, 13 Nov 2022 16:08:18 -0600 >>>>> Damon: no, you're wrong >>>>> Olcott: no, you're wrong >>>>> Damon: no, you're wrong >>>> >>>> Actually, it's more like: >>>> >>>> Damon: X is wrong because Y >>>> Olcott: but X is right! Also A. >>>> Damon: X is still wrong because Y, and A is wrong because B. >>>> Olcott: (stomps feet) but A is right!! Also F. >>>> Damon: X is still wrong because Y, and A is still wrong because B, >>>> and F is wrong because G. >>>> Olcott: (throws self on floor, kicking and pounding): but I'm >>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!! >>>> >>>> >>> >>> In the mean time since your last visit: >>> >>> MIT Professor Michael Sipser (author of the best selling book on the >>> theory of computation) has agreed that the following verbatim >>> paragraph is correct (he has not agreed to anything else): >>> >>> If simulating halt decider H correctly simulates its input >>> D until H correctly determines that its simulated D would >>> never stop running unless aborted then H can abort its >>> simulation of D and correctly report that D specifies a >>> non-halting sequence of configurations. >>> >> >> And his definition of that is that you need to show that a correct AND >> COMPLETE simulation of THIS input would never halt. >> > > You have already agreed that a correct and complete simulation of P by H > never stops running. Why do you lie about things that you already agreed > to? > >> Thus, you don't get to change the H that D calls, and need to >> correctly and completely simualate the D and the H it calls to show >> the result. >> >> You don't do that. > > You already know that there is no need for the simulation to be correct > and complete. We (and H) can infer the behavior of the correct and > complete simulation of D by H on the basis of the correct partial > simulation of D by H. > > Why do you insist on lying about this? > A simulation that is not complete does not by itself prove non-halting. How can H correctly predict the behavior of something that DOESN'T HAPPEN. H can NOT perform a correcrt and complete simulation and return an answer. Your problem is that you logic presumes that the H that D calls gets stuck in an infinite loop when we know that H doesn't, because the H called by D WILL Stop its simulation, which your logic of the H deciding ignores. You try to explain this by the fact that somehow the H called by D acts differently, but tha is actually impossible, and when asked WHERE that difference occurs you just ignore the request. Unless you can actual show a proof or example shoing your assertion that H(D,D) acts differently when called by D then when directly run, you have the problem that since the H(D,D) must return 0 even when called by D(D), that it CAN'T get stuck in an infinite loop. All you have done is proved that you H isn't actually the required "pure" function. YOU FAIL.
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-11-14 19:27 +0000 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <20221114192716.000071a6@reddwarf.jmc.corp> |
| In reply to | #59623 |
On Sun, 13 Nov 2022 19:29:16 -0500
Richard Damon <Richard@Damon-Family.org> wrote:
> On 11/13/22 6:26 PM, olcott wrote:
> > On 11/13/2022 5:14 PM, Richard Damon wrote:
> >> On 11/13/22 5:42 PM, olcott wrote:
> >>> On 11/13/2022 4:33 PM, Dennis Bush wrote:
> >>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble
> >>>> wrote:
> >>>>> On Sun, 13 Nov 2022 16:08:18 -0600
> >>>>> Damon: no, you're wrong
> >>>>> Olcott: no, you're wrong
> >>>>> Damon: no, you're wrong
> >>>>
> >>>> Actually, it's more like:
> >>>>
> >>>> Damon: X is wrong because Y
> >>>> Olcott: but X is right! Also A.
> >>>> Damon: X is still wrong because Y, and A is wrong because B.
> >>>> Olcott: (stomps feet) but A is right!! Also F.
> >>>> Damon: X is still wrong because Y, and A is still wrong because
> >>>> B, and F is wrong because G.
> >>>> Olcott: (throws self on floor, kicking and pounding): but I'm
> >>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
> >>>>
> >>>>
> >>>
> >>> In the mean time since your last visit:
> >>>
> >>> MIT Professor Michael Sipser (author of the best selling book on
> >>> the theory of computation) has agreed that the following verbatim
> >>> paragraph is correct (he has not agreed to anything else):
> >>>
> >>> If simulating halt decider H correctly simulates its input
> >>> D until H correctly determines that its simulated D would
> >>> never stop running unless aborted then H can abort its
> >>> simulation of D and correctly report that D specifies a
> >>> non-halting sequence of configurations.
> >>>
> >>
> >> And his definition of that is that you need to show that a correct
> >> AND COMPLETE simulation of THIS input would never halt.
> >>
> >
> > You have already agreed that a correct and complete simulation of P
> > by H never stops running. Why do you lie about things that you
> > already agreed to?
> >
> >> Thus, you don't get to change the H that D calls, and need to
> >> correctly and completely simualate the D and the H it calls to
> >> show the result.
> >>
> >> You don't do that.
> >
> > You already know that there is no need for the simulation to be
> > correct and complete. We (and H) can infer the behavior of the
> > correct and complete simulation of D by H on the basis of the
> > correct partial simulation of D by H.
> >
> > Why do you insist on lying about this?
> >
>
> A simulation that is not complete does not by itself prove
> non-halting.
>
> How can H correctly predict the behavior of something that DOESN'T
> HAPPEN.
Nonsense.
A partial simulation of:
void f()
{
infinite_loop: goto infinite_loop;
}
is all that is required to detect the infinite loop by detecting
repeated machine state.
Again: the only way for a SHD to return a correct result of non-halting
in FINITE TIME is to do a PARTIAL simulation BY DEFINITION (a halt
decider must always return a result in finite time).
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-11-14 13:44 -0600 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <tku5r5$1qpj8$3@dont-email.me> |
| In reply to | #59640 |
On 11/14/2022 1:27 PM, Mr Flibble wrote:
> On Sun, 13 Nov 2022 19:29:16 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/13/22 6:26 PM, olcott wrote:
>>> On 11/13/2022 5:14 PM, Richard Damon wrote:
>>>> On 11/13/22 5:42 PM, olcott wrote:
>>>>> On 11/13/2022 4:33 PM, Dennis Bush wrote:
>>>>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble
>>>>>> wrote:
>>>>>>> On Sun, 13 Nov 2022 16:08:18 -0600
>>>>>>> Damon: no, you're wrong
>>>>>>> Olcott: no, you're wrong
>>>>>>> Damon: no, you're wrong
>>>>>>
>>>>>> Actually, it's more like:
>>>>>>
>>>>>> Damon: X is wrong because Y
>>>>>> Olcott: but X is right! Also A.
>>>>>> Damon: X is still wrong because Y, and A is wrong because B.
>>>>>> Olcott: (stomps feet) but A is right!! Also F.
>>>>>> Damon: X is still wrong because Y, and A is still wrong because
>>>>>> B, and F is wrong because G.
>>>>>> Olcott: (throws self on floor, kicking and pounding): but I'm
>>>>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>>>>>>
>>>>>>
>>>>>
>>>>> In the mean time since your last visit:
>>>>>
>>>>> MIT Professor Michael Sipser (author of the best selling book on
>>>>> the theory of computation) has agreed that the following verbatim
>>>>> paragraph is correct (he has not agreed to anything else):
>>>>>
>>>>> If simulating halt decider H correctly simulates its input
>>>>> D until H correctly determines that its simulated D would
>>>>> never stop running unless aborted then H can abort its
>>>>> simulation of D and correctly report that D specifies a
>>>>> non-halting sequence of configurations.
>>>>>
>>>>
>>>> And his definition of that is that you need to show that a correct
>>>> AND COMPLETE simulation of THIS input would never halt.
>>>>
>>>
>>> You have already agreed that a correct and complete simulation of P
>>> by H never stops running. Why do you lie about things that you
>>> already agreed to?
>>>
>>>> Thus, you don't get to change the H that D calls, and need to
>>>> correctly and completely simualate the D and the H it calls to
>>>> show the result.
>>>>
>>>> You don't do that.
>>>
>>> You already know that there is no need for the simulation to be
>>> correct and complete. We (and H) can infer the behavior of the
>>> correct and complete simulation of D by H on the basis of the
>>> correct partial simulation of D by H.
>>>
>>> Why do you insist on lying about this?
>>>
>>
>> A simulation that is not complete does not by itself prove
>> non-halting.
>>
>> How can H correctly predict the behavior of something that DOESN'T
>> HAPPEN.
>
> Nonsense.
>
> A partial simulation of:
>
> void f()
> {
> infinite_loop: goto infinite_loop;
> }
>
> is all that is required to detect the infinite loop by detecting
> repeated machine state.
>
> Again: the only way for a SHD to return a correct result of non-halting
> in FINITE TIME is to do a PARTIAL simulation BY DEFINITION (a halt
> decider must always return a result in finite time).
>
> /Flibble
>
He knows that and doesn't care. He looks for every lame excuse to form
any rebuttal that would at least convince gullible fools that are not
paying enough attention to see that he is lying.
Now the best rebuttal that Andre has is ad hominem thus confirming that
I was right all along. Andre previously was pretty good at sticking to
the actual facts.
Now that he knows that there are no such facts that can be used for
rebuttal he switches to ad hominem because that is all that is left
besides simply admitted the truth that I was right all along.
--
Copyright 2022 Pete 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 | 2022-11-14 21:53 -0500 |
| Subject | Re: E correctly simulated by H would never reach its last instruction and terminate normally |
| Message-ID | <KaDcL.37174$I1C9.24175@fx42.iad> |
| In reply to | #59641 |
On 11/14/22 2:44 PM, olcott wrote:
> On 11/14/2022 1:27 PM, Mr Flibble wrote:
>> On Sun, 13 Nov 2022 19:29:16 -0500
>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>> On 11/13/22 6:26 PM, olcott wrote:
>>>> On 11/13/2022 5:14 PM, Richard Damon wrote:
>>>>> On 11/13/22 5:42 PM, olcott wrote:
>>>>>> On 11/13/2022 4:33 PM, Dennis Bush wrote:
>>>>>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble
>>>>>>> wrote:
>>>>>>>> On Sun, 13 Nov 2022 16:08:18 -0600
>>>>>>>> Damon: no, you're wrong
>>>>>>>> Olcott: no, you're wrong
>>>>>>>> Damon: no, you're wrong
>>>>>>>
>>>>>>> Actually, it's more like:
>>>>>>>
>>>>>>> Damon: X is wrong because Y
>>>>>>> Olcott: but X is right! Also A.
>>>>>>> Damon: X is still wrong because Y, and A is wrong because B.
>>>>>>> Olcott: (stomps feet) but A is right!! Also F.
>>>>>>> Damon: X is still wrong because Y, and A is still wrong because
>>>>>>> B, and F is wrong because G.
>>>>>>> Olcott: (throws self on floor, kicking and pounding): but I'm
>>>>>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>>>>>>>
>>>>>>
>>>>>> In the mean time since your last visit:
>>>>>>
>>>>>> MIT Professor Michael Sipser (author of the best selling book on
>>>>>> the theory of computation) has agreed that the following verbatim
>>>>>> paragraph is correct (he has not agreed to anything else):
>>>>>>
>>>>>> If simulating halt decider H correctly simulates its input
>>>>>> D until H correctly determines that its simulated D would
>>>>>> never stop running unless aborted then H can abort its
>>>>>> simulation of D and correctly report that D specifies a
>>>>>> non-halting sequence of configurations.
>>>>>
>>>>> And his definition of that is that you need to show that a correct
>>>>> AND COMPLETE simulation of THIS input would never halt.
>>>>
>>>> You have already agreed that a correct and complete simulation of P
>>>> by H never stops running. Why do you lie about things that you
>>>> already agreed to?
>>>>> Thus, you don't get to change the H that D calls, and need to
>>>>> correctly and completely simualate the D and the H it calls to
>>>>> show the result.
>>>>>
>>>>> You don't do that.
>>>>
>>>> You already know that there is no need for the simulation to be
>>>> correct and complete. We (and H) can infer the behavior of the
>>>> correct and complete simulation of D by H on the basis of the
>>>> correct partial simulation of D by H.
>>>>
>>>> Why do you insist on lying about this?
>>>
>>> A simulation that is not complete does not by itself prove
>>> non-halting.
>>>
>>> How can H correctly predict the behavior of something that DOESN'T
>>> HAPPEN.
>>
>> Nonsense.
>>
>> A partial simulation of:
>>
>> void f()
>> {
>> infinite_loop: goto infinite_loop;
>> }
>>
>> is all that is required to detect the infinite loop by detecting
>> repeated machine state.
>>
>> Again: the only way for a SHD to return a correct result of non-halting
>> in FINITE TIME is to do a PARTIAL simulation BY DEFINITION (a halt
>> decider must always return a result in finite time).
>>
>> /Flibble
>>
>
> He knows that and doesn't care. He looks for every lame excuse to form
> any rebuttal that would at least convince gullible fools that are not
> paying enough attention to see that he is lying.
>
> Now the best rebuttal that Andre has is ad hominem thus confirming that
> I was right all along. Andre previously was pretty good at sticking to
> the actual facts.
>
> Now that he knows that there are no such facts that can be used for
> rebuttal he switches to ad hominem because that is all that is left
> besides simply admitted the truth that I was right all along.
>
Nope, you just don't understand that some things are just impossible.
Try to provide an algorithm that will ALWAYS WIN at tic tac toe.
It is a VALID question,
The answer is it is impossible.
[toc] | [prev] | [next] | [standalone]
Page 5 of 9 — ← Prev page 1 2 3 4 [5] 6 7 8 9 Next page →
Back to top | Article view | comp.theory
csiph-web