Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #106095 > unrolled thread
| Started by | immibis <news@immibis.com> |
|---|---|
| First post | 2024-06-03 02:16 +0200 |
| Last post | 2024-06-03 13:38 +0300 |
| Articles | 20 on this page of 332 — 14 participants |
Back to article view | Back to comp.theory
Why does Olcott care about simulation, anyway? immibis <news@immibis.com> - 2024-06-03 02:16 +0200
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-02 20:34 -0400
Re: Why does Olcott care about simulation, anyway? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-03 04:28 +0100
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-02 22:50 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-03 07:14 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review immibis <news@immibis.com> - 2024-06-03 15:36 +0200
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-03 17:25 +0100
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-03 12:54 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-03 20:57 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-04 02:38 +0100
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-03 20:46 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-03 21:59 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-03 21:18 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-03 22:49 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-04 12:12 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-04 21:47 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Mikko <mikko.levanto@iki.fi> - 2024-06-05 10:08 +0300
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-05 08:08 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review wij <wyniijj5@gmail.com> - 2024-06-05 21:47 +0800
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-05 09:10 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Mikko <mikko.levanto@iki.fi> - 2024-06-06 11:25 +0300
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-06 08:13 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Mikko <mikko.levanto@iki.fi> - 2024-06-06 18:18 +0300
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-06 10:32 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-06 07:10 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-04 03:57 +0100
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-03 22:12 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-03 23:57 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review olcott <polcott333@gmail.com> - 2024-06-04 12:26 -0500
Re: Why does Olcott care about simulation, anyway? --- Mikes Review Richard Damon <richard@damon-family.org> - 2024-06-04 21:47 -0400
Re: Why does Olcott care about simulation, anyway? --- Mikes Review immibis <news2@immibis.com> - 2024-06-04 19:36 +0200
Re: Why does Olcott care about simulation, anyway? Ben Bacarisse <ben@bsb.me.uk> - 2024-06-03 10:42 +0100
Re: Why does Olcott care about simulation, anyway? --- Ben's Review olcott <polcott333@gmail.com> - 2024-06-03 07:20 -0500
Re: Why does Olcott care about simulation, anyway? --- Ben's Review immibis <news@immibis.com> - 2024-06-03 15:39 +0200
Re: Why does Olcott care about simulation, anyway? --- Ben's Review Mikko <mikko.levanto@iki.fi> - 2024-06-03 17:27 +0300
Re: Why does Olcott care about simulation, anyway? --- Ben's Review olcott <polcott333@gmail.com> - 2024-06-03 13:14 -0500
Re: Why does Olcott care about simulation, anyway? --- Ben's Review Richard Damon <richard@damon-family.org> - 2024-06-03 20:56 -0400
Re: Why does Olcott care about simulation, anyway? --- Ben's Review joes <noreply@example.com> - 2024-06-04 08:21 +0000
Re: Why does Olcott care about simulation, anyway? --- Ben's Review olcott <polcott333@gmail.com> - 2024-06-04 12:31 -0500
Re: Why does Olcott care about simulation, anyway? --- Ben's Review Mikko <mikko.levanto@iki.fi> - 2024-06-04 11:28 +0300
Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-04 12:40 -0500
Re: Halting Problem is wrong two different ways immibis <news2@immibis.com> - 2024-06-04 20:27 +0200
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-04 21:48 -0400
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-04 21:05 -0500
Re: Halting Problem is wrong two different ways John Smith <news2@immibis.com> - 2024-06-05 04:12 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-04 21:16 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-04 22:22 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-05 10:28 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-05 08:24 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-05 19:39 -0400
Re: Halting Problem is wrong two different ways John Smith <news2@immibis.com> - 2024-06-05 19:03 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-05 12:09 -0500
Re: Halting Problem is wrong two different ways John Smith <news2@immibis.com> - 2024-06-05 19:29 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-05 12:37 -0500
Re: Halting Problem is wrong two different ways joes <noreply@example.com> - 2024-06-05 18:16 +0000
Re: Halting Problem is wrong two different ways joes <noreply@example.com> - 2024-06-05 18:33 +0000
Re: Halting Problem is wrong two different ways --very stupid olcott <polcott333@gmail.com> - 2024-06-05 21:09 -0500
Re: Halting Problem is wrong two different ways --very stupid Richard Damon <richard@damon-family.org> - 2024-06-05 22:28 -0400
Re: Halting Problem is wrong two different ways --very stupid Mikko <mikko.levanto@iki.fi> - 2024-06-06 11:52 +0300
Re: Halting Problem is wrong two different ways --very stupid olcott <polcott333@gmail.com> - 2024-06-06 08:37 -0500
Re: Halting Problem is wrong two different ways --very stupid Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-05 19:42 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-06 11:45 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 08:23 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-04 22:22 -0400
Re: Halting Problem is wrong two different ways "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 10:11 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-05 08:59 -0500
Re: Halting Problem is wrong two different ways "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 20:51 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-05 17:44 -0500
Re: Halting Problem is wrong two different ways "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-06 18:01 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 11:07 -0500
Re: Halting Problem is wrong two different ways "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-06 18:34 +0200
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 11:44 -0500
Re: Halting Problem is wrong two different ways immibis <news2@immibis.com> - 2024-06-06 20:09 +0200
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-05 19:46 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-06 12:02 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 08:41 -0500
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-06 18:07 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 10:15 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-07 09:19 +0300
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-06 22:08 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-05 10:13 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-05 08:18 -0500
Re: Halting Problem is wrong two different ways joes <noreply@example.com> - 2024-06-05 18:25 +0000
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-05 19:51 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-06 12:34 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 08:48 -0500
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-06 18:09 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-06 10:18 -0500
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-07 09:22 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-07 09:09 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-07 11:14 -0400
Re: Halting Problem is wrong two different ways joes <noreply@example.com> - 2024-06-07 21:02 +0000
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-07 17:27 -0500
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-08 09:13 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-08 07:42 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-09 11:09 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-09 08:27 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: Halting Problem is wrong two different ways Mikko <mikko.levanto@iki.fi> - 2024-06-08 09:06 +0300
Re: Halting Problem is wrong two different ways olcott <polcott333@gmail.com> - 2024-06-08 07:35 -0500
Re: Halting Problem is wrong two different ways Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: Halting Problem is wrong two different ways immibis <news@immibis.com> - 2024-06-07 16:25 +0200
Re: Why does Olcott care about simulation, anyway? --- Ben's Review immibis <news@immibis.com> - 2024-06-04 16:38 +0200
Re: Why does Olcott care about simulation, anyway? --- Ben's Review "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 22:09 +0200
Mike Terry Reply to Fred Zwarts olcott <polcott333@gmail.com> - 2024-06-03 16:24 -0500
Re: Mike Terry Reply to Fred Zwarts "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-04 12:29 +0200
Re: Mike Terry Reply to Fred Zwarts "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-04 12:52 +0200
Re: Mike Terry Reply to Fred Zwarts Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-04 17:58 +0100
How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-04 13:02 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-04 21:26 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-04 17:16 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-04 21:48 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 10:21 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 09:04 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-05 18:28 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 20:55 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-05 09:32 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 07:45 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-05 18:05 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error John Smith <news2@immibis.com> - 2024-06-05 03:20 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-04 20:33 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error John Smith <news2@immibis.com> - 2024-06-05 03:39 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-04 21:07 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error John Smith <news2@immibis.com> - 2024-06-05 04:13 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-04 21:19 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error John Smith <news2@immibis.com> - 2024-06-05 17:40 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 11:51 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-05 18:38 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-05 19:52 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Ben Bacarisse <ben@bsb.me.uk> - 2024-06-05 10:38 +0100
Re: How Partial Simulations correctly determine non-halting --- Ben's strawman deception olcott <polcott333@gmail.com> - 2024-06-05 07:09 -0500
Re: How Partial Simulations correctly determine non-halting --- Ben's strawman deception joes <noreply@example.com> - 2024-06-05 17:57 +0000
Re: How Partial Simulations correctly determine non-halting --- Ben's strawman deception olcon'tt <news2@immibis.com> - 2024-06-07 16:10 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-05 16:55 +0100
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 11:49 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error John Smith <news2@immibis.com> - 2024-06-05 19:25 +0200
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 12:35 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-05 18:22 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-06 00:33 +0100
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error !!! olcott <polcott333@gmail.com> - 2024-06-05 19:48 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error !!! Richard Damon <richard@damon-family.org> - 2024-06-05 21:10 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-05 21:28 +0100
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 17:07 -0500
Re: How Partial Simulations incorrectly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-05 23:04 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-06 22:55 +0100
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-06 21:53 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-06 23:29 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-07 14:55 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-07 09:59 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-07 11:14 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error joes <noreply@example.com> - 2024-06-07 15:24 +0000
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-04 21:48 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mikko <mikko.levanto@iki.fi> - 2024-06-05 10:37 +0300
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-05 08:29 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-05 19:54 -0400
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mikko <mikko.levanto@iki.fi> - 2024-06-06 13:15 +0300
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-06 08:53 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mikko <mikko.levanto@iki.fi> - 2024-06-06 18:14 +0300
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error olcott <polcott333@gmail.com> - 2024-06-06 10:31 -0500
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Mikko <mikko.levanto@iki.fi> - 2024-06-07 09:30 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 09:47 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Python <python@invalid.org> - 2024-06-07 16:55 +0200
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 10:05 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Python <python@invalid.org> - 2024-06-07 17:09 +0200
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 10:20 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 11:28 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-07 15:32 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 10:40 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 11:51 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-07 16:34 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 11:53 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-07 20:40 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-08 03:43 +0100
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 23:03 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 22:36 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 08:43 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 10:05 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 11:15 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 08:45 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 22:16 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 09:03 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-08 09:28 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 07:47 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 08:59 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 08:22 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 10:06 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-08 17:43 +0100
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis --- olcott <polcott333@gmail.com> - 2024-06-08 12:19 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis --- Richard Damon <richard@damon-family.org> - 2024-06-08 16:33 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 11:19 -0400
Re: How Partial Simulations incorrectly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-07 15:27 +0000
Re: How Partial Simulations incorrectly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 10:30 -0500
Re: How Partial Simulations incorrectly determine non-halting ---Ben's 10/2022 analysis news2@immibis.com - 2024-06-07 17:32 +0200
Re: How Partial Simulations incorrectly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 11:52 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 11:14 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-07 19:56 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 12:11 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 14:32 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-08 09:36 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 07:52 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 09:10 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 08:48 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 10:10 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 09:20 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 10:54 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 10:07 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 11:15 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 10:32 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 12:03 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 12:10 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? joes <noreply@example.com> - 2024-06-08 18:12 +0000
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 13:36 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? joes <noreply@example.com> - 2024-06-08 19:59 +0000
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 15:15 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? joes <noreply@example.com> - 2024-06-08 21:37 +0000
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 16:42 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 17:50 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 17:04 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 18:27 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 17:34 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 22:47 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 21:58 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 23:53 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 23:02 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-09 00:11 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 23:38 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Mikko <mikko.levanto@iki.fi> - 2024-06-09 11:38 +0300
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-09 08:58 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Mikko <mikko.levanto@iki.fi> - 2024-06-09 18:56 +0300
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-09 11:23 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Mikko <mikko.levanto@iki.fi> - 2024-06-10 09:30 +0300
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-10 09:59 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Mikko <mikko.levanto@iki.fi> - 2024-06-11 10:35 +0300
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-11 12:38 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 16:23 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 15:34 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 16:47 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 15:52 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 16:57 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 16:14 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 17:28 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 16:38 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 17:48 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 16:58 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 18:25 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 17:30 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 22:47 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 22:02 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-08 23:56 -0400
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? olcott <polcott333@gmail.com> - 2024-06-08 23:06 -0500
Re: How Partial Simulations correctly determine non-halting ---Should I quit Richard at this point? Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 11:20 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 08:53 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 18:15 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 11:18 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-10 09:57 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-10 10:05 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-11 10:22 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-10 12:50 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-07 21:00 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 17:26 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 19:00 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-07 23:19 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 18:44 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 20:38 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Python <python@invalid.org> - 2024-06-08 02:25 +0200
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-07 19:35 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-07 20:48 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-08 09:42 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 08:04 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 15:20 +0200
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 08:32 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-08 15:56 +0200
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 09:11 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 10:20 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 10:17 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 09:36 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis joes <noreply@example.com> - 2024-06-08 13:46 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-08 09:02 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-08 10:31 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 11:52 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 09:03 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 18:13 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 11:15 -0500
Re: How Partial Simulations correctly determine non-halting joes <noreply@example.com> - 2024-06-09 17:47 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-10 10:54 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-10 10:22 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 11:47 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 08:59 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-09 18:11 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-09 11:09 -0500
Re: How Partial Simulations correctly determine non-halting -- TM as finite string joes <noreply@example.com> - 2024-06-09 17:50 +0000
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-10 11:01 +0300
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis olcott <polcott333@gmail.com> - 2024-06-10 10:23 -0500
Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis Mikko <mikko.levanto@iki.fi> - 2024-06-11 10:25 +0300
Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error Richard Damon <richard@damon-family.org> - 2024-06-07 11:14 -0400
Re: Mike Terry Reply to Fred Zwarts "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-04 13:02 +0200
Re: Why does Olcott care about simulation, anyway? --- Ben's Review Richard Damon <richard@damon-family.org> - 2024-06-03 20:56 -0400
Re: Why does Olcott care about simulation, anyway? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-03 17:58 +0100
Re: Why does Olcott care about simulation, anyway? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 09:58 +0200
Re: Why does Olcott care about simulation, anyway? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-03 18:36 +0100
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-03 13:03 -0500
Re: Why does Olcott care about simulation, anyway? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-06-03 19:56 +0100
Re: Why does Olcott care about simulation, anyway? --- woeful ignorance olcott <polcott333@gmail.com> - 2024-06-03 14:26 -0500
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-03 19:47 -0500
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-03 20:59 -0400
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-03 20:05 -0500
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-03 21:44 -0400
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-03 20:54 -0500
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-03 21:58 -0400
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-03 21:09 -0500
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-03 22:26 -0400
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-03 21:47 -0500
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-03 22:53 -0400
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-04 12:06 -0500
Re: Why does Olcott care about simulation, anyway? Richard Damon <richard@damon-family.org> - 2024-06-04 21:47 -0400
Re: Why does Olcott care about simulation, anyway? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-05 10:31 +0200
Re: Why does Olcott care about simulation, anyway? olcott <polcott333@gmail.com> - 2024-06-05 09:06 -0500
Re: Why is Olcott so ignorant, anyway? immibis <news@immibis.com> - 2024-06-04 17:25 +0200
Re: Why does Olcott care about simulation, anyway? Mikko <mikko.levanto@iki.fi> - 2024-06-03 13:38 +0300
Page 7 of 17 — ← Prev page 1 … 5 6 [7] 8 9 … 17 Next page →
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-05 20:55 +0200 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3qcbs$1305p$2@dont-email.me> |
| In reply to | #106318 |
Op 05.jun.2024 om 16:04 schreef olcott:
> On 6/5/2024 3:21 AM, Fred. Zwarts wrote:
>> Op 05.jun.2024 om 00:16 schreef olcott:
>>> On 6/4/2024 4:26 PM, joes wrote:
>>>> Am Tue, 04 Jun 2024 13:02:03 -0500 schrieb olcott:
>>>>> On 6/4/2024 11:58 AM, Mike Terry wrote:
>>>>>> On 04/06/2024 11:52, Fred. Zwarts wrote:
>>>>>>> Op 04.jun.2024 om 12:29 schreef Fred. Zwarts:
>>>>>>>> Op 03.jun.2024 om 23:24 schreef olcott:
>>>>>>>>> On 6/3/2024 3:09 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 03.jun.2024 om 14:20 schreef olcott:
>>>>>>>>>>> On 6/3/2024 4:42 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> Mike Terry <news.dead.person.stones@darjeeling.plus.com>
>>>>>>>>>>>> writes:
>>>>>>>>>>>>
>>>>>>>>>>> *DD correctly simulated by HH would never stop running unless
>>>>>>>>>>> aborted*
>>>>>>>>>>> *We can see that the following DD cannot possibly halt when*
>>>>>>>>>>> *correctly simulated by every HH that can possibly exist*
>>>>>>>>>>
>>>>>>>>>> It is very clear that if the simulated HH would halt, then DD
>>>>>>>>>> would
>>>>>>>>>> halt. So your claim comes down to HH not halting when simulating
>>>>>>>>>> itself.
>>>>>>>>>>
>>>>>>>>> Mike Terry replied to this and explained it correctly as reply
>>>>>>>>> directly to you On 6/3/2024 12:36 PM, Mike Terry wrote:
>>>>>>>>>
>>>>>>>>> http://al.howardknight.net/?
>>>> STYPE=msgid&MSGI=%3CHlGdnbvc3Ly_YsD7nZ2dnZfqn_adnZ2d%40brightview.co.uk%3E
>>>>>>>>>
>>>>>>>>>
>>>>>>>> He says that there is no infinite recursion, because the simulation
>>>>>>>> is aborted.
>>>>>>>> If you want to interpret his reply in this way,
>>>>>>
>>>>>> Yes, that's my intended meaning
>>>>>>
>>>>>>> then it also shows that neither HH, nor DD are
>>>>>>>> involved in a recursive recursion. This implies
>>>>>>>
>>>>>>> That should be: ... are involved in an infinite recursion,
>>>>>>> because the
>>>>>>> simulation was aborted,
>>>>>>
>>>>>> Yes. (There is finite recursive simulation, i.e. H partially
>>>>>> simulates
>>>>>> H etc..)
>>>>>>
>>>>>>> which implies ...
>>>>>>>
>>>>>>>> that none of them reaches their final state.
>>>>>>
>>>>>> None of their /simulations by H/ reach their final state. Obviously
>>>>>> there's a huge distinction between the abstract concept of a
>>>>>> computation/halting, and a partial simulation of that computation by
>>>>>> some other program, and I'm surprised anyone (not you specifically)
>>>>>> tolerates confusion on that point.
>>>>>>
>>>>>> Suppose P(I) is some computation that halts after 13422 steps.
>>>>>> Clearly
>>>>>> a partial simulation of P(I) by H could be abandoned ("aborted")
>>>>>> after
>>>>>> 8333 steps. So the /partial simulation by H/ "does not halt", but
>>>>>> the
>>>>>> computation P(I) of course halts.
>>>>>>
>>>>>> I'm not trying to suggest that considering the "halting" behaviour
>>>>>> of a
>>>>>> partial simulation by a specific program is a /useful/ thing to be
>>>>>> looking at, but none the less that is what PO is doing...
>>>>>>
>>>>> The meaning of these words prove that I am correct about how partial
>>>>> simulations correctly determine the halt status of their non-halting
>>>>> inputs.
>>>>> <Professor Sipser agreed>
>>>>> </Professor Sipser agreed>
>>>>
>>>> You completely missed the point. The simulator absolutely can keep
>>>> track
>>>> of repeating states; it just can't halt if its input doesn't,
>>>
>>> You don't seem to know the first thing about deciders, in that
>>> they must always halt.
>>>
>>
>> Yes. And the fact that your decider diagnoses itself as non-halting
>> proves that there is something wrong with your decider.
>> Get the cream out of your eyes!
>>
>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>
>> int H(ptr p, ptr i);
>>
>> int main()
>> {
>> H(main, 0);
>> }
>>
>> H diagnoses this program as non-halting. The only reason is obvious:
>> the simulation of H by itself did not reach the final state.
>
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
>
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
> *The simulation of H is not required to halt*
>
> I actually tried this example and it does prove that main()
> halts and it also proves that the directly executed H(main, 0)
> halts and correctly returns 0; I gave you all of the details
> in another reply.
>
H reported 0, meaning that main does not halt. Clearly a false negative,
because you proved that main does halt. Exactly my point.
Thanks for the support.
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-05 09:32 +0000 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3pbas$338rb$1@i2pn2.org> |
| In reply to | #106260 |
Am Tue, 04 Jun 2024 17:16:48 -0500 schrieb olcott:
> On 6/4/2024 4:26 PM, joes wrote:
>> Am Tue, 04 Jun 2024 13:02:03 -0500 schrieb olcott:
>>> On 6/4/2024 11:58 AM, Mike Terry wrote:
>>>> On 04/06/2024 11:52, Fred. Zwarts wrote:
>>>>> Op 04.jun.2024 om 12:29 schreef Fred. Zwarts:
>>>>>> Op 03.jun.2024 om 23:24 schreef olcott:
>>>>>>> On 6/3/2024 3:09 PM, Fred. Zwarts wrote:
>>>>>>>> Op 03.jun.2024 om 14:20 schreef olcott:
>>>>>>>>> On 6/3/2024 4:42 AM, Ben Bacarisse wrote:
>>>>>>>>>> Mike Terry <news.dead.person.stones@darjeeling.plus.com>
>>>>>>>>>> writes:
>>>> None of their /simulations by H/ reach their final state. Obviously
>>>> there's a huge distinction between the abstract concept of a
>>>> computation/halting, and a partial simulation of that computation by
>>>> some other program, and I'm surprised anyone (not you specifically)
>>>> tolerates confusion on that point.
>>>>
>>>> Suppose P(I) is some computation that halts after 13422 steps.
>>>> Clearly a partial simulation of P(I) by H could be abandoned
>>>> ("aborted") after 8333 steps. So the /partial simulation by H/ "does
>>>> not halt", but the computation P(I) of course halts.
>>>>
>>>> I'm not trying to suggest that considering the "halting" behaviour of
>>>> a partial simulation by a specific program is a /useful/ thing to be
>>>> looking at, but none the less that is what PO is doing...
>>>>
>>> The meaning of these words prove that I am correct about how partial
>>> simulations correctly determine the halt status of their non-halting
>>> inputs.
>>> <Professor Sipser agreed>
>>> </Professor Sipser agreed>
>>
>> You completely missed the point. The simulator absolutely can keep
>> track of repeating states; it just can't halt if its input doesn't,
>
> You don't seem to know the first thing about deciders, in that they must
> always halt.
You don't seem to know the first thing about simulators, in that they can
never abort.
So why can't reach past line 4 if H halts and returns from infinite
recursion?
>> because that is a difference in behaviour which it is not allowed to
>> have.
--
joes
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-05 07:45 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3pmlj$v133$3@dont-email.me> |
| In reply to | #106302 |
On 6/5/2024 4:32 AM, joes wrote:
> Am Tue, 04 Jun 2024 17:16:48 -0500 schrieb olcott:
>> On 6/4/2024 4:26 PM, joes wrote:
>>> Am Tue, 04 Jun 2024 13:02:03 -0500 schrieb olcott:
>>>> On 6/4/2024 11:58 AM, Mike Terry wrote:
>>>>> On 04/06/2024 11:52, Fred. Zwarts wrote:
>>>>>> Op 04.jun.2024 om 12:29 schreef Fred. Zwarts:
>>>>>>> Op 03.jun.2024 om 23:24 schreef olcott:
>>>>>>>> On 6/3/2024 3:09 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 03.jun.2024 om 14:20 schreef olcott:
>>>>>>>>>> On 6/3/2024 4:42 AM, Ben Bacarisse wrote:
>>>>>>>>>>> Mike Terry <news.dead.person.stones@darjeeling.plus.com>
>>>>>>>>>>> writes:
>
>>>>> None of their /simulations by H/ reach their final state. Obviously
>>>>> there's a huge distinction between the abstract concept of a
>>>>> computation/halting, and a partial simulation of that computation by
>>>>> some other program, and I'm surprised anyone (not you specifically)
>>>>> tolerates confusion on that point.
>>>>>
>>>>> Suppose P(I) is some computation that halts after 13422 steps.
>>>>> Clearly a partial simulation of P(I) by H could be abandoned
>>>>> ("aborted") after 8333 steps. So the /partial simulation by H/ "does
>>>>> not halt", but the computation P(I) of course halts.
>>>>>
>>>>> I'm not trying to suggest that considering the "halting" behaviour of
>>>>> a partial simulation by a specific program is a /useful/ thing to be
>>>>> looking at, but none the less that is what PO is doing...
>>>>>
>>>> The meaning of these words prove that I am correct about how partial
>>>> simulations correctly determine the halt status of their non-halting
>>>> inputs.
>>>> <Professor Sipser agreed>
>>>> </Professor Sipser agreed>
>>>
>>> You completely missed the point. The simulator absolutely can keep
>>> track of repeating states; it just can't halt if its input doesn't,
>>
>> You don't seem to know the first thing about deciders, in that they must
>> always halt.
> You don't seem to know the first thing about simulators, in that they can
> never abort.
I am apparently the sole inventor of a simulating halt decider.
A simulator correctly simulates and typically does not halt
when its input does not halt. A halt decider must always halt.
When we combine these two terms together then we get a simulator
that always halts.
<Professor Sipser agreed>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</Professor Sipser agreed>
Ben Bacarisse checked Professor Sipser really did agree to those
verbatim words, he did not agree or disagree with any other words
in any of his communications with me.
> So why can't reach past line 4 if H halts and returns from infinite
> recursion?
>
Anyone with sufficient expertise in the semantics of either C
or x86 language or both already knows why and everyone else does
not have the required prerequisite knowledge to understand why.
*Here is the complete proof all over again all in one place*
https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf
>>> because that is a difference in behaviour which it is not allowed to
>>> have.
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-05 18:05 +0000 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3q9dv$34b9u$8@i2pn2.org> |
| In reply to | #106307 |
Am Wed, 05 Jun 2024 07:45:39 -0500 schrieb olcott: > On 6/5/2024 4:32 AM, joes wrote: >> Am Tue, 04 Jun 2024 17:16:48 -0500 schrieb olcott: >>> On 6/4/2024 4:26 PM, joes wrote: >>>> Am Tue, 04 Jun 2024 13:02:03 -0500 schrieb olcott: >>>>> On 6/4/2024 11:58 AM, Mike Terry wrote: >>>>>> On 04/06/2024 11:52, Fred. Zwarts wrote: >>>>>>> Op 04.jun.2024 om 12:29 schreef Fred. Zwarts: >>>>>>>> Op 03.jun.2024 om 23:24 schreef olcott: >>>>>>>>> On 6/3/2024 3:09 PM, Fred. Zwarts wrote: >>>>>>>>>> Op 03.jun.2024 om 14:20 schreef olcott: >>>>>>>>>>> On 6/3/2024 4:42 AM, Ben Bacarisse wrote: >>>>>>>>>>>> Mike Terry <news.dead.person.stones@darjeeling.plus.com> >>>>>>>>>>>> writes: >> You don't seem to know the first thing about simulators, in that they >> can never abort. > I am apparently the sole inventor of a simulating halt decider. > A simulator correctly simulates and typically does not halt when its > input does not halt. A halt decider must always halt. When we combine > these two terms together then we get a simulator that always halts. What is the correct behaviour on a nonterminating input? > <Professor Sipser agreed> > </Professor Sipser agreed> You should ask him if a simulator is allowed to abort a nonterminating input. >> So why can't reach past line 4 if H halts and returns from infinite >> recursion? > Anyone with sufficient expertise in the semantics of either C or x86 > language or both already knows why and everyone else does not have the > required prerequisite knowledge to understand why. Ad hominem. What happens after H halts? -- joes
[toc] | [prev] | [next] | [standalone]
| From | John Smith <news2@immibis.com> |
|---|---|
| Date | 2024-06-05 03:20 +0200 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3oeh5$jthg$2@dont-email.me> |
| In reply to | #106256 |
On 4/06/24 20:02, olcott wrote:
> Those words are dead obviously correct about how a partial simulation
> does correctly determine the halt status of this function:
>
> void Infinite_Recursion2(u32 N)
> {
> H(Infinite_Recursion2, (ptr)N);
> }
Does Infinite_Recursion2 halt?
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-04 20:33 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3of8e$lirl$1@dont-email.me> |
| In reply to | #106262 |
On 6/4/2024 8:20 PM, John Smith wrote:
> On 4/06/24 20:02, olcott wrote:
>> Those words are dead obviously correct about how a partial simulation
>> does correctly determine the halt status of this function:
>>
>> void Infinite_Recursion2(u32 N)
>> {
>> H(Infinite_Recursion2, (ptr)N);
>> }
>
> Does Infinite_Recursion2 halt?
When halting is defined in the software engineering terms of
terminating normally then Infinite_Recursion2 does not even
halt when it runs out of stack space and crashes.
*Tail Recursion*
Tail recursion is a recursion of a function where it does not consumes
stack space and hence prevents stack overflow. If the recursive function
is made tail-recursive then it is more efficient than a non-tail-
recursive function because every function call does not need to go on
stack and pop when the call is done. And it prevents the ugly stack
overflow.
https://vijeshsalian.medium.com/recursion-how-to-overflow-the-stack-and-how-not-to-b9dcffdfab27
--
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 | John Smith <news2@immibis.com> |
|---|---|
| Date | 2024-06-05 03:39 +0200 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3ofld$jthh$1@dont-email.me> |
| In reply to | #106263 |
On 5/06/24 03:33, olcott wrote:
> On 6/4/2024 8:20 PM, John Smith wrote:
>> On 4/06/24 20:02, olcott wrote:
>>> Those words are dead obviously correct about how a partial simulation
>>> does correctly determine the halt status of this function:
>>>
>>> void Infinite_Recursion2(u32 N)
>>> {
>>> H(Infinite_Recursion2, (ptr)N);
>>> }
>>
>> Does Infinite_Recursion2 halt?
>
> When halting is defined in the software engineering terms of
> terminating normally then Infinite_Recursion2 does not even
> halt when it runs out of stack space and crashes.
H always halts, and never runs out of stack space, because it is a
decider. How does Infinite_Recursion2 run out of stack space, if H
doesn't run out of stack space?
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-04 21:07 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3oh8l$pi6u$3@dont-email.me> |
| In reply to | #106264 |
On 6/4/2024 8:39 PM, John Smith wrote:
> On 5/06/24 03:33, olcott wrote:
>> On 6/4/2024 8:20 PM, John Smith wrote:
>>> On 4/06/24 20:02, olcott wrote:
>>>> Those words are dead obviously correct about how a partial simulation
>>>> does correctly determine the halt status of this function:
>>>>
>>>> void Infinite_Recursion2(u32 N)
>>>> {
>>>> H(Infinite_Recursion2, (ptr)N);
>>>> }
>>>
>>> Does Infinite_Recursion2 halt?
>>
>> When halting is defined in the software engineering terms of
>> terminating normally then Infinite_Recursion2 does not even
>> halt when it runs out of stack space and crashes.
>
> H always halts, and never runs out of stack space, because it is a
> decider. How does Infinite_Recursion2 run out of stack space, if H
> doesn't run out of stack space?
>
When we are on actual physical machines as my fully operational
HH/DD are running put of stack space is possible.
--
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 | John Smith <news2@immibis.com> |
|---|---|
| Date | 2024-06-05 04:13 +0200 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3ohkh$jthg$4@dont-email.me> |
| In reply to | #106277 |
On 5/06/24 04:07, olcott wrote:
> On 6/4/2024 8:39 PM, John Smith wrote:
>> On 5/06/24 03:33, olcott wrote:
>>> On 6/4/2024 8:20 PM, John Smith wrote:
>>>> On 4/06/24 20:02, olcott wrote:
>>>>> Those words are dead obviously correct about how a partial simulation
>>>>> does correctly determine the halt status of this function:
>>>>>
>>>>> void Infinite_Recursion2(u32 N)
>>>>> {
>>>>> H(Infinite_Recursion2, (ptr)N);
>>>>> }
>>>>
>>>> Does Infinite_Recursion2 halt?
>>>
>>> When halting is defined in the software engineering terms of
>>> terminating normally then Infinite_Recursion2 does not even
>>> halt when it runs out of stack space and crashes.
>>
>> H always halts, and never runs out of stack space, because it is a
>> decider. How does Infinite_Recursion2 run out of stack space, if H
>> doesn't run out of stack space?
>>
>
> When we are on actual physical machines as my fully operational
> HH/DD are running put of stack space is possible.
>
Then increase the stack space until it doesn't run out. Turing machines
can't run out of stack space unless you programmed them wrong.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-04 21:19 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3ohvb$pi6u$5@dont-email.me> |
| In reply to | #106279 |
On 6/4/2024 9:13 PM, John Smith wrote:
> On 5/06/24 04:07, olcott wrote:
>> On 6/4/2024 8:39 PM, John Smith wrote:
>>> On 5/06/24 03:33, olcott wrote:
>>>> On 6/4/2024 8:20 PM, John Smith wrote:
>>>>> On 4/06/24 20:02, olcott wrote:
>>>>>> Those words are dead obviously correct about how a partial simulation
>>>>>> does correctly determine the halt status of this function:
>>>>>>
>>>>>> void Infinite_Recursion2(u32 N)
>>>>>> {
>>>>>> H(Infinite_Recursion2, (ptr)N);
>>>>>> }
>>>>>
>>>>> Does Infinite_Recursion2 halt?
>>>>
>>>> When halting is defined in the software engineering terms of
>>>> terminating normally then Infinite_Recursion2 does not even
>>>> halt when it runs out of stack space and crashes.
>>>
>>> H always halts, and never runs out of stack space, because it is a
>>> decider. How does Infinite_Recursion2 run out of stack space, if H
>>> doesn't run out of stack space?
>>>
>>
>> When we are on actual physical machines as my fully operational
>> HH/DD are running put of stack space is possible.
>>
>
> Then increase the stack space until it doesn't run out. Turing machines
> can't run out of stack space unless you programmed them wrong.
It is fully operational C code it can run out of stack space
even if you give it googolplex of terabytes.
--
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 | John Smith <news2@immibis.com> |
|---|---|
| Date | 2024-06-05 17:40 +0200 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3q0u4$q84p$1@dont-email.me> |
| In reply to | #106281 |
On 5/06/24 04:19, olcott wrote:
> On 6/4/2024 9:13 PM, John Smith wrote:
>> On 5/06/24 04:07, olcott wrote:
>>> On 6/4/2024 8:39 PM, John Smith wrote:
>>>> On 5/06/24 03:33, olcott wrote:
>>>>> On 6/4/2024 8:20 PM, John Smith wrote:
>>>>>> On 4/06/24 20:02, olcott wrote:
>>>>>>> Those words are dead obviously correct about how a partial
>>>>>>> simulation
>>>>>>> does correctly determine the halt status of this function:
>>>>>>>
>>>>>>> void Infinite_Recursion2(u32 N)
>>>>>>> {
>>>>>>> H(Infinite_Recursion2, (ptr)N);
>>>>>>> }
>>>>>>
>>>>>> Does Infinite_Recursion2 halt?
>>>>>
>>>>> When halting is defined in the software engineering terms of
>>>>> terminating normally then Infinite_Recursion2 does not even
>>>>> halt when it runs out of stack space and crashes.
>>>>
>>>> H always halts, and never runs out of stack space, because it is a
>>>> decider. How does Infinite_Recursion2 run out of stack space, if H
>>>> doesn't run out of stack space?
>>>>
>>>
>>> When we are on actual physical machines as my fully operational
>>> HH/DD are running put of stack space is possible.
>>>
>>
>> Then increase the stack space until it doesn't run out. Turing
>> machines can't run out of stack space unless you programmed them wrong.
>
> It is fully operational C code it can run out of stack space
> even if you give it googolplex of terabytes.
>
Sounds like it's infinite recursion. Infinite recursion doesn't halt.
Deciders always halt, so a program that's infinitely recursive isn't a
decider.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-05 11:51 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3q52d$11tp3$2@dont-email.me> |
| In reply to | #106321 |
On 6/5/2024 10:40 AM, John Smith wrote:
> On 5/06/24 04:19, olcott wrote:
>> On 6/4/2024 9:13 PM, John Smith wrote:
>>> On 5/06/24 04:07, olcott wrote:
>>>> On 6/4/2024 8:39 PM, John Smith wrote:
>>>>> On 5/06/24 03:33, olcott wrote:
>>>>>> On 6/4/2024 8:20 PM, John Smith wrote:
>>>>>>> On 4/06/24 20:02, olcott wrote:
>>>>>>>> Those words are dead obviously correct about how a partial
>>>>>>>> simulation
>>>>>>>> does correctly determine the halt status of this function:
>>>>>>>>
>>>>>>>> void Infinite_Recursion2(u32 N)
>>>>>>>> {
>>>>>>>> H(Infinite_Recursion2, (ptr)N);
>>>>>>>> }
>>>>>>>
>>>>>>> Does Infinite_Recursion2 halt?
>>>>>>
>>>>>> When halting is defined in the software engineering terms of
>>>>>> terminating normally then Infinite_Recursion2 does not even
>>>>>> halt when it runs out of stack space and crashes.
>>>>>
>>>>> H always halts, and never runs out of stack space, because it is a
>>>>> decider. How does Infinite_Recursion2 run out of stack space, if H
>>>>> doesn't run out of stack space?
>>>>>
>>>>
>>>> When we are on actual physical machines as my fully operational
>>>> HH/DD are running put of stack space is possible.
>>>>
>>>
>>> Then increase the stack space until it doesn't run out. Turing
>>> machines can't run out of stack space unless you programmed them wrong.
>>
>> It is fully operational C code it can run out of stack space
>> even if you give it googolplex of terabytes.
>>
>
> Sounds like it's infinite recursion. Infinite recursion doesn't halt.
> Deciders always halt, so a program that's infinitely recursive isn't a
> decider.
HH detects non-halting inputs and stops simulating them when
it sees a repeating state.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-05 18:38 +0000 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3qba8$34b9u$16@i2pn2.org> |
| In reply to | #106324 |
Am Wed, 05 Jun 2024 11:51:24 -0500 schrieb olcott: > On 6/5/2024 10:40 AM, John Smith wrote: >> On 5/06/24 04:19, olcott wrote: >>> On 6/4/2024 9:13 PM, John Smith wrote: >>>> On 5/06/24 04:07, olcott wrote: >>>>> On 6/4/2024 8:39 PM, John Smith wrote: >>>>>> On 5/06/24 03:33, olcott wrote: >>>>>>> On 6/4/2024 8:20 PM, John Smith wrote: >>>>>>>> On 4/06/24 20:02, olcott wrote: >>> It is fully operational C code it can run out of stack space even if >>> you give it googolplex of terabytes. >> Sounds like it's infinite recursion. Infinite recursion doesn't halt. >> Deciders always halt, so a program that's infinitely recursive isn't a >> decider. > HH detects non-halting inputs and stops simulating them when it sees a > repeating state. As already said many times, non-halting inputs must be simulated forever. -- joes
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-05 19:52 -0400 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3qto3$354ia$3@i2pn2.org> |
| In reply to | #106324 |
On 6/5/24 12:51 PM, olcott wrote:
> On 6/5/2024 10:40 AM, John Smith wrote:
>> On 5/06/24 04:19, olcott wrote:
>>> On 6/4/2024 9:13 PM, John Smith wrote:
>>>> On 5/06/24 04:07, olcott wrote:
>>>>> On 6/4/2024 8:39 PM, John Smith wrote:
>>>>>> On 5/06/24 03:33, olcott wrote:
>>>>>>> On 6/4/2024 8:20 PM, John Smith wrote:
>>>>>>>> On 4/06/24 20:02, olcott wrote:
>>>>>>>>> Those words are dead obviously correct about how a partial
>>>>>>>>> simulation
>>>>>>>>> does correctly determine the halt status of this function:
>>>>>>>>>
>>>>>>>>> void Infinite_Recursion2(u32 N)
>>>>>>>>> {
>>>>>>>>> H(Infinite_Recursion2, (ptr)N);
>>>>>>>>> }
>>>>>>>>
>>>>>>>> Does Infinite_Recursion2 halt?
>>>>>>>
>>>>>>> When halting is defined in the software engineering terms of
>>>>>>> terminating normally then Infinite_Recursion2 does not even
>>>>>>> halt when it runs out of stack space and crashes.
>>>>>>
>>>>>> H always halts, and never runs out of stack space, because it is a
>>>>>> decider. How does Infinite_Recursion2 run out of stack space, if H
>>>>>> doesn't run out of stack space?
>>>>>>
>>>>>
>>>>> When we are on actual physical machines as my fully operational
>>>>> HH/DD are running put of stack space is possible.
>>>>>
>>>>
>>>> Then increase the stack space until it doesn't run out. Turing
>>>> machines can't run out of stack space unless you programmed them wrong.
>>>
>>> It is fully operational C code it can run out of stack space
>>> even if you give it googolplex of terabytes.
>>>
>>
>> Sounds like it's infinite recursion. Infinite recursion doesn't halt.
>> Deciders always halt, so a program that's infinitely recursive isn't a
>> decider.
>
> HH detects non-halting inputs and stops simulating them when
> it sees a repeating state.
>
And Thus, DD that is using that same HH also gets out of that repeating
state.
Or you are just admitting that you have been lying for years that DD was
built correctly, perhaps because you don't know the meaning of the word
correct.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben@bsb.me.uk> |
|---|---|
| Date | 2024-06-05 10:38 +0100 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <87frtr6867.fsf@bsb.me.uk> |
| In reply to | #106279 |
John Smith <news2@immibis.com> writes: > Then increase the stack space until it doesn't run out. Turing machines > can't run out of stack space unless you programmed them wrong. A Turing machine can't run out of stack space because there is no stack. That's like saying a polynomial has limited precision if you evaluate it badly. It's the evaluation that's wrong, not the polynomial. I know what you mean, but having talked to maths crank on Usenet for years, one thing I would caution against is being slowly sucked into the cranks bad use of technical terms. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-05 07:09 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting --- Ben's strawman deception |
| Message-ID | <v3pkig$v133$1@dont-email.me> |
| In reply to | #106303 |
On 6/5/2024 4:38 AM, Ben Bacarisse wrote:
> John Smith <news2@immibis.com> writes:
>
>> Then increase the stack space until it doesn't run out. Turing machines
>> can't run out of stack space unless you programmed them wrong.
>
> A Turing machine can't run out of stack space because there is no stack.
> That's like saying a polynomial has limited precision if you evaluate it
> badly. It's the evaluation that's wrong, not the polynomial. I know
> what you mean, but having talked to maths crank on Usenet for years, one
> thing I would caution against is being slowly sucked into the cranks bad
> use of technical terms.
>
void Recursion_Chain_03(int M)
{
Recursion_Chain_01(M);
}
void Recursion_Chain_02(int M)
{
Recursion_Chain_03(M);
}
void Recursion_Chain_01(int M)
{
Recursion_Chain_02(M);
}
int main()
{
Output("Input_Halts = ", H(Recursion_Chain_01,(ptr)5));
}
My simulating termination analyzer correctly determines
that the above sequence will not terminate.
When theory of computation questions are analyzed on physical machines
having physical memory running out is stack space is possible, thus
changing to subject to something else as a type of rebuttal is still the
strawman deception.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-05 17:57 +0000 |
| Subject | Re: How Partial Simulations correctly determine non-halting --- Ben's strawman deception |
| Message-ID | <v3q8um$34b9u$6@i2pn2.org> |
| In reply to | #106305 |
Am Wed, 05 Jun 2024 07:09:52 -0500 schrieb olcott: > On 6/5/2024 4:38 AM, Ben Bacarisse wrote: >> John Smith <news2@immibis.com> writes: >> >>> Then increase the stack space until it doesn't run out. Turing >>> machines can't run out of stack space unless you programmed them >>> wrong. >> >> A Turing machine can't run out of stack space because there is no >> stack. >> That's like saying a polynomial has limited precision if you evaluate >> it badly. It's the evaluation that's wrong, not the polynomial. I >> know what you mean, but having talked to maths crank on Usenet for >> years, one thing I would caution against is being slowly sucked into >> the cranks bad use of technical terms. > When theory of computation questions are analyzed on physical machines > having physical memory running out is stack space is possible, thus > changing to subject to something else as a type of rebuttal is still the > strawman deception. The halting problem with limited memory is boring. Theory is not concerned with physical problems. -- joes
[toc] | [prev] | [next] | [standalone]
| From | olcon'tt <news2@immibis.com> |
|---|---|
| Date | 2024-06-07 16:10 +0200 |
| Subject | Re: How Partial Simulations correctly determine non-halting --- Ben's strawman deception |
| Message-ID | <v3v4d0$1o9em$2@dont-email.me> |
| In reply to | #106305 |
On 5/06/24 14:09, olcott wrote:
>
> void Recursion_Chain_03(int M)
> {
> Recursion_Chain_01(M);
> }
>
> void Recursion_Chain_02(int M)
> {
> Recursion_Chain_03(M);
> }
>
> void Recursion_Chain_01(int M)
> {
> Recursion_Chain_02(M);
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Recursion_Chain_01,(ptr)5));
> }
>
> My simulating termination analyzer correctly determines
> that the above sequence will not terminate.
Your simulating termination analyzer incorrectly determines that the
below sequence will not terminate.
void Recursion_Chain_03(int M)
{
H(Recursion_Chain_01, M);
}
void Recursion_Chain_02(int M)
{
H(Recursion_Chain_03, M);
}
void Recursion_Chain_01(int M)
{
H(Recursion_Chain_02, M);
}
int main()
{
Output("Input_Halts = ", H(Recursion_Chain_01,(ptr)5));
}
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2024-06-05 16:55 +0100 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <p5ydnbxV2pHtF_37nZ2dnZfqn_WdnZ2d@brightview.co.uk> |
| In reply to | #106303 |
On 05/06/2024 10:38, Ben Bacarisse wrote: > John Smith <news2@immibis.com> writes: > >> Then increase the stack space until it doesn't run out. Turing machines >> can't run out of stack space unless you programmed them wrong. > > A Turing machine can't run out of stack space because there is no stack. > That's like saying a polynomial has limited precision if you evaluate it > badly. It's the evaluation that's wrong, not the polynomial. I know > what you mean, but having talked to maths crank on Usenet for years, one > thing I would caution against is being slowly sucked into the cranks bad > use of technical terms. > Wandering slightly : also, PO's H/HH/etc. (running under x86utm) requires minimal stack space to run - probably just a few KB would suffice, /regardless of recursion depth/. Given that PO allocates 64KB for the stack, this is not going to be a problem. The reason recusion depth is not a factor is that H /simulates/ D rather than calling it. The simulation does not consume H's stack space, and neither do nested simulations - they all have their own separately allocated stacks. PO's design uses a single 32-bit address space which must hold ALL levels of nested recursion, so obviously something has to fail as nesting levels grow. That would be an "out of memory" failure when trying to acquire resource to create a new simulation level. I.e. a /heap/ error rather than "out of stack". In practice his system would become unusable long before then due to CPU requirements in simulating instructions for each recursion level - that grows exponentially with a factor of (something like) 200 between each level. So at a recursive simulation depth of just 10, a single instruction would take something like 100,000,000,000,000,000,000,000 outer level instructions to simulate, which is just impractical. Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-05 11:49 -0500 |
| Subject | Re: How Partial Simulations correctly determine non-halting ---Mike Terry Error |
| Message-ID | <v3q4ut$11tp3$1@dont-email.me> |
| In reply to | #106322 |
On 6/5/2024 10:55 AM, Mike Terry wrote: > On 05/06/2024 10:38, Ben Bacarisse wrote: >> John Smith <news2@immibis.com> writes: >> >>> Then increase the stack space until it doesn't run out. Turing machines >>> can't run out of stack space unless you programmed them wrong. >> >> A Turing machine can't run out of stack space because there is no stack. >> That's like saying a polynomial has limited precision if you evaluate it >> badly. It's the evaluation that's wrong, not the polynomial. I know >> what you mean, but having talked to maths crank on Usenet for years, one >> thing I would caution against is being slowly sucked into the cranks bad >> use of technical terms. >> > > Wandering slightly : also, PO's H/HH/etc. (running under x86utm) > requires minimal stack space to run - probably just a few KB would > suffice, /regardless of recursion depth/. Given that PO allocates 64KB > for the stack, this is not going to be a problem. > > The reason recusion depth is not a factor is that H /simulates/ D rather > than calling it. The simulation does not consume H's stack space, and > neither do nested simulations - they all have their own separately > allocated stacks. > > PO's design uses a single 32-bit address space which must hold ALL > levels of nested recursion, so obviously something has to fail as > nesting levels grow. That would be an "out of memory" failure when > trying to acquire resource to create a new simulation level. I.e. a > /heap/ error rather than "out of stack". > > In practice his system would become unusable long before then due to CPU > requirements in simulating instructions for each recursion level - that > grows exponentially with a factor of (something like) 200 between each > level. So at a recursive simulation depth of just 10, a single > instruction would take something like 100,000,000,000,000,000,000,000 > outer level instructions to simulate, which is just impractical. > > > Mike. > Thank you very much for being the voice of correct reasoning here. I just figured out how to handle your objection to my HH code. My idea was to have the executed HH pass a portion of what is essentially its own Turing Machine tape down to the simulated instances of HH. It does do this now. The key objection that you seemed to have is that it can't pass any information to its simulated instance that they can use in their own halt status decision. None of the simulated instances ever did this, yet I can make this more clear. As soon as they are initialized they can store their own first location of this tape and never look at any location before their own first location. In this case they would never get a chance to look any data from the outer simulations that they can use to change their own behavior. I will implement this in code sometime later today and publish this code to my repository. The only issue left that seems to not matter is that each simulated HH needs to see if it must initialize its own tape. Since this has no effect on its halt status decision I don't think it makes any difference. I will double check everything to make sure there is no data passed from the outer simulations to the inner simulations that can possibly be used for any halt status decision by these inner simulated instances of HH. I really appreciate your help on this. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 7 of 17 — ← Prev page 1 … 5 6 [7] 8 9 … 17 Next page →
Back to top | Article view | comp.theory
csiph-web