Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #107463 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-19 19:00 -0500 |
| Last post | 2024-06-30 12:30 +0300 |
| Articles | 20 on this page of 197 — 8 participants |
Back to article view | Back to comp.theory
195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-19 19:00 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-20 10:09 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-20 09:12 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Richard Damon <richard@damon-family.org> - 2024-06-20 18:37 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-20 17:45 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Richard Damon <richard@damon-family.org> - 2024-06-20 21:55 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-21 09:44 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 08:01 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 10:02 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 09:44 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 11:25 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 12:04 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 13:09 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 12:22 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 13:40 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 12:55 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 14:00 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 13:22 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 14:39 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 13:51 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 15:11 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-21 14:23 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-21 15:54 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply joes <noreply@example.com> - 2024-06-25 20:31 +0000
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-25 16:22 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply joes <noreply@example.com> - 2024-06-26 08:11 +0000
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-26 08:32 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-22 11:27 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-22 08:11 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-22 09:38 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply joes <noreply@example.com> - 2024-06-22 14:41 +0000
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-22 10:53 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-22 20:50 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-22 13:53 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-22 15:22 -0400
DDD correctly emulated by H0 olcott <polcott333@gmail.com> - 2024-06-22 14:45 -0500
Re: DDD correctly emulated by H0 Richard Damon <richard@damon-family.org> - 2024-06-22 16:10 -0400
Re: DDD correctly emulated by H0 olcott <polcott333@gmail.com> - 2024-06-22 19:01 -0500
Re: DDD correctly emulated by H0 Richard Damon <richard@damon-family.org> - 2024-06-22 20:14 -0400
Re: DDD correctly emulated by H0 olcott <polcott333@gmail.com> - 2024-06-22 22:28 -0500
Re: DDD correctly emulated by H0 Richard Damon <richard@damon-family.org> - 2024-06-23 07:28 -0400
Re: DDD correctly emulated by H0 olcott <polcott333@gmail.com> - 2024-06-23 08:38 -0500
Re: DDD correctly emulated by H0 Richard Damon <richard@damon-family.org> - 2024-06-23 14:23 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-23 11:45 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-23 08:30 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-24 11:43 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply olcott <polcott333@gmail.com> - 2024-06-24 13:16 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 ---Boilerplate Reply Richard Damon <richard@damon-family.org> - 2024-06-24 19:23 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 Mikko <mikko.levanto@iki.fi> - 2024-06-23 11:22 +0300
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-23 08:17 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Mikko <mikko.levanto@iki.fi> - 2024-06-24 10:37 +0300
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-24 08:48 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 joes <noreply@example.com> - 2024-06-24 19:36 +0000
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-24 16:04 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Richard Damon <richard@damon-family.org> - 2024-06-24 19:43 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-25 14:08 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 08:12 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-25 16:13 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 12:29 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-25 20:19 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 13:26 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-25 20:49 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 13:51 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-25 21:17 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 14:30 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-26 10:01 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-26 08:07 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-27 11:38 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-27 12:21 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 10:06 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 09:12 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 16:43 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 10:01 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 17:19 +0200
Re: 197 page execution trace of DDD incorrectly simulated by HHH joes <noreply@example.com> - 2024-06-28 16:28 +0000
Re: 197 page execution trace of DDD incorrectly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 13:24 -0500
Re: 197 page execution trace of DDD incorrectly simulated by HHH joes <noreply@example.com> - 2024-06-28 19:25 +0000
Re: 197 page execution trace of DDD incorrectly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 16:03 -0500
Re: 197 page execution trace of DDD incorrectly simulated by HHH Alan Mackenzie <acm@muc.de> - 2024-06-28 21:26 +0000
Re: 197 page execution trace of DDD incorrectly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 16:52 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-26 08:30 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-27 11:45 +0200
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-27 12:30 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 10:23 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 09:27 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 16:53 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 10:04 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 17:22 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 10:32 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 17:48 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 11:54 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 20:22 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 13:31 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-28 20:48 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 14:01 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-29 10:52 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-29 21:51 -0500
Re: simulation trace of DDD joes <noreply@example.org> - 2024-06-30 08:58 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-06-30 08:34 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 joes <noreply@example.com> - 2024-06-28 13:14 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 10:25 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.com> - 2024-06-28 16:26 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 12:05 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.com> - 2024-06-28 17:41 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 12:53 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.com> - 2024-06-28 19:18 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 14:28 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-06-29 19:44 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-29 15:03 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-06-29 16:11 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-06-30 08:42 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-30 12:25 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-06-30 15:31 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-06-30 20:16 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-01 10:27 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 07:57 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-01 16:27 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 09:35 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-07-01 15:52 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 10:56 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-01 20:14 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 13:29 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-02 10:45 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-01 20:01 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 13:25 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-02 10:39 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-07-01 15:48 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 20:38 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 20:39 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 22:03 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-30 12:42 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-30 12:20 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-01 10:23 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 07:59 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-07-01 16:25 +0200
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 09:31 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 20:38 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 20:38 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 20:36 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 22:24 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 21:34 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 22:44 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 22:14 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-01 23:21 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-01 22:34 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-02 07:30 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-02 07:39 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-02 18:44 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-02 17:58 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-02 19:03 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-02 18:09 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-02 21:07 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-02 20:28 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-02 21:32 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-07-02 20:42 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-07-02 21:48 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH --- clueless olcott <polcott333@gmail.com> - 2024-07-02 20:54 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH --- clueless Richard Damon <richard@damon-family.org> - 2024-07-02 21:59 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless olcott <polcott333@gmail.com> - 2024-07-02 21:09 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless Richard Damon <richard@damon-family.org> - 2024-07-02 22:23 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless olcott <polcott333@gmail.com> - 2024-07-02 21:35 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless Richard Damon <richard@damon-family.org> - 2024-07-02 22:46 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless olcott <polcott333@gmail.com> - 2024-07-02 22:10 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless Richard Damon <richard@damon-family.org> - 2024-07-02 23:26 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless Richard Damon <richard@damon-family.org> - 2024-07-02 23:27 -0400
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-07-03 03:55 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH Mikko <mikko.levanto@iki.fi> - 2024-07-02 09:42 +0300
Re: 197 page execution trace of DDD correctly simulated by HHH joes <noreply@example.org> - 2024-07-02 08:06 +0000
Re: 197 page execution trace of DDD correctly simulated by HHH Mikko <mikko.levanto@iki.fi> - 2024-07-02 09:40 +0300
Re: 195 page execution trace of DDD correctly simulated by HH0 Mikko <mikko.levanto@iki.fi> - 2024-06-26 11:10 +0300
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-26 07:55 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Alan Mackenzie <acm@muc.de> - 2024-06-26 13:40 +0000
DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 09:04 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Alan Mackenzie <acm@muc.de> - 2024-06-26 16:03 +0000
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 11:24 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Python <python@invalid.org> - 2024-06-26 18:30 +0200
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Alan Mackenzie <acm@muc.de> - 2024-06-26 19:43 +0000
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 15:10 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure --- addendum olcott <polcott333@gmail.com> - 2024-06-26 15:30 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure joes <noreply@example.com> - 2024-06-26 20:55 +0000
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 16:15 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Mikko <mikko.levanto@iki.fi> - 2024-06-27 09:34 +0300
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-27 12:07 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Mikko <mikko.levanto@iki.fi> - 2024-06-28 10:17 +0300
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-28 10:28 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Mikko <mikko.levanto@iki.fi> - 2024-06-29 10:23 +0300
Re: 197 page execution trace of DDD correctly simulated by HHH olcott <polcott333@gmail.com> - 2024-06-29 21:50 -0500
Re: 197 page execution trace of DDD correctly simulated by HHH Mikko <mikko.levanto@iki.fi> - 2024-06-30 12:12 +0300
Re: 197 page execution trace of DDD correctly simulated by HHH Richard Damon <richard@damon-family.org> - 2024-06-30 08:34 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 21:12 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Richard Damon <richard@damon-family.org> - 2024-06-25 22:20 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 joes <noreply@example.com> - 2024-06-25 20:44 +0000
Re: 195 page execution trace of DDD correctly simulated by HH0 olcott <polcott333@gmail.com> - 2024-06-25 16:38 -0500
Re: 195 page execution trace of DDD correctly simulated by HH0 Richard Damon <richard@damon-family.org> - 2024-06-24 19:24 -0400
Re: 195 page execution trace of DDD correctly simulated by HH0 Mikko <mikko.levanto@iki.fi> - 2024-06-30 12:30 +0300
Page 4 of 10 — ← Prev page 1 2 3 [4] 5 6 … 10 Next page →
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-25 20:19 +0200 |
| Message-ID | <v5f1nm$1lp16$1@dont-email.me> |
| In reply to | #107803 |
Op 25.jun.2024 om 19:29 schreef olcott:
> On 6/25/2024 9:13 AM, Fred. Zwarts wrote:
>> Op 25.jun.2024 om 15:12 schreef olcott:
>>> On 6/25/2024 7:08 AM, Fred. Zwarts wrote:
>>>> Op 24.jun.2024 om 23:04 schreef olcott:
>>>>> On 6/24/2024 2:36 PM, joes wrote:
>>>>>> Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:
>>>>>>> On 6/24/2024 2:37 AM, Mikko wrote:
>>>>>>>> On 2024-06-23 13:17:27 +0000, olcott said:
>>>>>>>>> On 6/23/2024 3:22 AM, Mikko wrote:
>>>>>>>>>> That code is not from the mentined trace file. In that file
>>>>>>>>>> _DDD()
>>>>>>>>>> is at the addresses 2093..20a4. According to the trace no
>>>>>>>>>> instruction
>>>>>>>>>> at the address is executed (because that address points to the
>>>>>>>>>> last
>>>>>>>>>> byte of a three byte instruction.
>>>>>>>>>
>>>>>>>>> In order to make my examples I must edit the code and this
>>>>>>>>> changes the
>>>>>>>>> addresses of some functions.
>>>>>>>>
>>>>>>>> Why do you need to make an example when you already have one in the
>>>>>>>> file mentioned in the subject line?
>>>>>>>>
>>>>>>> I had to make a few more examples such as HH1(DD,DD)
>>>>>> AFACT HH1 is the same as HH0, right? What happens when HH1 tries to
>>>>>> simulate a function DD1 that only calls HH1?
>>>>>>
>>>>>
>>>>> typedef uint32_t u32;
>>>>> u32 H(u32 P, u32 I);
>>>>>
>>>>> int P(u32 x)
>>>>> {
>>>>> int Halt_Status = H(x, x);
>>>>> if (Halt_Status)
>>>>> HERE: goto HERE;
>>>>> return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> H(P,P);
>>>>> }
>>>>>
>>>>> I am going to have to go through my code and standardize my names.
>>>>> H(P,P) was the original name. Then I had to make a one parameter
>>>>> version, a version that is identical to H, except P does not call
>>>>> it and then versions using different algorithms. People have never
>>>>> been able to understand the different algorithm.
>>>>>
>>>>> typedef void (*ptr)();
>>>>> typedef int (*ptr2)();
>>>>> int HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>> int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>> int HHH(ptr P); // used with void DDD() that calls HHH
>>>>> int HHH1(ptr P); // used with void DDD() that calls HHH
>>>>>
>>>>> *The different algorithm version has been deprecated*
>>>>> int H(ptr2 , ptr2 I); // used with int D(ptr2 P) that calls H
>>>>> int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>
>>>>> *It is much easier for people to see the infinite recursion*
>>>>> *behavior pattern when they see it actually cycle through the*
>>>>> *same instructions twice*
>>>>
>>>> Twice is not equal to infinitely. When will you see that?
>>>> It is strange that you call that an infinite recursion, when H
>>>> aborts after two cycles and the simulated H cannot reach its own
>>>> abort operation, because it is aborted when it had only one more
>>>> cycle to go.
>>>> None of the aborted simulations would cycle more than twice, so
>>>> infinite recursion is not seen for an H that aborts the simulation
>>>> of itself.
>>>
>>> typedef void (*ptr)();
>>> int H0(ptr P);
>>>
>>> void DDD()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> int main()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> _DDD()
>>> [00002172] 55 push ebp ; housekeeping
>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>> [00002175] 6872210000 push 00002172 ; push DDD
>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>> [0000217f] 83c404 add esp,+04
>>> [00002182] 5d pop ebp
>>> [00002183] c3 ret
>>> Size in bytes:(0018) [00002183]
>>>
>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>> by H0 cannot possibly return.
>>
>> Contradictio in terminis. The fact that the simulated H0 does not
>> return shows that the simulation is incorrect.
>
> void Infinite_Recursion()
> {
> Infinite_Recursion();
> }
>
> Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
> correct simulating termination analyzer would be required to
> abort its simulation to correctly report non-terminating behavior.
> That seems quite dumb of you.
Change of subject ignored.
>
>> The simulated H0 does not return, because it is aborted one cycle too
>> soon. One cycle later it would return.
>
> Complete lack of sufficient software engineering skill.
Maybe you should study some software engineering to get over it.
> Unless the outermost directly executed H0 aborts its
> simulation after a fixed number of recursive invocations
> NONE OF THEM DO.
Change of subject. We are talking about an H0 that aborts, so dreaming
of one that does not abort is irrelevant.
H0 aborts after two cycles. Then it aborts the simulated H0 which at
that moment has run only one cycle. One cycle later the simulated H0
would also return, if not aborted.
>
> This did baffle me for three days 3.5 years ago until
> I took the time to THINK IT ALL THE WAY THROUGH.
Apparently, your thinking went completely wrong.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 13:26 -0500 |
| Message-ID | <v5f246$1m2fl$1@dont-email.me> |
| In reply to | #107805 |
On 6/25/2024 1:19 PM, Fred. Zwarts wrote:
> Op 25.jun.2024 om 19:29 schreef olcott:
>> On 6/25/2024 9:13 AM, Fred. Zwarts wrote:
>>> Op 25.jun.2024 om 15:12 schreef olcott:
>>>> On 6/25/2024 7:08 AM, Fred. Zwarts wrote:
>>>>> Op 24.jun.2024 om 23:04 schreef olcott:
>>>>>> On 6/24/2024 2:36 PM, joes wrote:
>>>>>>> Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:
>>>>>>>> On 6/24/2024 2:37 AM, Mikko wrote:
>>>>>>>>> On 2024-06-23 13:17:27 +0000, olcott said:
>>>>>>>>>> On 6/23/2024 3:22 AM, Mikko wrote:
>>>>>>>>>>> That code is not from the mentined trace file. In that file
>>>>>>>>>>> _DDD()
>>>>>>>>>>> is at the addresses 2093..20a4. According to the trace no
>>>>>>>>>>> instruction
>>>>>>>>>>> at the address is executed (because that address points to
>>>>>>>>>>> the last
>>>>>>>>>>> byte of a three byte instruction.
>>>>>>>>>>
>>>>>>>>>> In order to make my examples I must edit the code and this
>>>>>>>>>> changes the
>>>>>>>>>> addresses of some functions.
>>>>>>>>>
>>>>>>>>> Why do you need to make an example when you already have one in
>>>>>>>>> the
>>>>>>>>> file mentioned in the subject line?
>>>>>>>>>
>>>>>>>> I had to make a few more examples such as HH1(DD,DD)
>>>>>>> AFACT HH1 is the same as HH0, right? What happens when HH1 tries to
>>>>>>> simulate a function DD1 that only calls HH1?
>>>>>>>
>>>>>>
>>>>>> typedef uint32_t u32;
>>>>>> u32 H(u32 P, u32 I);
>>>>>>
>>>>>> int P(u32 x)
>>>>>> {
>>>>>> int Halt_Status = H(x, x);
>>>>>> if (Halt_Status)
>>>>>> HERE: goto HERE;
>>>>>> return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H(P,P);
>>>>>> }
>>>>>>
>>>>>> I am going to have to go through my code and standardize my names.
>>>>>> H(P,P) was the original name. Then I had to make a one parameter
>>>>>> version, a version that is identical to H, except P does not call
>>>>>> it and then versions using different algorithms. People have never
>>>>>> been able to understand the different algorithm.
>>>>>>
>>>>>> typedef void (*ptr)();
>>>>>> typedef int (*ptr2)();
>>>>>> int HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>> int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>> int HHH(ptr P); // used with void DDD() that calls HHH
>>>>>> int HHH1(ptr P); // used with void DDD() that calls HHH
>>>>>>
>>>>>> *The different algorithm version has been deprecated*
>>>>>> int H(ptr2 , ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>> int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>
>>>>>> *It is much easier for people to see the infinite recursion*
>>>>>> *behavior pattern when they see it actually cycle through the*
>>>>>> *same instructions twice*
>>>>>
>>>>> Twice is not equal to infinitely. When will you see that?
>>>>> It is strange that you call that an infinite recursion, when H
>>>>> aborts after two cycles and the simulated H cannot reach its own
>>>>> abort operation, because it is aborted when it had only one more
>>>>> cycle to go.
>>>>> None of the aborted simulations would cycle more than twice, so
>>>>> infinite recursion is not seen for an H that aborts the simulation
>>>>> of itself.
>>>>
>>>> typedef void (*ptr)();
>>>> int H0(ptr P);
>>>>
>>>> void DDD()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>> _DDD()
>>>> [00002172] 55 push ebp ; housekeeping
>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>> [0000217f] 83c404 add esp,+04
>>>> [00002182] 5d pop ebp
>>>> [00002183] c3 ret
>>>> Size in bytes:(0018) [00002183]
>>>>
>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>> by H0 cannot possibly return.
>>>
>>> Contradictio in terminis. The fact that the simulated H0 does not
>>> return shows that the simulation is incorrect.
>>
>> void Infinite_Recursion()
>> {
>> Infinite_Recursion();
>> }
>>
>> Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
>> correct simulating termination analyzer would be required to
>> abort its simulation to correctly report non-terminating behavior.
>> That seems quite dumb of you.
>
> Change of subject ignored.
>
>>
>>> The simulated H0 does not return, because it is aborted one cycle too
>>> soon. One cycle later it would return.
>>
>> Complete lack of sufficient software engineering skill.
>
> Maybe you should study some software engineering to get over it.
>
>> Unless the outermost directly executed H0 aborts its
>> simulation after a fixed number of recursive invocations
>> NONE OF THEM DO.
>
> Change of subject. We are talking about an H0 that aborts, so dreaming
> of one that does not abort is irrelevant.
No one here can possibly handle more than one single point
at a time without leaping to the conclusion that I must
be incorrect. Because of this I will not tolerate moving
beyond one single point at a time.
> H0 aborts after two cycles. Then it aborts the simulated H0 which at
> that moment has run only one cycle. One cycle later the simulated H0
> would also return, if not aborted.
>
>>
>> This did baffle me for three days 3.5 years ago until
>> I took the time to THINK IT ALL THE WAY THROUGH.
>
> Apparently, your thinking went completely wrong.
>
No the actual truth is that you are one of my least competent
reviewers.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-25 20:49 +0200 |
| Message-ID | <v5f3fg$1lp16$2@dont-email.me> |
| In reply to | #107806 |
Op 25.jun.2024 om 20:26 schreef olcott:
> On 6/25/2024 1:19 PM, Fred. Zwarts wrote:
>> Op 25.jun.2024 om 19:29 schreef olcott:
>>> On 6/25/2024 9:13 AM, Fred. Zwarts wrote:
>>>> Op 25.jun.2024 om 15:12 schreef olcott:
>>>>> On 6/25/2024 7:08 AM, Fred. Zwarts wrote:
>>>>>> Op 24.jun.2024 om 23:04 schreef olcott:
>>>>>>> On 6/24/2024 2:36 PM, joes wrote:
>>>>>>>> Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:
>>>>>>>>> On 6/24/2024 2:37 AM, Mikko wrote:
>>>>>>>>>> On 2024-06-23 13:17:27 +0000, olcott said:
>>>>>>>>>>> On 6/23/2024 3:22 AM, Mikko wrote:
>>>>>>>>>>>> That code is not from the mentined trace file. In that file
>>>>>>>>>>>> _DDD()
>>>>>>>>>>>> is at the addresses 2093..20a4. According to the trace no
>>>>>>>>>>>> instruction
>>>>>>>>>>>> at the address is executed (because that address points to
>>>>>>>>>>>> the last
>>>>>>>>>>>> byte of a three byte instruction.
>>>>>>>>>>>
>>>>>>>>>>> In order to make my examples I must edit the code and this
>>>>>>>>>>> changes the
>>>>>>>>>>> addresses of some functions.
>>>>>>>>>>
>>>>>>>>>> Why do you need to make an example when you already have one
>>>>>>>>>> in the
>>>>>>>>>> file mentioned in the subject line?
>>>>>>>>>>
>>>>>>>>> I had to make a few more examples such as HH1(DD,DD)
>>>>>>>> AFACT HH1 is the same as HH0, right? What happens when HH1 tries to
>>>>>>>> simulate a function DD1 that only calls HH1?
>>>>>>>>
>>>>>>>
>>>>>>> typedef uint32_t u32;
>>>>>>> u32 H(u32 P, u32 I);
>>>>>>>
>>>>>>> int P(u32 x)
>>>>>>> {
>>>>>>> int Halt_Status = H(x, x);
>>>>>>> if (Halt_Status)
>>>>>>> HERE: goto HERE;
>>>>>>> return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H(P,P);
>>>>>>> }
>>>>>>>
>>>>>>> I am going to have to go through my code and standardize my names.
>>>>>>> H(P,P) was the original name. Then I had to make a one parameter
>>>>>>> version, a version that is identical to H, except P does not call
>>>>>>> it and then versions using different algorithms. People have never
>>>>>>> been able to understand the different algorithm.
>>>>>>>
>>>>>>> typedef void (*ptr)();
>>>>>>> typedef int (*ptr2)();
>>>>>>> int HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>> int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>> int HHH(ptr P); // used with void DDD() that calls HHH
>>>>>>> int HHH1(ptr P); // used with void DDD() that calls HHH
>>>>>>>
>>>>>>> *The different algorithm version has been deprecated*
>>>>>>> int H(ptr2 , ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>> int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>>
>>>>>>> *It is much easier for people to see the infinite recursion*
>>>>>>> *behavior pattern when they see it actually cycle through the*
>>>>>>> *same instructions twice*
>>>>>>
>>>>>> Twice is not equal to infinitely. When will you see that?
>>>>>> It is strange that you call that an infinite recursion, when H
>>>>>> aborts after two cycles and the simulated H cannot reach its own
>>>>>> abort operation, because it is aborted when it had only one more
>>>>>> cycle to go.
>>>>>> None of the aborted simulations would cycle more than twice, so
>>>>>> infinite recursion is not seen for an H that aborts the simulation
>>>>>> of itself.
>>>>>
>>>>> typedef void (*ptr)();
>>>>> int H0(ptr P);
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> _DDD()
>>>>> [00002172] 55 push ebp ; housekeeping
>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>> [0000217f] 83c404 add esp,+04
>>>>> [00002182] 5d pop ebp
>>>>> [00002183] c3 ret
>>>>> Size in bytes:(0018) [00002183]
>>>>>
>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>> by H0 cannot possibly return.
>>>>
>>>> Contradictio in terminis. The fact that the simulated H0 does not
>>>> return shows that the simulation is incorrect.
>>>
>>> void Infinite_Recursion()
>>> {
>>> Infinite_Recursion();
>>> }
>>>
>>> Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
>>> correct simulating termination analyzer would be required to
>>> abort its simulation to correctly report non-terminating behavior.
>>> That seems quite dumb of you.
>>
>> Change of subject ignored.
>>
>>>
>>>> The simulated H0 does not return, because it is aborted one cycle
>>>> too soon. One cycle later it would return.
>>>
>>> Complete lack of sufficient software engineering skill.
>>
>> Maybe you should study some software engineering to get over it.
>>
>>> Unless the outermost directly executed H0 aborts its
>>> simulation after a fixed number of recursive invocations
>>> NONE OF THEM DO.
>>
>> Change of subject. We are talking about an H0 that aborts, so dreaming
>> of one that does not abort is irrelevant.
>
> No one here can possibly handle more than one single point
> at a time without leaping to the conclusion that I must
> be incorrect. Because of this I will not tolerate moving
> beyond one single point at a time.
You are the one that started to talk about a second point (an H0 that
does not abort), when we were talking about an H0 that aborts.
So, I agree, let us forget about that second point (an H0 that does not
abort). From now on we only talk about an H0 that aborts after two
cycles. So, no infinite recursion, two cycles at most.
>
>> H0 aborts after two cycles. Then it aborts the simulated H0 which at
>> that moment has run only one cycle. One cycle later the simulated H0
>> would also return, if not aborted.
>>
>>>
>>> This did baffle me for three days 3.5 years ago until
>>> I took the time to THINK IT ALL THE WAY THROUGH.
>>
>> Apparently, your thinking went completely wrong.
>>
>
> No the actual truth is that you are one of my least competent
> reviewers.
>
Bad excuse for not showing any error in my reasoning.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 13:51 -0500 |
| Message-ID | <v5f3j8$1m2fl$2@dont-email.me> |
| In reply to | #107807 |
On 6/25/2024 1:49 PM, Fred. Zwarts wrote:
> Op 25.jun.2024 om 20:26 schreef olcott:
>> On 6/25/2024 1:19 PM, Fred. Zwarts wrote:
>>> Op 25.jun.2024 om 19:29 schreef olcott:
>>>> On 6/25/2024 9:13 AM, Fred. Zwarts wrote:
>>>>> Op 25.jun.2024 om 15:12 schreef olcott:
>>>>>> On 6/25/2024 7:08 AM, Fred. Zwarts wrote:
>>>>>>> Op 24.jun.2024 om 23:04 schreef olcott:
>>>>>>>> On 6/24/2024 2:36 PM, joes wrote:
>>>>>>>>> Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:
>>>>>>>>>> On 6/24/2024 2:37 AM, Mikko wrote:
>>>>>>>>>>> On 2024-06-23 13:17:27 +0000, olcott said:
>>>>>>>>>>>> On 6/23/2024 3:22 AM, Mikko wrote:
>>>>>>>>>>>>> That code is not from the mentined trace file. In that file
>>>>>>>>>>>>> _DDD()
>>>>>>>>>>>>> is at the addresses 2093..20a4. According to the trace no
>>>>>>>>>>>>> instruction
>>>>>>>>>>>>> at the address is executed (because that address points to
>>>>>>>>>>>>> the last
>>>>>>>>>>>>> byte of a three byte instruction.
>>>>>>>>>>>>
>>>>>>>>>>>> In order to make my examples I must edit the code and this
>>>>>>>>>>>> changes the
>>>>>>>>>>>> addresses of some functions.
>>>>>>>>>>>
>>>>>>>>>>> Why do you need to make an example when you already have one
>>>>>>>>>>> in the
>>>>>>>>>>> file mentioned in the subject line?
>>>>>>>>>>>
>>>>>>>>>> I had to make a few more examples such as HH1(DD,DD)
>>>>>>>>> AFACT HH1 is the same as HH0, right? What happens when HH1
>>>>>>>>> tries to
>>>>>>>>> simulate a function DD1 that only calls HH1?
>>>>>>>>>
>>>>>>>>
>>>>>>>> typedef uint32_t u32;
>>>>>>>> u32 H(u32 P, u32 I);
>>>>>>>>
>>>>>>>> int P(u32 x)
>>>>>>>> {
>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>> if (Halt_Status)
>>>>>>>> HERE: goto HERE;
>>>>>>>> return Halt_Status;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> H(P,P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> I am going to have to go through my code and standardize my names.
>>>>>>>> H(P,P) was the original name. Then I had to make a one parameter
>>>>>>>> version, a version that is identical to H, except P does not call
>>>>>>>> it and then versions using different algorithms. People have never
>>>>>>>> been able to understand the different algorithm.
>>>>>>>>
>>>>>>>> typedef void (*ptr)();
>>>>>>>> typedef int (*ptr2)();
>>>>>>>> int HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>>> int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>>> int HHH(ptr P); // used with void DDD() that calls HHH
>>>>>>>> int HHH1(ptr P); // used with void DDD() that calls HHH
>>>>>>>>
>>>>>>>> *The different algorithm version has been deprecated*
>>>>>>>> int H(ptr2 , ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>>> int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>>>
>>>>>>>> *It is much easier for people to see the infinite recursion*
>>>>>>>> *behavior pattern when they see it actually cycle through the*
>>>>>>>> *same instructions twice*
>>>>>>>
>>>>>>> Twice is not equal to infinitely. When will you see that?
>>>>>>> It is strange that you call that an infinite recursion, when H
>>>>>>> aborts after two cycles and the simulated H cannot reach its own
>>>>>>> abort operation, because it is aborted when it had only one more
>>>>>>> cycle to go.
>>>>>>> None of the aborted simulations would cycle more than twice, so
>>>>>>> infinite recursion is not seen for an H that aborts the
>>>>>>> simulation of itself.
>>>>>>
>>>>>> typedef void (*ptr)();
>>>>>> int H0(ptr P);
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>> H0(DDD);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H0(DDD);
>>>>>> }
>>>>>>
>>>>>> _DDD()
>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>> [0000217f] 83c404 add esp,+04
>>>>>> [00002182] 5d pop ebp
>>>>>> [00002183] c3 ret
>>>>>> Size in bytes:(0018) [00002183]
>>>>>>
>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>> by H0 cannot possibly return.
>>>>>
>>>>> Contradictio in terminis. The fact that the simulated H0 does not
>>>>> return shows that the simulation is incorrect.
>>>>
>>>> void Infinite_Recursion()
>>>> {
>>>> Infinite_Recursion();
>>>> }
>>>>
>>>> Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
>>>> correct simulating termination analyzer would be required to
>>>> abort its simulation to correctly report non-terminating behavior.
>>>> That seems quite dumb of you.
>>>
>>> Change of subject ignored.
>>>
>>>>
>>>>> The simulated H0 does not return, because it is aborted one cycle
>>>>> too soon. One cycle later it would return.
>>>>
>>>> Complete lack of sufficient software engineering skill.
>>>
>>> Maybe you should study some software engineering to get over it.
>>>
>>>> Unless the outermost directly executed H0 aborts its
>>>> simulation after a fixed number of recursive invocations
>>>> NONE OF THEM DO.
>>>
>>> Change of subject. We are talking about an H0 that aborts, so
>>> dreaming of one that does not abort is irrelevant.
>>
>> No one here can possibly handle more than one single point
>> at a time without leaping to the conclusion that I must
>> be incorrect. Because of this I will not tolerate moving
>> beyond one single point at a time.
>
> You are the one that started to talk about a second point (an H0 that
> does not abort), when we were talking about an H0 that aborts.
> So, I agree, let us forget about that second point (an H0 that does not
> abort). From now on we only talk about an H0 that aborts after two
> cycles. So, no infinite recursion, two cycles at most.
>
>>
>>> H0 aborts after two cycles. Then it aborts the simulated H0 which at
>>> that moment has run only one cycle. One cycle later the simulated H0
>>> would also return, if not aborted.
>>>
>>>>
>>>> This did baffle me for three days 3.5 years ago until
>>>> I took the time to THINK IT ALL THE WAY THROUGH.
>>>
>>> Apparently, your thinking went completely wrong.
>>>
>>
>> No the actual truth is that you are one of my least competent
>> reviewers.
>>
>
> Bad excuse for not showing any error in my reasoning.
I did and it was over your head.
Unless the outer directly executed H aborts NONE-OF-THEM DO.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return.
Until you acknowledge this is true, this is the
only thing that I am willing to talk to you about.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-25 21:17 +0200 |
| Message-ID | <v5f54f$1lp16$3@dont-email.me> |
| In reply to | #107808 |
Op 25.jun.2024 om 20:51 schreef olcott:
> On 6/25/2024 1:49 PM, Fred. Zwarts wrote:
>> Op 25.jun.2024 om 20:26 schreef olcott:
>>> On 6/25/2024 1:19 PM, Fred. Zwarts wrote:
>>>> Op 25.jun.2024 om 19:29 schreef olcott:
>>>>> On 6/25/2024 9:13 AM, Fred. Zwarts wrote:
>>>>>> Op 25.jun.2024 om 15:12 schreef olcott:
>>>>>>> On 6/25/2024 7:08 AM, Fred. Zwarts wrote:
>>>>>>>> Op 24.jun.2024 om 23:04 schreef olcott:
>>>>>>>>> On 6/24/2024 2:36 PM, joes wrote:
>>>>>>>>>> Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:
>>>>>>>>>>> On 6/24/2024 2:37 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-06-23 13:17:27 +0000, olcott said:
>>>>>>>>>>>>> On 6/23/2024 3:22 AM, Mikko wrote:
>>>>>>>>>>>>>> That code is not from the mentined trace file. In that
>>>>>>>>>>>>>> file _DDD()
>>>>>>>>>>>>>> is at the addresses 2093..20a4. According to the trace no
>>>>>>>>>>>>>> instruction
>>>>>>>>>>>>>> at the address is executed (because that address points to
>>>>>>>>>>>>>> the last
>>>>>>>>>>>>>> byte of a three byte instruction.
>>>>>>>>>>>>>
>>>>>>>>>>>>> In order to make my examples I must edit the code and this
>>>>>>>>>>>>> changes the
>>>>>>>>>>>>> addresses of some functions.
>>>>>>>>>>>>
>>>>>>>>>>>> Why do you need to make an example when you already have one
>>>>>>>>>>>> in the
>>>>>>>>>>>> file mentioned in the subject line?
>>>>>>>>>>>>
>>>>>>>>>>> I had to make a few more examples such as HH1(DD,DD)
>>>>>>>>>> AFACT HH1 is the same as HH0, right? What happens when HH1
>>>>>>>>>> tries to
>>>>>>>>>> simulate a function DD1 that only calls HH1?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> typedef uint32_t u32;
>>>>>>>>> u32 H(u32 P, u32 I);
>>>>>>>>>
>>>>>>>>> int P(u32 x)
>>>>>>>>> {
>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> H(P,P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> I am going to have to go through my code and standardize my names.
>>>>>>>>> H(P,P) was the original name. Then I had to make a one parameter
>>>>>>>>> version, a version that is identical to H, except P does not call
>>>>>>>>> it and then versions using different algorithms. People have never
>>>>>>>>> been able to understand the different algorithm.
>>>>>>>>>
>>>>>>>>> typedef void (*ptr)();
>>>>>>>>> typedef int (*ptr2)();
>>>>>>>>> int HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>>>> int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>>>> int HHH(ptr P); // used with void DDD() that calls HHH
>>>>>>>>> int HHH1(ptr P); // used with void DDD() that calls HHH
>>>>>>>>>
>>>>>>>>> *The different algorithm version has been deprecated*
>>>>>>>>> int H(ptr2 , ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>>>> int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>>>>
>>>>>>>>> *It is much easier for people to see the infinite recursion*
>>>>>>>>> *behavior pattern when they see it actually cycle through the*
>>>>>>>>> *same instructions twice*
>>>>>>>>
>>>>>>>> Twice is not equal to infinitely. When will you see that?
>>>>>>>> It is strange that you call that an infinite recursion, when H
>>>>>>>> aborts after two cycles and the simulated H cannot reach its own
>>>>>>>> abort operation, because it is aborted when it had only one more
>>>>>>>> cycle to go.
>>>>>>>> None of the aborted simulations would cycle more than twice, so
>>>>>>>> infinite recursion is not seen for an H that aborts the
>>>>>>>> simulation of itself.
>>>>>>>
>>>>>>> typedef void (*ptr)();
>>>>>>> int H0(ptr P);
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> H0(DDD);
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H0(DDD);
>>>>>>> }
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>>> [0000217f] 83c404 add esp,+04
>>>>>>> [00002182] 5d pop ebp
>>>>>>> [00002183] c3 ret
>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>
>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>>> by H0 cannot possibly return.
>>>>>>
>>>>>> Contradictio in terminis. The fact that the simulated H0 does not
>>>>>> return shows that the simulation is incorrect.
>>>>>
>>>>> void Infinite_Recursion()
>>>>> {
>>>>> Infinite_Recursion();
>>>>> }
>>>>>
>>>>> Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
>>>>> correct simulating termination analyzer would be required to
>>>>> abort its simulation to correctly report non-terminating behavior.
>>>>> That seems quite dumb of you.
>>>>
>>>> Change of subject ignored.
>>>>
>>>>>
>>>>>> The simulated H0 does not return, because it is aborted one cycle
>>>>>> too soon. One cycle later it would return.
>>>>>
>>>>> Complete lack of sufficient software engineering skill.
>>>>
>>>> Maybe you should study some software engineering to get over it.
>>>>
>>>>> Unless the outermost directly executed H0 aborts its
>>>>> simulation after a fixed number of recursive invocations
>>>>> NONE OF THEM DO.
>>>>
>>>> Change of subject. We are talking about an H0 that aborts, so
>>>> dreaming of one that does not abort is irrelevant.
>>>
>>> No one here can possibly handle more than one single point
>>> at a time without leaping to the conclusion that I must
>>> be incorrect. Because of this I will not tolerate moving
>>> beyond one single point at a time.
>>
>> You are the one that started to talk about a second point (an H0 that
>> does not abort), when we were talking about an H0 that aborts.
>> So, I agree, let us forget about that second point (an H0 that does
>> not abort). From now on we only talk about an H0 that aborts after two
>> cycles. So, no infinite recursion, two cycles at most.
>>
>>>
>>>> H0 aborts after two cycles. Then it aborts the simulated H0 which at
>>>> that moment has run only one cycle. One cycle later the simulated H0
>>>> would also return, if not aborted.
>>>>
>>>>>
>>>>> This did baffle me for three days 3.5 years ago until
>>>>> I took the time to THINK IT ALL THE WAY THROUGH.
>>>>
>>>> Apparently, your thinking went completely wrong.
>>>>
>>>
>>> No the actual truth is that you are one of my least competent
>>> reviewers.
>>>
>>
>> Bad excuse for not showing any error in my reasoning.
>
> I did and it was over your head.
No, you didn't.
> Unless the outer directly executed H aborts NONE-OF-THEM DO.
>
> _DDD()
> [00002172] 55 push ebp ; housekeeping
> [00002173] 8bec mov ebp,esp ; housekeeping
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
> [0000217f] 83c404 add esp,+04
> [00002182] 5d pop ebp
> [00002183] c3 ret
> Size in bytes:(0018) [00002183]
>
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by H0 cannot possibly return.
>
> Until you acknowledge this is true, this is the
> only thing that I am willing to talk to you about.
>
>
It might be true, but it is irrelevant, because the simulated H0 is
aborted prematurely. The simulating H0 aborts after two cycles, when the
simulated H0 has one cycle to go before it would return.
So, the only reason that the simulated H0 does not return is that it is
aborted prematurely. A correct simulation would show that one cycle
later it returns.
It seems that it is over your head that a prematurely aborted simulation
is not a correct simulation.
There are a few reasons why a simulation can be incorrect:
1) Some instructions are incorrectly simulated.
2) Instructions are simulated out of order.
3) Some instructions are not simulated at all.
Your problem is 3).
You only prove that your H0 is unable to simulate itself correctly,
because it aborts too soon and fails to simulate the end of itself.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 14:30 -0500 |
| Message-ID | <v5f5sd$1mcif$1@dont-email.me> |
| In reply to | #107809 |
On 6/25/2024 2:17 PM, Fred. Zwarts wrote: > > It might be true, but it is irrelevant, because the simulated H0 is > aborted prematurely. The simulating H0 aborts after two cycles, *I am not even talking about a simulating halt decider yet dumbo* If you can't begin to comprehend x86 emulators then our conversation is dead right here. For every x86 emulator Ho that can possibly exist at machine address 0000217a... _DDD() [00002172] 55 push ebp ; housekeeping [00002173] 8bec mov ebp,esp ; housekeeping [00002175] 6872210000 push 00002172 ; push DDD [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) [0000217f] 83c404 add esp,+04 [00002182] 5d pop ebp [00002183] c3 ret Size in bytes:(0018) [00002183] The call from DDD to H0(DDD) when DDD is correctly emulated by H0 cannot possibly return. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-26 10:01 +0200 |
| Message-ID | <v5ght9$21jrt$1@dont-email.me> |
| In reply to | #107810 |
Op 25.jun.2024 om 21:30 schreef olcott: > On 6/25/2024 2:17 PM, Fred. Zwarts wrote: >> >> It might be true, but it is irrelevant, because the simulated H0 is >> aborted prematurely. The simulating H0 aborts after two cycles, > > *I am not even talking about a simulating halt decider yet dumbo* Neither am I. Why do you mention a simulating halt decider? (Who is the dumbo?) > If you can't begin to comprehend x86 emulators then our conversation > is dead right here. Fortunately, I am very well able to do so. But it seems that you have to learn a few basic facts about simulation. > > For every x86 emulator Ho that can possibly exist > at machine address 0000217a... > > _DDD() > [00002172] 55 push ebp ; housekeeping > [00002173] 8bec mov ebp,esp ; housekeeping > [00002175] 6872210000 push 00002172 ; push DDD > [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) > [0000217f] 83c404 add esp,+04 > [00002182] 5d pop ebp > [00002183] c3 ret > Size in bytes:(0018) [00002183] > > The call from DDD to H0(DDD) when DDD is correctly emulated > by H0 cannot possibly return. So, you repeat your claim without showing any error in my reasoning. Therefore, I repeat again: It might be true hat H0 cannot return, but it is irrelevant, because the simulated H0 is aborted prematurely. The simulating H0 aborts after two cycles, when the simulated H0 has one cycle to go before it would return. So, the only reason that the simulated H0 does not return is that it is aborted prematurely. A correct simulation would show that one cycle later it would return. It seems that it is over your head that a prematurely aborted simulation is not a correct simulation. There are a few reasons why a simulation can be incorrect: 1) Some instructions are incorrectly simulated. 2) Instructions are simulated out of order. 3) Some instructions are not simulated at all. Your problem is 3). You only prove that your H0 is unable to simulate itself correctly, because it aborts too soon and fails to simulate the end of itself.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 08:07 -0500 |
| Message-ID | <v5h3rd$24jbd$6@dont-email.me> |
| In reply to | #107845 |
On 6/26/2024 3:01 AM, Fred. Zwarts wrote: > Op 25.jun.2024 om 21:30 schreef olcott: >> On 6/25/2024 2:17 PM, Fred. Zwarts wrote: >>> >>> It might be true, but it is irrelevant, because the simulated H0 is >>> aborted prematurely. The simulating H0 aborts after two cycles, >> >> *I am not even talking about a simulating halt decider yet dumbo* > > Neither am I. Why do you mention a simulating halt decider? (Who is the > dumbo?) > >> If you can't begin to comprehend x86 emulators then our conversation >> is dead right here. > > Fortunately, I am very well able to do so. > But it seems that you have to learn a few basic facts about simulation. > >> >> For every x86 emulator Ho that can possibly exist >> at machine address 0000217a... >> >> _DDD() >> [00002172] 55 push ebp ; housekeeping >> [00002173] 8bec mov ebp,esp ; housekeeping >> [00002175] 6872210000 push 00002172 ; push DDD >> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >> [0000217f] 83c404 add esp,+04 >> [00002182] 5d pop ebp >> [00002183] c3 ret >> Size in bytes:(0018) [00002183] >> >> The call from DDD to H0(DDD) when DDD is correctly emulated >> by H0 cannot possibly return. > > So, you repeat your claim without showing any error in my reasoning. > Therefore, I repeat again: > > It might be true hat H0 cannot return, As soon as you say that you are certain that it is true we can move on to its relevance. That it is true is as simple as arithmetic. Why it is relevant is much more difficult. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-27 11:38 +0200 |
| Message-ID | <v5jbub$2m18t$1@dont-email.me> |
| In reply to | #107858 |
Op 26.jun.2024 om 15:07 schreef olcott: > On 6/26/2024 3:01 AM, Fred. Zwarts wrote: >> Op 25.jun.2024 om 21:30 schreef olcott: >>> On 6/25/2024 2:17 PM, Fred. Zwarts wrote: >>>> >>>> It might be true, but it is irrelevant, because the simulated H0 is >>>> aborted prematurely. The simulating H0 aborts after two cycles, >>> >>> *I am not even talking about a simulating halt decider yet dumbo* >> >> Neither am I. Why do you mention a simulating halt decider? (Who is >> the dumbo?) >> >>> If you can't begin to comprehend x86 emulators then our conversation >>> is dead right here. >> >> Fortunately, I am very well able to do so. >> But it seems that you have to learn a few basic facts about simulation. >> >>> >>> For every x86 emulator Ho that can possibly exist >>> at machine address 0000217a... >>> >>> _DDD() >>> [00002172] 55 push ebp ; housekeeping >>> [00002173] 8bec mov ebp,esp ; housekeeping >>> [00002175] 6872210000 push 00002172 ; push DDD >>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>> [0000217f] 83c404 add esp,+04 >>> [00002182] 5d pop ebp >>> [00002183] c3 ret >>> Size in bytes:(0018) [00002183] >>> >>> The call from DDD to H0(DDD) when DDD is correctly emulated >>> by H0 cannot possibly return. >> >> So, you repeat your claim without showing any error in my reasoning. >> Therefore, I repeat again: >> >> It might be true hat H0 cannot return, > > As soon as you say that you are certain that it is true > we can move on to its relevance. That it is true is as > simple as arithmetic. Why it is relevant is much more > difficult. > I cannot be certain, because you keep changing your definitions and there are no clear specifications for H0. Anyhow, the only reason why the simulation of H0 would not return is that the simulation is aborted before it could return. Since we know that H0 runs two cycles before it aborts, we know that no infinite recursion is involved, so the premature abort makes it impossible for the simulation to return. It seems that it is over your head that a prematurely aborted simulation is not a correct simulation. There are a few reasons why a simulation can be incorrect: 1) Some instructions are incorrectly simulated. 2) Instructions are simulated out of order. 3) Some instructions are not simulated at all. Your problem is 3). You only prove that your H0 is unable to simulate itself correctly, because it aborts too soon and fails to simulate the end of itself. Only if we can agree about this, then we can discuss what it means that H0 cannot possibly return. I cannot tolerate to skip this step, because otherwise we will run in circles.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-27 12:21 -0500 |
| Message-ID | <v5k72o$2qsdr$4@dont-email.me> |
| In reply to | #107921 |
On 6/27/2024 4:38 AM, Fred. Zwarts wrote:
> Op 26.jun.2024 om 15:07 schreef olcott:
>> On 6/26/2024 3:01 AM, Fred. Zwarts wrote:
>>> Op 25.jun.2024 om 21:30 schreef olcott:
>>>> On 6/25/2024 2:17 PM, Fred. Zwarts wrote:
>>>>>
>>>>> It might be true, but it is irrelevant, because the simulated H0 is
>>>>> aborted prematurely. The simulating H0 aborts after two cycles,
>>>>
>>>> *I am not even talking about a simulating halt decider yet dumbo*
>>>
>>> Neither am I. Why do you mention a simulating halt decider? (Who is
>>> the dumbo?)
>>>
>>>> If you can't begin to comprehend x86 emulators then our conversation
>>>> is dead right here.
>>>
>>> Fortunately, I am very well able to do so.
>>> But it seems that you have to learn a few basic facts about simulation.
>>>
>>>>
>>>> For every x86 emulator Ho that can possibly exist
>>>> at machine address 0000217a...
>>>>
>>>> _DDD()
>>>> [00002172] 55 push ebp ; housekeeping
>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>> [0000217f] 83c404 add esp,+04
>>>> [00002182] 5d pop ebp
>>>> [00002183] c3 ret
>>>> Size in bytes:(0018) [00002183]
>>>>
>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>> by H0 cannot possibly return.
>>>
>>> So, you repeat your claim without showing any error in my reasoning.
>>> Therefore, I repeat again:
>>>
>>> It might be true hat H0 cannot return,
>>
>> As soon as you say that you are certain that it is true
>> we can move on to its relevance. That it is true is as
>> simple as arithmetic. Why it is relevant is much more
>> difficult.
>>
>
> I cannot be certain, because you keep changing your definitions and
> there are no clear specifications for H0.
You have to fix your own ignorance of the C programming
language and the x86 programming language.
typedef void (*ptr)();
int H0(ptr P);
void DDD()
{
H0(DDD);
}
int main()
{
H0(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
The call from DDD to H0(DDD) when DDD is correctly emulated
by x86 emulator H0 cannot possibly return.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-28 10:06 +0200 |
| Message-ID | <v5lqul$386u3$1@dont-email.me> |
| In reply to | #107934 |
Op 27.jun.2024 om 19:21 schreef olcott:
> On 6/27/2024 4:38 AM, Fred. Zwarts wrote:
>> Op 26.jun.2024 om 15:07 schreef olcott:
>>> On 6/26/2024 3:01 AM, Fred. Zwarts wrote:
>>>> Op 25.jun.2024 om 21:30 schreef olcott:
>>>>> On 6/25/2024 2:17 PM, Fred. Zwarts wrote:
>>>>>>
>>>>>> It might be true, but it is irrelevant, because the simulated H0
>>>>>> is aborted prematurely. The simulating H0 aborts after two cycles,
>>>>>
>>>>> *I am not even talking about a simulating halt decider yet dumbo*
>>>>
>>>> Neither am I. Why do you mention a simulating halt decider? (Who is
>>>> the dumbo?)
>>>>
>>>>> If you can't begin to comprehend x86 emulators then our conversation
>>>>> is dead right here.
>>>>
>>>> Fortunately, I am very well able to do so.
>>>> But it seems that you have to learn a few basic facts about simulation.
>>>>
>>>>>
>>>>> For every x86 emulator Ho that can possibly exist
>>>>> at machine address 0000217a...
>>>>>
>>>>> _DDD()
>>>>> [00002172] 55 push ebp ; housekeeping
>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>> [0000217f] 83c404 add esp,+04
>>>>> [00002182] 5d pop ebp
>>>>> [00002183] c3 ret
>>>>> Size in bytes:(0018) [00002183]
>>>>>
>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>> by H0 cannot possibly return.
>>>>
>>>> So, you repeat your claim without showing any error in my reasoning.
>>>> Therefore, I repeat again:
>>>>
>>>> It might be true hat H0 cannot return,
>>>
>>> As soon as you say that you are certain that it is true
>>> we can move on to its relevance. That it is true is as
>>> simple as arithmetic. Why it is relevant is much more
>>> difficult.
>>>
>>
>> I cannot be certain, because you keep changing your definitions and
>> there are no clear specifications for H0.
>
> You have to fix your own ignorance of the C programming
> language and the x86 programming language.
Irrelevant nonsense ignored.
>
> typedef void (*ptr)();
> int H0(ptr P);
>
> void DDD()
> {
> H0(DDD);
> }
>
> int main()
> {
> H0(DDD);
> }
>
> _DDD()
> [00002172] 55 push ebp ; housekeeping
> [00002173] 8bec mov ebp,esp ; housekeeping
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
> [0000217f] 83c404 add esp,+04
> [00002182] 5d pop ebp
> [00002183] c3 ret
> Size in bytes:(0018) [00002183]
>
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by x86 emulator H0 cannot possibly return.
>
>
Repeating your claim does not show any error in my reasoning.
Your claim is a contradictio in terminus.
1) It is impossible for a simulator to simulate itself correctly.
Therefore the word 'correctly' tells us already that such an H0 does not
exist.
2) When H0 aborts the simulation of itself, it makes it impossible for
the simulated H0 to return. Therefore, the fact that the simulated call
does not return is an error of the simulator.
3) When H0 aborts, it fails to emulate the few remaining instructions up
to the return of the simulated H0.
A correct simulation of two cycles of recursion is a simulation of both
these two cycles, up to the return.
You will probably be tempted to show your infinite_recursion example
again, but that does not apply here, because here are only two cycles of
recursion.
This has been pointed out to you so many times. You could never point to
an error, but only repeat this verified false claims.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 09:12 -0500 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v5mgd9$3cds2$1@dont-email.me> |
| In reply to | #107948 |
On 6/28/2024 3:06 AM, Fred. Zwarts wrote:
> Op 27.jun.2024 om 19:21 schreef olcott:
>> On 6/27/2024 4:38 AM, Fred. Zwarts wrote:
>>> Op 26.jun.2024 om 15:07 schreef olcott:
>>>> On 6/26/2024 3:01 AM, Fred. Zwarts wrote:
>>>>> Op 25.jun.2024 om 21:30 schreef olcott:
>>>>>> On 6/25/2024 2:17 PM, Fred. Zwarts wrote:
>>>>>>>
>>>>>>> It might be true, but it is irrelevant, because the simulated H0
>>>>>>> is aborted prematurely. The simulating H0 aborts after two cycles,
>>>>>>
>>>>>> *I am not even talking about a simulating halt decider yet dumbo*
>>>>>
>>>>> Neither am I. Why do you mention a simulating halt decider? (Who is
>>>>> the dumbo?)
>>>>>
>>>>>> If you can't begin to comprehend x86 emulators then our conversation
>>>>>> is dead right here.
>>>>>
>>>>> Fortunately, I am very well able to do so.
>>>>> But it seems that you have to learn a few basic facts about
>>>>> simulation.
>>>>>
>>>>>>
>>>>>> For every x86 emulator Ho that can possibly exist
>>>>>> at machine address 0000217a...
>>>>>>
>>>>>> _DDD()
>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>> [0000217f] 83c404 add esp,+04
>>>>>> [00002182] 5d pop ebp
>>>>>> [00002183] c3 ret
>>>>>> Size in bytes:(0018) [00002183]
>>>>>>
>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>> by H0 cannot possibly return.
>>>>>
>>>>> So, you repeat your claim without showing any error in my reasoning.
>>>>> Therefore, I repeat again:
>>>>>
>>>>> It might be true hat H0 cannot return,
>>>>
>>>> As soon as you say that you are certain that it is true
>>>> we can move on to its relevance. That it is true is as
>>>> simple as arithmetic. Why it is relevant is much more
>>>> difficult.
>>>>
>>>
>>> I cannot be certain, because you keep changing your definitions and
>>> there are no clear specifications for H0.
>>
>> You have to fix your own ignorance of the C programming
>> language and the x86 programming language.
>
> Irrelevant nonsense ignored.
>
>>
>> typedef void (*ptr)();
>> int H0(ptr P);
>>
>> void DDD()
>> {
>> H0(DDD);
>> }
>>
>> int main()
>> {
>> H0(DDD);
>> }
>>
>> _DDD()
>> [00002172] 55 push ebp ; housekeeping
>> [00002173] 8bec mov ebp,esp ; housekeeping
>> [00002175] 6872210000 push 00002172 ; push DDD
>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>> [0000217f] 83c404 add esp,+04
>> [00002182] 5d pop ebp
>> [00002183] c3 ret
>> Size in bytes:(0018) [00002183]
>>
>> The call from DDD to H0(DDD) when DDD is correctly emulated
>> by x86 emulator H0 cannot possibly return.
>>
>>
>
> Repeating your claim does not show any error in my reasoning.
>
> Your claim is a contradictio in terminus.
> 1) It is impossible for a simulator to simulate itself correctly.
*I have already proven otherwise*
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
*I have standardized the naming conventions for code and my paper*
HHH(DDD) and HHH1(DDD) are the standard names for DDD input
DDD calls HHH(DDD) and HHH1 is identical to HHH.
HH(DD,DD) and HH1(DD,DD) are the standard names for (DD,DD) input
DD calls HH(DD,DD) and HH1 is identical to HH.
Now that I standardized the names and provided a full
color-coded execution trace of HHH(DDD) your counter-factual
claims are clearly refuted.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-28 16:43 +0200 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v5mi5t$3cmj8$1@dont-email.me> |
| In reply to | #107960 |
Op 28.jun.2024 om 16:12 schreef olcott:
> On 6/28/2024 3:06 AM, Fred. Zwarts wrote:
>> Op 27.jun.2024 om 19:21 schreef olcott:
>>> On 6/27/2024 4:38 AM, Fred. Zwarts wrote:
>>>> Op 26.jun.2024 om 15:07 schreef olcott:
>>>>> On 6/26/2024 3:01 AM, Fred. Zwarts wrote:
>>>>>> Op 25.jun.2024 om 21:30 schreef olcott:
>>>>>>> On 6/25/2024 2:17 PM, Fred. Zwarts wrote:
>>>>>>>>
>>>>>>>> It might be true, but it is irrelevant, because the simulated H0
>>>>>>>> is aborted prematurely. The simulating H0 aborts after two cycles,
>>>>>>>
>>>>>>> *I am not even talking about a simulating halt decider yet dumbo*
>>>>>>
>>>>>> Neither am I. Why do you mention a simulating halt decider? (Who
>>>>>> is the dumbo?)
>>>>>>
>>>>>>> If you can't begin to comprehend x86 emulators then our conversation
>>>>>>> is dead right here.
>>>>>>
>>>>>> Fortunately, I am very well able to do so.
>>>>>> But it seems that you have to learn a few basic facts about
>>>>>> simulation.
>>>>>>
>>>>>>>
>>>>>>> For every x86 emulator Ho that can possibly exist
>>>>>>> at machine address 0000217a...
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>>> [0000217f] 83c404 add esp,+04
>>>>>>> [00002182] 5d pop ebp
>>>>>>> [00002183] c3 ret
>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>
>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>>> by H0 cannot possibly return.
>>>>>>
>>>>>> So, you repeat your claim without showing any error in my reasoning.
>>>>>> Therefore, I repeat again:
>>>>>>
>>>>>> It might be true hat H0 cannot return,
>>>>>
>>>>> As soon as you say that you are certain that it is true
>>>>> we can move on to its relevance. That it is true is as
>>>>> simple as arithmetic. Why it is relevant is much more
>>>>> difficult.
>>>>>
>>>>
>>>> I cannot be certain, because you keep changing your definitions and
>>>> there are no clear specifications for H0.
>>>
>>> You have to fix your own ignorance of the C programming
>>> language and the x86 programming language.
>>
>> Irrelevant nonsense ignored.
>>
>>>
>>> typedef void (*ptr)();
>>> int H0(ptr P);
>>>
>>> void DDD()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> int main()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> _DDD()
>>> [00002172] 55 push ebp ; housekeeping
>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>> [00002175] 6872210000 push 00002172 ; push DDD
>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>> [0000217f] 83c404 add esp,+04
>>> [00002182] 5d pop ebp
>>> [00002183] c3 ret
>>> Size in bytes:(0018) [00002183]
>>>
>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>> by x86 emulator H0 cannot possibly return.
>>>
>>>
>>
>> Repeating your claim does not show any error in my reasoning.
>>
>> Your claim is a contradictio in terminus.
>> 1) It is impossible for a simulator to simulate itself correctly.
>
> *I have already proven otherwise*
> https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
Except that this trace only proved that I am right. The simulator is
unable to simulate itself correctly, which is shown in this trace.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 10:01 -0500 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v5mj8m$3cibm$3@dont-email.me> |
| In reply to | #107963 |
On 6/28/2024 9:43 AM, Fred. Zwarts wrote:
> Op 28.jun.2024 om 16:12 schreef olcott:
>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote:
>>> Op 27.jun.2024 om 19:21 schreef olcott:
>>>>
>>>> _DDD()
>>>> [00002172] 55 push ebp ; housekeeping
>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>> [0000217f] 83c404 add esp,+04
>>>> [00002182] 5d pop ebp
>>>> [00002183] c3 ret
>>>> Size in bytes:(0018) [00002183]
>>>>
>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>> by x86 emulator H0 cannot possibly return.
>>>>
>>>>
>>>
>>> Repeating your claim does not show any error in my reasoning.
>>>
>>> Your claim is a contradictio in terminus.
>>> 1) It is impossible for a simulator to simulate itself correctly.
>>
>> *I have already proven otherwise*
>> https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
>
> Except that this trace only proved that I am right. The simulator is
> unable to simulate itself correctly, which is shown in this trace.
>
void Infinite_Recursion()
{
Infinite_Recursion();
}
That is counter-factual. HHH(DDD) does correctly emulate
the call from DDD to HHH(DDD) emulating itself emulating DDD.
That you don't seem to have a clue about how HHH correctly
decides Infinite_Recursion() prevents your understanding of HHH(DDD).
_Infinite_Recursion()
[00002122] 55 push ebp
[00002123] 8bec mov ebp,esp
[00002125] e8f8ffffff call 00002122
[0000212a] 5d pop ebp
[0000212b] c3 ret
Size in bytes:(0010) [0000212b]
_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6822210000 push 00002122
[0000219a] e833f4ffff call 000015d2
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] eb04 jmp 000021b6
[000021b2] 33c0 xor eax,eax
[000021b4] eb02 jmp 000021b8
[000021b6] 33c0 xor eax,eax
[000021b8] 5d pop ebp
[000021b9] c3 ret
Size in bytes:(0040) [000021b9]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00002192][00103826][00000000] 55 push ebp
[00002193][00103826][00000000] 8bec mov ebp,esp
[00002195][00103822][00002122] 6822210000 push 00002122
[0000219a][0010381e][0000219f] e833f4ffff call 000015d2
New slave_stack at:1038ca
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d2
[00002122][001138c2][001138c6] 55 push ebp
[00002123][001138c2][001138c6] 8bec mov ebp,esp
[00002125][001138be][0000212a] e8f8ffffff call 00002122
[00002122][001138ba][001138c2] 55 push ebp
[00002123][001138ba][001138c2] 8bec mov ebp,esp
[00002125][001138b6][0000212a] e8f8ffffff call 00002122
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[0000219f][00103826][00000000] 83c404 add esp,+04
[000021a2][00103822][00000000] 50 push eax
[000021a3][0010381e][00000743] 6843070000 push 00000743
[000021a8][0010381e][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103826][00000000] 83c408 add esp,+08
[000021b0][00103826][00000000] eb04 jmp 000021b6
[000021b6][00103826][00000000] 33c0 xor eax,eax
[000021b8][0010382a][00000018] 5d pop ebp
[000021b9][0010382e][00000000] c3 ret
Number of Instructions Executed(864) == 13 Pages
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-28 17:19 +0200 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v5mk9j$3cmj8$3@dont-email.me> |
| In reply to | #107966 |
Op 28.jun.2024 om 17:01 schreef olcott:
> On 6/28/2024 9:43 AM, Fred. Zwarts wrote:
>> Op 28.jun.2024 om 16:12 schreef olcott:
>>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote:
>>>> Op 27.jun.2024 om 19:21 schreef olcott:
>>>>>
>>>>> _DDD()
>>>>> [00002172] 55 push ebp ; housekeeping
>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>> [0000217f] 83c404 add esp,+04
>>>>> [00002182] 5d pop ebp
>>>>> [00002183] c3 ret
>>>>> Size in bytes:(0018) [00002183]
>>>>>
>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>> by x86 emulator H0 cannot possibly return.
>>>>>
>>>>>
>>>>
>>>> Repeating your claim does not show any error in my reasoning.
>>>>
>>>> Your claim is a contradictio in terminus.
>>>> 1) It is impossible for a simulator to simulate itself correctly.
>>>
>>> *I have already proven otherwise*
>>> https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
>>
>> Except that this trace only proved that I am right. The simulator is
>> unable to simulate itself correctly, which is shown in this trace.
>>
>
> void Infinite_Recursion()
> {
> Infinite_Recursion();
> }
>
> That is counter-factual. HHH(DDD) does correctly emulate
> the call from DDD to HHH(DDD) emulating itself emulating DDD.
>
> That you don't seem to have a clue about how HHH correctly
> decides Infinite_Recursion() prevents your understanding of HHH(DDD).
>
> _Infinite_Recursion()
> [00002122] 55 push ebp
> [00002123] 8bec mov ebp,esp
> [00002125] e8f8ffffff call 00002122
> [0000212a] 5d pop ebp
> [0000212b] c3 ret
> Size in bytes:(0010) [0000212b]
>
> _main()
> [00002192] 55 push ebp
> [00002193] 8bec mov ebp,esp
> [00002195] 6822210000 push 00002122
> [0000219a] e833f4ffff call 000015d2
> [0000219f] 83c404 add esp,+04
> [000021a2] 50 push eax
> [000021a3] 6843070000 push 00000743
> [000021a8] e8b5e5ffff call 00000762
> [000021ad] 83c408 add esp,+08
> [000021b0] eb04 jmp 000021b6
> [000021b2] 33c0 xor eax,eax
> [000021b4] eb02 jmp 000021b8
> [000021b6] 33c0 xor eax,eax
> [000021b8] 5d pop ebp
> [000021b9] c3 ret
> Size in bytes:(0040) [000021b9]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [00002192][00103826][00000000] 55 push ebp
> [00002193][00103826][00000000] 8bec mov ebp,esp
> [00002195][00103822][00002122] 6822210000 push 00002122
> [0000219a][0010381e][0000219f] e833f4ffff call 000015d2
> New slave_stack at:1038ca
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:1138d2
> [00002122][001138c2][001138c6] 55 push ebp
> [00002123][001138c2][001138c6] 8bec mov ebp,esp
> [00002125][001138be][0000212a] e8f8ffffff call 00002122
> [00002122][001138ba][001138c2] 55 push ebp
> [00002123][001138ba][001138c2] 8bec mov ebp,esp
> [00002125][001138b6][0000212a] e8f8ffffff call 00002122
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> [0000219f][00103826][00000000] 83c404 add esp,+04
> [000021a2][00103822][00000000] 50 push eax
> [000021a3][0010381e][00000743] 6843070000 push 00000743
> [000021a8][0010381e][00000743] e8b5e5ffff call 00000762
> Input_Halts = 0
> [000021ad][00103826][00000000] 83c408 add esp,+08
> [000021b0][00103826][00000000] eb04 jmp 000021b6
> [000021b6][00103826][00000000] 33c0 xor eax,eax
> [000021b8][0010382a][00000018] 5d pop ebp
> [000021b9][0010382e][00000000] c3 ret
> Number of Instructions Executed(864) == 13 Pages
>
>
Don't start talking about infinite recursion if you do not even
understand two cycles of simulation.
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-28 16:28 +0000 |
| Subject | Re: 197 page execution trace of DDD incorrectly simulated by HHH |
| Message-ID | <v5mobr$1d3t3$3@i2pn2.org> |
| In reply to | #107966 |
Am Fri, 28 Jun 2024 10:01:41 -0500 schrieb olcott: > On 6/28/2024 9:43 AM, Fred. Zwarts wrote: >> Op 28.jun.2024 om 16:12 schreef olcott: >>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote: >>>> Op 27.jun.2024 om 19:21 schreef olcott: >>>>> The call from DDD to H0(DDD) when DDD is correctly emulated by x86 >>>>> emulator H0 cannot possibly return. > That is counter-factual. HHH(DDD) does correctly emulate the call from > DDD to HHH(DDD) emulating itself emulating DDD. Just gonna leave this side by side.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 13:24 -0500 |
| Subject | Re: 197 page execution trace of DDD incorrectly simulated by HHH |
| Message-ID | <v5mv5n$3f3fn$1@dont-email.me> |
| In reply to | #107978 |
On 6/28/2024 11:28 AM, joes wrote:
> Am Fri, 28 Jun 2024 10:01:41 -0500 schrieb olcott:
>> On 6/28/2024 9:43 AM, Fred. Zwarts wrote:
>>> Op 28.jun.2024 om 16:12 schreef olcott:
>>>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote:
>>>>> Op 27.jun.2024 om 19:21 schreef olcott:
>
>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated by x86
>>>>>> emulator H0 cannot possibly return.
>
>> That is counter-factual. HHH(DDD) does correctly emulate the call from
>> DDD to HHH(DDD) emulating itself emulating DDD.
>
> Just gonna leave this side by side.
HHH correctly emulates DDD including emulating itself emulating
DDD and sees that this proves that DDD is stuck in recursive
simulation thus aborts DDD and correctly returns 0 indicating
it has rejected its input according to this criteria:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-28 19:25 +0000 |
| Subject | Re: 197 page execution trace of DDD incorrectly simulated by HHH |
| Message-ID | <v5n2n4$1d3t3$11@i2pn2.org> |
| In reply to | #107984 |
Am Fri, 28 Jun 2024 13:24:55 -0500 schrieb olcott: > On 6/28/2024 11:28 AM, joes wrote: >> Am Fri, 28 Jun 2024 10:01:41 -0500 schrieb olcott: >>> On 6/28/2024 9:43 AM, Fred. Zwarts wrote: >>>> Op 28.jun.2024 om 16:12 schreef olcott: >>>>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote: >>>>>> Op 27.jun.2024 om 19:21 schreef olcott: >> >>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated by x86 >>>>>>> emulator H0 cannot possibly return. >>> That is counter-factual. HHH(DDD) does correctly emulate the call from >>> DDD to HHH(DDD) emulating itself emulating DDD. You are really immune to contradictions, are you? > HHH correctly emulates DDD including emulating itself emulating DDD and > sees that this proves that DDD is stuck in recursive simulation thus > aborts DDD and correctly returns 0 indicating it has rejected its input > according to this criterion: If it were able to correctly simulate itself it would see that its recursive call also aborts, and could accept DDD as halting. -- Am Fri, 21 Jun 2024 12:22:04 -0500 schrieb olcott: the logical impossibility of specifying a halt decider H that correctly reports the halt status of input D that is defined to do the opposite of whatever value that H reports.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 16:03 -0500 |
| Subject | Re: 197 page execution trace of DDD incorrectly simulated by HHH |
| Message-ID | <v5n8e9$3gt9c$1@dont-email.me> |
| In reply to | #107989 |
On 6/28/2024 2:25 PM, joes wrote:
> Am Fri, 28 Jun 2024 13:24:55 -0500 schrieb olcott:
>> On 6/28/2024 11:28 AM, joes wrote:
>>> Am Fri, 28 Jun 2024 10:01:41 -0500 schrieb olcott:
>>>> On 6/28/2024 9:43 AM, Fred. Zwarts wrote:
>>>>> Op 28.jun.2024 om 16:12 schreef olcott:
>>>>>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote:
>>>>>>> Op 27.jun.2024 om 19:21 schreef olcott:
>>>
>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated by x86
>>>>>>>> emulator H0 cannot possibly return.
>>>> That is counter-factual. HHH(DDD) does correctly emulate the call from
>>>> DDD to HHH(DDD) emulating itself emulating DDD.
> You are really immune to contradictions, are you?
>
>> HHH correctly emulates DDD including emulating itself emulating DDD and
>> sees that this proves that DDD is stuck in recursive simulation thus
>> aborts DDD and correctly returns 0 indicating it has rejected its input
>> according to this criterion:
> If it were able to correctly simulate itself it would see that its
> recursive call also aborts, and could accept DDD as halting.
>
*You might just be too dumb to comprehend this*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2024-06-28 21:26 +0000 |
| Subject | Re: 197 page execution trace of DDD incorrectly simulated by HHH |
| Message-ID | <v5n9ph$2i0b$1@news.muc.de> |
| In reply to | #107991 |
olcott <polcott333@gmail.com> wrote: > On 6/28/2024 2:25 PM, joes wrote: >> Am Fri, 28 Jun 2024 13:24:55 -0500 schrieb olcott: >>> On 6/28/2024 11:28 AM, joes wrote: >>>> Am Fri, 28 Jun 2024 10:01:41 -0500 schrieb olcott: >>>>> On 6/28/2024 9:43 AM, Fred. Zwarts wrote: >>>>>> Op 28.jun.2024 om 16:12 schreef olcott: >>>>>>> On 6/28/2024 3:06 AM, Fred. Zwarts wrote: >>>>>>>> Op 27.jun.2024 om 19:21 schreef olcott: >>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated by x86 >>>>>>>>> emulator H0 cannot possibly return. >>>>> That is counter-factual. HHH(DDD) does correctly emulate the call from >>>>> DDD to HHH(DDD) emulating itself emulating DDD. >> You are really immune to contradictions, are you? >>> HHH correctly emulates DDD including emulating itself emulating DDD and >>> sees that this proves that DDD is stuck in recursive simulation thus >>> aborts DDD and correctly returns 0 indicating it has rejected its input >>> according to this criterion: >> If it were able to correctly simulate itself it would see that its >> recursive call also aborts, and could accept DDD as halting. > *You might just be too dumb to comprehend this* The gratuitous insult is uncalled for. It's quite clear that Joes understands the matter adequately. > <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> > If simulating halt decider H correctly simulates its input D > until H correctly determines that its simulated D would never > stop running unless aborted then > H can abort its simulation of D and correctly report that D > specifies a non-halting sequence of configurations. > </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> But it seems you're not clever enough to understand the above. Professor Sipser would have agreed to these words knowing that the first "if" clause, with its "correctly simulates" can never hold. He would have wanted to get you, a crank, off his back so that he could continue uninterrupted with his work. He surely has real students who want to learn, to teach. Agreeing to that vacuous truth, which wouldn't stain his conscience, seems to have been effective. You appear not to have troubled Professor Sipser in over a year. > -- > Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
Page 4 of 10 — ← Prev page 1 2 3 [4] 5 6 … 10 Next page →
Back to top | Article view | comp.theory
csiph-web