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 10 of 32 — ← Prev page 1 … 8 9 [10] 11 12 … 32 Next page →
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2025-05-10 10:18 +0200 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvn25i$3dv8d$4@dont-email.me> |
| In reply to | #118240 |
Op 10.mei.2025 om 05:13 schreef olcott:
> On 5/9/2025 9:40 PM, Keith Thompson wrote:
>> olcott <polcott333@gmail.com> writes:
>>> On 5/9/2025 4:40 PM, Richard Heathfield wrote:
>>>> On 09/05/2025 21:15, olcott wrote:
>>>>> On 5/9/2025 3:07 PM, Richard Heathfield wrote:
>>>>>> On 09/05/2025 20:46, olcott wrote:
>>>>>>> We have not begun to get into any of those points.
>>>>>>> We are only asking can DDD correctly simulated
>>>>>>> by any HHH that can exist ever reach its own
>>>>>>> "return" instruction.
>>>>>>
>>>>>> DDD can't be correctly simulated by itself (which is effectively
>>>>>> what you're trying to do when you fire up the simulation from
>>>>>> inside DDD).
>>>>>
>>>>> How the Hell did you twist my words to say that?
>>>> I haven't touched your words. What I have done is to observe that
>>>> DDD's /only/ action is to call a simulator. Since DDD isn't itself a
>>>> simulator, there is nothing to simulate except a call to a
>>>> simulator.
>>>> It's recursion without a base case - a rookie error.
>>>> HHH cannot successfully complete its task, because it never regains
>>>> control after the first recursion. To return, it must abort the
>>>> simulation, which means the simulation fails.
>>>>
>>>>> void DDD()
>>>>> {
>>>>> HHH(DDD);
>>>>> return;
>>>>> }
>>>>>
>>>>> When 1 or more statements of DDD are correctly
>>>>> simulated by HHH then this correctly simulated
>>>>> DDD cannot possibly reach its own “return statement”.
>>>> On what grounds can you persuade an extraordinarily sceptical
>>>> readership that HHH 'correctly simulated' DDD?
>>>
>>> Any competent C programmer can see that
>>> the call from DDD to HHH(DDD) (its own simulator)
>>> is equivalent to infinite recursion.
>>>
>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>>>> Assuming that HHH(DDD) "correctly simulates" DDD, and assuming it
>>>> does nothing else, your code would be equivalent to this:
>>>>
>>>> void DDD(void) {
>>>> DDD();
>>>> return;
>>>> }
>>>>
>>>> Then the return statement (which is unnecessary anyway) will never be
>>>> reached. In practice, the program will likely crash due to a stack
>>>> overflow, unless the compiler implements tail-call optimization, in
>>>> which case the program might just run forever -- which also means the
>>>> unnecessary return statement will never be reached.
>>
>> I had not intended to post again, but I feel the need to make
>> a clarification.
>>
>> I acknowledged that the return statement would never be reached
>> *given the assumption* that HHH correctly simulates DDD. Given
>> that assumption, a call to DDD() should be equivalent to a call
>> to HHH(DDD).
>>
>
> Yes and then I moved on the next tiny incremental> step of my proof. Correctly simulated less than
> an infinite number of instructions does not help
> the simulated DDD to reach its "return statement"
> final halt state.
The word 'tiny' is misleading. It is a fundamental change. Now HHH does
no longer do a correct simulation, because it ignores the input part of
the input that specifies that HHH simulates only a *finite* number of steps.
>
>> I did not address whether the assumption is valid. I merely
>> temporarily accepted it for the sake of discussion, just as I would
>> accept that if I were ten feet tall I would bump my head against
>> the ceiling in my house.
>>
>> The discussion I had with olcott did not reach the point of
>> discussing *how* HHH could correctly simulate DDD, or whether it
>> would even be logically possible for it to do so.
>
> Right this takes a glimmering of understanding of
> the x86 language. The x86 language it needed to
> get an exactly precise understanding of the control
> flow of DDD as directed graph state transition
> diagram.
Yes and it takes into account that the input contains x86 instruction to
abort and halt.
>
>> I also did not
>> address any issues of partial simulation, where olcott claims that
>> HHH can "accurately simulate" only a few x86 instructions rather
>> than simulating its entire execution.
>
>> I did not participate in
>> any discussion that would require knowledge of x86 machine or
>> assembly code. (I have no doubt that I could learn x86 machine
>> and assembly code reasonably well if motivated to do so, but I am
>> not so motivated.)
>>
>> What I acknowledged was barely more than "if HHH correctly simulates
>> DDD, then HHH correctly simulates DDD".
>
> No much more than this you acknowledged that
> when DDD is correctly simulated by HHH that
> the simulated DDD cannot possibly reach its
> own "return statement" (final halt state)
But when that HHH ignores an important part of its input, it is no
longer correct.
>
> This is very important to computer science because
> non-termination is entirely measured by the impossibility
> of reaching a final halt state.
>
> From all of the we know that when HHH(DDD) reports
> on the behavior of its correct simulation of its input
> that it can correctly reject this input as not
> specifying a sequence of configurations that halts.
It can only report that it aborted the simulation prematurely, without
analysing the full input.
[toc] | [prev] | [next] | [standalone]
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 11:24 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvn9gu$3fn79$1@dont-email.me> |
| In reply to | #118289 |
On 10/05/2025 09:18, Fred. Zwarts wrote: > Op 10.mei.2025 om 05:13 schreef olcott: >> On 5/9/2025 9:40 PM, Keith Thompson wrote: <snip> >>> I had not intended to post again, but I feel the need to make >>> a clarification. >>> >>> I acknowledged that the return statement would never be reached >>> *given the assumption* that HHH correctly simulates DDD. Given >>> that assumption, a call to DDD() should be equivalent to a call >>> to HHH(DDD). >>> >> >> Yes and then I moved on the next tiny incremental> step of my >> proof. Correctly simulated less than >> an infinite number of instructions does not help >> the simulated DDD to reach its "return statement" >> final halt state. > > The word 'tiny' is misleading. It is a fundamental change. Now > HHH does no longer do a correct simulation, because it ignores > the input part of the input that specifies that HHH simulates > only a *finite* number of steps. HHH is /required/ to ignore its input. It can /call/ DDD, but it mustn't inspect it. When it does so, it violates a 'shall' outside of a constraint. <snip> -- 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-09 17:34 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <48a0de4e95a7d464a52b24dd17f995a32fd9a44a@i2pn2.org> |
| In reply to | #118184 |
On 5/9/25 3:46 PM, olcott wrote:
> On 5/9/2025 12:00 PM, Richard Damon wrote:
>> On 5/9/25 11:48 AM, olcott wrote:
>>> On 5/9/2025 3:47 AM, Fred. Zwarts wrote:
>>>> Op 09.mei.2025 om 04:23 schreef Keith Thompson:
>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>> [...]
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> HHH(DDD);
>>>>>>> return;
>>>>>>> }
>>>>>>> We don't need to look at any of my code for me
>>>>>>> to totally prove my point. For example when
>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>> "return" instruction.
>>>>>>
>>>>>> And thus not correctly simulatd.
>>>>>>
>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>
>>>>> Perhaps I've missed something. I don't see anything in the above that
>>>>> implies that HHH does not correctly simulate DDD. Richard, you've
>>>>> read
>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>
>>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>>> equivalent to:
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> DDD();
>>>>> return;
>>>>> }
>>>>>
>>>>> which is a trivial case of infinite recursion. As far as I can tell,
>>>>> assuming that DDD() is actually called at some point, neither the
>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>> can reach the return statement. Infinite recursion might either
>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>> loop if the compiler implements tail call optimization.
>>>>>
>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>> recursion, something that's well understood by anyone with a
>>>>> reasonable level of programming experience. (And it has nothing to
>>>>> do with the halting problem as far as I can tell, though of course
>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>
>>>>> Richard, what am I missing?
>>>>>
>>>>
>>>> What you are missing is that the next step of olcott is to say that
>>>> when he uses the 'exact same HHH, with only some extra code to abort
>>>> the simulation', it is still an infinite recursion. He does not
>>>> understand that adding the abort code makes the behaviour
>>>> fundamentally different.
>>>
>>> When 1 or more statements of DDD are correctly simulated
>>> by HHH this correctly simulated DDD cannot possibly reach
>>> its own "return statement" final halt state.
>>
>>
>> But HHH can not correctly emulate this input (the code of just DDD)
>> past the call instruction and remain a pure function, as it hasn't
>> been given that code.
>>
>
> We have not begun to get into any of those points.
> We are only asking can DDD correctly simulated
> by any HHH that can exist ever reach its own
> "return" instruction.
>
>
But the rules still apply.
AN emulator can not emulate what it isn't given.
So, until you include the code for HHH is the actual input, you can't
correctdly siulate the call HHH instruction.
Thus, your argument fails on a category error, as your input is just no
correctly simulatable.
And you are proving you are just ignorant of what you are talking about,
as you don't know how to do what you are talking about.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2025-05-10 10:05 +0200 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvn1cd$3dv8d$3@dont-email.me> |
| In reply to | #118148 |
Op 09.mei.2025 om 17:48 schreef olcott:
> On 5/9/2025 3:47 AM, Fred. Zwarts wrote:
>> Op 09.mei.2025 om 04:23 schreef Keith Thompson:
>>> Richard Damon <richard@damon-family.org> writes:
>>>> On 5/8/25 7:53 PM, olcott wrote:
>>> [...]
>>>>> void DDD()
>>>>> {
>>>>> HHH(DDD);
>>>>> return;
>>>>> }
>>>>> We don't need to look at any of my code for me
>>>>> to totally prove my point. For example when
>>>>> the above DDD is correctly simulated by HHH
>>>>> this simulated DDD cannot possibly reach its own
>>>>> "return" instruction.
>>>>
>>>> And thus not correctly simulatd.
>>>>
>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>
>>> Perhaps I've missed something. I don't see anything in the above that
>>> implies that HHH does not correctly simulate DDD. Richard, you've read
>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>
>>> If we assume that HHH correctly simulates DDD, then the above code is
>>> equivalent to:
>>>
>>> void DDD()
>>> {
>>> DDD();
>>> return;
>>> }
>>>
>>> which is a trivial case of infinite recursion. As far as I can tell,
>>> assuming that DDD() is actually called at some point, neither the
>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>> can reach the return statement. Infinite recursion might either
>>> cause a stack overflow and a probable program crash, or an unending
>>> loop if the compiler implements tail call optimization.
>>>
>>> I see no contradiction, just an uninteresting case of infinite
>>> recursion, something that's well understood by anyone with a
>>> reasonable level of programming experience. (And it has nothing to
>>> do with the halting problem as far as I can tell, though of course
>>> olcott has discussed the halting problem elsewhere.)
>>>
>>> Richard, what am I missing?
>>>
>>
>> What you are missing is that the next step of olcott is to say that
>> when he uses the 'exact same HHH, with only some extra code to abort
>> the simulation', it is still an infinite recursion. He does not
>> understand that adding the abort code makes the behaviour
>> fundamentally different.
>
> When 1 or more statements of DDD are correctly simulated
> by HHH this correctly simulated DDD cannot possibly reach
> its own "return statement" final halt state.
>
You see? Exactly what I predicted. Now he uses another HHH that does not
correctly simulate the whole input, but only makes a start. He will
still hold his claim that there is an infinite recursion and may quote a
C expert, Keith Thompson, to support his claim. The only way out is that
Keith Thompson explicitly explains that his example only holds for the
simulator that does not stop after 1 or more statements.
[toc] | [prev] | [next] | [standalone]
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 11:18 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvn969$3fgj2$3@dont-email.me> |
| In reply to | #118288 |
On 10/05/2025 09:05, Fred. Zwarts wrote: > Op 09.mei.2025 om 17:48 schreef olcott: <snip> >> When 1 or more statements of DDD are correctly simulated >> by HHH this correctly simulated DDD cannot possibly reach >> its own "return statement" final halt state. >> > You see? Exactly what I predicted. Now he uses another HHH that > does not correctly simulate the whole input, but only makes a > start. He will still hold his claim that there is an infinite > recursion and may quote a C expert, Keith Thompson, to support > his claim. The only way out is that Keith Thompson explicitly > explains that his example only holds for the simulator that does > not stop after 1 or more statements. Keith has already clarified that his reply applies only on the assumption that HHH(DDD) simulates DDD correctly, and is tantamount to saying that if X is true then X is true. X, of course, is not true. -- 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 | Richard Damon <news.x.richarddamon@xoxy.net> |
|---|---|
| Date | 2025-05-09 13:59 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlhrl$2vfvk$1@dont-email.me> |
| In reply to | #118089 |
On 5/8/25 10:23 PM, Keith Thompson wrote:
> Richard Damon <richard@damon-family.org> writes:
>> On 5/8/25 7:53 PM, olcott wrote:
> [...]
>>> void DDD()
>>> {
>>> HHH(DDD);
>>> return;
>>> }
>>> We don't need to look at any of my code for me
>>> to totally prove my point. For example when
>>> the above DDD is correctly simulated by HHH
>>> this simulated DDD cannot possibly reach its own
>>> "return" instruction.
>>
>> And thus not correctly simulatd.
>>
>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>
> Perhaps I've missed something. I don't see anything in the above that
> implies that HHH does not correctly simulate DDD. Richard, you've read
> far more of olcott's posts than I have, so perhaps you can clarify.
>
> If we assume that HHH correctly simulates DDD, then the above code is
> equivalent to:
>
> void DDD()
> {
> DDD();
> return;
> }
>
> which is a trivial case of infinite recursion. As far as I can tell,
> assuming that DDD() is actually called at some point, neither the
> outer execution of DDD nor the nested (simulated) execution of DDD
> can reach the return statement. Infinite recursion might either
> cause a stack overflow and a probable program crash, or an unending
> loop if the compiler implements tail call optimization.
>
> I see no contradiction, just an uninteresting case of infinite
> recursion, something that's well understood by anyone with a
> reasonable level of programming experience. (And it has nothing to
> do with the halting problem as far as I can tell, though of course
> olcott has discussed the halting problem elsewhere.)
>
> Richard, what am I missing?
>
You are missing the equivocation he is using on what is "DDD()"
First, he tries to define it as just the code of the function, and not
including any of the code that it calls. He does this so all the various
HHH that he talks about are given the "same" input.
Then he tries to also say that when those functions look at DDD, they
can follow the memory chain to the functions that it calls, that weren't
actually part of the input.
This means the "behavior" of his input isn't actually defined by the input.
He has also, to get around other objections about what he is doing,
stipulated that his functions must be pure functions, and thus only
dependent on their direct input, other wise we can add the following
code to the beginning of HHH to make his statement false:
int HHH(void (*p)()) {
static int flag = 0;
if (flag) return 0;
flag = 1;
/* then the rest of the code that he uses to simulate the input */
Such an HHH obviously can "correctly simulate" a call to itself in the
same memory space to the return of DDD.
But, since HHH has been stipulated to be a pure function, it can't
access memory that wasn't part of its input, and thus his first
definition can't be used, and when we use the second definiton, it is
clear that each of his HHH's get different input, so is ploy to show
that the HHH that does correctly emulate the input which show that "the"
DDD is non-halting also shows that the HHH that does abort, and was
given the "same" input can also conclude that.
Of course, different inputs can behavie differently and thus he is just
using his projection that HHH(DDD) is just like the sum(2,3) that
returned 7 as the sum of 2 + 5 since it "changed" the input to something
it wasn't.
His goal is to ge this "fact" agreed to in the abstract case, so he can
claim it must also be true
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2025-05-10 01:23 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvm69v$34ivd$1@dont-email.me> |
| In reply to | #118089 |
On 09/05/2025 03:23, Keith Thompson wrote:
> Richard Damon <richard@damon-family.org> writes:
>> On 5/8/25 7:53 PM, olcott wrote:
> [...]
>>> void DDD()
>>> {
>>> HHH(DDD);
>>> return;
>>> }
>>> We don't need to look at any of my code for me
>>> to totally prove my point. For example when
>>> the above DDD is correctly simulated by HHH
>>> this simulated DDD cannot possibly reach its own
>>> "return" instruction.
>>
>> And thus not correctly simulatd.
>>
>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>
> Perhaps I've missed something. I don't see anything in the above that
> implies that HHH does not correctly simulate DDD. Richard, you've read
> far more of olcott's posts than I have, so perhaps you can clarify.
>
> If we assume that HHH correctly simulates DDD, then the above code is
> equivalent to:
>
> void DDD()
> {
> DDD();
> return;
> }
>
> which is a trivial case of infinite recursion. As far as I can tell,
> assuming that DDD() is actually called at some point, neither the
> outer execution of DDD nor the nested (simulated) execution of DDD
> can reach the return statement. Infinite recursion might either
> cause a stack overflow and a probable program crash, or an unending
> loop if the compiler implements tail call optimization.
>
> I see no contradiction, just an uninteresting case of infinite
> recursion, something that's well understood by anyone with a
> reasonable level of programming experience. (And it has nothing to
> do with the halting problem as far as I can tell, though of course
> olcott has discussed the halting problem elsewhere.)
>
> Richard, what am I missing?
>
Depends on what you've picked up on.
Do you get that HHH's simulation is a /partial/ simulation? HHH is free to simulate a few x86
instructions of DDD, and then simply abandon the simulation and return. Since such a simulation is
obviously NOT equivalent to a direct call to DDD, and above you argue that it is, I'd say you've
missed that.
The other thing to be aware of is that use of terminology "simulation" varies considerably between
posters! This in turn affects what different posters consider a "correct" simulation.
Full vs Partial:
(Posters differ on which type is intended if not explicitly qualified full/partial)
a) Full: the simulation continues until the target computation halts (returns).
This is logically like a direct call, because control cannot break out of
the simulation until the target halts. (Same as a direct call)
b) Partial: the simulator can choose to abandon the simulation at any point.
This is logically distinct from a direct call, because control to exit
remains firmly with the simulator.
Scope includes a halt decision? :
c) No: A "correct" simulation means the correct x86 instruction simulations, in
the correct sequence, correctly updating the x86 VM state (memory/regs)
as each instruction is simulated. [Also for someone in camp (a), a
simulation abandoned simulation is not correct]
d) Yes: As (c), but the simulation is required to decide halts/nothalts as part of
the simulation. For a (c) poster, the simulator simulates instructions,
and the Halt Decider logic decides halt/nothalt.
PO is a (b)(c) guy. Since his HHH (more or less) simulates individual instructions correctly, PO
claims HHH "correctly" simulates DDD. Others who are in (a) or (d) camps would say that HHH does
not correctly simulate DDD, because either HHH performs a /partial/ simulation [for them an error in
its own right] or because HHH decides nothalt when in fact PO's DDD halts.
Terminology usage is not a right/wrong issue, but the different possibilities maximise
misunderstandings if not resolved. E.g. as I said PO's simulations are nearly always taken to be
partial. Richard D. knows that, but as he is in (b) camp he points out that PO is lying every time
he says "HHH correctly simulates DDD". PO then says RD is playing head games and challenges RD to
point out an error, and so it goes on for hundreds of posts. To be fair, PO should be well aware
that RD is in camp (a), but does nothing to resolve the terminology issue, so both posters get what
they deserve!
FTR I am in the (b)(c) camp... I could explain why I think that's more logical, but that's going OT
I think.
Other posters have suggested that what you're missing is some variation of "once you answer PO's
current question (about whether the simulation by HHH progresses as far as DDD's return) PO will go
on to do something else wrong". Well, of course he will, but that's hardly something you're missing
if he's not done it yet! :) I'd also say it's no reason not to answer PO's question honestly,
acknowledging that he is talking about /partial/ simulations... The time to challenge future
mistakes he will go on to make, is when he makes them.
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 19:48 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvm7o3$34mm4$1@dont-email.me> |
| In reply to | #118196 |
On 5/9/2025 7:23 PM, Mike Terry wrote:
> On 09/05/2025 03:23, Keith Thompson wrote:
>> Richard Damon <richard@damon-family.org> writes:
>>> On 5/8/25 7:53 PM, olcott wrote:
>> [...]
>>>> void DDD()
>>>> {
>>>> HHH(DDD);
>>>> return;
>>>> }
>>>> We don't need to look at any of my code for me
>>>> to totally prove my point. For example when
>>>> the above DDD is correctly simulated by HHH
>>>> this simulated DDD cannot possibly reach its own
>>>> "return" instruction.
>>>
>>> And thus not correctly simulatd.
>>>
>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>
>> Perhaps I've missed something. I don't see anything in the above that
>> implies that HHH does not correctly simulate DDD. Richard, you've read
>> far more of olcott's posts than I have, so perhaps you can clarify.
>>
>> If we assume that HHH correctly simulates DDD, then the above code is
>> equivalent to:
>>
>> void DDD()
>> {
>> DDD();
>> return;
>> }
>>
>> which is a trivial case of infinite recursion. As far as I can tell,
>> assuming that DDD() is actually called at some point, neither the
>> outer execution of DDD nor the nested (simulated) execution of DDD
>> can reach the return statement. Infinite recursion might either
>> cause a stack overflow and a probable program crash, or an unending
>> loop if the compiler implements tail call optimization.
>>
>> I see no contradiction, just an uninteresting case of infinite
>> recursion, something that's well understood by anyone with a
>> reasonable level of programming experience. (And it has nothing to
>> do with the halting problem as far as I can tell, though of course
>> olcott has discussed the halting problem elsewhere.)
>>
>> Richard, what am I missing?
>>
>
> Depends on what you've picked up on.
>
> Do you get that HHH's simulation is a /partial/ simulation? HHH is free
That was not in the specification that he responded to.
Thus within this specification DDD correctly simulated
by HHH cannot possibly reach its final halt state in an
infinite number of steps.
If an infinite number steps steps is insufficient
then how can less an infinite steps possibly help?
> to simulate a few x86 instructions of DDD, and then simply abandon the
> simulation and return. Since such a simulation is obviously NOT
> equivalent to a direct call to DDD, and above you argue that it is, I'd
> say you've missed that.
>
> The other thing to be aware of is that use of terminology "simulation"
> varies considerably between posters! This in turn affects what
> different posters consider a "correct" simulation.
>
<snip>
>
> PO is a (b)(c) guy. Since his HHH (more or less) simulates individual
> instructions correctly, PO claims HHH "correctly" simulates DDD. Others
> who are in (a) or (d) camps would say that HHH does not correctly
> simulate DDD, because either HHH performs a /partial/ simulation [for
> them an error in its own right] or because HHH decides nothalt when in
> fact PO's DDD halts.
>
_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]
Try to show how DDD simulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final state and you already know that
you will fail. You dodge this question so that
you can remain disagreeable.
> Terminology usage is not a right/wrong issue, but the different
> possibilities maximise misunderstandings if not resolved. E.g. as I
> said PO's simulations are nearly always taken to be partial. Richard D.
> knows that, but as he is in (b) camp he points out that PO is lying
> every time he says "HHH correctly simulates DDD". PO then says RD is
> playing head games and challenges RD to point out an error, and so it
> goes on for hundreds of posts. To be fair, PO should be well aware that
> RD is in camp (a), but does nothing to resolve the terminology issue, so
> both posters get what they deserve!
>
I resolved the terminology issue long ago and
you and everyone else ignores this so that you
can remain disagreeable.
When one or more instructions of DDD are emulated
by HHH according to the rules of the x86 language
this emulated DDD cannot possibly reach its own
final halt state because it calls HHH(DDD) in
recursive emulation.
> FTR I am in the (b)(c) camp... I could explain why I think that's more
> logical, but that's going OT I think.
>
> Other posters have suggested that what you're missing is some variation
> of "once you answer PO's current question (about whether the simulation
> by HHH progresses as far as DDD's return) PO will go on to do something
> else wrong".
> Well, of course he will, but that's hardly something
> you're missing if he's not done it yet! :) I'd also say it's no reason
> not to answer PO's question honestly, acknowledging that he is talking
> about /partial/ simulations... The time to challenge future mistakes he
> will go on to make, is when he makes them.
>
>
> Mike.
>
--
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:20 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <fd7bd4fb8797300a4a3982bbafd7f9decaee2c77@i2pn2.org> |
| In reply to | #118201 |
On 5/9/25 8:48 PM, olcott wrote:
> On 5/9/2025 7:23 PM, Mike Terry wrote:
>> On 09/05/2025 03:23, Keith Thompson wrote:
>>> Richard Damon <richard@damon-family.org> writes:
>>>> On 5/8/25 7:53 PM, olcott wrote:
>>> [...]
>>>>> void DDD()
>>>>> {
>>>>> HHH(DDD);
>>>>> return;
>>>>> }
>>>>> We don't need to look at any of my code for me
>>>>> to totally prove my point. For example when
>>>>> the above DDD is correctly simulated by HHH
>>>>> this simulated DDD cannot possibly reach its own
>>>>> "return" instruction.
>>>>
>>>> And thus not correctly simulatd.
>>>>
>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>
>>> Perhaps I've missed something. I don't see anything in the above that
>>> implies that HHH does not correctly simulate DDD. Richard, you've read
>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>
>>> If we assume that HHH correctly simulates DDD, then the above code is
>>> equivalent to:
>>>
>>> void DDD()
>>> {
>>> DDD();
>>> return;
>>> }
>>>
>>> which is a trivial case of infinite recursion. As far as I can tell,
>>> assuming that DDD() is actually called at some point, neither the
>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>> can reach the return statement. Infinite recursion might either
>>> cause a stack overflow and a probable program crash, or an unending
>>> loop if the compiler implements tail call optimization.
>>>
>>> I see no contradiction, just an uninteresting case of infinite
>>> recursion, something that's well understood by anyone with a
>>> reasonable level of programming experience. (And it has nothing to
>>> do with the halting problem as far as I can tell, though of course
>>> olcott has discussed the halting problem elsewhere.)
>>>
>>> Richard, what am I missing?
>>>
>>
>> Depends on what you've picked up on.
>>
>> Do you get that HHH's simulation is a /partial/ simulation? HHH is free
>
> That was not in the specification that he responded to.
> Thus within this specification DDD correctly simulated
> by HHH cannot possibly reach its final halt state in an
> infinite number of steps.
Excpet that no HHH CAN correct emulate the DDD that you give it, as the
input for DDD just isn't a complete program, and thus the attempt to
simulate hits a category error of using undefined (to the input) memory.
>
> If an infinite number steps steps is insufficient
> then how can less an infinite steps possibly help?
But you HHH can't do an infinite number of steps, as by your definition
of the input, it can't go beyond the call to HHH, as the code to emulate
wasn't given.
>
>> to simulate a few x86 instructions of DDD, and then simply abandon the
>> simulation and return. Since such a simulation is obviously NOT
>> equivalent to a direct call to DDD, and above you argue that it is,
>> I'd say you've missed that.
>>
>> The other thing to be aware of is that use of terminology "simulation"
>> varies considerably between posters! This in turn affects what
>> different posters consider a "correct" simulation.
>>
>
> <snip>
>
>>
>> PO is a (b)(c) guy. Since his HHH (more or less) simulates individual
>> instructions correctly, PO claims HHH "correctly" simulates DDD.
>> Others who are in (a) or (d) camps would say that HHH does not
>> correctly simulate DDD, because either HHH performs a /partial/
>> simulation [for them an error in its own right] or because HHH decides
>> nothalt when in fact PO's DDD halts.
>>
>
> _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]
>
> Try to show how DDD simulated by HHH according to the
> rules of the x86 language reaches its own "ret"
> instruction final state and you already know that
> you will fail. You dodge this question so that
> you can remain disagreeable.
>
>> Terminology usage is not a right/wrong issue, but the different
>> possibilities maximise misunderstandings if not resolved. E.g. as I
>> said PO's simulations are nearly always taken to be partial. Richard
>> D. knows that, but as he is in (b) camp he points out that PO is lying
>> every time he says "HHH correctly simulates DDD". PO then says RD is
>> playing head games and challenges RD to point out an error, and so it
>> goes on for hundreds of posts. To be fair, PO should be well aware
>> that RD is in camp (a), but does nothing to resolve the terminology
>> issue, so both posters get what they deserve!
>>
>
> I resolved the terminology issue long ago and
> you and everyone else ignores this so that you
> can remain disagreeable.
>
> When one or more instructions of DDD are emulated
> by HHH according to the rules of the x86 language
> this emulated DDD cannot possibly reach its own
> final halt state because it calls HHH(DDD) in
> recursive emulation.
>
>> FTR I am in the (b)(c) camp... I could explain why I think that's
>> more logical, but that's going OT I think.
>>
>> Other posters have suggested that what you're missing is some
>> variation of "once you answer PO's current question (about whether the
>> simulation by HHH progresses as far as DDD's return) PO will go on to
>> do something else wrong". Well, of course he will, but that's hardly
>> something you're missing if he's not done it yet! :) I'd also say
>> it's no reason not to answer PO's question honestly, acknowledging
>> that he is talking about /partial/ simulations... The time to
>> challenge future mistakes he will go on to make, is when he makes them.
>>
>>
>> Mike.
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 21:41 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmece$3a34p$1@dont-email.me> |
| In reply to | #118226 |
On 5/9/2025 9:20 PM, Richard Damon wrote:
> On 5/9/25 8:48 PM, olcott wrote:
>> On 5/9/2025 7:23 PM, Mike Terry wrote:
>>> On 09/05/2025 03:23, Keith Thompson wrote:
>>>> Richard Damon <richard@damon-family.org> writes:
>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>> [...]
>>>>>> void DDD()
>>>>>> {
>>>>>> HHH(DDD);
>>>>>> return;
>>>>>> }
>>>>>> We don't need to look at any of my code for me
>>>>>> to totally prove my point. For example when
>>>>>> the above DDD is correctly simulated by HHH
>>>>>> this simulated DDD cannot possibly reach its own
>>>>>> "return" instruction.
>>>>>
>>>>> And thus not correctly simulatd.
>>>>>
>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>
>>>> Perhaps I've missed something. I don't see anything in the above that
>>>> implies that HHH does not correctly simulate DDD. Richard, you've read
>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>
>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>> equivalent to:
>>>>
>>>> void DDD()
>>>> {
>>>> DDD();
>>>> return;
>>>> }
>>>>
>>>> which is a trivial case of infinite recursion. As far as I can tell,
>>>> assuming that DDD() is actually called at some point, neither the
>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>> can reach the return statement. Infinite recursion might either
>>>> cause a stack overflow and a probable program crash, or an unending
>>>> loop if the compiler implements tail call optimization.
>>>>
>>>> I see no contradiction, just an uninteresting case of infinite
>>>> recursion, something that's well understood by anyone with a
>>>> reasonable level of programming experience. (And it has nothing to
>>>> do with the halting problem as far as I can tell, though of course
>>>> olcott has discussed the halting problem elsewhere.)
>>>>
>>>> Richard, what am I missing?
>>>>
>>>
>>> Depends on what you've picked up on.
>>>
>>> Do you get that HHH's simulation is a /partial/ simulation? HHH is free
>>
>> That was not in the specification that he responded to.
>> Thus within this specification DDD correctly simulated
>> by HHH cannot possibly reach its final halt state in an
>> infinite number of steps.
>
> Excpet that no HHH CAN correct emulate the DDD that you give it, as the
> input for DDD just isn't a complete program,
Do I have to repeat this 1000 times before you ever notice
that I said it once?
HHH is in the same freaking memory space as 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 Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 03:59 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmfe1$34h6f$7@dont-email.me> |
| In reply to | #118233 |
On 10/05/2025 03:41, olcott wrote: > On 5/9/2025 9:20 PM, Richard Damon wrote: <snip> >> Excpet that no HHH CAN correct emulate the DDD that you give >> it, as the input for DDD just isn't a complete program, > > Do I have to repeat this 1000 times before you ever notice > that I said it once? That's an unexpectedly revealing question. So now we know. And the answer is 'no'. You can save yourself a lot of time by just saying it once. If it's right, repetition won't make it any righter, and if it's wrong, repetition just makes you look foolish. -- 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-09 23:06 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <c8e49aa39864058808dd92f3ab91fe0ae9300fa0@i2pn2.org> |
| In reply to | #118233 |
On 5/9/25 10:41 PM, olcott wrote:
> On 5/9/2025 9:20 PM, Richard Damon wrote:
>> On 5/9/25 8:48 PM, olcott wrote:
>>> On 5/9/2025 7:23 PM, Mike Terry wrote:
>>>> On 09/05/2025 03:23, Keith Thompson wrote:
>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>> [...]
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> HHH(DDD);
>>>>>>> return;
>>>>>>> }
>>>>>>> We don't need to look at any of my code for me
>>>>>>> to totally prove my point. For example when
>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>> "return" instruction.
>>>>>>
>>>>>> And thus not correctly simulatd.
>>>>>>
>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>
>>>>> Perhaps I've missed something. I don't see anything in the above that
>>>>> implies that HHH does not correctly simulate DDD. Richard, you've
>>>>> read
>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>
>>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>>> equivalent to:
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> DDD();
>>>>> return;
>>>>> }
>>>>>
>>>>> which is a trivial case of infinite recursion. As far as I can tell,
>>>>> assuming that DDD() is actually called at some point, neither the
>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>> can reach the return statement. Infinite recursion might either
>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>> loop if the compiler implements tail call optimization.
>>>>>
>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>> recursion, something that's well understood by anyone with a
>>>>> reasonable level of programming experience. (And it has nothing to
>>>>> do with the halting problem as far as I can tell, though of course
>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>
>>>>> Richard, what am I missing?
>>>>>
>>>>
>>>> Depends on what you've picked up on.
>>>>
>>>> Do you get that HHH's simulation is a /partial/ simulation? HHH is
>>>> free
>>>
>>> That was not in the specification that he responded to.
>>> Thus within this specification DDD correctly simulated
>>> by HHH cannot possibly reach its final halt state in an
>>> infinite number of steps.
>>
>> Excpet that no HHH CAN correct emulate the DDD that you give it, as
>> the input for DDD just isn't a complete program,
>
> Do I have to repeat this 1000 times before you ever notice
> that I said it once?
>
> HHH is in the same freaking memory space as DDD.
>
So?
Does that mean you are removing the requirement that HHH be a pure function?
In that case my version of HHH that uses a static variable to let it
succeed is valid.
Your problem is you are just totally ignorant of the langauge you are
using, and too stupid to realize you need to learn more, or maybe too
stupid to actually learn it.
Your words are effectively just an admittion that you proof is nothing
by a big lie based on equivocation and just out and out lies.
That you are too stupid to see this doesn't make it not true, just shows
your stupidity.
If you want to try to argue these points, show how your HHH can emulate
the input correctly, and meet the requirement that YOU have stipulate,
in particular that the input is JUST the code of the C function DDD, and
that HHH is a pure function and thus can only look at the contents of
what is the input.
These together means that HHH is not allowed to look at its own code for
processsing the meaning of the input.
[toc] | [prev] | [next] | [standalone]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2025-05-10 10:21 +0000 |
| Subject | Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] |
| Message-ID | <vvn9bp$2u4m$1@news.muc.de> |
| In reply to | #118233 |
olcott <polcott333@gmail.com> wrote: [ .... ] > Do I have to repeat this 1000 times before you ever notice > that I said it once? Most of what you write, you have written many, many times. Reading your posts is dull, dull, dull. Whenever I look at your posts and see yet one more x86 instruction sequence, or yet one more C fragment, I just subconsciously skim over it. You must have posted these literally 1000 times and more. Why can't you post something original and fresh, for a change? [ .... ] > -- > Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius > hits a target no one else can see." Arthur Schopenhauer -- Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-10 09:30 -0500 |
| Subject | Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] |
| Message-ID | <vvnnt8$3in62$1@dont-email.me> |
| In reply to | #118304 |
On 5/10/2025 5:21 AM, Alan Mackenzie wrote: > olcott <polcott333@gmail.com> wrote: > > [ .... ] > >> Do I have to repeat this 1000 times before you ever notice >> that I said it once? > > Most of what you write, you have written many, many times. Reading your > posts is dull, dull, dull. Whenever I look at your posts and see yet one > more x86 instruction sequence, or yet one more C fragment, I just > subconsciously skim over it. You must have posted these literally 1000 > times and more. > > Why can't you post something original and fresh, for a change? > > [ .... ] > >> -- >> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius >> hits a target no one else can see." Arthur Schopenhauer > *I only came up with this in the last month* _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] HHH(DDD) is only allowed to compute the mapping from its input finite string to the behavior that this input finite string actually. This is measured by HHH emulating DDD according to the rules of the x86 language. -- 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 | dbush <dbush.mobile@gmail.com> |
|---|---|
| Date | 2025-05-10 10:57 -0400 |
| Subject | Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] |
| Message-ID | <vvnph5$3j8lm$1@dont-email.me> |
| In reply to | #118325 |
On 5/10/2025 10:30 AM, olcott wrote: > On 5/10/2025 5:21 AM, Alan Mackenzie wrote: >> olcott <polcott333@gmail.com> wrote: >> >> [ .... ] >> >>> Do I have to repeat this 1000 times before you ever notice >>> that I said it once? >> >> Most of what you write, you have written many, many times. Reading your >> posts is dull, dull, dull. Whenever I look at your posts and see yet one >> more x86 instruction sequence, or yet one more C fragment, I just >> subconsciously skim over it. You must have posted these literally 1000 >> times and more. >> >> Why can't you post something original and fresh, for a change? >> >> [ .... ] >> >>> -- >>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius >>> hits a target no one else can see." Arthur Schopenhauer >> > > *I only came up with this in the last month* > > _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] > > HHH(DDD) is only allowed to compute the mapping from > its input finite string to the behavior that this > input finite string actually. This is measured by Executing DD directly as per the problem requirements: Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y: A solution to the halting problem is an algorithm H that computes the following mapping: (<X>,Y) maps to 1 if and only if X(Y) halts when executed directly (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2025-05-10 16:57 +0200 |
| Subject | Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] |
| Message-ID | <vvnphn$3j0g1$2@dont-email.me> |
| In reply to | #118325 |
Op 10.mei.2025 om 16:30 schreef olcott: > On 5/10/2025 5:21 AM, Alan Mackenzie wrote: >> olcott <polcott333@gmail.com> wrote: >> >> [ .... ] >> >>> Do I have to repeat this 1000 times before you ever notice >>> that I said it once? >> >> Most of what you write, you have written many, many times. Reading your >> posts is dull, dull, dull. Whenever I look at your posts and see yet one >> more x86 instruction sequence, or yet one more C fragment, I just >> subconsciously skim over it. You must have posted these literally 1000 >> times and more. >> >> Why can't you post something original and fresh, for a change? >> >> [ .... ] >> >>> -- >>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius >>> hits a target no one else can see." Arthur Schopenhauer >> > > *I only came up with this in the last month* And this irrelevant text has been posted already many times. > > _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] > > HHH(DDD) is only allowed to compute the mapping from > its input finite string to the behavior that this > input finite string actually. This is measured by HHH > emulating DDD according to the rules of the x86 language. > Since this strings includes the conditional abort, it specifies a halting program, but hHH computes another mapping, which makes it incorrect. That HHH is blind for the specified behaviour does not mean that the behaviour is not specified. It only proves that there are bugs in HHH, because it violates the semantics of the x86 language.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-10 15:21 -0400 |
| Subject | Re: Repetitive posting [ Was: Incorrect requirements --- Computing the mapping from the input to HHH(DD)] |
| Message-ID | <cf87399131d82c9eee6fd569846f30ccb820fd7e@i2pn2.org> |
| In reply to | #118325 |
On 5/10/25 10:30 AM, olcott wrote: > On 5/10/2025 5:21 AM, Alan Mackenzie wrote: >> olcott <polcott333@gmail.com> wrote: >> >> [ .... ] >> >>> Do I have to repeat this 1000 times before you ever notice >>> that I said it once? >> >> Most of what you write, you have written many, many times. Reading your >> posts is dull, dull, dull. Whenever I look at your posts and see yet one >> more x86 instruction sequence, or yet one more C fragment, I just >> subconsciously skim over it. You must have posted these literally 1000 >> times and more. >> >> Why can't you post something original and fresh, for a change? >> >> [ .... ] >> >>> -- >>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius >>> hits a target no one else can see." Arthur Schopenhauer >> > > *I only came up with this in the last month* > > _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] > > HHH(DDD) is only allowed to compute the mapping from > its input finite string to the behavior that this > input finite string actually. This is measured by HHH > emulating DDD according to the rules of the x86 language. > Right, the mapping that HHH computes must be by those rules, but since it breaks its rules, it doesn't get the right answer. Any HHH that reports an answer needed to break the correct emulation rule by doing ony a partial emulation. The mapping that it must compute to be CORRECT does not need to be a computable result. That mapping is based on the correct emulation of the input, not restricted to being by HHH (and in fact, it can't be, since any HHH that gives an answer can't have followed the rules). This mapping will see that any of your HHH that answer, will abort their emulation when they have been called by DDD, and return to that DDD which will halt. Thus, the mapping of ANY DDD that calls an HHH(DDD) that returns an answer will halt, so that HHH would have needed to return a 1 to have been correct.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2025-05-10 10:38 +0200 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvn3as$3dv8d$9@dont-email.me> |
| In reply to | #118201 |
Op 10.mei.2025 om 02:48 schreef olcott:
> On 5/9/2025 7:23 PM, Mike Terry wrote:
>> On 09/05/2025 03:23, Keith Thompson wrote:
>>> Richard Damon <richard@damon-family.org> writes:
>>>> On 5/8/25 7:53 PM, olcott wrote:
>>> [...]
>>>>> void DDD()
>>>>> {
>>>>> HHH(DDD);
>>>>> return;
>>>>> }
>>>>> We don't need to look at any of my code for me
>>>>> to totally prove my point. For example when
>>>>> the above DDD is correctly simulated by HHH
>>>>> this simulated DDD cannot possibly reach its own
>>>>> "return" instruction.
>>>>
>>>> And thus not correctly simulatd.
>>>>
>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>
>>> Perhaps I've missed something. I don't see anything in the above that
>>> implies that HHH does not correctly simulate DDD. Richard, you've read
>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>
>>> If we assume that HHH correctly simulates DDD, then the above code is
>>> equivalent to:
>>>
>>> void DDD()
>>> {
>>> DDD();
>>> return;
>>> }
>>>
>>> which is a trivial case of infinite recursion. As far as I can tell,
>>> assuming that DDD() is actually called at some point, neither the
>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>> can reach the return statement. Infinite recursion might either
>>> cause a stack overflow and a probable program crash, or an unending
>>> loop if the compiler implements tail call optimization.
>>>
>>> I see no contradiction, just an uninteresting case of infinite
>>> recursion, something that's well understood by anyone with a
>>> reasonable level of programming experience. (And it has nothing to
>>> do with the halting problem as far as I can tell, though of course
>>> olcott has discussed the halting problem elsewhere.)
>>>
>>> Richard, what am I missing?
>>>
>>
>> Depends on what you've picked up on.
>>
>> Do you get that HHH's simulation is a /partial/ simulation? HHH is free
>
> That was not in the specification that he responded to.
> Thus within this specification DDD correctly simulated
> by HHH cannot possibly reach its final halt state in an
> infinite number of steps.
>
> If an infinite number steps steps is insufficient
> then how can less an infinite steps possibly help?
It will certainly help. Not in making a better simulator, but by
creating an input DDD that halts. (But your HHH misses that verifiable
fact.)
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <Keith.S.Thompson+u@gmail.com> |
|---|---|
| Date | 2025-05-09 20:12 -0700 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <87msblcg60.fsf@nosuchdomain.example.com> |
| In reply to | #118196 |
Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
> On 09/05/2025 03:23, Keith Thompson wrote:
>> Richard Damon <richard@damon-family.org> writes:
>>> On 5/8/25 7:53 PM, olcott wrote:
>> [...]
>>>> void DDD()
>>>> {
>>>> HHH(DDD);
>>>> return;
>>>> }
>>>> We don't need to look at any of my code for me
>>>> to totally prove my point. For example when
>>>> the above DDD is correctly simulated by HHH
>>>> this simulated DDD cannot possibly reach its own
>>>> "return" instruction.
>>>
>>> And thus not correctly simulatd.
>>>
>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>> Perhaps I've missed something. I don't see anything in the above
>> that
>> implies that HHH does not correctly simulate DDD. Richard, you've read
>> far more of olcott's posts than I have, so perhaps you can clarify.
>> If we assume that HHH correctly simulates DDD, then the above code
>> is
>> equivalent to:
>> void DDD()
>> {
>> DDD();
>> return;
>> }
>> which is a trivial case of infinite recursion. As far as I can
>> tell,
>> assuming that DDD() is actually called at some point, neither the
>> outer execution of DDD nor the nested (simulated) execution of DDD
>> can reach the return statement. Infinite recursion might either
>> cause a stack overflow and a probable program crash, or an unending
>> loop if the compiler implements tail call optimization.
>> I see no contradiction, just an uninteresting case of infinite
>> recursion, something that's well understood by anyone with a
>> reasonable level of programming experience. (And it has nothing to
>> do with the halting problem as far as I can tell, though of course
>> olcott has discussed the halting problem elsewhere.)
>> Richard, what am I missing?
>
> Depends on what you've picked up on.
>
> Do you get that HHH's simulation is a /partial/ simulation? HHH is
> free to simulate a few x86 instructions of DDD, and then simply
> abandon the simulation and return. Since such a simulation is
> obviously NOT equivalent to a direct call to DDD, and above you argue
> that it is, I'd say you've missed that.
I have not read the vast majority of olcott's post here. For most
of the recent discussion I had with him, there was no mention of
partial simulation. olcott finally said something about simulating
just a few instructions, but at the same time he finally indicated
that understanding his arguments would require an understanding of
x86 machine and/or assembly language. That's when I bailed out.
A "correct simulation", as I understand the term, would require fully
simulate the execution of DDD. If DDD never halts, its simulation never
halts. olcott seems to think that he's found a way around this that's
relevant to the Halting Problem, but I withdrew before getting to that
point.
[...]
> Other posters have suggested that what you're missing is some
> variation of "once you answer PO's current question (about whether the
> simulation by HHH progresses as far as DDD's return) PO will go on to
> do something else wrong". Well, of course he will, but that's hardly
> something you're missing if he's not done it yet! :) I'd also say
> it's no reason not to answer PO's question honestly, acknowledging
> that he is talking about /partial/ simulations... The time to
> challenge future mistakes he will go on to make, is when he makes
> them.
That sounds about right.
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 22:17 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmggq$3a34p$6@dont-email.me> |
| In reply to | #118238 |
On 5/9/2025 10:12 PM, Keith Thompson wrote:
> Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
>> On 09/05/2025 03:23, Keith Thompson wrote:
>>> Richard Damon <richard@damon-family.org> writes:
>>>> On 5/8/25 7:53 PM, olcott wrote:
>>> [...]
>>>>> void DDD()
>>>>> {
>>>>> HHH(DDD);
>>>>> return;
>>>>> }
>>>>> We don't need to look at any of my code for me
>>>>> to totally prove my point. For example when
>>>>> the above DDD is correctly simulated by HHH
>>>>> this simulated DDD cannot possibly reach its own
>>>>> "return" instruction.
>>>>
>>>> And thus not correctly simulatd.
>>>>
>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>> Perhaps I've missed something. I don't see anything in the above
>>> that
>>> implies that HHH does not correctly simulate DDD. Richard, you've read
>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>> If we assume that HHH correctly simulates DDD, then the above code
>>> is
>>> equivalent to:
>>> void DDD()
>>> {
>>> DDD();
>>> return;
>>> }
>>> which is a trivial case of infinite recursion. As far as I can
>>> tell,
>>> assuming that DDD() is actually called at some point, neither the
>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>> can reach the return statement. Infinite recursion might either
>>> cause a stack overflow and a probable program crash, or an unending
>>> loop if the compiler implements tail call optimization.
>>> I see no contradiction, just an uninteresting case of infinite
>>> recursion, something that's well understood by anyone with a
>>> reasonable level of programming experience. (And it has nothing to
>>> do with the halting problem as far as I can tell, though of course
>>> olcott has discussed the halting problem elsewhere.)
>>> Richard, what am I missing?
>>
>> Depends on what you've picked up on.
>>
>> Do you get that HHH's simulation is a /partial/ simulation? HHH is
>> free to simulate a few x86 instructions of DDD, and then simply
>> abandon the simulation and return. Since such a simulation is
>> obviously NOT equivalent to a direct call to DDD, and above you argue
>> that it is, I'd say you've missed that.
>
> I have not read the vast majority of olcott's post here. For most
> of the recent discussion I had with him, there was no mention of
> partial simulation. olcott finally said something about simulating
> just a few instructions, but at the same time he finally indicated
> that understanding his arguments would require an understanding of
> x86 machine and/or assembly language. That's when I bailed out.
>
> A "correct simulation", as I understand the term, would require fully
> simulate the execution of DDD. If DDD never halts, its simulation never
> halts. olcott seems to think that he's found a way around this that's
> relevant to the Halting Problem, but I withdrew before getting to that
> point.
>
It only need be a correct simulation until HHH sees the
repeating pattern that would cause itself to never terminate.
The best selling author of theory of computation textbooks
agreed that I could quote his agreement with my words.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 10 of 32 — ← Prev page 1 … 8 9 [10] 11 12 … 32 Next page →
Back to top | Article view | comp.theory
csiph-web