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 7 of 32 — ← Prev page 1 … 5 6 [7] 8 9 … 32 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 14:46 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlm2k$30idv$1@dont-email.me> |
| In reply to | #118165 |
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.
--
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-09 21:07 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlnad$2uvnf$5@dont-email.me> |
| In reply to | #118184 |
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). So the question is flawed. What you delight in calling a 'category error'. Any competent C programmer will see my point. (You won't.) -- Richard Heathfield Email: rjh at cpax dot org dot uk "Usenet is a strange place" - dmr 29 July 1999 Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 15:15 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlnpj$30vce$1@dont-email.me> |
| In reply to | #118185 |
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?
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”.
--
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 17:35 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <cab8c538b102bf2ab7f21fda497fae015946e27b@i2pn2.org> |
| In reply to | #118186 |
On 5/9/25 4:15 PM, 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?
>
> 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”.
>
>
Which is can't do since it hasn't been given enough of the code.
HHH *MUST& fail when it gets to the call HHH instruction, as the code
for that hasn't been given to it.
[toc] | [prev] | [next] | [standalone]
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-09 22:40 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlsp5$31vqc$1@dont-email.me> |
| In reply to | #118186 |
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?
There are only two possibilities:
(a) HHH aborts the simulation prematurely, or
(b) it doesn't.
If (a), the simulation fails to 'play' DDD correctly.
If (b), the simulation fails to arrive at a decision.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 17:18 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlv04$32kt3$1@dont-email.me> |
| In reply to | #118189 |
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.
--
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-09 18:31 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvlvog$2pnkn$1@dont-email.me> |
| In reply to | #118190 |
On 5/9/2025 6:18 PM, olcott wrote:
> 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.
>
>
But if it aborts it's not a correct simulation:
On 5/9/2025 12:11 AM, Keith Thompson wrote:
> Now you're talking about simulating "1 or more instructions"
> of DD. I thought that HHH was supposed to "accurately simulate"
> the function whose argument is passed to it. Emulating just "1 or
> more instructions" is not accurate simulation.
Which you have admitted on the record:
On 5/5/2025 8:24 AM, dbush wrote:
> On 5/4/2025 11:03 PM, dbush wrote:
>> On 5/4/2025 10:05 PM, olcott wrote:
>>> On 5/4/2025 7:23 PM, Richard Damon wrote:
>>>> But HHH doesn't correct emulated DD by those rules, as those rules
>>>> do not allow HHH to stop its emulation,
>>>
>>> Sure they do you freaking moron...
>>
>> Then show where in the Intel instruction manual that the execution of
>> any instruction other than a HLT is allowed to stop instead of
>> executing the next instruction.
>>
>> Failure to do so in your next reply, or within one hour of your next
>> post on this newsgroup, will be taken as you official on-the-record
>> admission that there is no such allowance and that HHH does NOT
>> correctly simulate DD.
>
> Let the record show that Peter Olcott made the following post in this
> newsgroup after the above message:
>
> On 5/4/2025 11:04 PM, olcott wrote:
> > D *WOULD NEVER STOP RUNNING UNLESS*
> > indicates that professor Sipser was agreeing
> > to hypotheticals AS *NOT CHANGING THE INPUT*
> >
> > You are taking
> > *WOULD NEVER STOP RUNNING UNLESS*
> > to mean *NEVER STOPS RUNNING* that is incorrect.
>
> And has made no attempt after over 9 hours to show where in the Intel
> instruction manual that execution is allowed to stop after any
> instruction other than HLT.
>
> Therefore, as per the above criteria:
>
> LET THE RECORD SHOW
>
> That Peter Olcott
>
> Has *officially* admitted
>
> That DD is NOT correctly simulated by HHH
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2025-05-09 19:34 -0400 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <03ea9fd1a111da858622a85fc7164f7a0dded74e@i2pn2.org> |
| In reply to | #118190 |
On 5/9/25 6:18 PM, olcott wrote:
> 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.
No, it isn't, not if the input to the simulator is incorrect, and thus
not actually the call you are talking about.
Your problem is that you HHH *CAN'T* be doing what you say, as it is
LOGICALLY IMPOSSIBLE for it to be doing so, as the input just doesn't
have the information to allow it to do so.
Your problem is you have just LIED to yourself about what things need to be.
The input to a simulator MUST BE a full representation of the PROGRAM
that it is to simulate, and thus must represent *ALL* the code that it
is going to use.
SInce you have defined your input as ONLY the code generated for the C
function DDD, as soon as HHH tryies to access ANY code outside that,
even its own as data, then it have VIOLATED its requirements.
THus, all you have done is proven that you are just a stupid liar that
doesn't know what he is talking about and doesn't care that he is just
ignorant of what he is talking about.
>
> 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.
>
>
[toc] | [prev] | [next] | [standalone]
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2025-05-10 01:26 +0100 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvm6g6$34h6f$1@dont-email.me> |
| In reply to | #118190 |
On 09/05/2025 23:18, olcott wrote:
> 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.
Sheer bluster.
> 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.
I just wrote:
>> HHH cannot successfully complete its task, because it never
>> regains control after the first recursion.
Keith wrote:
> 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.
Keith and I are in complete agreement.
You, on the other describe abject failure as 'correctly
simulated'. There's nothing correct about it.
--
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 | Keith Thompson <Keith.S.Thompson+u@gmail.com> |
|---|---|
| Date | 2025-05-09 20:14 -0700 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <87ikm9cg2b.fsf@nosuchdomain.example.com> |
| In reply to | #118197 |
Richard Heathfield <rjh@cpax.org.uk> writes:
[...]
> Keith and I are in complete agreement.
>
> You, on the other describe abject failure as 'correctly
> simulated'. There's nothing correct about it.
It's simply a matter of applying abject-oriented programming.
I'll see myself out.
--
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 | Keith Thompson <Keith.S.Thompson+u@gmail.com> |
|---|---|
| Date | 2025-05-09 19:40 -0700 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <87r00xchn5.fsf@nosuchdomain.example.com> |
| In reply to | #118190 |
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).
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. 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". (My understanding from
posts by others, whom I presume to be sufficiently knowledgeable,
is that HHH logically cannot accurately simulate DDD.) I would
prefer that olcott refrain from using my words to support any of
his arguments beyond the scope of what he and I directly discussed.
--
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 | wij <wyniijj5@gmail.com> |
|---|---|
| Date | 2025-05-10 11:13 +0800 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <23a27379d226b7b3b9f8c303a492f66edc9019ff.camel@gmail.com> |
| In reply to | #118232 |
On Fri, 2025-05-09 at 19:40 -0700, 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).
>
> 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. 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". (My understanding from
> posts by others, whom I presume to be sufficiently knowledgeable,
> is that HHH logically cannot accurately simulate DDD.) I would
> prefer that olcott refrain from using my words to support any of
> his arguments beyond the scope of what he and I directly discussed.
Don't know why you people stick on the 'simulation' stuff so long.
The HP simply asks for such an H (in function form. POOH does not
resemble TM):
H(D)=1 if D() halt.
H(D)=0 if D() not halt.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 22:24 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmgtr$3a34p$7@dont-email.me> |
| In reply to | #118239 |
On 5/9/2025 10:13 PM, wij wrote:
> On Fri, 2025-05-09 at 19:40 -0700, 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).
>>
>> 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. 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". (My understanding from
>> posts by others, whom I presume to be sufficiently knowledgeable,
>> is that HHH logically cannot accurately simulate DDD.) I would
>> prefer that olcott refrain from using my words to support any of
>> his arguments beyond the scope of what he and I directly discussed.
>
> Don't know why you people stick on the 'simulation' stuff so long.
> The HP simply asks for such an H (in function form. POOH does not
> resemble TM):
> H(D)=1 if D() halt.
> H(D)=0 if D() not halt.
My invention of a simulating termination
analyzer shows exactly how to compute the
mapping that the input that HHH(DD) specifies
into a correct answer for the halting problem's
otherwise impossible input.
All rebuttals are based on failing to compute
this mapping correctly.
--
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 | wij <wyniijj5@gmail.com> |
|---|---|
| Date | 2025-05-10 11:43 +0800 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <1020d30c2c5b5a7cce584777131d5ce414b480ea.camel@gmail.com> |
| In reply to | #118250 |
On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
> On 5/9/2025 10:13 PM, wij wrote:
> > On Fri, 2025-05-09 at 19:40 -0700, 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).
> > >
> > > 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. 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". (My understanding from
> > > posts by others, whom I presume to be sufficiently knowledgeable,
> > > is that HHH logically cannot accurately simulate DDD.) I would
> > > prefer that olcott refrain from using my words to support any of
> > > his arguments beyond the scope of what he and I directly discussed.
> >
> > Don't know why you people stick on the 'simulation' stuff so long.
> > The HP simply asks for such an H (in function form. POOH does not
> > resemble TM):
> > H(D)=1 if D() halt.
> > H(D)=0 if D() not halt.
>
> My invention of a simulating termination
> analyzer shows exactly how to compute the
> mapping that the input that HHH(DD) specifies
> into a correct answer for the halting problem's
> otherwise impossible input.
>
> All rebuttals are based on failing to compute
> this mapping correctly.
>
What is the correct mapping?
If POOH are not talking about the mapping:
H(D)=1 if D() halt.
H(D)=0 if D() not halt.
POOH is likely nothing to do with HP
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 23:18 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmk29$3atmt$3@dont-email.me> |
| In reply to | #118252 |
On 5/9/2025 10:43 PM, wij wrote:
> On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
>> On 5/9/2025 10:13 PM, wij wrote:
>>> On Fri, 2025-05-09 at 19:40 -0700, 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).
>>>>
>>>> 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. 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". (My understanding from
>>>> posts by others, whom I presume to be sufficiently knowledgeable,
>>>> is that HHH logically cannot accurately simulate DDD.) I would
>>>> prefer that olcott refrain from using my words to support any of
>>>> his arguments beyond the scope of what he and I directly discussed.
>>>
>>> Don't know why you people stick on the 'simulation' stuff so long.
>>> The HP simply asks for such an H (in function form. POOH does not
>>> resemble TM):
>>> H(D)=1 if D() halt.
>>> H(D)=0 if D() not halt.
>>
>> My invention of a simulating termination
>> analyzer shows exactly how to compute the
>> mapping that the input that HHH(DD) specifies
>> into a correct answer for the halting problem's
>> otherwise impossible input.
>>
>> All rebuttals are based on failing to compute
>> this mapping correctly.
>>
>
> What is the correct mapping?
>
_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]
Computing the mapping of DDD emulated by HHH
according the the rules of the x86 language
to its behavior by HHH actually emulating DDD.
> If POOH are not talking about the mapping:
>
> H(D)=1 if D() halt.
> H(D)=0 if D() not halt.
>
The way that simulating termination analyzers process
their input by showing all of the steps of how the mapping
must be computed refutes the above simplistic view.
> POOH is likely nothing to do with HP
>
--
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 | wij <wyniijj5@gmail.com> |
|---|---|
| Date | 2025-05-10 12:32 +0800 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <0323d5ca6d757a1e35d7e4cf5eb4fc8f41bc866a.camel@gmail.com> |
| In reply to | #118263 |
On Fri, 2025-05-09 at 23:18 -0500, olcott wrote:
> On 5/9/2025 10:43 PM, wij wrote:
> > On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
> > > On 5/9/2025 10:13 PM, wij wrote:
> > > > On Fri, 2025-05-09 at 19:40 -0700, 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).
> > > > >
> > > > > 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. 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". (My understanding from
> > > > > posts by others, whom I presume to be sufficiently knowledgeable,
> > > > > is that HHH logically cannot accurately simulate DDD.) I would
> > > > > prefer that olcott refrain from using my words to support any of
> > > > > his arguments beyond the scope of what he and I directly discussed.
> > > >
> > > > Don't know why you people stick on the 'simulation' stuff so long.
> > > > The HP simply asks for such an H (in function form. POOH does not
> > > > resemble TM):
> > > > H(D)=1 if D() halt.
> > > > H(D)=0 if D() not halt.
> > >
> > > My invention of a simulating termination
> > > analyzer shows exactly how to compute the
> > > mapping that the input that HHH(DD) specifies
> > > into a correct answer for the halting problem's
> > > otherwise impossible input.
> > >
> > > All rebuttals are based on failing to compute
> > > this mapping correctly.
> > >
> >
> > What is the correct mapping?
> >
>
> _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]
>
> Computing the mapping of DDD emulated by HHH
> according the the rules of the x86 language
> to its behavior by HHH actually emulating DDD.
The above says you have no idea what the mapping is.
> > If POOH are not talking about the mapping:
> >
> > H(D)=1 if D() halt.
> > H(D)=0 if D() not halt.
> >
>
> The way that simulating termination analyzers process
> their input by showing all of the steps of how the mapping
> must be computed refutes the above simplistic view.
No (real) problem with that. But the HP asks:
H(D)=1 if D() halt.
H(D)=0 if D() not halt.
You still evade the question: Is POO H anything to do with the HP?
> > POOH is likely nothing to do with HP
> >
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-09 23:44 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmlk0$3blcs$1@dont-email.me> |
| In reply to | #118266 |
On 5/9/2025 11:32 PM, wij wrote:
> On Fri, 2025-05-09 at 23:18 -0500, olcott wrote:
>> On 5/9/2025 10:43 PM, wij wrote:
>>> On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
>>>> On 5/9/2025 10:13 PM, wij wrote:
>>>>> On Fri, 2025-05-09 at 19:40 -0700, 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).
>>>>>>
>>>>>> 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. 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". (My understanding from
>>>>>> posts by others, whom I presume to be sufficiently knowledgeable,
>>>>>> is that HHH logically cannot accurately simulate DDD.) I would
>>>>>> prefer that olcott refrain from using my words to support any of
>>>>>> his arguments beyond the scope of what he and I directly discussed.
>>>>>
>>>>> Don't know why you people stick on the 'simulation' stuff so long.
>>>>> The HP simply asks for such an H (in function form. POOH does not
>>>>> resemble TM):
>>>>> H(D)=1 if D() halt.
>>>>> H(D)=0 if D() not halt.
>>>>
>>>> My invention of a simulating termination
>>>> analyzer shows exactly how to compute the
>>>> mapping that the input that HHH(DD) specifies
>>>> into a correct answer for the halting problem's
>>>> otherwise impossible input.
>>>>
>>>> All rebuttals are based on failing to compute
>>>> this mapping correctly.
>>>>
>>>
>>> What is the correct mapping?
>>>
>>
>> _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]
>>
>> Computing the mapping of DDD emulated by HHH
>> according the the rules of the x86 language
>> to its behavior by HHH actually emulating DDD.
>
> The above says you have no idea what the mapping is.
>
>>> If POOH are not talking about the mapping:
>>>
>>> H(D)=1 if D() halt.
>>> H(D)=0 if D() not halt.
>>>
>>
>> The way that simulating termination analyzers process
>> their input by showing all of the steps of how the mapping
>> must be computed refutes the above simplistic view.
>
> No (real) problem with that. But the HP asks:
>
> H(D)=1 if D() halt.
> H(D)=0 if D() not halt.
>
> You still evade the question: Is POO H anything to do with the HP?
>
I have recently proven that the above requirements are incorrect.
That people consistently ignore this proof with pure bluster
is not actually any rebuttal at all.
>>> POOH is likely nothing to do with HP
>>>
>>
>>
>
>
--
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 | wij <wyniijj5@gmail.com> |
|---|---|
| Date | 2025-05-10 12:51 +0800 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <c6904fbe42c4ad1eb3d1dcc50d18e6e75f159d75.camel@gmail.com> |
| In reply to | #118267 |
On Fri, 2025-05-09 at 23:44 -0500, olcott wrote:
> On 5/9/2025 11:32 PM, wij wrote:
> > On Fri, 2025-05-09 at 23:18 -0500, olcott wrote:
> > > On 5/9/2025 10:43 PM, wij wrote:
> > > > On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
> > > > > On 5/9/2025 10:13 PM, wij wrote:
> > > > > > On Fri, 2025-05-09 at 19:40 -0700, 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).
> > > > > > >
> > > > > > > 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. 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". (My understanding from
> > > > > > > posts by others, whom I presume to be sufficiently knowledgeable,
> > > > > > > is that HHH logically cannot accurately simulate DDD.) I would
> > > > > > > prefer that olcott refrain from using my words to support any of
> > > > > > > his arguments beyond the scope of what he and I directly discussed.
> > > > > >
> > > > > > Don't know why you people stick on the 'simulation' stuff so long.
> > > > > > The HP simply asks for such an H (in function form. POOH does not
> > > > > > resemble TM):
> > > > > > H(D)=1 if D() halt.
> > > > > > H(D)=0 if D() not halt.
> > > > >
> > > > > My invention of a simulating termination
> > > > > analyzer shows exactly how to compute the
> > > > > mapping that the input that HHH(DD) specifies
> > > > > into a correct answer for the halting problem's
> > > > > otherwise impossible input.
> > > > >
> > > > > All rebuttals are based on failing to compute
> > > > > this mapping correctly.
> > > > >
> > > >
> > > > What is the correct mapping?
> > > >
> > >
> > > _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]
> > >
> > > Computing the mapping of DDD emulated by HHH
> > > according the the rules of the x86 language
> > > to its behavior by HHH actually emulating DDD.
> >
> > The above says you have no idea what the mapping is.
> >
> > > > If POOH are not talking about the mapping:
> > > >
> > > > H(D)=1 if D() halt.
> > > > H(D)=0 if D() not halt.
> > > >
> > >
> > > The way that simulating termination analyzers process
> > > their input by showing all of the steps of how the mapping
> > > must be computed refutes the above simplistic view.
> >
> > No (real) problem with that. But the HP asks:
> >
> > H(D)=1 if D() halt.
> > H(D)=0 if D() not halt.
> >
> > You still evade the question: Is POO H anything to do with the HP?
> >
>
> I have recently proven that the above requirements are incorrect.
it that correct?
Be it (HP) correct or not. Your 'revision' says POOH is not about the HP,
it that correct?
> That people consistently ignore this proof with pure bluster
> is not actually any rebuttal at all.
Other people's rebuttal of POOH may not be valid, if POOH is not about the HP.
> > > > POOH is likely nothing to do with HP
> > > >
> > >
> > >
> >
> >
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2025-05-10 00:06 -0500 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <vvmmtd$3bqvb$1@dont-email.me> |
| In reply to | #118269 |
On 5/9/2025 11:51 PM, wij wrote:
> On Fri, 2025-05-09 at 23:44 -0500, olcott wrote:
>> On 5/9/2025 11:32 PM, wij wrote:
>>> On Fri, 2025-05-09 at 23:18 -0500, olcott wrote:
>>>> On 5/9/2025 10:43 PM, wij wrote:
>>>>> On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
>>>>>> On 5/9/2025 10:13 PM, wij wrote:
>>>>>>> On Fri, 2025-05-09 at 19:40 -0700, 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).
>>>>>>>>
>>>>>>>> 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. 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". (My understanding from
>>>>>>>> posts by others, whom I presume to be sufficiently knowledgeable,
>>>>>>>> is that HHH logically cannot accurately simulate DDD.) I would
>>>>>>>> prefer that olcott refrain from using my words to support any of
>>>>>>>> his arguments beyond the scope of what he and I directly discussed.
>>>>>>>
>>>>>>> Don't know why you people stick on the 'simulation' stuff so long.
>>>>>>> The HP simply asks for such an H (in function form. POOH does not
>>>>>>> resemble TM):
>>>>>>> H(D)=1 if D() halt.
>>>>>>> H(D)=0 if D() not halt.
>>>>>>
>>>>>> My invention of a simulating termination
>>>>>> analyzer shows exactly how to compute the
>>>>>> mapping that the input that HHH(DD) specifies
>>>>>> into a correct answer for the halting problem's
>>>>>> otherwise impossible input.
>>>>>>
>>>>>> All rebuttals are based on failing to compute
>>>>>> this mapping correctly.
>>>>>>
>>>>>
>>>>> What is the correct mapping?
>>>>>
>>>>
>>>> _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]
>>>>
>>>> Computing the mapping of DDD emulated by HHH
>>>> according the the rules of the x86 language
>>>> to its behavior by HHH actually emulating DDD.
>>>
>>> The above says you have no idea what the mapping is.
>>>
>>>>> If POOH are not talking about the mapping:
>>>>>
>>>>> H(D)=1 if D() halt.
>>>>> H(D)=0 if D() not halt.
>>>>>
>>>>
>>>> The way that simulating termination analyzers process
>>>> their input by showing all of the steps of how the mapping
>>>> must be computed refutes the above simplistic view.
>>>
>>> No (real) problem with that. But the HP asks:
>>>
>>> H(D)=1 if D() halt.
>>> H(D)=0 if D() not halt.
>>>
>>> You still evade the question: Is POO H anything to do with the HP?
>>>
>>
>> I have recently proven that the above requirements are incorrect.
> it that correct?
>
> Be it (HP) correct or not. Your 'revision' says POOH is not about the HP,
> it that correct?
>
When mathematical mapping is properly understood
it will be known that functions computed by models
of computation must transform their input into
outputs according to the specific steps of an
algorithm.
_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]
For example HHH(DDD) only correctly map to the
behavior that its input actually specifies by correctly
emulating DDD according to the rules of the x86 language.
This causes the first four instructions of DDD
to be emulated followed by HHH emulating itself
emulating the first three instructions of DDD.
It is right at this recursive simulation just
before HHH(DDD) is called again that HHH recognizes
the repeating pattern and rejects DDD.
>> That people consistently ignore this proof with pure bluster
>> is not actually any rebuttal at all.
>
> Other people's rebuttal of POOH may not be valid, if POOH is not about the HP.
>
>
>>>>> POOH is likely nothing to do with HP
>>>>>
>>>>
>>>>
>>>
>>>
>>
>>
>
>
--
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 | wij <wyniijj5@gmail.com> |
|---|---|
| Date | 2025-05-10 13:13 +0800 |
| Subject | Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD) |
| Message-ID | <9f5774bfb493325652f97d72f760ad98442c333d.camel@gmail.com> |
| In reply to | #118270 |
On Sat, 2025-05-10 at 00:06 -0500, olcott wrote:
> On 5/9/2025 11:51 PM, wij wrote:
> > On Fri, 2025-05-09 at 23:44 -0500, olcott wrote:
> > > On 5/9/2025 11:32 PM, wij wrote:
> > > > On Fri, 2025-05-09 at 23:18 -0500, olcott wrote:
> > > > > On 5/9/2025 10:43 PM, wij wrote:
> > > > > > On Fri, 2025-05-09 at 22:24 -0500, olcott wrote:
> > > > > > > On 5/9/2025 10:13 PM, wij wrote:
> > > > > > > > On Fri, 2025-05-09 at 19:40 -0700, 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).
> > > > > > > > >
> > > > > > > > > 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. 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". (My understanding from
> > > > > > > > > posts by others, whom I presume to be sufficiently knowledgeable,
> > > > > > > > > is that HHH logically cannot accurately simulate DDD.) I would
> > > > > > > > > prefer that olcott refrain from using my words to support any of
> > > > > > > > > his arguments beyond the scope of what he and I directly discussed.
> > > > > > > >
> > > > > > > > Don't know why you people stick on the 'simulation' stuff so long.
> > > > > > > > The HP simply asks for such an H (in function form. POOH does not
> > > > > > > > resemble TM):
> > > > > > > > H(D)=1 if D() halt.
> > > > > > > > H(D)=0 if D() not halt.
> > > > > > >
> > > > > > > My invention of a simulating termination
> > > > > > > analyzer shows exactly how to compute the
> > > > > > > mapping that the input that HHH(DD) specifies
> > > > > > > into a correct answer for the halting problem's
> > > > > > > otherwise impossible input.
> > > > > > >
> > > > > > > All rebuttals are based on failing to compute
> > > > > > > this mapping correctly.
> > > > > > >
> > > > > >
> > > > > > What is the correct mapping?
> > > > > >
> > > > >
> > > > > _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]
> > > > >
> > > > > Computing the mapping of DDD emulated by HHH
> > > > > according the the rules of the x86 language
> > > > > to its behavior by HHH actually emulating DDD.
> > > >
> > > > The above says you have no idea what the mapping is.
> > > >
> > > > > > If POOH are not talking about the mapping:
> > > > > >
> > > > > > H(D)=1 if D() halt.
> > > > > > H(D)=0 if D() not halt.
> > > > > >
> > > > >
> > > > > The way that simulating termination analyzers process
> > > > > their input by showing all of the steps of how the mapping
> > > > > must be computed refutes the above simplistic view.
> > > >
> > > > No (real) problem with that. But the HP asks:
> > > >
> > > > H(D)=1 if D() halt.
> > > > H(D)=0 if D() not halt.
> > > >
> > > > You still evade the question: Is POO H anything to do with the HP?
> > > >
> > >
> > > I have recently proven that the above requirements are incorrect.
> > it that correct?
> >
> > Be it (HP) correct or not. Your 'revision' says POOH is not about the HP,
> > it that correct?
> >
>
> When mathematical mapping is properly understood
> it will be known that functions computed by models
> of computation must transform their input into
> outputs according to the specific steps of an
> algorithm.
>
> _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]
>
> For example HHH(DDD) only correctly map to the
> behavior that its input actually specifies by correctly
> emulating DDD according to the rules of the x86 language.
>
> This causes the first four instructions of DDD
> to be emulated followed by HHH emulating itself
> emulating the first three instructions of DDD.
>
> It is right at this recursive simulation just
> before HHH(DDD) is called again that HHH recognizes
> the repeating pattern and rejects DDD.
Yes, but you still did not answer the question: Is POOH exactly about HP?
> > > That people consistently ignore this proof with pure bluster
> > > is not actually any rebuttal at all.
> >
> > Other people's rebuttal of POOH may not be valid, if POOH is not about the HP.
> >
> >
> > > > > > POOH is likely nothing to do with HP
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>
[toc] | [prev] | [next] | [standalone]
Page 7 of 32 — ← Prev page 1 … 5 6 [7] 8 9 … 32 Next page →
Back to top | Article view | comp.theory
csiph-web