Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #117472 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2025-05-04 21:23 -0500 |
| Last post | 2025-05-06 22:07 -0400 |
| Articles | 20 on this page of 628 — 16 participants |
Back to article view | Back to comp.theory
Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-04 21:23 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mikko <mikko.levanto@iki.fi> - 2025-05-05 10:01 +0300
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-05 10:47 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 10:33 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-05 16:05 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 12:30 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-05 18:19 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 13:44 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-05 18:52 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 14:22 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-05 19:34 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 14:52 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-05 20:12 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 16:03 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-06 08:30 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-06 09:43 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-06 21:57 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable joes <noreply@example.org> - 2025-05-06 10:04 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-06 12:14 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-06 22:01 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mikko <mikko.levanto@iki.fi> - 2025-05-07 10:52 +0300
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-05 07:04 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-05 14:46 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-05 16:51 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-05 16:10 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-05 17:59 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-05 21:08 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 10:31 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-05 21:11 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 21:26 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-06 07:16 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-05 23:27 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-06 08:17 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-06 09:36 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Alan Mackenzie <acm@muc.de> - 2025-05-06 15:38 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-06 17:16 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Ben Bacarisse <ben@bsb.me.uk> - 2025-05-07 17:01 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 17:22 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-07 17:11 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 18:51 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 18:59 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Ben Bacarisse <ben@bsb.me.uk> - 2025-05-09 01:58 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 05:43 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 12:55 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 19:14 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-07 18:17 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 19:32 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-07 19:11 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 22:23 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 13:31 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 14:32 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 19:59 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 14:35 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 22:30 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 16:46 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 17:47 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 16:56 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 18:05 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:05 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 19:10 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:16 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 19:18 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:26 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 19:31 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:39 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 20:14 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:40 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 20:15 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 19:19 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 20:44 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 20:20 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 21:30 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 20:48 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 21:59 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 05:09 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-08 00:22 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 06:33 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-08 17:14 +0100
Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 12:00 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-08 21:04 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 14:42 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 21:01 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-08 21:35 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 23:12 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 15:26 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 15:31 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 17:47 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 16:45 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 18:53 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 17:00 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 19:14 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 21:07 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 20:33 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 22:11 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 18:54 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 05:50 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 00:01 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 06:23 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 06:52 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 10:41 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:39 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 12:50 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 09:39 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 21:02 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 19:23 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 21:28 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 21:18 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <news.x.richarddamon@xoxy.net> - 2025-05-08 23:01 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 21:22 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 23:56 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 07:00 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 06:59 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:16 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 12:52 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 09:52 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 12:57 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 09:59 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 10:47 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:48 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 13:00 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 14:46 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 21:07 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 15:15 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 17:35 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 22:40 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 17:18 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-09 18:31 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 19:34 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 01:26 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-09 20:14 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-09 19:40 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 11:13 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 22:24 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 11:43 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 23:18 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 12:32 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 23:44 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 12:51 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 00:06 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 13:13 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 00:19 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 13:27 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 00:41 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 14:00 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 01:06 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 14:19 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 09:51 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 11:01 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 17:14 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 23:14 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 10:43 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 00:00 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 11:15 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 12:18 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 00:21 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 11:44 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 12:55 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 17:34 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 18:05 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 17:07 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:30 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 08:39 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 08:37 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 08:36 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 15:16 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 08:54 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 08:53 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:53 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 23:13 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 00:18 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:25 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 08:59 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:22 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:31 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 23:21 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:34 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 09:42 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 09:09 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 22:13 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:45 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:18 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 11:24 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 17:34 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:05 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 11:18 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <news.x.richarddamon@xoxy.net> - 2025-05-09 13:59 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-10 01:23 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 19:48 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 22:20 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 21:41 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 03:59 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:06 -0400
Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] Alan Mackenzie <acm@muc.de> - 2025-05-10 10:21 +0000
Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] olcott <polcott333@gmail.com> - 2025-05-10 09:30 -0500
Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] dbush <dbush.mobile@gmail.com> - 2025-05-10 10:57 -0400
Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 16:57 +0200
Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] Richard Damon <richard@damon-family.org> - 2025-05-10 15:21 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:38 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-09 20:12 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 22:17 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:29 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 23:27 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:44 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 09:15 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 15:23 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:42 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 05:35 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 22:18 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 06:41 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 10:39 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:33 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-09 15:42 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:53 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:06 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 13:58 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:46 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:41 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:08 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 17:50 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 00:30 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 18:41 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 00:46 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 16:54 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 19:05 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 21:13 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 20:35 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 19:14 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-09 06:10 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 22:37 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 22:13 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 11:03 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 11:02 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:09 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:49 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 19:02 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 21:22 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 22:30 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Bonita Montero <Bonita.Montero@gmail.com> - 2025-05-10 14:37 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 09:33 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 16:54 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-10 23:28 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 10:45 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 00:06 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 11:19 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 12:21 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 00:29 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 11:47 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 01:01 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 12:17 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 13:19 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 02:09 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 13:17 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 14:24 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 02:37 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 13:47 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 03:02 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 14:29 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 05:44 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 17:03 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 18:39 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-10 22:55 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 19:03 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-10 23:35 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 18:57 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 09:17 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 20:26 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 02:43 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 09:44 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 20:56 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 10:09 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 21:19 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 07:03 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-11 22:34 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 10:38 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 00:28 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 12:00 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 01:21 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 12:40 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 13:44 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 02:38 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 15:19 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 16:21 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 04:23 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 15:50 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 15:53 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 17:01 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 05:48 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 17:00 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 17:05 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 06:11 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 17:30 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 06:50 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 18:08 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) wij <wyniijj5@gmail.com> - 2025-05-12 08:33 +0800
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 19:51 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 21:15 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 20:51 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 21:56 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:30 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-16 15:38 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-16 10:50 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-16 12:04 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mikko <mikko.levanto@iki.fi> - 2025-05-17 11:09 +0300
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 19:59 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOS detector olcott <polcott333@gmail.com> - 2025-05-11 19:57 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOS detector dbush <dbush.mobile@gmail.com> - 2025-05-11 21:01 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOS detector joes <noreply@example.org> - 2025-05-12 09:22 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOS detector olcott <polcott333@gmail.com> - 2025-05-12 10:58 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 19:34 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 17:06 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mikko <mikko.levanto@iki.fi> - 2025-05-12 11:03 +0300
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 10:04 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 11:06 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 11:19 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 12:41 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 11:54 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 13:07 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 12:16 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 13:30 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 12:58 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 14:19 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 13:23 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mikko <mikko.levanto@iki.fi> - 2025-05-13 13:19 +0300
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-12 21:29 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <Richard@Damon-Family.org> - 2025-05-12 23:10 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 16:25 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Ben Bacarisse <ben@bsb.me.uk> - 2025-05-12 17:46 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 12:23 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:38 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <Richard@Damon-Family.org> - 2025-05-12 23:11 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 22:12 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 21:54 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-11 11:07 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 11:37 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 16:36 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 16:13 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 19:36 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 13:20 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 18:52 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 15:32 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 15:25 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-10 18:48 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 13:56 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 15:03 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 15:33 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-10 18:58 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-10 20:07 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-10 20:17 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 15:29 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 18:58 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-11 10:34 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-11 11:48 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 12:57 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-11 12:09 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 13:12 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-11 12:17 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 13:36 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-11 12:41 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 14:58 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 10:44 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 16:49 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 16:50 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 10:14 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 16:27 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 15:26 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-10 20:45 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 15:58 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 17:01 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 19:23 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 19:04 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 21:27 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-10 20:22 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-10 15:42 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-10 16:50 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 19:27 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-11 11:13 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 11:44 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 12:52 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 12:35 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 13:43 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 13:10 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 18:11 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-12 01:38 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 19:48 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 20:58 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 20:05 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 21:07 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 21:40 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 21:11 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:39 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 21:27 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 20:56 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 21:59 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 21:14 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 22:28 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 21:36 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 22:38 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 21:46 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 22:49 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 21:56 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 22:57 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 22:00 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 23:03 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 22:36 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 23:39 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 22:50 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 23:54 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 23:11 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 07:46 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 11:32 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-12 12:45 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-12 21:27 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 13:01 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 13:05 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:44 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:42 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-12 02:25 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Ben Bacarisse <ben@bsb.me.uk> - 2025-05-12 18:03 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Ben Bacarisse <ben@bsb.me.uk> - 2025-05-12 18:05 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-12 19:13 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Ben Bacarisse <ben@bsb.me.uk> - 2025-05-13 01:18 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-13 03:38 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-12 19:06 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-13 03:17 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-12 21:32 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:59 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 12:58 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-13 03:41 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-13 09:01 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-13 18:46 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-13 16:04 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-13 18:45 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-13 20:58 -0400
How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-13 20:07 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met dbush <dbush.mobile@gmail.com> - 2025-05-13 21:19 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-13 20:40 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met dbush <dbush.mobile@gmail.com> - 2025-05-13 21:45 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-13 20:55 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met dbush <dbush.mobile@gmail.com> - 2025-05-13 21:58 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-13 21:43 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met dbush <dbush.mobile@gmail.com> - 2025-05-13 22:44 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-13 22:18 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met dbush <dbush.mobile@gmail.com> - 2025-05-13 23:35 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met joes <noreply@example.org> - 2025-05-14 08:17 +0000
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 10:06 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met joes <noreply@example.org> - 2025-05-14 18:37 +0000
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 13:42 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 19:56 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 14:02 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 20:17 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 14:21 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 20:49 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 15:00 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 21:18 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 15:25 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 21:26 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met joes <noreply@example.org> - 2025-05-14 20:28 +0000
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 15:40 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 21:54 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 21:51 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met Ben Bacarisse <ben@bsb.me.uk> - 2025-05-14 20:20 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 14:46 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met dbush <dbush.mobile@gmail.com> - 2025-05-14 17:18 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Damon <richard@damon-family.org> - 2025-05-14 21:51 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-15 00:02 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 18:17 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 18:27 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Ben Bacarisse <ben@bsb.me.uk> - 2025-05-15 01:02 +0100
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 19:09 -0500
Re: How the requirements that Professor Sipser agreed to are exactly met Richard Damon <richard@damon-family.org> - 2025-05-14 07:46 -0400
Re: How the requirements that Professor Sipser agreed to are exactly met olcott <polcott333@gmail.com> - 2025-05-14 10:23 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-11 19:54 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 17:02 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 16:15 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 19:39 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 19:29 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-11 21:31 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 21:03 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 22:05 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-12 22:49 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 12:46 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 12:48 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-13 13:16 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-11 12:26 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-11 12:34 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Alan Mackenzie <acm@muc.de> - 2025-05-11 14:38 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-11 10:26 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-11 16:38 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) dbush <dbush.mobile@gmail.com> - 2025-05-11 11:58 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 15:25 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 09:45 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:13 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 11:00 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:59 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:15 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 10:52 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 16:49 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 18:59 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 21:15 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 20:41 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 22:18 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 18:30 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 21:13 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 22:35 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-09 04:14 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 22:34 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-09 09:48 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:08 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) joes <noreply@example.org> - 2025-05-09 15:47 +0000
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:57 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:22 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 07:12 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 21:11 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 23:49 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 22:31 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 00:49 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-08 23:17 -0700
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:03 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:24 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 07:21 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 07:18 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 07:15 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 18:02 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 19:36 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 18:43 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 20:37 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 15:28 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 01:29 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 20:38 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 01:48 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 19:54 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 22:25 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 21:43 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:08 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 19:51 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 02:15 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 20:29 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 02:32 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 20:50 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 20:48 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 03:15 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 21:20 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 22:39 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 21:47 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:12 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 23:46 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 11:03 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 14:57 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-10 09:17 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:10 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 14:59 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 22:34 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 20:50 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 03:19 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 21:27 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:17 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU olcott <polcott333@gmail.com> - 2025-05-09 22:29 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU Richard Damon <richard@damon-family.org> - 2025-05-09 23:50 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU olcott <polcott333@gmail.com> - 2025-05-09 23:05 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU Richard Damon <richard@damon-family.org> - 2025-05-10 09:20 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 14:55 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 22:32 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 22:30 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 21:45 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 23:22 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 11:14 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 11:04 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:25 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 16:41 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 23:13 +0100
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 17:20 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 07:25 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:55 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:29 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 10:33 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 10:29 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:32 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 09:37 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 19:35 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 18:48 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 21:18 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-08 20:55 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-08 22:26 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 11:28 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 11:13 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:33 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-09 11:25 +0200
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) olcott <polcott333@gmail.com> - 2025-05-09 11:11 -0500
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) Richard Damon <richard@damon-family.org> - 2025-05-09 14:34 -0400
Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 09:53 +0200
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 18:45 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-08 07:21 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:41 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 22:52 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 16:59 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 23:16 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-07 22:26 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 23:29 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 18:09 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 03:24 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 21:41 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 05:12 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-07 21:33 -0700
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 23:54 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-08 06:02 +0100
Re: faithful simulations [was: Formal systems that cannot possibly be incomplete except for unknowns and unknowable] joes <noreply@example.org> - 2025-05-08 11:07 +0000
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 14:18 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 13:35 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 14:38 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 15:03 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 16:07 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 15:39 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 16:53 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 15:58 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 17:03 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 16:24 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable dbush <dbush.mobile@gmail.com> - 2025-05-07 17:29 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-07 13:03 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mikko <mikko.levanto@iki.fi> - 2025-05-08 11:38 +0300
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable olcott <polcott333@gmail.com> - 2025-05-06 12:06 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mikko <mikko.levanto@iki.fi> - 2025-05-07 11:02 +0300
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 09:19 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-06 22:04 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Mikko <mikko.levanto@iki.fi> - 2025-05-07 10:57 +0300
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Heathfield <rjh@cpax.org.uk> - 2025-05-07 09:05 +0100
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable Richard Damon <richard@damon-family.org> - 2025-05-06 07:20 -0400
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable ---ELABORATED olcott <polcott333@gmail.com> - 2025-05-06 12:46 -0500
Re: Formal systems that cannot possibly be incomplete except for unknowns and unknowable ---ELABORATED Richard Damon <richard@damon-family.org> - 2025-05-06 22:07 -0400
Page 28 of 32 — ← Prev page 1 … 26 27 [28] 29 30 … 32 Next page →
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 03:15 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmcsj$34h6g$4@dont-email.me> |
| In reply to | #118213 |
On 10/05/2025 02:48, olcott wrote: > On 5/9/2025 8:32 PM, Richard Heathfield wrote: >> On 10/05/2025 02:29, olcott wrote: >>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>> On 10/05/2025 01:51, olcott wrote: >>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>> Correctly emulating one or more instructions <is> >>>>>>> the correct emulation of 1 or more instructions >>>>>>> of DD. This is a truism. >>>>>> >>>>>> No, it's not. Correct emulation would entail accurately >>>>>> simulating the whole of DDD's behaviour. >>>>> >>>>> It is stupidly wrong to require the complete >>>>> emulation of a non-terminating input. >>>> >>>> It is touchingly naive to think you can persuade people to >>>> accept incomplete emulation as 'correct'. >>>> >>> >>> If one instruction is emulated correctly >>> then is is dishonest to say that zero >>> instructions were emulated correctly. >> >> Which instruction do you think is emulated correctly? > _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) Assumes facts not in evidence. Your HHH function is in a translation unit that contains a syntax error. You have made an extraordinary claim. Carl Sagan rightly said that extraordinary claims require extraordinary evidence. It is not sufficient to handwave your way past syntax errors and attempt to browbeat your critics. If you want to convince anyone that you're right, you have to be convincing. Calling people dishonest for challenging you is not the mark of a convincing argument. -- Richard Heathfield Email: rjh at cpax dot org dot uk "Usenet is a strange place" - dmr 29 July 1999 Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 21:20 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmd54$39lof$2@dont-email.me> |
| In reply to | #118216 |
On 5/9/2025 9:15 PM, Richard Heathfield wrote: > On 10/05/2025 02:48, olcott wrote: >> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>> On 10/05/2025 02:29, olcott wrote: >>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>> On 10/05/2025 01:51, olcott wrote: >>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>> the correct emulation of 1 or more instructions >>>>>>>> of DD. This is a truism. >>>>>>> >>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>> simulating the whole of DDD's behaviour. >>>>>> >>>>>> It is stupidly wrong to require the complete >>>>>> emulation of a non-terminating input. >>>>> >>>>> It is touchingly naive to think you can persuade people to accept >>>>> incomplete emulation as 'correct'. >>>>> >>>> >>>> If one instruction is emulated correctly >>>> then is is dishonest to say that zero >>>> instructions were emulated correctly. >>> >>> Which instruction do you think is emulated correctly? > >> _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) > > > Assumes facts not in evidence. Your HHH function is in a translation > unit that contains a syntax error. > It is a truism that when DDD is emulated by HHH according to the rules of the x86 language that the first four instructions of DDD would be emulated and then HHH would also be required to emulate itself emulating DDD. -- 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 | 2025-05-09 22:39 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <55e8616cd348689d709970345f2f012d41a9396c@i2pn2.org> |
| In reply to | #118219 |
On 5/9/25 10:20 PM, olcott wrote: > On 5/9/2025 9:15 PM, Richard Heathfield wrote: >> On 10/05/2025 02:48, olcott wrote: >>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>> On 10/05/2025 02:29, olcott wrote: >>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>> of DD. This is a truism. >>>>>>>> >>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>> simulating the whole of DDD's behaviour. >>>>>>> >>>>>>> It is stupidly wrong to require the complete >>>>>>> emulation of a non-terminating input. >>>>>> >>>>>> It is touchingly naive to think you can persuade people to accept >>>>>> incomplete emulation as 'correct'. >>>>>> >>>>> >>>>> If one instruction is emulated correctly >>>>> then is is dishonest to say that zero >>>>> instructions were emulated correctly. >>>> >>>> Which instruction do you think is emulated correctly? >> >>> _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) >> >> >> Assumes facts not in evidence. Your HHH function is in a translation >> unit that contains a syntax error. >> > > It is a truism that when DDD is emulated by HHH > according to the rules of the x86 language that > the first four instructions of DDD would be emulated > and then HHH would also be required to emulate > itself emulating DDD. > Nope, because by your definitions HHH can not correctly emulate that DDD, as it doesn't include the code for the HHH that it calls, and thus HHH can't emulate that and be a pure function. If you relax the requirement of being pure function, then I have shown a version of HHH that CAN do the operation, and thus your "truim" is just proven false. Sorry, you have been caught in your lie, and until you explain where the refutation of your claim is incorrect, you have accepted that refutation and admited you are just a liar.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 21:47 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmeoi$3a34p$4@dont-email.me> |
| In reply to | #118231 |
On 5/9/2025 9:39 PM, Richard Damon wrote: > On 5/9/25 10:20 PM, olcott wrote: >> On 5/9/2025 9:15 PM, Richard Heathfield wrote: >>> On 10/05/2025 02:48, olcott wrote: >>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>> On 10/05/2025 02:29, olcott wrote: >>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>> of DD. This is a truism. >>>>>>>>> >>>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>>> simulating the whole of DDD's behaviour. >>>>>>>> >>>>>>>> It is stupidly wrong to require the complete >>>>>>>> emulation of a non-terminating input. >>>>>>> >>>>>>> It is touchingly naive to think you can persuade people to accept >>>>>>> incomplete emulation as 'correct'. >>>>>>> >>>>>> >>>>>> If one instruction is emulated correctly >>>>>> then is is dishonest to say that zero >>>>>> instructions were emulated correctly. >>>>> >>>>> Which instruction do you think is emulated correctly? >>> >>>> _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) >>> >>> >>> Assumes facts not in evidence. Your HHH function is in a translation >>> unit that contains a syntax error. >>> >> >> It is a truism that when DDD is emulated by HHH >> according to the rules of the x86 language that >> the first four instructions of DDD would be emulated >> and then HHH would also be required to emulate >> itself emulating DDD. >> > > Nope, because by your definitions HHH can not correctly emulate that > DDD, as it doesn't include the code for the HHH that it calls, DDD are HHH are on the same memory space I told you this 50 times DDD are HHH are on the same memory space I told you this 50 times DDD are HHH are on the same memory space I told you this 50 times DDD are HHH are on the same memory space I told you this 50 times DDD are HHH are on the same memory space I told you this 50 times -- 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 | 2025-05-09 23:12 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <bf5c22eacf2617714289873ef70f39fb5c98917a@i2pn2.org> |
| In reply to | #118236 |
On 5/9/25 10:47 PM, olcott wrote: > On 5/9/2025 9:39 PM, Richard Damon wrote: >> On 5/9/25 10:20 PM, olcott wrote: >>> On 5/9/2025 9:15 PM, Richard Heathfield wrote: >>>> On 10/05/2025 02:48, olcott wrote: >>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 02:29, olcott wrote: >>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>>> of DD. This is a truism. >>>>>>>>>> >>>>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>>>> simulating the whole of DDD's behaviour. >>>>>>>>> >>>>>>>>> It is stupidly wrong to require the complete >>>>>>>>> emulation of a non-terminating input. >>>>>>>> >>>>>>>> It is touchingly naive to think you can persuade people to >>>>>>>> accept incomplete emulation as 'correct'. >>>>>>>> >>>>>>> >>>>>>> If one instruction is emulated correctly >>>>>>> then is is dishonest to say that zero >>>>>>> instructions were emulated correctly. >>>>>> >>>>>> Which instruction do you think is emulated correctly? >>>> >>>>> _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) >>>> >>>> >>>> Assumes facts not in evidence. Your HHH function is in a translation >>>> unit that contains a syntax error. >>>> >>> >>> It is a truism that when DDD is emulated by HHH >>> according to the rules of the x86 language that >>> the first four instructions of DDD would be emulated >>> and then HHH would also be required to emulate >>> itself emulating DDD. >>> >> >> Nope, because by your definitions HHH can not correctly emulate that >> DDD, as it doesn't include the code for the HHH that it calls, > > DDD are HHH are on the same memory space I told you this 50 times > DDD are HHH are on the same memory space I told you this 50 times > DDD are HHH are on the same memory space I told you this 50 times > DDD are HHH are on the same memory space I told you this 50 times > DDD are HHH are on the same memory space I told you this 50 times > But that doesn't mean that HHH is allowed to access it. I guess you are just admitting that you are just a stupid liar that doesn't know the meaning of the words he uses. If HHH needs to be a pure function, it can't access what isn't in the input, and thus you are lying that it can. If HHH doesn't need to be a pure function, I have given you a version of it that does what you says it can't, showing you are wrong. Either way, you have admitted that you are just a stupid liar.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 23:46 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmlme$3blcs$2@dont-email.me> |
| In reply to | #118247 |
On 5/9/2025 10:12 PM, Richard Damon wrote: > On 5/9/25 10:47 PM, olcott wrote: >> On 5/9/2025 9:39 PM, Richard Damon wrote: >>> On 5/9/25 10:20 PM, olcott wrote: >>>> On 5/9/2025 9:15 PM, Richard Heathfield wrote: >>>>> On 10/05/2025 02:48, olcott wrote: >>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>>>> On 10/05/2025 02:29, olcott wrote: >>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>>>> of DD. This is a truism. >>>>>>>>>>> >>>>>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>>>>> simulating the whole of DDD's behaviour. >>>>>>>>>> >>>>>>>>>> It is stupidly wrong to require the complete >>>>>>>>>> emulation of a non-terminating input. >>>>>>>>> >>>>>>>>> It is touchingly naive to think you can persuade people to >>>>>>>>> accept incomplete emulation as 'correct'. >>>>>>>>> >>>>>>>> >>>>>>>> If one instruction is emulated correctly >>>>>>>> then is is dishonest to say that zero >>>>>>>> instructions were emulated correctly. >>>>>>> >>>>>>> Which instruction do you think is emulated correctly? >>>>> >>>>>> _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) >>>>> >>>>> >>>>> Assumes facts not in evidence. Your HHH function is in a >>>>> translation unit that contains a syntax error. >>>>> >>>> >>>> It is a truism that when DDD is emulated by HHH >>>> according to the rules of the x86 language that >>>> the first four instructions of DDD would be emulated >>>> and then HHH would also be required to emulate >>>> itself emulating DDD. >>>> >>> >>> Nope, because by your definitions HHH can not correctly emulate that >>> DDD, as it doesn't include the code for the HHH that it calls, >> >> DDD are HHH are on the same memory space I told you this 50 times >> DDD are HHH are on the same memory space I told you this 50 times >> DDD are HHH are on the same memory space I told you this 50 times >> DDD are HHH are on the same memory space I told you this 50 times >> DDD are HHH are on the same memory space I told you this 50 times >> > > But that doesn't mean that HHH is allowed to access it. > Yes it does mean this. -- 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 Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 11:03 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvn8a8$3fgj2$1@dont-email.me> |
| In reply to | #118268 |
On 10/05/2025 05:46, olcott wrote: > On 5/9/2025 10:12 PM, Richard Damon wrote: >> On 5/9/25 10:47 PM, olcott wrote: >>> On 5/9/2025 9:39 PM, Richard Damon wrote: >>>> On 5/9/25 10:20 PM, olcott wrote: >>>>> On 5/9/2025 9:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 02:48, olcott wrote: >>>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 02:29, olcott wrote: >>>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>>>>> of DD. This is a truism. >>>>>>>>>>>> >>>>>>>>>>>> No, it's not. Correct emulation would entail >>>>>>>>>>>> accurately simulating the whole of DDD's behaviour. >>>>>>>>>>> >>>>>>>>>>> It is stupidly wrong to require the complete >>>>>>>>>>> emulation of a non-terminating input. >>>>>>>>>> >>>>>>>>>> It is touchingly naive to think you can persuade people >>>>>>>>>> to accept incomplete emulation as 'correct'. >>>>>>>>>> >>>>>>>>> >>>>>>>>> If one instruction is emulated correctly >>>>>>>>> then is is dishonest to say that zero >>>>>>>>> instructions were emulated correctly. >>>>>>>> >>>>>>>> Which instruction do you think is emulated correctly? >>>>>> >>>>>>> _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) >>>>>> >>>>>> >>>>>> Assumes facts not in evidence. Your HHH function is in a >>>>>> translation unit that contains a syntax error. >>>>>> >>>>> >>>>> It is a truism that when DDD is emulated by HHH >>>>> according to the rules of the x86 language that >>>>> the first four instructions of DDD would be emulated >>>>> and then HHH would also be required to emulate >>>>> itself emulating DDD. >>>>> >>>> >>>> Nope, because by your definitions HHH can not correctly >>>> emulate that DDD, as it doesn't include the code for the HHH >>>> that it calls, >>> >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> >> >> But that doesn't mean that HHH is allowed to access it. >> > > Yes it does mean this. Any competent C programmer (that /is/ your phrase, I think?) knows different. When in order to gain access to DDD your code inspects the memory at the address pointed to by ptr P (after first casting to u32), it violates a 'shall' clause. 6.6(9) reads: "An address constant is a null pointer, a pointer to an lvalue designating an object of static storage duration, or a pointer to a function designator; it shall be created explicitly using the unary & operator or an integer constant cast to pointer type, or implicitly by the use of an expression of array or function type. The array-subscript [] and member-access . and -> operators, the address & and indirection * unary operators, and pointer casts may be used in the creation of an address constant, but the value of an object shall not be accessed by use of these operators." In other words, you can't just not touch; you can't even look. 6.6(9) is not a constraint, so your compiler is not obliged to diagnose the flaw, but flaw it remains. What does that mean? 4(2) reads: "If a ‘‘shall’’ or ‘‘shall not’’ requirement that appears outside of a constraint is violated, the behavior is undefined." Putting it another way, the C language standard absolves your compiler of any responsibility for translating your code into the behaviour you intended. Putting it another nother way, you screwed up. In programming, details can get terribly tedious. Perhaps you should leave that kind of thing to people who like that kind of thing. -- Richard Heathfield Email: rjh at cpax dot org dot uk "Usenet is a strange place" - dmr 29 July 1999 Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2025-05-10 14:57 +0200 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvnig0$3hcgj$2@dont-email.me> |
| In reply to | #118268 |
Op 10.mei.2025 om 06:46 schreef olcott: > On 5/9/2025 10:12 PM, Richard Damon wrote: >> On 5/9/25 10:47 PM, olcott wrote: >>> On 5/9/2025 9:39 PM, Richard Damon wrote: >>>> On 5/9/25 10:20 PM, olcott wrote: >>>>> On 5/9/2025 9:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 02:48, olcott wrote: >>>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 02:29, olcott wrote: >>>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>>>>> of DD. This is a truism. >>>>>>>>>>>> >>>>>>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>>>>>> simulating the whole of DDD's behaviour. >>>>>>>>>>> >>>>>>>>>>> It is stupidly wrong to require the complete >>>>>>>>>>> emulation of a non-terminating input. >>>>>>>>>> >>>>>>>>>> It is touchingly naive to think you can persuade people to >>>>>>>>>> accept incomplete emulation as 'correct'. >>>>>>>>>> >>>>>>>>> >>>>>>>>> If one instruction is emulated correctly >>>>>>>>> then is is dishonest to say that zero >>>>>>>>> instructions were emulated correctly. >>>>>>>> >>>>>>>> Which instruction do you think is emulated correctly? >>>>>> >>>>>>> _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) >>>>>> >>>>>> >>>>>> Assumes facts not in evidence. Your HHH function is in a >>>>>> translation unit that contains a syntax error. >>>>>> >>>>> >>>>> It is a truism that when DDD is emulated by HHH >>>>> according to the rules of the x86 language that >>>>> the first four instructions of DDD would be emulated >>>>> and then HHH would also be required to emulate >>>>> itself emulating DDD. >>>>> >>>> >>>> Nope, because by your definitions HHH can not correctly emulate that >>>> DDD, as it doesn't include the code for the HHH that it calls, >>> >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> >> >> But that doesn't mean that HHH is allowed to access it. >> > > Yes it does mean this. > If so, the conditional abort done by HHH also belongs to the input and HHH should simulate that as well. But it does not. It ignores that very relevant part of the input, making the simulation incorrect.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-10 09:17 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <0816bf671c9d326eb905b713f7b90003d4731386@i2pn2.org> |
| In reply to | #118268 |
On 5/10/25 12:46 AM, olcott wrote: > On 5/9/2025 10:12 PM, Richard Damon wrote: >> On 5/9/25 10:47 PM, olcott wrote: >>> On 5/9/2025 9:39 PM, Richard Damon wrote: >>>> On 5/9/25 10:20 PM, olcott wrote: >>>>> On 5/9/2025 9:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 02:48, olcott wrote: >>>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 02:29, olcott wrote: >>>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>>>>> of DD. This is a truism. >>>>>>>>>>>> >>>>>>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>>>>>> simulating the whole of DDD's behaviour. >>>>>>>>>>> >>>>>>>>>>> It is stupidly wrong to require the complete >>>>>>>>>>> emulation of a non-terminating input. >>>>>>>>>> >>>>>>>>>> It is touchingly naive to think you can persuade people to >>>>>>>>>> accept incomplete emulation as 'correct'. >>>>>>>>>> >>>>>>>>> >>>>>>>>> If one instruction is emulated correctly >>>>>>>>> then is is dishonest to say that zero >>>>>>>>> instructions were emulated correctly. >>>>>>>> >>>>>>>> Which instruction do you think is emulated correctly? >>>>>> >>>>>>> _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) >>>>>> >>>>>> >>>>>> Assumes facts not in evidence. Your HHH function is in a >>>>>> translation unit that contains a syntax error. >>>>>> >>>>> >>>>> It is a truism that when DDD is emulated by HHH >>>>> according to the rules of the x86 language that >>>>> the first four instructions of DDD would be emulated >>>>> and then HHH would also be required to emulate >>>>> itself emulating DDD. >>>>> >>>> >>>> Nope, because by your definitions HHH can not correctly emulate that >>>> DDD, as it doesn't include the code for the HHH that it calls, >>> >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> DDD are HHH are on the same memory space I told you this 50 times >>> >> >> But that doesn't mean that HHH is allowed to access it. >> > > Yes it does mean this. > really? WHere do you get that from? Are you removing your restriction that HHH is a pure function? Pure functions can only get there data from their input, so if the code isn't in the input, it can't be accessed. You are just running into the fact that you whole world is built on equivocations and contradictiory definitions, and thus you can't actually see what is true,
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-09 23:10 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <3e9b2e25626aaf9c1ce680e8126b686238de7123@i2pn2.org> |
| In reply to | #118219 |
On 5/9/25 10:20 PM, olcott wrote: > On 5/9/2025 9:15 PM, Richard Heathfield wrote: >> On 10/05/2025 02:48, olcott wrote: >>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>> On 10/05/2025 02:29, olcott wrote: >>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>> of DD. This is a truism. >>>>>>>> >>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>> simulating the whole of DDD's behaviour. >>>>>>> >>>>>>> It is stupidly wrong to require the complete >>>>>>> emulation of a non-terminating input. >>>>>> >>>>>> It is touchingly naive to think you can persuade people to accept >>>>>> incomplete emulation as 'correct'. >>>>>> >>>>> >>>>> If one instruction is emulated correctly >>>>> then is is dishonest to say that zero >>>>> instructions were emulated correctly. >>>> >>>> Which instruction do you think is emulated correctly? >> >>> _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) >> >> >> Assumes facts not in evidence. Your HHH function is in a translation >> unit that contains a syntax error. >> > > It is a truism that when DDD is emulated by HHH > according to the rules of the x86 language that > the first four instructions of DDD would be emulated > and then HHH would also be required to emulate > itself emulating DDD. > Yes, but since that wasn't given as part of the input, it can't do that. You have stipulated things that force this requirement, and thus your HHH just can't exist in compliance to your own rules. Sorry, you have sunk you logic system by your own lies, equivocation and contradictions into the lake of fire that you will be joining it in.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2025-05-10 14:59 +0200 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvnika$3hcgj$3@dont-email.me> |
| In reply to | #118219 |
Op 10.mei.2025 om 04:20 schreef olcott: > On 5/9/2025 9:15 PM, Richard Heathfield wrote: >> On 10/05/2025 02:48, olcott wrote: >>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>> On 10/05/2025 02:29, olcott wrote: >>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>> of DD. This is a truism. >>>>>>>> >>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>> simulating the whole of DDD's behaviour. >>>>>>> >>>>>>> It is stupidly wrong to require the complete >>>>>>> emulation of a non-terminating input. >>>>>> >>>>>> It is touchingly naive to think you can persuade people to accept >>>>>> incomplete emulation as 'correct'. >>>>>> >>>>> >>>>> If one instruction is emulated correctly >>>>> then is is dishonest to say that zero >>>>> instructions were emulated correctly. >>>> >>>> Which instruction do you think is emulated correctly? >> >>> _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) >> >> >> Assumes facts not in evidence. Your HHH function is in a translation >> unit that contains a syntax error. >> > > It is a truism that when DDD is emulated by HHH > according to the rules of the x86 language that > the first four instructions of DDD would be emulated > and then HHH would also be required to emulate > itself emulating DDD. > Yes, and it should also simulate the conditional abort in its input, because the semantics of the x86 language does not allow to ignore it.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-09 22:34 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <edae0d09d974077c8c06ec861fe1aadff767e16f@i2pn2.org> |
| In reply to | #118213 |
On 5/9/25 9:48 PM, olcott wrote: > On 5/9/2025 8:32 PM, Richard Heathfield wrote: >> On 10/05/2025 02:29, olcott wrote: >>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>> On 10/05/2025 01:51, olcott wrote: >>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>> Correctly emulating one or more instructions <is> >>>>>>> the correct emulation of 1 or more instructions >>>>>>> of DD. This is a truism. >>>>>> >>>>>> No, it's not. Correct emulation would entail accurately simulating >>>>>> the whole of DDD's behaviour. >>>>> >>>>> It is stupidly wrong to require the complete >>>>> emulation of a non-terminating input. >>>> >>>> It is touchingly naive to think you can persuade people to accept >>>> incomplete emulation as 'correct'. >>>> >>> >>> If one instruction is emulated correctly >>> then is is dishonest to say that zero >>> instructions were emulated correctly. >> >> Which instruction do you think is emulated correctly? >> > > _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] > > The entire sequence of the first four instructions > of DDD is emulated correctly. This sequence also > includes HHH emulating itself emulating DDD. This > results in a whole other sequence of first three > instructions of DDD being correctly emulated. > No it doesn't. The correct emulation of the call HHH instruction requires that the next instruction emualated (and that it will be emulated) is the first instruciton of HHH. You just are showing your ignorance of the x86 language, or how ANY computer works. Now, for HHH to emulate that first instuction of HHH, it needs to have been given it, which it hasn't, so HHH just can't do what it needs to.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 20:50 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmbdt$35ds5$3@dont-email.me> |
| In reply to | #118210 |
On 5/9/2025 8:32 PM, Richard Heathfield wrote: > On 10/05/2025 02:29, olcott wrote: >> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>> On 10/05/2025 01:51, olcott wrote: >>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>> On 10/05/2025 00:02, olcott wrote: >>>>>> Correctly emulating one or more instructions <is> >>>>>> the correct emulation of 1 or more instructions >>>>>> of DD. This is a truism. >>>>> >>>>> No, it's not. Correct emulation would entail accurately simulating >>>>> the whole of DDD's behaviour. >>>> >>>> It is stupidly wrong to require the complete >>>> emulation of a non-terminating input. >>> >>> It is touchingly naive to think you can persuade people to accept >>> incomplete emulation as 'correct'. >>> >> >> If one instruction is emulated correctly >> then is is dishonest to say that zero >> instructions were emulated correctly. > > Which instruction do you think is emulated correctly? > _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] The entire sequence of the first four instructions of DDD is emulated correctly. This sequence also includes HHH emulating itself emulating DDD. This results in a whole other sequence of first three instructions of DDD being correctly emulated. -- 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 Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 03:19 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmd2p$34h6g$5@dont-email.me> |
| In reply to | #118214 |
On 10/05/2025 02:50, olcott wrote: > On 5/9/2025 8:32 PM, Richard Heathfield wrote: >> On 10/05/2025 02:29, olcott wrote: >>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>> On 10/05/2025 01:51, olcott wrote: >>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>> Correctly emulating one or more instructions <is> >>>>>>> the correct emulation of 1 or more instructions >>>>>>> of DD. This is a truism. >>>>>> >>>>>> No, it's not. Correct emulation would entail accurately >>>>>> simulating the whole of DDD's behaviour. >>>>> >>>>> It is stupidly wrong to require the complete >>>>> emulation of a non-terminating input. >>>> >>>> It is touchingly naive to think you can persuade people to >>>> accept incomplete emulation as 'correct'. >>>> >>> >>> If one instruction is emulated correctly >>> then is is dishonest to say that zero >>> instructions were emulated correctly. >> >> Which instruction do you think is emulated correctly? >> <snip> > The entire sequence of the first four instructions > of DDD is emulated correctly. Nope. Syntax errors don't count as correct. -- Richard Heathfield Email: rjh at cpax dot org dot uk "Usenet is a strange place" - dmr 29 July 1999 Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 21:27 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmdij$39lof$3@dont-email.me> |
| In reply to | #118218 |
On 5/9/2025 9:19 PM, Richard Heathfield wrote: > On 10/05/2025 02:50, olcott wrote: >> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>> On 10/05/2025 02:29, olcott wrote: >>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>> On 10/05/2025 01:51, olcott wrote: >>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>> the correct emulation of 1 or more instructions >>>>>>>> of DD. This is a truism. >>>>>>> >>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>> simulating the whole of DDD's behaviour. >>>>>> >>>>>> It is stupidly wrong to require the complete >>>>>> emulation of a non-terminating input. >>>>> >>>>> It is touchingly naive to think you can persuade people to accept >>>>> incomplete emulation as 'correct'. >>>>> >>>> >>>> If one instruction is emulated correctly >>>> then is is dishonest to say that zero >>>> instructions were emulated correctly. >>> >>> Which instruction do you think is emulated correctly? >>> > <snip> > >> The entire sequence of the first four instructions >> of DDD is emulated correctly. > > Nope. Syntax errors don't count as correct. > Any HHH that emulates DDD according to the rules of the x86 language must emulate the first four instructions of DDD followed by HHH emulating itself emulated DDD and then the first three instructions of DDD when seven of the instructions of DDD are correctly emulated. This is axiomatic according to the rules of the x86 language applied to the input to HHH(DDD). -- 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 | 2025-05-09 23:17 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <f6b1f6e12df4290c5dc0ec097df5c3e3950206ce@i2pn2.org> |
| In reply to | #118221 |
On 5/9/25 10:27 PM, olcott wrote: > On 5/9/2025 9:19 PM, Richard Heathfield wrote: >> On 10/05/2025 02:50, olcott wrote: >>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>> On 10/05/2025 02:29, olcott wrote: >>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>> of DD. This is a truism. >>>>>>>> >>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>> simulating the whole of DDD's behaviour. >>>>>>> >>>>>>> It is stupidly wrong to require the complete >>>>>>> emulation of a non-terminating input. >>>>>> >>>>>> It is touchingly naive to think you can persuade people to accept >>>>>> incomplete emulation as 'correct'. >>>>>> >>>>> >>>>> If one instruction is emulated correctly >>>>> then is is dishonest to say that zero >>>>> instructions were emulated correctly. >>>> >>>> Which instruction do you think is emulated correctly? >>>> >> <snip> >> >>> The entire sequence of the first four instructions >>> of DDD is emulated correctly. >> >> Nope. Syntax errors don't count as correct. >> > > Any HHH that emulates DDD according to the rules > of the x86 language must emulate the first four > instructions of DDD followed by HHH emulating > itself emulated DDD and then the first three > instructions of DDD when seven of the instructions > of DDD are correctly emulated. > > This is axiomatic according to the rules of > the x86 language applied to the input to HHH(DDD). > Nope. I have shown an HHH that just by the rules of the x86 language can correctly emulate the code of DDD that references itself. Thus, you are proven to not understand what you say, and since you just refuse to point out the errors in the errors I have pointed out in yourl lpgic, you have accepted that you are just a liar. If you try to exclude that program by the requriement of HHH needing to be a pure program, then HHH can't emulate the code of HHH withouyt it being included. And if you do that, then you next step is broken as DDD isn't a single input, but is a DDD/HHH pairing, each being different, so the DDD paired with the HHH that is a pure emulator is a different input than the DDD paired with the HHH that is the decider, which is the input given to that decider, and thus you can't use the behavior of one version to apply to the second. Your logic is just sunk by your errors.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 22:29 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU |
| Message-ID | <vvmh6p$3a34p$8@dont-email.me> |
| In reply to | #118248 |
On 5/9/2025 10:17 PM, Richard Damon wrote: > On 5/9/25 10:27 PM, olcott wrote: >> On 5/9/2025 9:19 PM, Richard Heathfield wrote: >>> On 10/05/2025 02:50, olcott wrote: >>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote: >>>>> On 10/05/2025 02:29, olcott wrote: >>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote: >>>>>>> On 10/05/2025 01:51, olcott wrote: >>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote: >>>>>>>>> On 10/05/2025 00:02, olcott wrote: >>>>>>>>>> Correctly emulating one or more instructions <is> >>>>>>>>>> the correct emulation of 1 or more instructions >>>>>>>>>> of DD. This is a truism. >>>>>>>>> >>>>>>>>> No, it's not. Correct emulation would entail accurately >>>>>>>>> simulating the whole of DDD's behaviour. >>>>>>>> >>>>>>>> It is stupidly wrong to require the complete >>>>>>>> emulation of a non-terminating input. >>>>>>> >>>>>>> It is touchingly naive to think you can persuade people to accept >>>>>>> incomplete emulation as 'correct'. >>>>>>> >>>>>> >>>>>> If one instruction is emulated correctly >>>>>> then is is dishonest to say that zero >>>>>> instructions were emulated correctly. >>>>> >>>>> Which instruction do you think is emulated correctly? >>>>> >>> <snip> >>> >>>> The entire sequence of the first four instructions >>>> of DDD is emulated correctly. >>> >>> Nope. Syntax errors don't count as correct. >>> >> >> Any HHH that emulates DDD according to the rules >> of the x86 language must emulate the first four >> instructions of DDD followed by HHH emulating >> itself emulated DDD and then the first three >> instructions of DDD when seven of the instructions >> of DDD are correctly emulated. >> >> This is axiomatic according to the rules of >> the x86 language applied to the input to HHH(DDD). >> > > Nope. > > I have shown an HHH that just by the rules of the x86 language can > correctly emulate the code of DDD that references itself. > _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] You cannot possibly show any HHH that emulates this DDD according to the rules of the x86 language such that this DDD ever reaches its "ret" instruction final halt state. -- 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 | 2025-05-09 23:50 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU |
| Message-ID | <00aee6bd8a0017ac6015563227af021a810d494b@i2pn2.org> |
| In reply to | #118251 |
On 5/9/25 11:29 PM, olcott wrote:
> On 5/9/2025 10:17 PM, Richard Damon wrote:
>> On 5/9/25 10:27 PM, olcott wrote:
>>> On 5/9/2025 9:19 PM, Richard Heathfield wrote:
>>>> On 10/05/2025 02:50, olcott wrote:
>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote:
>>>>>> On 10/05/2025 02:29, olcott wrote:
>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote:
>>>>>>>> On 10/05/2025 01:51, olcott wrote:
>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote:
>>>>>>>>>> On 10/05/2025 00:02, olcott wrote:
>>>>>>>>>>> Correctly emulating one or more instructions <is>
>>>>>>>>>>> the correct emulation of 1 or more instructions
>>>>>>>>>>> of DD. This is a truism.
>>>>>>>>>>
>>>>>>>>>> No, it's not. Correct emulation would entail accurately
>>>>>>>>>> simulating the whole of DDD's behaviour.
>>>>>>>>>
>>>>>>>>> It is stupidly wrong to require the complete
>>>>>>>>> emulation of a non-terminating input.
>>>>>>>>
>>>>>>>> It is touchingly naive to think you can persuade people to
>>>>>>>> accept incomplete emulation as 'correct'.
>>>>>>>>
>>>>>>>
>>>>>>> If one instruction is emulated correctly
>>>>>>> then is is dishonest to say that zero
>>>>>>> instructions were emulated correctly.
>>>>>>
>>>>>> Which instruction do you think is emulated correctly?
>>>>>>
>>>> <snip>
>>>>
>>>>> The entire sequence of the first four instructions
>>>>> of DDD is emulated correctly.
>>>>
>>>> Nope. Syntax errors don't count as correct.
>>>>
>>>
>>> Any HHH that emulates DDD according to the rules
>>> of the x86 language must emulate the first four
>>> instructions of DDD followed by HHH emulating
>>> itself emulated DDD and then the first three
>>> instructions of DDD when seven of the instructions
>>> of DDD are correctly emulated.
>>>
>>> This is axiomatic according to the rules of
>>> the x86 language applied to the input to HHH(DDD).
>>>
>>
>> Nope.
>>
>> I have shown an HHH that just by the rules of the x86 language can
>> correctly emulate the code of DDD that references itself.
>>
>
> _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]
>
> You cannot possibly show any HHH that emulates this
> DDD according to the rules of the x86 language such
> that this DDD ever reaches its "ret" instruction
> final halt state.
>
>
Sure I have. I guess you are just admitting you are a blantant liar.
int HHH(ptr P) {
static int flag = 0;
if (flag) return 0;
flag = 1;
/* Now put your existing code for a correct simulator that never
aborts */
Tell me why this simulator can't reach the final state of DDD when we
call HHH(DDD)
it will simulate the introduction to DDD, then go into HHH and see that
flag has been set to 1 by the initial call to HHH, and then immediately
return 0 to DDD which will then halt.
THis has been explained several time TODAY, and thus your denial is just
proof that you are just a stupid liar.
I guess you want to get the express ticket to that lake of fire.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 23:05 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU |
| Message-ID | <vvmjar$3atmt$1@dont-email.me> |
| In reply to | #118256 |
On 5/9/2025 10:50 PM, Richard Damon wrote:
> On 5/9/25 11:29 PM, olcott wrote:
>> On 5/9/2025 10:17 PM, Richard Damon wrote:
>>> On 5/9/25 10:27 PM, olcott wrote:
>>>> On 5/9/2025 9:19 PM, Richard Heathfield wrote:
>>>>> On 10/05/2025 02:50, olcott wrote:
>>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote:
>>>>>>> On 10/05/2025 02:29, olcott wrote:
>>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote:
>>>>>>>>> On 10/05/2025 01:51, olcott wrote:
>>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote:
>>>>>>>>>>> On 10/05/2025 00:02, olcott wrote:
>>>>>>>>>>>> Correctly emulating one or more instructions <is>
>>>>>>>>>>>> the correct emulation of 1 or more instructions
>>>>>>>>>>>> of DD. This is a truism.
>>>>>>>>>>>
>>>>>>>>>>> No, it's not. Correct emulation would entail accurately
>>>>>>>>>>> simulating the whole of DDD's behaviour.
>>>>>>>>>>
>>>>>>>>>> It is stupidly wrong to require the complete
>>>>>>>>>> emulation of a non-terminating input.
>>>>>>>>>
>>>>>>>>> It is touchingly naive to think you can persuade people to
>>>>>>>>> accept incomplete emulation as 'correct'.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If one instruction is emulated correctly
>>>>>>>> then is is dishonest to say that zero
>>>>>>>> instructions were emulated correctly.
>>>>>>>
>>>>>>> Which instruction do you think is emulated correctly?
>>>>>>>
>>>>> <snip>
>>>>>
>>>>>> The entire sequence of the first four instructions
>>>>>> of DDD is emulated correctly.
>>>>>
>>>>> Nope. Syntax errors don't count as correct.
>>>>>
>>>>
>>>> Any HHH that emulates DDD according to the rules
>>>> of the x86 language must emulate the first four
>>>> instructions of DDD followed by HHH emulating
>>>> itself emulated DDD and then the first three
>>>> instructions of DDD when seven of the instructions
>>>> of DDD are correctly emulated.
>>>>
>>>> This is axiomatic according to the rules of
>>>> the x86 language applied to the input to HHH(DDD).
>>>>
>>>
>>> Nope.
>>>
>>> I have shown an HHH that just by the rules of the x86 language can
>>> correctly emulate the code of DDD that references itself.
>>>
>>
>> _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]
>>
>> You cannot possibly show any HHH that emulates this
>> DDD according to the rules of the x86 language such
>> that this DDD ever reaches its "ret" instruction
>> final halt state.
>>
>>
>
> Sure I have. I guess you are just admitting you are a blantant liar.
>
> int HHH(ptr P) {
> static int flag = 0;
> if (flag) return 0;
> flag = 1;
>
> /* Now put your existing code for a correct simulator that never
> aborts */
>
>
> Tell me why this simulator can't reach the final state of DDD when we
> call HHH(DDD)
>
> it will simulate the introduction to DDD, then go into HHH and see that
> flag has been set to 1 by the initial call to HHH, and then immediately
> return 0 to DDD which will then halt.
>
> THis has been explained several time TODAY, and thus your denial is just
> proof that you are just a stupid liar.
>
> I guess you want to get the express ticket to that lake of fire.
That would work so I need to make my spec tighter.
--
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 | 2025-05-10 09:20 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) --- DOUBLE DOG DARE YOU |
| Message-ID | <0a24808a31184cd2eaf7a9a38d7dc30c853e3a5e@i2pn2.org> |
| In reply to | #118259 |
On 5/10/25 12:05 AM, olcott wrote:
> On 5/9/2025 10:50 PM, Richard Damon wrote:
>> On 5/9/25 11:29 PM, olcott wrote:
>>> On 5/9/2025 10:17 PM, Richard Damon wrote:
>>>> On 5/9/25 10:27 PM, olcott wrote:
>>>>> On 5/9/2025 9:19 PM, Richard Heathfield wrote:
>>>>>> On 10/05/2025 02:50, olcott wrote:
>>>>>>> On 5/9/2025 8:32 PM, Richard Heathfield wrote:
>>>>>>>> On 10/05/2025 02:29, olcott wrote:
>>>>>>>>> On 5/9/2025 8:15 PM, Richard Heathfield wrote:
>>>>>>>>>> On 10/05/2025 01:51, olcott wrote:
>>>>>>>>>>> On 5/9/2025 7:29 PM, Richard Heathfield wrote:
>>>>>>>>>>>> On 10/05/2025 00:02, olcott wrote:
>>>>>>>>>>>>> Correctly emulating one or more instructions <is>
>>>>>>>>>>>>> the correct emulation of 1 or more instructions
>>>>>>>>>>>>> of DD. This is a truism.
>>>>>>>>>>>>
>>>>>>>>>>>> No, it's not. Correct emulation would entail accurately
>>>>>>>>>>>> simulating the whole of DDD's behaviour.
>>>>>>>>>>>
>>>>>>>>>>> It is stupidly wrong to require the complete
>>>>>>>>>>> emulation of a non-terminating input.
>>>>>>>>>>
>>>>>>>>>> It is touchingly naive to think you can persuade people to
>>>>>>>>>> accept incomplete emulation as 'correct'.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If one instruction is emulated correctly
>>>>>>>>> then is is dishonest to say that zero
>>>>>>>>> instructions were emulated correctly.
>>>>>>>>
>>>>>>>> Which instruction do you think is emulated correctly?
>>>>>>>>
>>>>>> <snip>
>>>>>>
>>>>>>> The entire sequence of the first four instructions
>>>>>>> of DDD is emulated correctly.
>>>>>>
>>>>>> Nope. Syntax errors don't count as correct.
>>>>>>
>>>>>
>>>>> Any HHH that emulates DDD according to the rules
>>>>> of the x86 language must emulate the first four
>>>>> instructions of DDD followed by HHH emulating
>>>>> itself emulated DDD and then the first three
>>>>> instructions of DDD when seven of the instructions
>>>>> of DDD are correctly emulated.
>>>>>
>>>>> This is axiomatic according to the rules of
>>>>> the x86 language applied to the input to HHH(DDD).
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> I have shown an HHH that just by the rules of the x86 language can
>>>> correctly emulate the code of DDD that references itself.
>>>>
>>>
>>> _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]
>>>
>>> You cannot possibly show any HHH that emulates this
>>> DDD according to the rules of the x86 language such
>>> that this DDD ever reaches its "ret" instruction
>>> final halt state.
>>>
>>>
>>
>> Sure I have. I guess you are just admitting you are a blantant liar.
>>
>> int HHH(ptr P) {
>> static int flag = 0;
>> if (flag) return 0;
>> flag = 1;
>>
>> /* Now put your existing code for a correct simulator that never
>> aborts */
>>
>>
>> Tell me why this simulator can't reach the final state of DDD when we
>> call HHH(DDD)
>>
>> it will simulate the introduction to DDD, then go into HHH and see
>> that flag has been set to 1 by the initial call to HHH, and then
>> immediately return 0 to DDD which will then halt.
>>
>> THis has been explained several time TODAY, and thus your denial is
>> just proof that you are just a stupid liar.
>>
>> I guess you want to get the express ticket to that lake of fire.
>
> That would work so I need to make my spec tighter.
>
The problem is you really don't get to "define" the specifications, only
your interpretations, and if they are compatible with the actual ones
you are just wrong.
You have a bit of flexability, as you only need to be Turing Compatible,
but that is part of the problem, you don't understand what that means,
and your system is fundamentally not that to the problem.
[toc] | [prev] | [next] | [standalone]
Page 28 of 32 — ← Prev page 1 … 26 27 [28] 29 30 … 32 Next page →
Back to top | Article view | comp.theory
csiph-web