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 9 of 10 — ← Prev page 1 … 7 8 [9] 10 Next page →
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-07-02 22:23 -0400 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless |
| Message-ID | <a6c36193b3d7181f8e63fc3b53aee6b7da47d792@i2pn2.org> |
| In reply to | #108183 |
On 7/2/24 10:09 PM, olcott wrote: > On 7/2/2024 8:59 PM, Richard Damon wrote: >> On 7/2/24 9:54 PM, olcott wrote: >>> On 7/2/2024 8:48 PM, Richard Damon wrote: >>>> On 7/2/24 9:42 PM, olcott wrote: >>>>> >>>>> The Tarski proof directly provides the detailed inference steps. >>>>> So it is not that I do under understand the Gödel proof it is that >>>>> this proof is opaque completely hiding all of the important details. >>>> >>>> No, you miss the fact that you are starting in the MIDDLE of an >>>> arguement, and that what you are thinking as a assumption is a >>>> proven statement (which you don't understand) >>>> >>> >>> You can't correct my error because you know that you have no >>> understanding of the Tarski proof. It is the same tactic as >>> always dishonestly deflect rather than make any attempt to >>> correct to hide the fact that you are clueless. >>> >>> >> >> Nope, I WON'T correct your error, because you have proved yourself to >> be a LIAR. >> > You just proved that you are clueless. Why, becasue I won't help a proven liar? You have proven that you do not have the necessary background to understand it, and even if you did you would just LIE about what it says, just like you always do. > >> I have explained it in the past, but you will not listen, because you >> have brainwashed yourself into beliving your own lies >> >> Until you either provide the Diagonalization proof you said you had, or > > *I never freaking said that I freaking had this* So you admit to claiming things that you do not know? That is just as bad. Remember, you said: > > Diagonalization conclusively proves otherwise and you know it. > Maybe the issue is that you are fundamentally a liar. > So, that seems to say you know a proof that proves something, I guess you are just admitting you don't know what you are talking about. I guess we should also consider EVERYTHING that you claim "must be true" is likely just another of your damned lies. > > I know that it does prove that G is unprovable yet is > horse shit because it totally hides why G is unprovable. > G is unprovable, because there is no finite proof of it, and you seem to agree to that. But G is also true, because it can not be false, and there *IS* an infinite logic sequence that can be done in PA that shows it to be true. Also, because G is a statement about the existance of a finite number with a specific computable property, it WILL be either True or False. It seems you logic doesn't want to accept such ideas, because you logic can only work on much simpler systems (if at all). YOU are the one full of Horse Shit because you don't understand logic, and you even contradict your own definitions.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-07-02 21:35 -0500 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless |
| Message-ID | <v62de5$20moo$1@dont-email.me> |
| In reply to | #108184 |
On 7/2/2024 9:23 PM, Richard Damon wrote: > On 7/2/24 10:09 PM, olcott wrote: >> On 7/2/2024 8:59 PM, Richard Damon wrote: >>> On 7/2/24 9:54 PM, olcott wrote: >>>> On 7/2/2024 8:48 PM, Richard Damon wrote: >>>>> On 7/2/24 9:42 PM, olcott wrote: >>>>>> >>>>>> The Tarski proof directly provides the detailed inference steps. >>>>>> So it is not that I do under understand the Gödel proof it is that >>>>>> this proof is opaque completely hiding all of the important details. >>>>> >>>>> No, you miss the fact that you are starting in the MIDDLE of an >>>>> arguement, and that what you are thinking as a assumption is a >>>>> proven statement (which you don't understand) >>>>> >>>> >>>> You can't correct my error because you know that you have no >>>> understanding of the Tarski proof. It is the same tactic as >>>> always dishonestly deflect rather than make any attempt to >>>> correct to hide the fact that you are clueless. >>>> >>>> >>> >>> Nope, I WON'T correct your error, because you have proved yourself to >>> be a LIAR. >>> >> You just proved that you are clueless. > > Why, becasue I won't help a proven liar? > > You have proven that you do not have the necessary background to > understand it, and even if you did you would just LIE about what it > says, just like you always do. > Dishonest dodge. I just looked up my rebuttal again. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-07-02 22:46 -0400 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless |
| Message-ID | <6c12c412fecfad2eec6f3c3776de9aa9785ad374@i2pn2.org> |
| In reply to | #108186 |
On 7/2/24 10:35 PM, olcott wrote: > On 7/2/2024 9:23 PM, Richard Damon wrote: >> On 7/2/24 10:09 PM, olcott wrote: >>> On 7/2/2024 8:59 PM, Richard Damon wrote: >>>> On 7/2/24 9:54 PM, olcott wrote: >>>>> On 7/2/2024 8:48 PM, Richard Damon wrote: >>>>>> On 7/2/24 9:42 PM, olcott wrote: >>>>>>> >>>>>>> The Tarski proof directly provides the detailed inference steps. >>>>>>> So it is not that I do under understand the Gödel proof it is that >>>>>>> this proof is opaque completely hiding all of the important details. >>>>>> >>>>>> No, you miss the fact that you are starting in the MIDDLE of an >>>>>> arguement, and that what you are thinking as a assumption is a >>>>>> proven statement (which you don't understand) >>>>>> >>>>> >>>>> You can't correct my error because you know that you have no >>>>> understanding of the Tarski proof. It is the same tactic as >>>>> always dishonestly deflect rather than make any attempt to >>>>> correct to hide the fact that you are clueless. >>>>> >>>>> >>>> >>>> Nope, I WON'T correct your error, because you have proved yourself >>>> to be a LIAR. >>>> >>> You just proved that you are clueless. >> >> Why, becasue I won't help a proven liar? >> >> You have proven that you do not have the necessary background to >> understand it, and even if you did you would just LIE about what it >> says, just like you always do. >> > > Dishonest dodge. I just looked up my rebuttal again. > So? You still haven't shown you understand what was actually being said. YOU are not a good judge of truth, you have proven it, as you have proven yourself to be just a dishonest liar. Or, are you going to show the nonsense proof that you believe shows Godel wrong? You logic is just so full of holes, it could be used as swiss cheese.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-07-02 22:10 -0500 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless |
| Message-ID | <v62ffc$20moo$4@dont-email.me> |
| In reply to | #108187 |
On 7/2/2024 9:46 PM, Richard Damon wrote: > On 7/2/24 10:35 PM, olcott wrote: >> On 7/2/2024 9:23 PM, Richard Damon wrote: >>> On 7/2/24 10:09 PM, olcott wrote: >>>> On 7/2/2024 8:59 PM, Richard Damon wrote: >>>>> On 7/2/24 9:54 PM, olcott wrote: >>>>>> On 7/2/2024 8:48 PM, Richard Damon wrote: >>>>>>> On 7/2/24 9:42 PM, olcott wrote: >>>>>>>> >>>>>>>> The Tarski proof directly provides the detailed inference steps. >>>>>>>> So it is not that I do under understand the Gödel proof it is that >>>>>>>> this proof is opaque completely hiding all of the important >>>>>>>> details. >>>>>>> >>>>>>> No, you miss the fact that you are starting in the MIDDLE of an >>>>>>> arguement, and that what you are thinking as a assumption is a >>>>>>> proven statement (which you don't understand) >>>>>>> >>>>>> >>>>>> You can't correct my error because you know that you have no >>>>>> understanding of the Tarski proof. It is the same tactic as >>>>>> always dishonestly deflect rather than make any attempt to >>>>>> correct to hide the fact that you are clueless. >>>>>> >>>>>> >>>>> >>>>> Nope, I WON'T correct your error, because you have proved yourself >>>>> to be a LIAR. >>>>> >>>> You just proved that you are clueless. >>> >>> Why, becasue I won't help a proven liar? >>> >>> You have proven that you do not have the necessary background to >>> understand it, and even if you did you would just LIE about what it >>> says, just like you always do. >>> >> >> Dishonest dodge. I just looked up my rebuttal again. >> > > So? You still haven't shown you understand what was actually being said. > I posted another whole thread that skipped his steps and proved that his conclusion is wrong. Reply only to this: *Tarski didn't understand truth-maker theory* -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-07-02 23:26 -0400 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless |
| Message-ID | <dbe19e3d11eb3255fc31d1e10c185025364f5fb0@i2pn2.org> |
| In reply to | #108190 |
On 7/2/24 11:10 PM, olcott wrote: > On 7/2/2024 9:46 PM, Richard Damon wrote: >> On 7/2/24 10:35 PM, olcott wrote: >>> On 7/2/2024 9:23 PM, Richard Damon wrote: >>>> On 7/2/24 10:09 PM, olcott wrote: >>>>> On 7/2/2024 8:59 PM, Richard Damon wrote: >>>>>> On 7/2/24 9:54 PM, olcott wrote: >>>>>>> On 7/2/2024 8:48 PM, Richard Damon wrote: >>>>>>>> On 7/2/24 9:42 PM, olcott wrote: >>>>>>>>> >>>>>>>>> The Tarski proof directly provides the detailed inference steps. >>>>>>>>> So it is not that I do under understand the Gödel proof it is that >>>>>>>>> this proof is opaque completely hiding all of the important >>>>>>>>> details. >>>>>>>> >>>>>>>> No, you miss the fact that you are starting in the MIDDLE of an >>>>>>>> arguement, and that what you are thinking as a assumption is a >>>>>>>> proven statement (which you don't understand) >>>>>>>> >>>>>>> >>>>>>> You can't correct my error because you know that you have no >>>>>>> understanding of the Tarski proof. It is the same tactic as >>>>>>> always dishonestly deflect rather than make any attempt to >>>>>>> correct to hide the fact that you are clueless. >>>>>>> >>>>>>> >>>>>> >>>>>> Nope, I WON'T correct your error, because you have proved yourself >>>>>> to be a LIAR. >>>>>> >>>>> You just proved that you are clueless. >>>> >>>> Why, becasue I won't help a proven liar? >>>> >>>> You have proven that you do not have the necessary background to >>>> understand it, and even if you did you would just LIE about what it >>>> says, just like you always do. >>>> >>> >>> Dishonest dodge. I just looked up my rebuttal again. >>> >> >> So? You still haven't shown you understand what was actually being said. >> > > I posted another whole thread that skipped his > steps and proved that his conclusion is wrong. > Reply only to this: *Tarski didn't understand truth-maker theory* > Why? Youtr logic has always be faulty. And where is the thread by that title? I think you are lying again, or at least stretching the truth.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-07-02 23:27 -0400 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH --- Richard proves that he is clueless |
| Message-ID | <45260538f600fb766bcae4e5bee4b6dcf3b3b115@i2pn2.org> |
| In reply to | #108190 |
On 7/2/24 11:10 PM, olcott wrote: > On 7/2/2024 9:46 PM, Richard Damon wrote: >> On 7/2/24 10:35 PM, olcott wrote: >>> On 7/2/2024 9:23 PM, Richard Damon wrote: >>>> On 7/2/24 10:09 PM, olcott wrote: >>>>> On 7/2/2024 8:59 PM, Richard Damon wrote: >>>>>> On 7/2/24 9:54 PM, olcott wrote: >>>>>>> On 7/2/2024 8:48 PM, Richard Damon wrote: >>>>>>>> On 7/2/24 9:42 PM, olcott wrote: >>>>>>>>> >>>>>>>>> The Tarski proof directly provides the detailed inference steps. >>>>>>>>> So it is not that I do under understand the Gödel proof it is that >>>>>>>>> this proof is opaque completely hiding all of the important >>>>>>>>> details. >>>>>>>> >>>>>>>> No, you miss the fact that you are starting in the MIDDLE of an >>>>>>>> arguement, and that what you are thinking as a assumption is a >>>>>>>> proven statement (which you don't understand) >>>>>>>> >>>>>>> >>>>>>> You can't correct my error because you know that you have no >>>>>>> understanding of the Tarski proof. It is the same tactic as >>>>>>> always dishonestly deflect rather than make any attempt to >>>>>>> correct to hide the fact that you are clueless. >>>>>>> >>>>>>> >>>>>> >>>>>> Nope, I WON'T correct your error, because you have proved yourself >>>>>> to be a LIAR. >>>>>> >>>>> You just proved that you are clueless. >>>> >>>> Why, becasue I won't help a proven liar? >>>> >>>> You have proven that you do not have the necessary background to >>>> understand it, and even if you did you would just LIE about what it >>>> says, just like you always do. >>>> >>> >>> Dishonest dodge. I just looked up my rebuttal again. >>> >> >> So? You still haven't shown you understand what was actually being said. >> > > I posted another whole thread that skipped his > steps and proved that his conclusion is wrong. > Reply only to this: *Tarski didn't understand truth-maker theory* > And where is the thread by that EXACT subhect. You don't even seem to know what you said.
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.org> |
|---|---|
| Date | 2024-07-03 03:55 +0000 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <5a0cfef928e00d92ceadeee1ad799e3add135828@i2pn2.org> |
| In reply to | #108166 |
Am Tue, 02 Jul 2024 17:58:55 -0500 schrieb olcott: > On 7/2/2024 5:44 PM, Richard Damon wrote: >> On 7/2/24 8:39 AM, olcott wrote: >>> On 7/2/2024 6:30 AM, Richard Damon wrote: >>>> On 7/1/24 11:34 PM, olcott wrote: >>>>> On 7/1/2024 10:21 PM, Richard Damon wrote: >>>>>> On 7/1/24 11:14 PM, olcott wrote: >>>>>>> On 7/1/2024 9:44 PM, Richard Damon wrote: >>>>>>>> On 7/1/24 10:34 PM, olcott wrote: >>>>>>>>> On 7/1/2024 9:24 PM, Richard Damon wrote: >>>>>>>>>> On 7/1/24 9:36 PM, olcott wrote: >>>>>>>>>>> On 7/1/2024 7:38 PM, Richard Damon wrote: >>>>>>>>>>>> On 7/1/24 8:59 AM, olcott wrote: >>>>>>>>>>>>> On 7/1/2024 3:23 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>> Op 30.jun.2024 om 19:20 schreef olcott: >>>>>>>>>>>>>>> >>>>>>>>>>>>>> It cannot possibly return, because HHH aborts itself one >>>>>>>>>>>>>> cycle too early, showing that the emulation is incorrect. >>>>>>>>>>>>>> If that is over your head, try to learn how x86 >>>>>>>>>>>>>> instructions work. >>>>>>>>>>>>> >>>>>>>>>>>> A "Correct Emulation" is one that produces the same result as >>>>>>>>>>>> the program at the input. >>>>>>>>>>>> >>>>>>>>>>> Which can only possibly occur be disregarding the semantics of >>>>>>>>>>> the x86 language. Liars would do that ignoramuses would do >>>>>>>>>>> that. Everyone with the equivalent of a BSCS would know that >>>>>>>>>>> what I said is true. >>>>>>>>>>> >>>>>>>>>> Why do you say that? That is EXACTLY the definition of Correct >>>>>>>>>> Emulation. >>>>>>> It may seem that way when you don't bother to pay attention that >>>>>>> this definition is contradicted by verified facts. >>>>>> >>>>>> WHAT "Verified facts". >>>>>> THe fact that DDD will halt since your HHH(DDD) retuns? >>>>>>>> No, DDD does halt if HHH is a decider and HHH(DDD) returns. >>>>>>>> >>>>>>>> >>>>>>> That is the same nutty bullshit as Gödel's 1931 incompleteness >>>>>>> theorem. If there are no truth preserving operations in PA to >>>>>>> either G or ~G then G has no truthmaker in PA making G not a >>>>>>> truth-bearer in PA. >>>>> Diagonalization conclusively proves otherwise and you know it. >>>>> Maybe the issue is that you are fundamentally a liar. >> You need to show your proof, that you can form a "Diagonalization" >> proof that Godel's sentence is not true. >>> *This source says nothing like what you claim* >>> https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom >>> >> Because they aren't using that terminology. That doesn't make the >> statement not true. >> >> Note, they do talk about how the sentence, if it were false, could be >> shown false by just showing the number that satisfies it. So, one way >> to demonstrate that it IS true, is to just test EVERY number (all >> countable infinite number of them) and show that none make the counter >> example. >> >> Most papers don't talk like that as we can't actually do it that way, >> but it is the simple explanation that should be able to sink into your >> head. If you want to show how that DOESN'T provide an infinite chain of >> steps to the truth of the statement, go ahead and try. >> >> Your problem is you like to quote from things that you don't >> understand. > > You have no source that validates this On 7/1/2024 10:21 PM, Richard > Damon wrote: > > But there ARE a set of truth preserving operations in PA to show G, > > it is just that it takes an infinite number of them, so they don't > > constitute a proof. > > Every source says that G is proved outside of PA and none says there are > any infinite sequence of steps in PA that derive G. IIRC you can enumerate the sentences that say „I don’t prove G”, of which there are infinitely many. Together they say there is no proof. -- Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott: Objectively I am a genius.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-07-02 09:42 +0300 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v607gr$1hluj$1@dont-email.me> |
| In reply to | #108132 |
On 2024-07-02 03:14:20 +0000, olcott said: > On 7/1/2024 9:44 PM, Richard Damon wrote: >> On 7/1/24 10:34 PM, olcott wrote: >>> On 7/1/2024 9:24 PM, Richard Damon wrote: >>>> On 7/1/24 9:36 PM, olcott wrote: >>>>> On 7/1/2024 7:38 PM, Richard Damon wrote: >>>>>> On 7/1/24 8:59 AM, olcott wrote: >>>>>>> On 7/1/2024 3:23 AM, Fred. Zwarts wrote: >>>>>>>> Op 30.jun.2024 om 19:20 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 HHH(DDD) >>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>> [00002182] 5d pop ebp >>>>>>>>> [00002183] c3 ret >>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>> >>>>>>>> >>>>>>>> It cannot possibly return, because HHH aborts itself one cycle too >>>>>>>> early, showing that the emulation is incorrect. If that is over your >>>>>>>> head, try to learn how x86 instructions work. >>>>>>> >>>>>>> _DDD() >>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>> [00002182] 5d pop ebp >>>>>>> [00002183] c3 ret >>>>>>> Size in bytes:(0018) [00002183] >>>>>>> >>>>>>> DDD is correctly emulated by HHH which calls an >>>>>>> emulated HHH(DDD) to repeat the process until aborted. >>>>>>> >>>>>>> >>>>>> >>>>>> CAN'T BE. >>>>>> >>>>>> A "Correct Emulation" is one that produces the same result as the >>>>>> program at the input. >>>>>> >>>>> >>>>> Which can only possibly occur be disregarding the semantics >>>>> of the x86 language. Liars would do that ignoramuses would do >>>>> that. Everyone with the equivalent of a BSCS would know that >>>>> what I said is true. >>>>> >>>>> >>>> >>>> Why do you say that? That is EXACTLY the definition of Correct Emulation. >>> >>> >>> WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH. >>> WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH. >>> WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH. >> >> And denying definitions is just lying. > > It may seem that way when you don't bother to pay > attention that this definition is contradicted > by verified facts. You have never proven that that definition be contradicted by verified (or claimed or assumed) facts. -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.org> |
|---|---|
| Date | 2024-07-02 08:06 +0000 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v60ce4$1pfp1$1@i2pn2.org> |
| In reply to | #108125 |
Am Mon, 01 Jul 2024 21:34:43 -0500 schrieb olcott: > On 7/1/2024 9:24 PM, Richard Damon wrote: >> On 7/1/24 9:36 PM, olcott wrote: >>> On 7/1/2024 7:38 PM, Richard Damon wrote: >>>> On 7/1/24 8:59 AM, olcott wrote: >>>>> On 7/1/2024 3:23 AM, Fred. Zwarts wrote: >>>>>> Op 30.jun.2024 om 19:20 schreef olcott: >>>> A "Correct Emulation" is one that produces the same result as the >>>> program at the input. >>>> >>> Which can only possibly occur be disregarding the semantics of the x86 >>> language. Liars would do that ignoramuses would do that. Everyone with >>> the equivalent of a BSCS would know that what I said is true. Therefore, HHH can’t be simulated by itself. >> Why do you say that? That is EXACTLY the definition of Correct >> Emulation. > > Every C programmer that knows what an x86 emulator is knows that when > HHH emulates the machine language of Infinite_Loop, Infinite_Recursion, > and DDD that it must abort these emulations so that itself can terminate > normally. An emulator does not need to abort. In fact, it should emulate infinite loops faithfully. > SO THESE THREE INPUTS DO NOT FREAKING HALT Why does the emulator halt then? -- Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott: Objectively I am a genius.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-07-02 09:40 +0300 |
| Subject | Re: 197 page execution trace of DDD correctly simulated by HHH |
| Message-ID | <v607cc$1hl9s$1@dont-email.me> |
| In reply to | #108112 |
On 2024-07-02 01:36:51 +0000, olcott said: > On 7/1/2024 7:38 PM, Richard Damon wrote: >> On 7/1/24 8:59 AM, olcott wrote: >>> On 7/1/2024 3:23 AM, Fred. Zwarts wrote: >>>> Op 30.jun.2024 om 19:20 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 HHH(DDD) >>>>> [0000217f] 83c404 add esp,+04 >>>>> [00002182] 5d pop ebp >>>>> [00002183] c3 ret >>>>> Size in bytes:(0018) [00002183] >>>>> >>>> >>>> It cannot possibly return, because HHH aborts itself one cycle too >>>> early, showing that the emulation is incorrect. If that is over your >>>> head, try to learn how x86 instructions work. >>> >>> _DDD() >>> [00002172] 55 push ebp ; housekeeping >>> [00002173] 8bec mov ebp,esp ; housekeeping >>> [00002175] 6872210000 push 00002172 ; push DDD >>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>> [0000217f] 83c404 add esp,+04 >>> [00002182] 5d pop ebp >>> [00002183] c3 ret >>> Size in bytes:(0018) [00002183] >>> >>> DDD is correctly emulated by HHH which calls an >>> emulated HHH(DDD) to repeat the process until aborted. >>> >>> >> >> CAN'T BE. >> >> A "Correct Emulation" is one that produces the same result as the >> program at the input. >> > > Which can only possibly occur be disregarding the semantics > of the x86 language. Whenever you say anything about the x86 semantics you should include a pointer to the relevant point in Intel's documentation. -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-26 11:10 +0300 |
| Message-ID | <v5gidq$221q3$1@dont-email.me> |
| In reply to | #107803 |
On 2024-06-25 17:29:12 +0000, olcott said:
> 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.
>
>> 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.
The relevant area of software engineering is testing. The usual attitude of
software engineers is that a program is accpted when it has been sufficiently
tested and passed all tests. Consequently, an important part of sofware work
is the design of tests.
In the current context the program to be tested is a halting decider. The
essential features are: (1) there is no computation or input that can be
given to the halting decider, (2) for every input the decider halts and
answers either "yes" or "no", and (3) if the computation described by the
input halts then the halting decider answers "yes", otherwise "no".
Software engineers want to have an answet to the questions "What test inpus
shall be given to the halting decider?" and "What are the correct answers
to these test cases?"
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 07:55 -0500 |
| Message-ID | <v5h34g$24jbd$4@dont-email.me> |
| In reply to | #107846 |
On 6/26/2024 3:10 AM, Mikko wrote:
> On 2024-06-25 17:29:12 +0000, olcott said:
>
>> 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.
>>
>>> 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.
>
> The relevant area of software engineering is testing. The usual attitude of
> software engineers is that a program is accpted when it has been
> sufficiently
> tested and passed all tests. Consequently, an important part of sofware
> work
> is the design of tests.
>
> In the current context the program to be tested is a halting decider.
*NO IT IS NOT. H0 IS ONLY AN X86 EMULATOR*
After you quit lying about the behavior of DDD correctly
emulated by H0 then we can move on to the next point.
--
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-26 13:40 +0000 |
| Message-ID | <v5h5oq$1g3$1@news.muc.de> |
| In reply to | #107856 |
olcott <polcott333@gmail.com> wrote: > On 6/26/2024 3:10 AM, Mikko wrote: [ .... ] >> The relevant area of software engineering is testing. The usual >> attitude of software engineers is that a program is accpted when it >> has been sufficiently tested and passed all tests. Consequently, an >> important part of sofware work is the design of tests. >> In the current context the program to be tested is a halting decider. > *NO IT IS NOT. H0 IS ONLY AN X86 EMULATOR* > After you quit lying about the behavior of DDD correctly > emulated by H0 then we can move on to the next point. I think the problem is rather your calling every program or function you talk about H, or H^, or HH, or HHH, or H0, or H1. Usually, in the past, you have meant purported halting deciders by these names. Now you're saying that you mean an X86 emulator. Where and when did this change happen, and how is anybody else supposed to know what you mean by particular uses of these names? Or is it just some subterfuge to enable you to abuse other posters? > -- > Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 09:04 -0500 |
| Subject | DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5h765$25q9l$1@dont-email.me> |
| In reply to | #107862 |
On 6/26/2024 8:40 AM, Alan Mackenzie wrote: > olcott <polcott333@gmail.com> wrote: >> On 6/26/2024 3:10 AM, Mikko wrote: > > [ .... ] > >>> The relevant area of software engineering is testing. The usual >>> attitude of software engineers is that a program is accpted when it >>> has been sufficiently tested and passed all tests. Consequently, an >>> important part of sofware work is the design of tests. > >>> In the current context the program to be tested is a halting decider. > >> *NO IT IS NOT. H0 IS ONLY AN X86 EMULATOR* >> After you quit lying about the behavior of DDD correctly >> emulated by H0 then we can move on to the next point. > > I think the problem is rather your calling every program or function you > talk about H, or H^, or HH, or HHH, or H0, or H1. Usually, in the past, > you have meant purported halting deciders by these names. Now you're > saying that you mean an X86 emulator. Where and when did this change > happen, and how is anybody else supposed to know what you mean by > particular uses of these names? > When I ask people to consider the behavior of DDD correctly emulated by H0 according to the semantics of the x86 programming language it really does seem to be the strawman deception when they try to get away with saying that it must be the behavior of the directly executed 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] It is clear that the semantics of the x86 language specifies that DDD correctly emulated by H0 at machine address 0000217a will continue to repeat the first four instructions of DDD until out-of-memory error. When we add that the outermost directly executed H0 can abort its simulation as soon as the behavior of its input matches the the infinite recursion behavior pattern it remains true that the call from the emulated DDD to the emulated H0(DDD) cannot possibly return. *That people consistently lie about this is quite annoying* *yet not nearly so much when their lie is easily exposed* > Or is it just some subterfuge to enable you to abuse other posters? > >> -- >> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius >> hits a target no one else can see." Arthur Schopenhauer > -- 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-26 16:03 +0000 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5he3t$1c0t$1@news.muc.de> |
| In reply to | #107865 |
[ Followup-To: set ] In comp.theory olcott <polcott333@gmail.com> wrote: > On 6/26/2024 8:40 AM, Alan Mackenzie wrote: >> olcott <polcott333@gmail.com> wrote: >>> On 6/26/2024 3:10 AM, Mikko wrote: >> [ .... ] >>>> The relevant area of software engineering is testing. The usual >>>> attitude of software engineers is that a program is accpted when it >>>> has been sufficiently tested and passed all tests. Consequently, an >>>> important part of sofware work is the design of tests. >>>> In the current context the program to be tested is a halting decider. >>> *NO IT IS NOT. H0 IS ONLY AN X86 EMULATOR* >>> After you quit lying about the behavior of DDD correctly >>> emulated by H0 then we can move on to the next point. >> I think the problem is rather your calling every program or function you >> talk about H, or H^, or HH, or HHH, or H0, or H1. Usually, in the past, >> you have meant purported halting deciders by these names. Now you're >> saying that you mean an X86 emulator. Where and when did this change >> happen, and how is anybody else supposed to know what you mean by >> particular uses of these names? > When I ask people to consider the behavior of DDD > correctly emulated by H0 according to the semantics > of the x86 programming language it really does seem > to be the strawman deception when they try to get away > with saying that it must be the behavior of the directly > executed DDD(). I don't think so. People's eyes glaze over when they see yet another one of your posts, virtually the same as so many others, and cannot reasonably be expected to read and understand every last word. Maybe if you restricted yourself to using E... when you mean an emulator, and H... when you mean a purported halting decider, there would be less confusion. Given how most people here are mathematically trained, perhaps if you started a typical post with "Suppose E is a code emulator ...", and other prerequisites there would be less confusion still. > _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] > It is clear that the semantics of the x86 language specifies > that DDD correctly emulated by H0 at machine address 0000217a > will continue to repeat the first four instructions of DDD > until out-of-memory error. It is not at all clear, given how murky the code at 15d2 is, and what you mean by "correctly emulated". > When we add that the outermost directly executed H0 can abort > its simulation as soon as the behavior of its input matches > the the infinite recursion behavior pattern it remains true > that the call from the emulated DDD to the emulated H0(DDD) > cannot possibly return. It might do. Convincing argument that this is the case (i.e. a proof) has not been forthcoming. > *That people consistently lie about this is quite annoying* > *yet not nearly so much when their lie is easily exposed* I haven't seen other people here lying. >> Or is it just some subterfuge to enable you to abuse other posters? > -- > Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 11:24 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5hfb8$26j79$1@dont-email.me> |
| In reply to | #107866 |
On 6/26/2024 11:03 AM, Alan Mackenzie wrote: > [ Followup-To: set ] > > In comp.theory olcott <polcott333@gmail.com> wrote: >> On 6/26/2024 8:40 AM, Alan Mackenzie wrote: >>> olcott <polcott333@gmail.com> wrote: >>>> On 6/26/2024 3:10 AM, Mikko wrote: > >>> [ .... ] > >>>>> The relevant area of software engineering is testing. The usual >>>>> attitude of software engineers is that a program is accpted when it >>>>> has been sufficiently tested and passed all tests. Consequently, an >>>>> important part of sofware work is the design of tests. > >>>>> In the current context the program to be tested is a halting decider. > >>>> *NO IT IS NOT. H0 IS ONLY AN X86 EMULATOR* >>>> After you quit lying about the behavior of DDD correctly >>>> emulated by H0 then we can move on to the next point. > >>> I think the problem is rather your calling every program or function you >>> talk about H, or H^, or HH, or HHH, or H0, or H1. Usually, in the past, >>> you have meant purported halting deciders by these names. Now you're >>> saying that you mean an X86 emulator. Where and when did this change >>> happen, and how is anybody else supposed to know what you mean by >>> particular uses of these names? > >> When I ask people to consider the behavior of DDD >> correctly emulated by H0 according to the semantics >> of the x86 programming language it really does seem >> to be the strawman deception when they try to get away >> with saying that it must be the behavior of the directly >> executed DDD(). > > I don't think so. People's eyes glaze over when they see yet another one > of your posts, virtually the same as so many others, and cannot > reasonably be expected to read and understand every last word. > > Maybe if you restricted yourself to using E... when you mean an emulator, > and H... when you mean a purported halting decider, there would be less > confusion. > Emulating termination analyzer H is inherently an emulator. It really should not be that hard to pay attention to that unless one only cares about rebuttal and thus does not care about truth. > Given how most people here are mathematically trained, perhaps if you > started a typical post with "Suppose E is a code emulator ...", and other > prerequisites there would be less confusion still. > OK that sounds like a reasonable way to avoid information overload. >> _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] > >> It is clear that the semantics of the x86 language specifies >> that DDD correctly emulated by H0 at machine address 0000217a >> will continue to repeat the first four instructions of DDD >> until out-of-memory error. > > It is not at all clear, given how murky the code at 15d2 is, and what you > mean by "correctly emulated". > Of course I must mean jumping up and down yelling and screaming and not be referring to anything like what an x86 emulator does. >> When we add that the outermost directly executed H0 can abort >> its simulation as soon as the behavior of its input matches >> the the infinite recursion behavior pattern it remains true >> that the call from the emulated DDD to the emulated H0(DDD) >> cannot possibly return. > > It might do. Convincing argument that this is the case (i.e. a proof) > has not been forthcoming. > We cannot prove differential calculus to anyone not knowing how to count to ten. That DDD correctly emulated by H0 must continue to repeat its first four instructions is self-evident true to anyone knowing what an x86 emulator is and having sufficient basic knowledge of the x86 programming language. I was very surprised to find out that one person having a PhD in computer science said that they had hardly any experience with programming. The CS courses that fulfilled the requirements for a BSCS degree at my university had quite a bit of programming. One of the projects for the data structures course was to write a LISP interpreter that could do car, cdr and cons. https://www.gnu.org/software/emacs/manual/html_node/eintr/car-cdr-_0026-cons.html These expressions could be arbitrarily complex. I was one of two students out of fifty that got the project in on time. The other one was my co-worker at the US Army Corps of engineers. He and I got a 100% grade. >> *That people consistently lie about this is quite annoying* >> *yet not nearly so much when their lie is easily exposed* > > I haven't seen other people here lying. > When they say that I am wrong knowing that they do not understand what I am saying this would be a lie. -- 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 | Python <python@invalid.org> |
|---|---|
| Date | 2024-06-26 18:30 +0200 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5hfmr$270et$2@dont-email.me> |
| In reply to | #107867 |
Le 26/06/2024 à 18:24, olcott a écrit : > On 6/26/2024 11:03 AM, Alan Mackenzie wrote: ... >> It is not at all clear, given how murky the code at 15d2 is, and what you >> mean by "correctly emulated". >> > > Of course I must mean jumping up and down yelling and screaming > and not be referring to anything like what an x86 emulator does. Ok! Why didn't you say that first :-) ? It was obvious anyway. > I was very surprised to find out that one person having a PhD > in computer science said that they had hardly any experience > with programming. > > The CS courses that fulfilled the requirements for a BSCS degree > at my university had quite a bit of programming. One of the projects > for the data structures course was to write a LISP interpreter that > could do car, cdr and cons. > https://www.gnu.org/software/emacs/manual/html_node/eintr/car-cdr-_0026-cons.html But yet you've shown to be incapable to program a Turing Machine emulator in C which is what any decent programmer could do in less than a couple of hours The only one who has been shown incapable of programming here is you, Peter Olcott.
[toc] | [prev] | [next] | [standalone]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2024-06-26 19:43 +0000 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5hr0e$1c0t$2@news.muc.de> |
| In reply to | #107867 |
olcott <polcott333@gmail.com> wrote: > On 6/26/2024 11:03 AM, Alan Mackenzie wrote: >> [ Followup-To: set ] >> In comp.theory olcott <polcott333@gmail.com> wrote: >>> On 6/26/2024 8:40 AM, Alan Mackenzie wrote: >>>> olcott <polcott333@gmail.com> wrote: >>>>> On 6/26/2024 3:10 AM, Mikko wrote: >>>> [ .... ] >>>>>> The relevant area of software engineering is testing. The usual >>>>>> attitude of software engineers is that a program is accpted when it >>>>>> has been sufficiently tested and passed all tests. Consequently, an >>>>>> important part of sofware work is the design of tests. >>>>>> In the current context the program to be tested is a halting decider. >>>>> *NO IT IS NOT. H0 IS ONLY AN X86 EMULATOR* >>>>> After you quit lying about the behavior of DDD correctly >>>>> emulated by H0 then we can move on to the next point. >>>> I think the problem is rather your calling every program or function you >>>> talk about H, or H^, or HH, or HHH, or H0, or H1. Usually, in the past, >>>> you have meant purported halting deciders by these names. Now you're >>>> saying that you mean an X86 emulator. Where and when did this change >>>> happen, and how is anybody else supposed to know what you mean by >>>> particular uses of these names? >>> When I ask people to consider the behavior of DDD >>> correctly emulated by H0 according to the semantics >>> of the x86 programming language it really does seem >>> to be the strawman deception when they try to get away >>> with saying that it must be the behavior of the directly >>> executed DDD(). >> I don't think so. People's eyes glaze over when they see yet another one >> of your posts, virtually the same as so many others, and cannot >> reasonably be expected to read and understand every last word. >> Maybe if you restricted yourself to using E... when you mean an emulator, >> and H... when you mean a purported halting decider, there would be less >> confusion. > Emulating termination analyzer H is inherently an emulator. > It really should not be that hard to pay attention to that > unless one only cares about rebuttal and thus does not care > about truth. Your posts are, in the main, tedious in the extreme. When you repeat the same thing 30 times over, you can't expect anybody to read each of the repetitions as though it were fresh and new. All the people you are debating with care about the truth. That's why they're in this group debating with you. >> Given how most people here are mathematically trained, perhaps if you >> started a typical post with "Suppose E is a code emulator ...", and other >> prerequisites there would be less confusion still. > OK that sounds like a reasonable way to avoid information overload. >>> _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] >>> It is clear that the semantics of the x86 language specifies >>> that DDD correctly emulated by H0 at machine address 0000217a >>> will continue to repeat the first four instructions of DDD >>> until out-of-memory error. >> It is not at all clear, given how murky the code at 15d2 is, and what you >> mean by "correctly emulated". > Of course I must mean jumping up and down yelling and screaming > and not be referring to anything like what an x86 emulator does. Anything "like" what an x86 emulator does is insufficiently precise. There are plenty of different functions which could appear at 15d2, some of them will return, some won't. Some of them could be called emulators, most couldn't. And the "semantics of x86" don't specify anthing beyond the meaning of x86 programs in general. >>> When we add that the outermost directly executed H0 can abort >>> its simulation as soon as the behavior of its input matches >>> the the infinite recursion behavior pattern it remains true >>> that the call from the emulated DDD to the emulated H0(DDD) >>> cannot possibly return. >> It might do. Convincing argument that this is the case (i.e. a proof) >> has not been forthcoming. > We cannot prove differential calculus to anyone not knowing > how to count to ten. Everybody else in this group knows differential calculus, and certainly how to count up to ten. They also know what a proof looks like, and how necessary it is. > That DDD correctly emulated by H0 must continue to repeat > its first four instructions is self-evident true to anyone > knowing what an x86 emulator is and having sufficient basic > knowledge of the x86 programming language. It is not self-evident. > I was very surprised to find out that one person having a PhD > in computer science said that they had hardly any experience > with programming. Why? Many architects won't have much experience of brick laying, either. > The CS courses that fulfilled the requirements for a BSCS degree > at my university had quite a bit of programming. One of the projects > for the data structures course was to write a LISP interpreter that > could do car, cdr and cons. > https://www.gnu.org/software/emacs/manual/html_node/eintr/car-cdr-_0026-cons.html I'm familiar with that page, being a member of the Emacs maintenance team. > These expressions could be arbitrarily complex. I was one of > two students out of fifty that got the project in on time. The > other one was my co-worker at the US Army Corps of engineers. > He and I got a 100% grade. >>> *That people consistently lie about this is quite annoying* >>> *yet not nearly so much when their lie is easily exposed* >> I haven't seen other people here lying. > When they say that I am wrong knowing that they do not understand > what I am saying this would be a lie. They say you are wrong because you are wrong. They do understand what you are saying, mostly, and understand that it is wrong, again mostly. > -- > Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 15:10 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5hsjs$29tg1$1@dont-email.me> |
| In reply to | #107869 |
On 6/26/2024 2:43 PM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>>
>> Emulating termination analyzer H is inherently an emulator.
>> It really should not be that hard to pay attention to that
>> unless one only cares about rebuttal and thus does not care
>> about truth.
>
> Your posts are, in the main, tedious in the extreme. When you repeat the
> same thing 30 times over, you can't expect anybody to read each of the
> repetitions as though it were fresh and new.
>
I must keep repeating them until they bother to pay attention
to the exact words that I am exactly saying because every fake
rebuttal is the strawman deception.
> All the people you are debating with care about the truth. That's why
> they're in this group debating with you.
>
It seems to me that they are only here to play the troll.
>>> Given how most people here are mathematically trained, perhaps if you
>>> started a typical post with "Suppose E is a code emulator ...", and other
>>> prerequisites there would be less confusion still.
>
>
>> OK that sounds like a reasonable way to avoid information overload.
>
>>>> _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]
>
>>>> It is clear that the semantics of the x86 language specifies
>>>> that DDD correctly emulated by H0 at machine address 0000217a
>>>> will continue to repeat the first four instructions of DDD
>>>> until out-of-memory error.
>
>>> It is not at all clear, given how murky the code at 15d2 is, and what you
>>> mean by "correctly emulated".
>
>> Of course I must mean jumping up and down yelling and screaming
>> and not be referring to anything like what an x86 emulator does.
>
> Anything "like" what an x86 emulator does is insufficiently precise.
An x86 emulator is already 100% perfectly precise if the
trolls that review my work don't think so then that proves
that they are trolls.
> There are plenty of different functions which could appear at 15d2, some
> of them will return, some won't.
Not if you know exactly what an x86 emulator is.
> Some of them could be called emulators,
> most couldn't.
Since I specify emulator changing the subject for rebuttal
is a damned lie.
> And the "semantics of x86" don't specify anthing beyond
> the meaning of x86 programs in general.
>
*That is a stupid thing to say*
The semantics of the x86 language provides 100% of all
of the details of the behavior of these two functions.
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
>>>> When we add that the outermost directly executed H0 can abort
>>>> its simulation as soon as the behavior of its input matches
>>>> the the infinite recursion behavior pattern it remains true
>>>> that the call from the emulated DDD to the emulated H0(DDD)
>>>> cannot possibly return.
>
>>> It might do. Convincing argument that this is the case (i.e. a proof)
>>> has not been forthcoming.
>
>> We cannot prove differential calculus to anyone not knowing
>> how to count to ten.
>
> Everybody else in this group knows differential calculus, and certainly
> how to count up to ten. They also know what a proof looks like, and how
> necessary it is.
>
Yet they are either mostly clueless about programming or
dishonestly pretend to be mostly clueless about programming.
>> That DDD correctly emulated by H0 must continue to repeat
>> its first four instructions is self-evident true to anyone
>> knowing what an x86 emulator is and having sufficient basic
>> knowledge of the x86 programming language.
>
> It is not self-evident.
>
To anyone that is mostly clueless about the x86 language.
>> I was very surprised to find out that one person having a PhD
>> in computer science said that they had hardly any experience
>> with programming.
>
> Why? Many architects won't have much experience of brick laying, either.
>
>> The CS courses that fulfilled the requirements for a BSCS degree
>> at my university had quite a bit of programming. One of the projects
>> for the data structures course was to write a LISP interpreter that
>> could do car, cdr and cons.
>> https://www.gnu.org/software/emacs/manual/html_node/eintr/car-cdr-_0026-cons.html
>
> I'm familiar with that page, being a member of the Emacs maintenance
> team.
>
>> These expressions could be arbitrarily complex. I was one of
>> two students out of fifty that got the project in on time. The
>> other one was my co-worker at the US Army Corps of engineers.
>> He and I got a 100% grade.
>
>>>> *That people consistently lie about this is quite annoying*
>>>> *yet not nearly so much when their lie is easily exposed*
>
>>> I haven't seen other people here lying.
>
>> When they say that I am wrong knowing that they do not understand
>> what I am saying this would be a lie.
>
> They say you are wrong because you are wrong.
_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.
They say that I am wrong about that lying in one of two
different ways (1) They don't have a clue what the code
means (2) They knowing lie about what the behavior is.
> They do understand what
> you are saying, mostly, and understand that it is wrong, again mostly.
>
>> --
>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 15:30 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure --- addendum |
| Message-ID | <v5htpj$29tg1$2@dont-email.me> |
| In reply to | #107870 |
On 6/26/2024 3:10 PM, olcott wrote:
> On 6/26/2024 2:43 PM, Alan Mackenzie wrote:
>> olcott <polcott333@gmail.com> wrote:
>>>
>>> Emulating termination analyzer H is inherently an emulator.
>>> It really should not be that hard to pay attention to that
>>> unless one only cares about rebuttal and thus does not care
>>> about truth.
>>
>> Your posts are, in the main, tedious in the extreme. When you repeat the
>> same thing 30 times over, you can't expect anybody to read each of the
>> repetitions as though it were fresh and new.
>>
>
> I must keep repeating them until they bother to pay attention
> to the exact words that I am exactly saying because every fake
> rebuttal is the strawman deception.
>
>> All the people you are debating with care about the truth. That's why
>> they're in this group debating with you.
>>
> It seems to me that they are only here to play the troll.
>
>>>> Given how most people here are mathematically trained, perhaps if you
>>>> started a typical post with "Suppose E is a code emulator ...", and
>>>> other
>>>> prerequisites there would be less confusion still.
>>
>>
>>> OK that sounds like a reasonable way to avoid information overload.
>>
>>>>> _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]
>>
>>>>> It is clear that the semantics of the x86 language specifies
>>>>> that DDD correctly emulated by H0 at machine address 0000217a
>>>>> will continue to repeat the first four instructions of DDD
>>>>> until out-of-memory error.
>>
>>>> It is not at all clear, given how murky the code at 15d2 is, and
>>>> what you
>>>> mean by "correctly emulated".
>>
>>> Of course I must mean jumping up and down yelling and screaming
>>> and not be referring to anything like what an x86 emulator does.
>>
>> Anything "like" what an x86 emulator does is insufficiently precise.
>
> An x86 emulator is already 100% perfectly precise if the
> trolls that review my work don't think so then that proves
> that they are trolls.
>
>> There are plenty of different functions which could appear at 15d2, some
>> of them will return, some won't.
>
> Not if you know exactly what an x86 emulator is.
>
>> Some of them could be called emulators,
>> most couldn't.
>
> Since I specify emulator changing the subject for rebuttal
> is a damned lie.
>
>> And the "semantics of x86" don't specify anthing beyond
>> the meaning of x86 programs in general.
>>
>
> *That is a stupid thing to say*
>
> The semantics of the x86 language provides 100% of all
> of the details of the behavior of these two functions.
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> void Infinite_Recursion()
> {
> Infinite_Recursion();
> }
>
_Infinite_Loop()
[00002162] 55 push ebp
[00002163] 8bec mov ebp,esp
[00002165] ebfe jmp 00002165
[00002167] 5d pop ebp
[00002168] c3 ret
Size in bytes:(0007) [00002168]
_Infinite_Recursion()
[00002152] 55 push ebp
[00002153] 8bec mov ebp,esp
[00002155] e8f8ffffff call 00002152
[0000215a] 5d pop ebp
[0000215b] c3 ret
Size in bytes:(0010) [0000215b]
>>>>> When we add that the outermost directly executed H0 can abort
>>>>> its simulation as soon as the behavior of its input matches
>>>>> the the infinite recursion behavior pattern it remains true
>>>>> that the call from the emulated DDD to the emulated H0(DDD)
>>>>> cannot possibly return.
>>
>>>> It might do. Convincing argument that this is the case (i.e. a proof)
>>>> has not been forthcoming.
>>
>>> We cannot prove differential calculus to anyone not knowing
>>> how to count to ten.
>>
>> Everybody else in this group knows differential calculus, and certainly
>> how to count up to ten. They also know what a proof looks like, and how
>> necessary it is.
>>
>
> Yet they are either mostly clueless about programming or
> dishonestly pretend to be mostly clueless about programming.
>
>>> That DDD correctly emulated by H0 must continue to repeat
>>> its first four instructions is self-evident true to anyone
>>> knowing what an x86 emulator is and having sufficient basic
>>> knowledge of the x86 programming language.
>>
>> It is not self-evident.
>>
>
> To anyone that is mostly clueless about the x86 language.
>
>>> I was very surprised to find out that one person having a PhD
>>> in computer science said that they had hardly any experience
>>> with programming.
>>
>> Why? Many architects won't have much experience of brick laying, either.
>>
>>> The CS courses that fulfilled the requirements for a BSCS degree
>>> at my university had quite a bit of programming. One of the projects
>>> for the data structures course was to write a LISP interpreter that
>>> could do car, cdr and cons.
>>> https://www.gnu.org/software/emacs/manual/html_node/eintr/car-cdr-_0026-cons.html
>>
>> I'm familiar with that page, being a member of the Emacs maintenance
>> team.
>>
>>> These expressions could be arbitrarily complex. I was one of
>>> two students out of fifty that got the project in on time. The
>>> other one was my co-worker at the US Army Corps of engineers.
>>> He and I got a 100% grade.
>>
>>>>> *That people consistently lie about this is quite annoying*
>>>>> *yet not nearly so much when their lie is easily exposed*
>>
>>>> I haven't seen other people here lying.
>>
>>> When they say that I am wrong knowing that they do not understand
>>> what I am saying this would be a lie.
>>
>> They say you are wrong because you are wrong.
>
> _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.
>
> They say that I am wrong about that lying in one of two
> different ways (1) They don't have a clue what the code
> means (2) They knowing lie about what the behavior is.
>
>> They do understand what
>> you are saying, mostly, and understand that it is wrong, again mostly.
>>
>>> --
>>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>>> hits a target no one else can see." Arthur Schopenhauer
>>
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 9 of 10 — ← Prev page 1 … 7 8 [9] 10 Next page →
Back to top | Article view | comp.theory
csiph-web