Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #103977 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-04-27 19:17 -0500 |
| Last post | 2024-04-29 09:10 -0500 |
| Articles | 20 on this page of 353 — 9 participants |
Back to article view | Back to comp.theory
Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-27 19:17 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-27 20:49 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-27 19:58 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-27 21:39 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-27 20:54 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-27 22:09 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-27 21:33 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-27 23:31 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-27 22:45 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 09:13 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 08:45 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 10:00 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 09:15 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 13:34 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 12:55 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 14:18 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 13:23 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 14:42 -0400
Re: Can D simulated by H terminate normally? POE olcott <polcott333@gmail.com> - 2024-04-28 14:06 -0500
Re: Can D simulated by H terminate normally? POE Richard Damon <richard@damon-family.org> - 2024-04-28 15:29 -0400
Re: Can D simulated by H terminate normally? POE olcott <polcott333@gmail.com> - 2024-04-28 14:43 -0500
Re: Can D simulated by H terminate normally? POE Richard Damon <richard@damon-family.org> - 2024-04-28 19:07 -0400
Re: Can D simulated by H terminate normally? POE olcott <polcott333@gmail.com> - 2024-04-28 17:28 -0500
Re: Can D simulated by H terminate normally? POE Richard Damon <richard@damon-family.org> - 2024-04-28 19:01 -0400
Re: Can D simulated by H terminate normally? POE olcott <polcott333@gmail.com> - 2024-04-28 23:07 -0500
Re: Can D simulated by H terminate normally? POE Richard Damon <richard@damon-family.org> - 2024-04-29 07:25 -0400
Re: Can D simulated by H terminate normally? POE olcott <polcott333@gmail.com> - 2024-04-29 09:47 -0500
Re: Can D simulated by H terminate normally? POE Richard Damon <richard@damon-family.org> - 2024-04-29 19:19 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 14:25 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 13:33 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 14:44 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 14:00 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 15:14 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-28 11:30 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 08:06 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 09:14 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-28 11:23 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 07:56 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 09:19 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 08:52 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 11:08 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 10:33 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 12:08 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 12:50 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 14:06 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 13:19 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 14:39 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 13:52 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 15:18 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 14:26 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 15:36 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 14:48 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 19:05 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 22:48 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-29 07:25 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 09:51 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-29 19:19 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 01:07 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-30 07:33 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 10:55 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-30 18:46 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 22:56 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 07:23 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 11:11 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:10 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 21:59 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:50 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:02 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 00:06 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:13 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 00:17 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-18 09:11 -0400
Re: Can D simulated by H terminate normally? --- Message-ID provided olcott <polcott333@gmail.com> - 2024-05-18 11:24 -0500
Re: Can D simulated by H terminate normally? --- Message-ID provided Richard Damon <richard@damon-family.org> - 2024-05-18 12:49 -0400
Re: Can D simulated by H terminate normally? --- Message-ID provided olcott <polcott333@gmail.com> - 2024-05-18 12:20 -0500
Re: Can D simulated by H terminate normally? --- Message-ID provided Richard Damon <richard@damon-family.org> - 2024-05-18 13:40 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 13:54 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 15:15 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 14:24 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 15:42 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 15:18 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 14:28 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 15:42 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 14:57 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 16:02 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 16:00 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 18:22 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 17:44 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 19:06 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 18:24 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-18 19:38 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-18 22:59 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided immibis <news@immibis.com> - 2024-05-19 14:16 +0200
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-19 08:06 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided immibis <news@immibis.com> - 2024-05-20 06:37 +0200
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-20 00:17 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided immibis <news@immibis.com> - 2024-05-20 10:37 +0200
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-20 10:32 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-20 07:24 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-20 13:17 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-19 08:14 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-19 13:17 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided immibis <news@immibis.com> - 2024-05-20 11:01 +0200
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-20 10:18 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-19 13:17 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-19 14:46 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-19 19:31 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-20 13:28 -0500
Re: Can D simulated by H terminate normally? --- Message_ID Provided Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Can D simulated by H terminate normally? --- Message_ID Provided immibis <news@immibis.com> - 2024-05-21 06:50 +0200
Re: Can D simulated by H terminate normally? --- Message_ID Provided olcott <polcott333@gmail.com> - 2024-05-21 00:05 -0500
Re: Can D simulated by H terminate normally? Message_ID Provided V2 olcott <polcott333@gmail.com> - 2024-05-19 19:06 -0500
Re: Can D simulated by H terminate normally? Message_ID Provided V2 Richard Damon <richard@damon-family.org> - 2024-05-19 21:10 -0400
Re: Can D simulated by H terminate normally? Message_ID Provided V2 olcott <polcott333@gmail.com> - 2024-05-19 21:52 -0500
Re: Can D simulated by H terminate normally? Message_ID Provided V2 Richard Damon <richard@damon-family.org> - 2024-05-19 23:11 -0400
Every D correctly simulated by H cannot possible reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-19 22:22 -0500
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-20 07:24 -0400
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-20 13:03 -0500
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-20 21:25 -0500
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-20 22:39 -0400
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-21 00:18 -0500
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-21 08:03 -0400
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-21 09:22 -0500
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-21 21:46 -0400
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-21 21:05 -0500
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-21 23:09 -0400
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-21 22:52 -0500
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-22 07:48 -0400
Every D correctly simulated by H remains stuck in recursive simulation olcott <polcott333@gmail.com> - 2024-05-22 10:41 -0500
Re: Every D correctly simulated by H remains stuck in recursive simulation Richard Damon <richard@damon-family.org> - 2024-05-22 19:01 -0400
Re: Every D correctly simulated by H remains stuck in recursive simulation olcott <polcott333@gmail.com> - 2024-05-22 21:15 -0500
Re: Every D correctly simulated by H remains stuck in recursive simulation Richard Damon <richard@damon-family.org> - 2024-05-22 22:36 -0400
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-22 09:52 +0200
Re: Every D correctly simulated by H cannot possibly reach its own line 06 and halt joes <noreply@example.com> - 2024-05-22 10:26 +0000
Re: Can D simulated by H terminate normally? Message_ID Provided V2 immibis <news@immibis.com> - 2024-05-20 13:31 +0200
Re: Can D simulated by H terminate normally? Message_ID Provided V2 olcott <polcott333@gmail.com> - 2024-05-20 10:23 -0500
Re: Can D simulated by H terminate normally? Message_ID Provided V2 Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Every D correctly simulated by H cannot possible reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-19 22:09 -0500
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-19 23:24 -0400
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-19 22:32 -0500
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-20 07:24 -0400
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt olcott <polcott333@gmail.com> - 2024-05-20 13:01 -0500
Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-29 16:44 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 09:20 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-30 13:27 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 10:50 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-30 18:46 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 23:19 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-01 09:42 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 10:26 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:16 -0400
Re: Can D simulated by H terminate normally? André G. Isaak <agisaak@gm.invalid> - 2024-05-01 18:44 -0600
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 21:13 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 20:44 -0500
Re: Can D simulated by H terminate normally? André G. Isaak <agisaak@gm.invalid> - 2024-05-01 20:30 -0600
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:55 -0500
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:03 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:54 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 07:23 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 11:26 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:25 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:12 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:54 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:08 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-01 12:51 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 10:51 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:28 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:16 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:50 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:04 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 00:10 -0400
Re: Can D simulated by H terminate normally? --- olcott <polcott333@gmail.com> - 2024-05-01 23:24 -0500
Re: Can D simulated by H terminate normally? --- Richard Damon <richard@damon-family.org> - 2024-05-02 07:04 -0400
Re: Can D simulated by H terminate normally? --- olcott <polcott333@gmail.com> - 2024-05-02 13:48 -0500
Re: Can D simulated by H terminate normally? --- Richard Damon <richard@damon-family.org> - 2024-05-02 21:48 -0400
Re: Can D simulated by H terminate normally? --- olcott <polcott333@gmail.com> - 2024-05-03 07:17 -0500
Re: Can D simulated by H terminate normally? --- Richard Damon <richard@damon-family.org> - 2024-05-03 22:12 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:21 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 07:03 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 13:46 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 21:48 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:22 -0500
Re: Can D simulated by H terminate normally? Richard Damon <Richard@Damon-Family.org> - 2024-05-03 18:15 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:23 -0500
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:27 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 07:04 -0400
Is Richard a Liar? olcott <polcott333@gmail.com> - 2024-05-14 10:42 -0500
Re: Olcott is a Liar! Richard Damon <richard@damon-family.org> - 2024-05-14 22:15 -0400
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-04-29 14:37 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 09:56 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-04-29 15:23 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 10:50 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-04-29 16:17 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 12:31 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-04-29 18:19 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 14:04 -0500
Re: Can D simulated by H terminate normally? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-04-30 10:46 +0200
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 10:18 -0500
Re: Can D simulated by H terminate normally? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-04-30 17:37 +0200
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 11:10 -0500
Re: Can D simulated by H terminate normally? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-04-30 18:24 +0200
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 11:27 -0500
Re: Can D simulated by H terminate normally? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-04-30 19:38 +0200
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 13:26 -0500
Re: Can D simulated by H terminate normally? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-01 11:02 +0200
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 10:20 -0500
Re: Can D simulated by H terminate normally? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-02 17:10 +0200
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 13:42 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-04-30 15:44 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 11:15 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-04-30 16:46 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 13:24 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-01 10:01 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 10:34 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:31 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:22 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:53 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:07 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 00:13 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-02 12:16 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 09:50 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 21:48 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:36 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:09 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-04 12:23 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-04 08:49 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-04 13:50 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-05 11:01 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-05 09:28 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-05 12:55 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-05 12:38 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-05 14:15 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-06 18:05 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-06 11:02 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-06 22:20 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-03 12:17 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 06:40 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:10 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-04 12:26 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-04 08:51 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-04 12:00 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-05 11:08 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-05 09:32 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-06 18:08 +0300
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-02 09:29 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 13:05 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 21:49 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:40 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 23:33 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 21:49 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:52 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:19 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 14:52 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-30 18:46 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 23:28 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 07:23 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 11:32 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:36 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:26 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:56 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:59 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 00:08 -0400
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-02 09:39 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 13:35 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 21:48 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:25 -0500
Re: Can D simulated by H terminate normally? joes <noreply@example.com> - 2024-05-03 19:30 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 16:26 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:35 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:29 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-03 12:33 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 06:55 -0500
Re: Can D simulated by H terminate normally? joes <noreply@example.com> - 2024-05-03 13:40 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 08:47 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:41 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:38 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-04 12:47 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-04 08:56 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-04 12:07 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-05 11:14 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-05 09:38 -0500
Re: Can D simulated by H terminate normally? joes <noreply@example.com> - 2024-05-05 17:07 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-05 12:43 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-05 14:20 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-06 18:16 +0300
Re: Can D simulated by H terminate normally? immibis <news@immibis.com> - 2024-05-07 03:37 +0200
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-02 09:07 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 12:45 -0500
Re: Can D simulated by H terminate normally? joes <noreply@example.com> - 2024-05-02 21:51 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 16:55 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 21:48 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:27 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:42 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 17:10 -0500
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 14:31 -0500
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 13:54 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 15:23 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 13:58 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 15:25 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 14:35 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 15:45 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 14:51 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-28 19:07 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-28 22:58 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-29 07:24 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 09:43 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-29 19:19 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 00:54 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-30 13:22 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 10:45 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-01 13:03 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 11:00 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-02 12:00 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 09:43 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-03 12:43 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 07:13 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-03 14:08 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 09:34 -0500
Re: Can D simulated by H terminate normally? Alan Mackenzie <acm@muc.de> - 2024-05-03 19:33 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 14:43 -0500
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 15:08 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 23:09 -0400
Re: Can D simulated by H terminate normally? joes <noreply@example.com> - 2024-05-03 19:10 +0000
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 16:22 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-04 08:43 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 23:07 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-03 23:20 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-04 08:53 -0400
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-03 22:54 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-05-04 13:10 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-04 08:59 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-04 13:51 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-02 15:13 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-30 07:40 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 10:58 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-04-30 18:46 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-30 23:11 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 07:23 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 11:06 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 20:41 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 22:29 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-01 23:59 -0400
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-05-01 23:09 -0500
Re: Can D simulated by H terminate normally? Richard Damon <richard@damon-family.org> - 2024-05-02 00:15 -0400
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-29 15:27 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 09:14 -0500
Re: Can D simulated by H terminate normally? Mikko <mikko.levanto@iki.fi> - 2024-04-29 15:22 +0300
Re: Can D simulated by H terminate normally? olcott <polcott333@gmail.com> - 2024-04-29 09:10 -0500
Page 15 of 18 — ← Prev page 1 … 13 14 [15] 16 17 18 Next page →
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-03 22:38 -0400 |
| Message-ID | <v14740$c31$6@i2pn2.org> |
| In reply to | #104252 |
On 5/3/24 7:55 AM, olcott wrote:
> On 5/3/2024 4:33 AM, Mikko wrote:
>> On 2024-05-02 18:35:19 +0000, olcott said:
>>
>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>> olcott <polcott333@gmail.com> wrote:
>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>
>>>> [ .... ]
>>>>
>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>> analyzer} to
>>>>>>> the existing idea of TM's then we must be careful how we define
>>>>>>> halting
>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>
>>>>
>>>>>> Why?
>>>>
>>>>>> That doesn't mean the machine reached a final state.
>>>>
>>>>
>>>>> Alan seems to believe that a final state is whatever state that an
>>>>> aborted simulation ends up in.
>>>>
>>>> Only through your twisted reasoning. For your information, I hold
>>>> to the
>>>> standard definition of final state, i.e. one which has no state
>>>> following
>>>> it. An aborted simulation is in some state, and that state is a final
>>>> one, since there is none following it.
>>>>
>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>> isn't a final state.
>>>>
>>>>>> Only if you try to define something that is NOT related to
>>>>>> Halting, do
>>>>>> you get into that issue.
>>>>
>>>>> "The all new ideas are wrong" assessment.
>>>>> Simulating termination analyzers <are> related to halting.
>>>>
>>>> Except you cannot define what such a thing is, and that relationship is
>>>> anything but clear.
>>>
>>> When a simulating termination analyzer matches one of three
>>> non-halting behavior patterns
>>> (a) Simple Infinite loop
>>> (b) Simple Infinite Recursion
>>> (c) Simple Recursive Simulation
>>
>> Simple recursive simulation is not a non-halting behaviour
>> if the recursion is not infinite.
>>
>
> In other words the only way that we can tell that an infinite
> loop never halts is to simulate it until the end of time?
>
> There are repeating state non-halting behavior patterns
> that can be recognized. These are three more functions
> where H derives the correct halt status:
>
> void Infinite_Recursion(u32 N)
> {
> Infinite_Recursion(N);
> }
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> int factorial(int n)
> {
> if (n >= 1)
> return n*factorial(n-1);
> else
> return 1;
> }
>
> Can D correctly simulated by H terminate normally?
> 00 int H(ptr x, ptr x) // ptr is pointer to int function
> 01 int D(ptr x)
> 02 {
> 03 int Halt_Status = H(x, x);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11 H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D) that Simulates D(D) at Line 01
>
> *keeps repeating* (unless aborted)
> Line 01
> Line 02
> Line 03: simulated D(D) invokes simulated H(D,D)
> that simulates D(D) at Line 01
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>
> I would think that a bright high school student would be
> able to tell that D(D) simulated by H cannot possibly
> reach past its own line 3. Four experts in C did say this.
>
> It does not make sense to me that this is actually too
> difficult for people that come to this group.
>
exceot I have described TWO DIFFERENT methods of design for Hs that make
this claim false.
The fact that you continue to repeat it shows you are not actually
interested in a honest discussion, but are just tryiing to hammer people
into blindly accepting your false claims (like rump does).
Even an average middle schooler should be able to understand my
arguments and see how you are wrong, so I guess you aren't smarter than
a 6th grader.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-05-04 12:47 +0300 |
| Message-ID | <v1507m$1549l$1@dont-email.me> |
| In reply to | #104252 |
On 2024-05-03 11:55:15 +0000, olcott said:
> On 5/3/2024 4:33 AM, Mikko wrote:
>> On 2024-05-02 18:35:19 +0000, olcott said:
>>
>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>> olcott <polcott333@gmail.com> wrote:
>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>
>>>> [ .... ]
>>>>
>>>>>>> When we add the brand new idea of {simulating termination analyzer} to
>>>>>>> the existing idea of TM's then we must be careful how we define halting
>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>
>>>>
>>>>>> Why?
>>>>
>>>>>> That doesn't mean the machine reached a final state.
>>>>
>>>>
>>>>> Alan seems to believe that a final state is whatever state that an
>>>>> aborted simulation ends up in.
>>>>
>>>> Only through your twisted reasoning. For your information, I hold to the
>>>> standard definition of final state, i.e. one which has no state following
>>>> it. An aborted simulation is in some state, and that state is a final
>>>> one, since there is none following it.
>>>>
>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>> isn't a final state.
>>>>
>>>>>> Only if you try to define something that is NOT related to Halting, do
>>>>>> you get into that issue.
>>>>
>>>>> "The all new ideas are wrong" assessment.
>>>>> Simulating termination analyzers <are> related to halting.
>>>>
>>>> Except you cannot define what such a thing is, and that relationship is
>>>> anything but clear.
>>>
>>> When a simulating termination analyzer matches one of three
>>> non-halting behavior patterns
>>> (a) Simple Infinite loop
>>> (b) Simple Infinite Recursion
>>> (c) Simple Recursive Simulation
>>
>> Simple recursive simulation is not a non-halting behaviour
>> if the recursion is not infinite.
>
> In other words the only way that we can tell that an infinite
> loop never halts is to simulate it until the end of time?
The phrase "in other words" is not correct here as it means that
what follows means the same as what precedes, and that is not
true here.
For same loops the only wha to detect non-termination may be
to simulate to infinity but they can be considered exluded by
the term "simple" in (a).
> There are repeating state non-halting behavior patterns
> that can be recognized. These are three more functions
> where H derives the correct halt status:
>
> void Infinite_Recursion(u32 N)
> {
> Infinite_Recursion(N);
> }
Per (b) that is non-halting and indeed it is (though the
execution may crash for "out of memeory").
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
Per (a) that is non-halting and indeed it is.
> int factorial(int n)
> {
> if (n >= 1)
> return n*factorial(n-1);
> else
> return 1;
> }
Per (c) that is non-halting but in reality it is not.
Ergo, the rule (c) is wrong.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-04 08:56 -0500 |
| Message-ID | <v15eqb$17unh$4@dont-email.me> |
| In reply to | #104303 |
On 5/4/2024 4:47 AM, Mikko wrote:
> On 2024-05-03 11:55:15 +0000, olcott said:
>
>> On 5/3/2024 4:33 AM, Mikko wrote:
>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>
>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>
>>>>> [ .... ]
>>>>>
>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>> analyzer} to
>>>>>>>> the existing idea of TM's then we must be careful how we define
>>>>>>>> halting
>>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>>
>>>>>
>>>>>>> Why?
>>>>>
>>>>>>> That doesn't mean the machine reached a final state.
>>>>>
>>>>>
>>>>>> Alan seems to believe that a final state is whatever state that an
>>>>>> aborted simulation ends up in.
>>>>>
>>>>> Only through your twisted reasoning. For your information, I hold
>>>>> to the
>>>>> standard definition of final state, i.e. one which has no state
>>>>> following
>>>>> it. An aborted simulation is in some state, and that state is a final
>>>>> one, since there is none following it.
>>>>>
>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>>> isn't a final state.
>>>>>
>>>>>>> Only if you try to define something that is NOT related to
>>>>>>> Halting, do
>>>>>>> you get into that issue.
>>>>>
>>>>>> "The all new ideas are wrong" assessment.
>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>
>>>>> Except you cannot define what such a thing is, and that
>>>>> relationship is
>>>>> anything but clear.
>>>>
>>>> When a simulating termination analyzer matches one of three
>>>> non-halting behavior patterns
>>>> (a) Simple Infinite loop
>>>> (b) Simple Infinite Recursion
>>>> (c) Simple Recursive Simulation
>>>
>>> Simple recursive simulation is not a non-halting behaviour
>>> if the recursion is not infinite.
>>
>> In other words the only way that we can tell that an infinite
>> loop never halts is to simulate it until the end of time?
>
> The phrase "in other words" is not correct here as it means that
> what follows means the same as what precedes, and that is not
> true here.
>
> For same loops the only wha to detect non-termination may be
> to simulate to infinity but they can be considered exluded by
> the term "simple" in (a).
>
>> There are repeating state non-halting behavior patterns
>> that can be recognized. These are three more functions
>> where H derives the correct halt status:
>>
>> void Infinite_Recursion(u32 N)
>> {
>> Infinite_Recursion(N);
>> }
>
> Per (b) that is non-halting and indeed it is (though the
> execution may crash for "out of memeory").
>
It is not actually infinite though because H recognizes the non-halting
behavior pattern, aborts the simulation and reports non-halting.
It is the exact same thing with D simulated by H on the basis
of the directly executed H(D,D).
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> }
>
> Per (a) that is non-halting and indeed it is.
It is not actually infinite though because H recognizes the non-halting
behavior pattern, aborts the simulation and reports non-halting.
It is the exact same thing with D simulated by H on the basis
of the directly executed H(D,D).
>
>> int factorial(int n)
>> {
>> if (n >= 1)
>> return n*factorial(n-1);
>> else
>> return 1;
>> }
>
> Per (c) that is non-halting but in reality it is not.
> Ergo, the rule (c) is wrong.
>
That was an example of an input that H correctly determines
does halt.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-04 12:07 -0400 |
| Message-ID | <v15mga$1qp5$1@i2pn2.org> |
| In reply to | #104315 |
On 5/4/24 9:56 AM, olcott wrote:
> On 5/4/2024 4:47 AM, Mikko wrote:
>> On 2024-05-03 11:55:15 +0000, olcott said:
>>
>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>
>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>
>>>>>> [ .... ]
>>>>>>
>>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>>> analyzer} to
>>>>>>>>> the existing idea of TM's then we must be careful how we define
>>>>>>>>> halting
>>>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>>>
>>>>>>
>>>>>>>> Why?
>>>>>>
>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>
>>>>>>
>>>>>>> Alan seems to believe that a final state is whatever state that an
>>>>>>> aborted simulation ends up in.
>>>>>>
>>>>>> Only through your twisted reasoning. For your information, I hold
>>>>>> to the
>>>>>> standard definition of final state, i.e. one which has no state
>>>>>> following
>>>>>> it. An aborted simulation is in some state, and that state is a
>>>>>> final
>>>>>> one, since there is none following it.
>>>>>>
>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>>>> isn't a final state.
>>>>>>
>>>>>>>> Only if you try to define something that is NOT related to
>>>>>>>> Halting, do
>>>>>>>> you get into that issue.
>>>>>>
>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>
>>>>>> Except you cannot define what such a thing is, and that
>>>>>> relationship is
>>>>>> anything but clear.
>>>>>
>>>>> When a simulating termination analyzer matches one of three
>>>>> non-halting behavior patterns
>>>>> (a) Simple Infinite loop
>>>>> (b) Simple Infinite Recursion
>>>>> (c) Simple Recursive Simulation
>>>>
>>>> Simple recursive simulation is not a non-halting behaviour
>>>> if the recursion is not infinite.
>>>
>>> In other words the only way that we can tell that an infinite
>>> loop never halts is to simulate it until the end of time?
>>
>> The phrase "in other words" is not correct here as it means that
>> what follows means the same as what precedes, and that is not
>> true here.
>>
>> For same loops the only wha to detect non-termination may be
>> to simulate to infinity but they can be considered exluded by
>> the term "simple" in (a).
>>
>>> There are repeating state non-halting behavior patterns
>>> that can be recognized. These are three more functions
>>> where H derives the correct halt status:
>>>
>>> void Infinite_Recursion(u32 N)
>>> {
>>> Infinite_Recursion(N);
>>> }
>>
>> Per (b) that is non-halting and indeed it is (though the
>> execution may crash for "out of memeory").
>>
>
> It is not actually infinite though because H recognizes the non-halting
> behavior pattern, aborts the simulation and reports non-halting.
No, the PROGRAM is non-halting,
The simulation reach a conclusion and terminated its simulation.
You don't seem to understand the difference.
>
> It is the exact same thing with D simulated by H on the basis
> of the directly executed H(D,D).
>
>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }
>>
>> Per (a) that is non-halting and indeed it is.
>
> It is not actually infinite though because H recognizes the non-halting
> behavior pattern, aborts the simulation and reports non-halting.
But the behavior of the program IS non-halting. The PROGRAM doesn't stop.
Again, the SIMULATION PROCESS halted, because it reached a conclusion
and aborted the simulation. So your concept of the SIMULAITON
"abnormally termination" has bearing, but that is an attribute of the
SIMULATION, not the program itself.
>
> It is the exact same thing with D simulated by H on the basis
> of the directly executed H(D,D).
>
>>
>>> int factorial(int n)
>>> {
>>> if (n >= 1)
>>> return n*factorial(n-1);
>>> else
>>> return 1;
>>> }
>>
>> Per (c) that is non-halting but in reality it is not.
>> Ergo, the rule (c) is wrong.
>>
>
> That was an example of an input that H correctly determines
> does halt.
>
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-05-05 11:14 +0300 |
| Message-ID | <v17f4p$1ojbj$1@dont-email.me> |
| In reply to | #104315 |
On 2024-05-04 13:56:27 +0000, olcott said:
> On 5/4/2024 4:47 AM, Mikko wrote:
>> On 2024-05-03 11:55:15 +0000, olcott said:
>>
>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>
>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>
>>>>>> [ .... ]
>>>>>>
>>>>>>>>> When we add the brand new idea of {simulating termination analyzer} to
>>>>>>>>> the existing idea of TM's then we must be careful how we define halting
>>>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>>>
>>>>>>
>>>>>>>> Why?
>>>>>>
>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>
>>>>>>
>>>>>>> Alan seems to believe that a final state is whatever state that an
>>>>>>> aborted simulation ends up in.
>>>>>>
>>>>>> Only through your twisted reasoning. For your information, I hold to the
>>>>>> standard definition of final state, i.e. one which has no state following
>>>>>> it. An aborted simulation is in some state, and that state is a final
>>>>>> one, since there is none following it.
>>>>>>
>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>>>> isn't a final state.
>>>>>>
>>>>>>>> Only if you try to define something that is NOT related to Halting, do
>>>>>>>> you get into that issue.
>>>>>>
>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>
>>>>>> Except you cannot define what such a thing is, and that relationship is
>>>>>> anything but clear.
>>>>>
>>>>> When a simulating termination analyzer matches one of three
>>>>> non-halting behavior patterns
>>>>> (a) Simple Infinite loop
>>>>> (b) Simple Infinite Recursion
>>>>> (c) Simple Recursive Simulation
>>>>
>>>> Simple recursive simulation is not a non-halting behaviour
>>>> if the recursion is not infinite.
>>>
>>> In other words the only way that we can tell that an infinite
>>> loop never halts is to simulate it until the end of time?
>>
>> The phrase "in other words" is not correct here as it means that
>> what follows means the same as what precedes, and that is not
>> true here.
>>
>> For same loops the only wha to detect non-termination may be
>> to simulate to infinity but they can be considered exluded by
>> the term "simple" in (a).
>>
>>> There are repeating state non-halting behavior patterns
>>> that can be recognized. These are three more functions
>>> where H derives the correct halt status:
>>>
>>> void Infinite_Recursion(u32 N)
>>> {
>>> Infinite_Recursion(N);
>>> }
>>
>> Per (b) that is non-halting and indeed it is (though the
>> execution may crash for "out of memeory").
>>
>
> It is not actually infinite though because H recognizes the non-halting
> behavior pattern, aborts the simulation and reports non-halting.
The recursion is infinite. The simulation by H is incomplete and finite.
> It is the exact same thing with D simulated by H on the basis
> of the directly executed H(D,D).
>
>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }
>>
>> Per (a) that is non-halting and indeed it is.
>
> It is not actually infinite though because H recognizes the non-halting
> behavior pattern, aborts the simulation and reports non-halting.
The loop is infinite. The simulation by H is incomplete and finite.
> It is the exact same thing with D simulated by H on the basis
> of the directly executed H(D,D).
>
>>
>>> int factorial(int n)
>>> {
>>> if (n >= 1)
>>> return n*factorial(n-1);
>>> else
>>> return 1;
>>> }
>>
>> Per (c) that is non-halting but in reality it is not.
>> Ergo, the rule (c) is wrong.
>
> That was an example of an input that H correctly determines
> does halt.
Maybe but it is an example of your non-halting pattern (c) as
presented above.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 09:38 -0500 |
| Message-ID | <v185lo$1t4hn$5@dont-email.me> |
| In reply to | #104358 |
On 5/5/2024 3:14 AM, Mikko wrote:
> On 2024-05-04 13:56:27 +0000, olcott said:
>
>> On 5/4/2024 4:47 AM, Mikko wrote:
>>> On 2024-05-03 11:55:15 +0000, olcott said:
>>>
>>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>>
>>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>>
>>>>>>> [ .... ]
>>>>>>>
>>>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>>>> analyzer} to
>>>>>>>>>> the existing idea of TM's then we must be careful how we
>>>>>>>>>> define halting
>>>>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>>>>
>>>>>>>
>>>>>>>>> Why?
>>>>>>>
>>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>>
>>>>>>>
>>>>>>>> Alan seems to believe that a final state is whatever state that an
>>>>>>>> aborted simulation ends up in.
>>>>>>>
>>>>>>> Only through your twisted reasoning. For your information, I
>>>>>>> hold to the
>>>>>>> standard definition of final state, i.e. one which has no state
>>>>>>> following
>>>>>>> it. An aborted simulation is in some state, and that state is a
>>>>>>> final
>>>>>>> one, since there is none following it.
>>>>>>>
>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>>>>> isn't a final state.
>>>>>>>
>>>>>>>>> Only if you try to define something that is NOT related to
>>>>>>>>> Halting, do
>>>>>>>>> you get into that issue.
>>>>>>>
>>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>>
>>>>>>> Except you cannot define what such a thing is, and that
>>>>>>> relationship is
>>>>>>> anything but clear.
>>>>>>
>>>>>> When a simulating termination analyzer matches one of three
>>>>>> non-halting behavior patterns
>>>>>> (a) Simple Infinite loop
>>>>>> (b) Simple Infinite Recursion
>>>>>> (c) Simple Recursive Simulation
>>>>>
>>>>> Simple recursive simulation is not a non-halting behaviour
>>>>> if the recursion is not infinite.
>>>>
>>>> In other words the only way that we can tell that an infinite
>>>> loop never halts is to simulate it until the end of time?
>>>
>>> The phrase "in other words" is not correct here as it means that
>>> what follows means the same as what precedes, and that is not
>>> true here.
>>>
>>> For same loops the only wha to detect non-termination may be
>>> to simulate to infinity but they can be considered exluded by
>>> the term "simple" in (a).
>>>
>>>> There are repeating state non-halting behavior patterns
>>>> that can be recognized. These are three more functions
>>>> where H derives the correct halt status:
>>>>
>>>> void Infinite_Recursion(u32 N)
>>>> {
>>>> Infinite_Recursion(N);
>>>> }
>>>
>>> Per (b) that is non-halting and indeed it is (though the
>>> execution may crash for "out of memeory").
>>>
>>
>> It is not actually infinite though because H recognizes the non-halting
>> behavior pattern, aborts the simulation and reports non-halting.
>
> The recursion is infinite. The simulation by H is incomplete and finite.
>
Do you understand that it is ridiculously stupid for a simulating
termination analyzer to simulate a non-terminating input forever?
>> It is the exact same thing with D simulated by H on the basis
>> of the directly executed H(D,D).
>>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>>>
>>> Per (a) that is non-halting and indeed it is.
>>
>> It is not actually infinite though because H recognizes the non-halting
>> behavior pattern, aborts the simulation and reports non-halting.
>
> The loop is infinite. The simulation by H is incomplete and finite.
>
Do you understand that it is ridiculously stupid for a simulating
termination analyzer to simulate a non-terminating input forever?
>> It is the exact same thing with D simulated by H on the basis
>> of the directly executed H(D,D).
>>
>>>
>>>> int factorial(int n)
>>>> {
>>>> if (n >= 1)
>>>> return n*factorial(n-1);
>>>> else
>>>> return 1;
>>>> }
>>>
>>> Per (c) that is non-halting but in reality it is not.
>>> Ergo, the rule (c) is wrong.
>>
>> That was an example of an input that H correctly determines
>> does halt.
>
> Maybe but it is an example of your non-halting pattern (c) as
> presented above.
>
No it is not. A simulating termination analyzer must get at least one
non-terminating input correctly and one terminating input correctly.
You couldn't even tell that ordinary factorial halts?
--
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-05-05 17:07 +0000 |
| Message-ID | <pan$3a773$3f336d55$1d23114a$8b7cc149@example.com> |
| In reply to | #104369 |
Am Sun, 05 May 2024 09:38:48 -0500 schrieb olcott:
> On 5/5/2024 3:14 AM, Mikko wrote:
>> On 2024-05-04 13:56:27 +0000, olcott said:
>>
>>> On 5/4/2024 4:47 AM, Mikko wrote:
>>>> On 2024-05-03 11:55:15 +0000, olcott said:
>>>>
>>>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>>>
>>>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>>>
>>>>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>>>>> analyzer} to the existing idea of TM's then we must be careful
>>>>>>>>>>> how we define halting otherwise every infinite loop will be
>>>>>>>>>>> construed as halting.
>>>>>>>>
>>>>>>>>>> Why?
>>>>>>>>
>>>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>>>
>>>>>>>>> Alan seems to believe that a final state is whatever state that
>>>>>>>>> an aborted simulation ends up in.
>>>>>>>>
>>>>>>>> Only through your twisted reasoning. For your information, I
>>>>>>>> hold to the standard definition of final state, i.e. one which
>>>>>>>> has no state following it. An aborted simulation is in some
>>>>>>>> state, and that state is a final one, since there is none
>>>>>>>> following it.
>>>>>>>>
>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>> You are thus mistaken in believing "abnormal" termination isn't
>>>>>>>>>> a final state.
>>>>>>>>
>>>>>>>>>> Only if you try to define something that is NOT related to
>>>>>>>>>> Halting, do you get into that issue.
>>>>>>>>
>>>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>>>
>>>>>>>> Except you cannot define what such a thing is, and that
>>>>>>>> relationship is anything but clear.
>>>>>>>
>>>>>>> When a simulating termination analyzer matches one of three
>>>>>>> non-halting behavior patterns (a) Simple Infinite loop (b) Simple
>>>>>>> Infinite Recursion (c) Simple Recursive Simulation
>>>>>>
>>>>>> Simple recursive simulation is not a non-halting behaviour if the
>>>>>> recursion is not infinite.
>>>>>
>>>>> In other words the only way that we can tell that an infinite loop
>>>>> never halts is to simulate it until the end of time?
>>>>
>>>> The phrase "in other words" is not correct here as it means that what
>>>> follows means the same as what precedes, and that is not true here.
>>>>
>>>> For same loops the only wha to detect non-termination may be to
>>>> simulate to infinity but they can be considered exluded by the term
>>>> "simple" in (a).
>>>>
>>>>> There are repeating state non-halting behavior patterns that can be
>>>>> recognized. These are three more functions where H derives the
>>>>> correct halt status:
>>>>>
>>>>> void Infinite_Recursion(u32 N)
>>>>> {
>>>>> Infinite_Recursion(N);
>>>>> }
>>>>
>>>> Per (b) that is non-halting and indeed it is (though the execution
>>>> may crash for "out of memeory").
>>>>
>>> It is not actually infinite though because H recognizes the
>>> non-halting behavior pattern, aborts the simulation and reports
>>> non-halting.
>>
>> The recursion is infinite. The simulation by H is incomplete and
>> finite.
>>
> Do you understand that it is ridiculously stupid for a simulating
> termination analyzer to simulate a non-terminating input forever?
That’s the point. Either it simulates until a possibly nonexistent
termination, or it aborts and is thus not a simulator.
>>> It is the exact same thing with D simulated by H on the basis of the
>>> directly executed H(D,D).
>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>> HERE: goto HERE;
>>>>> }
>>>>
>>>> Per (a) that is non-halting and indeed it is.
>>>
>>> It is not actually infinite though because H recognizes the
>>> non-halting behavior pattern, aborts the simulation and reports
>>> non-halting.
>>
>> The loop is infinite. The simulation by H is incomplete and finite.
>>
> Do you understand that it is ridiculously stupid for a simulating
> termination analyzer to simulate a non-terminating input forever?
If H aborts, THE SAME H that D calls also does, thus D terminates, so
H was wrong in aborting. That’s exactly the proof.
--
joes
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-05 12:43 -0500 |
| Message-ID | <v18gg2$1vhpv$5@dont-email.me> |
| In reply to | #104390 |
On 5/5/2024 12:07 PM, joes wrote:
> Am Sun, 05 May 2024 09:38:48 -0500 schrieb olcott:
>
>> On 5/5/2024 3:14 AM, Mikko wrote:
>>> On 2024-05-04 13:56:27 +0000, olcott said:
>>>
>>>> On 5/4/2024 4:47 AM, Mikko wrote:
>>>>> On 2024-05-03 11:55:15 +0000, olcott said:
>>>>>
>>>>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>>>>
>>>>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>>>>
>>>>>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>>>>>> analyzer} to the existing idea of TM's then we must be careful
>>>>>>>>>>>> how we define halting otherwise every infinite loop will be
>>>>>>>>>>>> construed as halting.
>>>>>>>>>
>>>>>>>>>>> Why?
>>>>>>>>>
>>>>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>>>>
>>>>>>>>>> Alan seems to believe that a final state is whatever state that
>>>>>>>>>> an aborted simulation ends up in.
>>>>>>>>>
>>>>>>>>> Only through your twisted reasoning. For your information, I
>>>>>>>>> hold to the standard definition of final state, i.e. one which
>>>>>>>>> has no state following it. An aborted simulation is in some
>>>>>>>>> state, and that state is a final one, since there is none
>>>>>>>>> following it.
>>>>>>>>>
>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>> You are thus mistaken in believing "abnormal" termination isn't
>>>>>>>>>>> a final state.
>>>>>>>>>
>>>>>>>>>>> Only if you try to define something that is NOT related to
>>>>>>>>>>> Halting, do you get into that issue.
>>>>>>>>>
>>>>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>>>>
>>>>>>>>> Except you cannot define what such a thing is, and that
>>>>>>>>> relationship is anything but clear.
>>>>>>>>
>>>>>>>> When a simulating termination analyzer matches one of three
>>>>>>>> non-halting behavior patterns (a) Simple Infinite loop (b) Simple
>>>>>>>> Infinite Recursion (c) Simple Recursive Simulation
>>>>>>>
>>>>>>> Simple recursive simulation is not a non-halting behaviour if the
>>>>>>> recursion is not infinite.
>>>>>>
>>>>>> In other words the only way that we can tell that an infinite loop
>>>>>> never halts is to simulate it until the end of time?
>>>>>
>>>>> The phrase "in other words" is not correct here as it means that what
>>>>> follows means the same as what precedes, and that is not true here.
>>>>>
>>>>> For same loops the only wha to detect non-termination may be to
>>>>> simulate to infinity but they can be considered exluded by the term
>>>>> "simple" in (a).
>>>>>
>>>>>> There are repeating state non-halting behavior patterns that can be
>>>>>> recognized. These are three more functions where H derives the
>>>>>> correct halt status:
>>>>>>
>>>>>> void Infinite_Recursion(u32 N)
>>>>>> {
>>>>>> Infinite_Recursion(N);
>>>>>> }
>>>>>
>>>>> Per (b) that is non-halting and indeed it is (though the execution
>>>>> may crash for "out of memeory").
>>>>>
>>>> It is not actually infinite though because H recognizes the
>>>> non-halting behavior pattern, aborts the simulation and reports
>>>> non-halting.
>>>
>>> The recursion is infinite. The simulation by H is incomplete and
>>> finite.
>>>
>> Do you understand that it is ridiculously stupid for a simulating
>> termination analyzer to simulate a non-terminating input forever?
> That’s the point. Either it simulates until a possibly nonexistent
> termination, or it aborts and is thus not a simulator.
>
So in other words you choose to simply "not believe in"
a simulating termination analyzer without being able to
show that it does not work correctly.
>>>> It is the exact same thing with D simulated by H on the basis of the
>>>> directly executed H(D,D).
>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>
>>>>> Per (a) that is non-halting and indeed it is.
>>>>
>>>> It is not actually infinite though because H recognizes the
>>>> non-halting behavior pattern, aborts the simulation and reports
>>>> non-halting.
>>>
>>> The loop is infinite. The simulation by H is incomplete and finite.
>>>
>> Do you understand that it is ridiculously stupid for a simulating
>> termination analyzer to simulate a non-terminating input forever?
>
> If H aborts, THE SAME H that D calls also does, thus D terminates, so
> H was wrong in aborting. That’s exactly the proof.
>
My new post is more clear on these things
[Every D(D) simulated by H presents non-halting behavior to H]
*This new post proves this conclusion*
From this we can definitely know that every D(D) of the infinite set of
H/D pairs where this D(D) is simulated by the H that this D(D) calls
that this D(D) presents non-halting behavior to this H.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-05 14:20 -0400 |
| Message-ID | <v18iks$5asr$8@i2pn2.org> |
| In reply to | #104393 |
On 5/5/24 1:43 PM, olcott wrote:
> On 5/5/2024 12:07 PM, joes wrote:
>> Am Sun, 05 May 2024 09:38:48 -0500 schrieb olcott:
>>
>>> On 5/5/2024 3:14 AM, Mikko wrote:
>>>> On 2024-05-04 13:56:27 +0000, olcott said:
>>>>
>>>>> On 5/4/2024 4:47 AM, Mikko wrote:
>>>>>> On 2024-05-03 11:55:15 +0000, olcott said:
>>>>>>
>>>>>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>>>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>>>>>
>>>>>>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>>>>>>> analyzer} to the existing idea of TM's then we must be careful
>>>>>>>>>>>>> how we define halting otherwise every infinite loop will be
>>>>>>>>>>>>> construed as halting.
>>>>>>>>>>
>>>>>>>>>>>> Why?
>>>>>>>>>>
>>>>>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>>>>>
>>>>>>>>>>> Alan seems to believe that a final state is whatever state that
>>>>>>>>>>> an aborted simulation ends up in.
>>>>>>>>>>
>>>>>>>>>> Only through your twisted reasoning. For your information, I
>>>>>>>>>> hold to the standard definition of final state, i.e. one which
>>>>>>>>>> has no state following it. An aborted simulation is in some
>>>>>>>>>> state, and that state is a final one, since there is none
>>>>>>>>>> following it.
>>>>>>>>>>
>>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>>> You are thus mistaken in believing "abnormal" termination isn't
>>>>>>>>>>>> a final state.
>>>>>>>>>>
>>>>>>>>>>>> Only if you try to define something that is NOT related to
>>>>>>>>>>>> Halting, do you get into that issue.
>>>>>>>>>>
>>>>>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>>>>>
>>>>>>>>>> Except you cannot define what such a thing is, and that
>>>>>>>>>> relationship is anything but clear.
>>>>>>>>>
>>>>>>>>> When a simulating termination analyzer matches one of three
>>>>>>>>> non-halting behavior patterns (a) Simple Infinite loop (b) Simple
>>>>>>>>> Infinite Recursion (c) Simple Recursive Simulation
>>>>>>>>
>>>>>>>> Simple recursive simulation is not a non-halting behaviour if the
>>>>>>>> recursion is not infinite.
>>>>>>>
>>>>>>> In other words the only way that we can tell that an infinite loop
>>>>>>> never halts is to simulate it until the end of time?
>>>>>>
>>>>>> The phrase "in other words" is not correct here as it means that what
>>>>>> follows means the same as what precedes, and that is not true here.
>>>>>>
>>>>>> For same loops the only wha to detect non-termination may be to
>>>>>> simulate to infinity but they can be considered exluded by the term
>>>>>> "simple" in (a).
>>>>>>
>>>>>>> There are repeating state non-halting behavior patterns that can be
>>>>>>> recognized. These are three more functions where H derives the
>>>>>>> correct halt status:
>>>>>>>
>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>> {
>>>>>>> Infinite_Recursion(N);
>>>>>>> }
>>>>>>
>>>>>> Per (b) that is non-halting and indeed it is (though the execution
>>>>>> may crash for "out of memeory").
>>>>>>
>>>>> It is not actually infinite though because H recognizes the
>>>>> non-halting behavior pattern, aborts the simulation and reports
>>>>> non-halting.
>>>>
>>>> The recursion is infinite. The simulation by H is incomplete and
>>>> finite.
>>>>
>>> Do you understand that it is ridiculously stupid for a simulating
>>> termination analyzer to simulate a non-terminating input forever?
>> That’s the point. Either it simulates until a possibly nonexistent
>> termination, or it aborts and is thus not a simulator.
>>
>
> So in other words you choose to simply "not believe in"
> a simulating termination analyzer without being able to
> show that it does not work correctly.
The onus of proof is on you.
Since D(D) Halts, H(D,D) can't say non-halting and be correct as a Halt
Decider.
IF you want to try to REALLY define what a simulating termination
analyzer means that is something actually useful and has a real meaning,
try to make that definition.
So far, I haven't see you actually try to define this as an actual
definition instead of trying to define by example.
>
>>>>> It is the exact same thing with D simulated by H on the basis of the
>>>>> directly executed H(D,D).
>>>>>
>>>>>>> void Infinite_Loop()
>>>>>>> {
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>
>>>>>> Per (a) that is non-halting and indeed it is.
>>>>>
>>>>> It is not actually infinite though because H recognizes the
>>>>> non-halting behavior pattern, aborts the simulation and reports
>>>>> non-halting.
>>>>
>>>> The loop is infinite. The simulation by H is incomplete and finite.
>>>>
>>> Do you understand that it is ridiculously stupid for a simulating
>>> termination analyzer to simulate a non-terminating input forever?
>>
>> If H aborts, THE SAME H that D calls also does, thus D terminates, so
>> H was wrong in aborting. That’s exactly the proof.
>>
>
> My new post is more clear on these things
> [Every D(D) simulated by H presents non-halting behavior to H]
>
> *This new post proves this conclusion*
> From this we can definitely know that every D(D) of the infinite set of
> H/D pairs where this D(D) is simulated by the H that this D(D) calls
> that this D(D) presents non-halting behavior to this H.
>
>
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-05-06 18:16 +0300 |
| Message-ID | <v1as8p$2km58$1@dont-email.me> |
| In reply to | #104369 |
On 2024-05-05 14:38:48 +0000, olcott said:
> On 5/5/2024 3:14 AM, Mikko wrote:
>> On 2024-05-04 13:56:27 +0000, olcott said:
>>
>>> On 5/4/2024 4:47 AM, Mikko wrote:
>>>> On 2024-05-03 11:55:15 +0000, olcott said:
>>>>
>>>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>>>
>>>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>>>
>>>>>>>> [ .... ]
>>>>>>>>
>>>>>>>>>>> When we add the brand new idea of {simulating termination analyzer} to
>>>>>>>>>>> the existing idea of TM's then we must be careful how we define halting
>>>>>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>>>>>
>>>>>>>>
>>>>>>>>>> Why?
>>>>>>>>
>>>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>>>
>>>>>>>>
>>>>>>>>> Alan seems to believe that a final state is whatever state that an
>>>>>>>>> aborted simulation ends up in.
>>>>>>>>
>>>>>>>> Only through your twisted reasoning. For your information, I hold to the
>>>>>>>> standard definition of final state, i.e. one which has no state following
>>>>>>>> it. An aborted simulation is in some state, and that state is a final
>>>>>>>> one, since there is none following it.
>>>>>>>>
>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>>>>>> isn't a final state.
>>>>>>>>
>>>>>>>>>> Only if you try to define something that is NOT related to Halting, do
>>>>>>>>>> you get into that issue.
>>>>>>>>
>>>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>>>
>>>>>>>> Except you cannot define what such a thing is, and that relationship is
>>>>>>>> anything but clear.
>>>>>>>
>>>>>>> When a simulating termination analyzer matches one of three
>>>>>>> non-halting behavior patterns
>>>>>>> (a) Simple Infinite loop
>>>>>>> (b) Simple Infinite Recursion
>>>>>>> (c) Simple Recursive Simulation
>>>>>>
>>>>>> Simple recursive simulation is not a non-halting behaviour
>>>>>> if the recursion is not infinite.
>>>>>
>>>>> In other words the only way that we can tell that an infinite
>>>>> loop never halts is to simulate it until the end of time?
>>>>
>>>> The phrase "in other words" is not correct here as it means that
>>>> what follows means the same as what precedes, and that is not
>>>> true here.
>>>>
>>>> For same loops the only wha to detect non-termination may be
>>>> to simulate to infinity but they can be considered exluded by
>>>> the term "simple" in (a).
>>>>
>>>>> There are repeating state non-halting behavior patterns
>>>>> that can be recognized. These are three more functions
>>>>> where H derives the correct halt status:
>>>>>
>>>>> void Infinite_Recursion(u32 N)
>>>>> {
>>>>> Infinite_Recursion(N);
>>>>> }
>>>>
>>>> Per (b) that is non-halting and indeed it is (though the
>>>> execution may crash for "out of memeory").
>>>>
>>>
>>> It is not actually infinite though because H recognizes the non-halting
>>> behavior pattern, aborts the simulation and reports non-halting.
>>
>> The recursion is infinite. The simulation by H is incomplete and finite.
>>
>
> Do you understand that it is ridiculously stupid for a simulating
> termination analyzer to simulate a non-terminating input forever?
>
>>> It is the exact same thing with D simulated by H on the basis
>>> of the directly executed H(D,D).
>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>> HERE: goto HERE;
>>>>> }
>>>>
>>>> Per (a) that is non-halting and indeed it is.
>>>
>>> It is not actually infinite though because H recognizes the non-halting
>>> behavior pattern, aborts the simulation and reports non-halting.
>>
>> The loop is infinite. The simulation by H is incomplete and finite.
>>
>
> Do you understand that it is ridiculously stupid for a simulating
> termination analyzer to simulate a non-terminating input forever?
Not necessarilty. As long as the the analyzer cannot determine
neither whether the execution will terminate nor whether the
termination could be determined after more simulation it makes
sense to simulate more. If neither determination is ever possible
this means that it makes sense to simulate forever (i.e., until
the user aborts the simulation).
>>> It is the exact same thing with D simulated by H on the basis
>>> of the directly executed H(D,D).
>>>
>>>>
>>>>> int factorial(int n)
>>>>> {
>>>>> if (n >= 1)
>>>>> return n*factorial(n-1);
>>>>> else
>>>>> return 1;
>>>>> }
>>>>
>>>> Per (c) that is non-halting but in reality it is not.
>>>> Ergo, the rule (c) is wrong.
>>>
>>> That was an example of an input that H correctly determines
>>> does halt.
>>
>> Maybe but it is an example of your non-halting pattern (c) as
>> presented above.
>
> No it is not.
True, but you said it is.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | immibis <news@immibis.com> |
|---|---|
| Date | 2024-05-07 03:37 +0200 |
| Message-ID | <v1c0js$2skfm$1@dont-email.me> |
| In reply to | #104369 |
On 5/05/24 16:38, olcott wrote:
> On 5/5/2024 3:14 AM, Mikko wrote:
>> On 2024-05-04 13:56:27 +0000, olcott said:
>>
>>> On 5/4/2024 4:47 AM, Mikko wrote:
>>>> On 2024-05-03 11:55:15 +0000, olcott said:
>>>>
>>>>> On 5/3/2024 4:33 AM, Mikko wrote:
>>>>>> On 2024-05-02 18:35:19 +0000, olcott said:
>>>>>>
>>>>>>> On 5/2/2024 4:39 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/30/2024 5:46 PM, Richard Damon wrote:
>>>>>>>>>> On 4/30/24 12:15 PM, olcott wrote:
>>>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>> On 4/30/2024 3:46 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 29.apr.2024 om 21:04 schreef olcott:
>>>>>>>>
>>>>>>>> [ .... ]
>>>>>>>>
>>>>>>>>>>> When we add the brand new idea of {simulating termination
>>>>>>>>>>> analyzer} to
>>>>>>>>>>> the existing idea of TM's then we must be careful how we
>>>>>>>>>>> define halting
>>>>>>>>>>> otherwise every infinite loop will be construed as halting.
>>>>>>>>
>>>>>>>>
>>>>>>>>>> Why?
>>>>>>>>
>>>>>>>>>> That doesn't mean the machine reached a final state.
>>>>>>>>
>>>>>>>>
>>>>>>>>> Alan seems to believe that a final state is whatever state that an
>>>>>>>>> aborted simulation ends up in.
>>>>>>>>
>>>>>>>> Only through your twisted reasoning. For your information, I
>>>>>>>> hold to the
>>>>>>>> standard definition of final state, i.e. one which has no state
>>>>>>>> following
>>>>>>>> it. An aborted simulation is in some state, and that state is a
>>>>>>>> final
>>>>>>>> one, since there is none following it.
>>>>>>>>
>>>>>>>>> On 4/30/2024 10:44 AM, Alan Mackenzie wrote:
>>>>>>>>>> You are thus mistaken in believing "abnormal" termination
>>>>>>>>>> isn't a final state.
>>>>>>>>
>>>>>>>>>> Only if you try to define something that is NOT related to
>>>>>>>>>> Halting, do
>>>>>>>>>> you get into that issue.
>>>>>>>>
>>>>>>>>> "The all new ideas are wrong" assessment.
>>>>>>>>> Simulating termination analyzers <are> related to halting.
>>>>>>>>
>>>>>>>> Except you cannot define what such a thing is, and that
>>>>>>>> relationship is
>>>>>>>> anything but clear.
>>>>>>>
>>>>>>> When a simulating termination analyzer matches one of three
>>>>>>> non-halting behavior patterns
>>>>>>> (a) Simple Infinite loop
>>>>>>> (b) Simple Infinite Recursion
>>>>>>> (c) Simple Recursive Simulation
>>>>>>
>>>>>> Simple recursive simulation is not a non-halting behaviour
>>>>>> if the recursion is not infinite.
>>>>>
>>>>> In other words the only way that we can tell that an infinite
>>>>> loop never halts is to simulate it until the end of time?
>>>>
>>>> The phrase "in other words" is not correct here as it means that
>>>> what follows means the same as what precedes, and that is not
>>>> true here.
>>>>
>>>> For same loops the only wha to detect non-termination may be
>>>> to simulate to infinity but they can be considered exluded by
>>>> the term "simple" in (a).
>>>>
>>>>> There are repeating state non-halting behavior patterns
>>>>> that can be recognized. These are three more functions
>>>>> where H derives the correct halt status:
>>>>>
>>>>> void Infinite_Recursion(u32 N)
>>>>> {
>>>>> Infinite_Recursion(N);
>>>>> }
>>>>
>>>> Per (b) that is non-halting and indeed it is (though the
>>>> execution may crash for "out of memeory").
>>>>
>>>
>>> It is not actually infinite though because H recognizes the non-halting
>>> behavior pattern, aborts the simulation and reports non-halting.
>>
>> The recursion is infinite. The simulation by H is incomplete and finite.
>>
>
> Do you understand that it is ridiculously stupid for a simulating
> termination analyzer to simulate a non-terminating input forever?
I'm back!
Yes, we understand that. Do you understand that since all simulating
termination analyzers must simulate their non-terminating input forever,
simulating termination analyzers do not always terminate?
Facts don't care if you think they're stupid. I think entropy is stupid.
Tough shit.
> No it is not. A simulating termination analyzer must get at least one
> non-terminating input correctly and one terminating input correctly.
> You couldn't even tell that ordinary factorial halts?
According to this definition, simulating termination analyzers do not exist.
I can prove that circles have 90-degree corners:
1. Consider a square circle.
2. It has 90-degree corners because it's a square.
[toc] | [prev] | [next] | [standalone]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2024-05-02 09:07 +0000 |
| Message-ID | <v0vl3o$209h$1@news.muc.de> |
| In reply to | #104082 |
olcott <polcott333@gmail.com> wrote:
> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>> olcott <polcott333@gmail.com> wrote:
>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>> olcott <polcott333@gmail.com> wrote:
>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
[ .... ]
>>> A simulating termination analyzer is not the same thing as a UTM.
>> At the moment, on this newsgroup, it's a meaningless term. You seem to
>> have used it merely as a synonym for halting decider in the past. Yet
>> you fail to say what you mean by it, if you mean something different.
>>> Within my brand new idea of a {simulating termination analyzer}
>>> there is the idea of abnormal termination.
>> It's unlikely to be a brand new idea, whatever it might be, since you
>> aren't familiar with the literature and so most likely have come up with
>> somebody else's old idea.
[ .... ]
>> You've failed, repeatedly, to address the points I've been making in my
>> last few posts, so it seems that you have accepted them. In particular,
>> you have accepted that "having been aborted" is indeed a final state for
>> a turing machine or a program.
> All of the "points" that you have been making were entirely anchored in
> your ignorance about what "simulating termination analyzer" are and how
> they work.
I think it much more likely that there's no such thing as a "simulating
termination analyzer". I.e. there's no theory about it, no interesting
results, no use for it, or anything like that. I've asked you several
times to define this object, other people have asked you too, yet you
fail to do so. Producing a few lines of scrappy C code is not anything
like producing a definition.
"Simulating termination analyzer" probably just means halt decider. We
all know there's no such thing.
> --
> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
> hits a target no one else can see." Arthur Schopenhauer
--
Alan Mackenzie (Nuremberg, Germany).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-02 12:45 -0500 |
| Message-ID | <v10jg9$3vuqr$1@dont-email.me> |
| In reply to | #104207 |
On 5/2/2024 4:07 AM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>>> olcott <polcott333@gmail.com> wrote:
>>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>
> [ .... ]
>
>>>> A simulating termination analyzer is not the same thing as a UTM.
>
>>> At the moment, on this newsgroup, it's a meaningless term. You seem to
>>> have used it merely as a synonym for halting decider in the past. Yet
>>> you fail to say what you mean by it, if you mean something different.
>
>>>> Within my brand new idea of a {simulating termination analyzer}
>>>> there is the idea of abnormal termination.
>
>>> It's unlikely to be a brand new idea, whatever it might be, since you
>>> aren't familiar with the literature and so most likely have come up with
>>> somebody else's old idea.
>
> [ .... ]
>
>>> You've failed, repeatedly, to address the points I've been making in my
>>> last few posts, so it seems that you have accepted them. In particular,
>>> you have accepted that "having been aborted" is indeed a final state for
>>> a turing machine or a program.
>
>> All of the "points" that you have been making were entirely anchored in
>> your ignorance about what "simulating termination analyzer" are and how
>> they work.
>
> I think it much more likely that there's no such thing as a "simulating
> termination analyzer".
You say that when I my code proves that H does correctly
determine the halt status of these three inputs.
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
void Infinite_Loop()
{
HERE: goto HERE;
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
int main()
{
Output("Input_Halts = ", H(factorial, (ptr)5));
Output("Input_Halts = ", H0(Infinite_Loop));
Output("Input_Halts = ", H(Infinite_Recursion, (ptr)5));
}
> I.e. there's no theory about it, no interesting
> results, no use for it, or anything like that. I've asked you several
> times to define this object, other people have asked you too, yet you
> fail to do so. Producing a few lines of scrappy C code is not anything
> like producing a definition.
>
When a simulating termination analyzer matches one of three
non-halting behavior patterns
(a) Simple Infinite loop
(b) Simple Infinite Recursion
(c) Simple Recursive Simulation
It aborts it simulation and reports that the input specifies
a non-halting sequence of configurations. Otherwise it continues
to simulate the input to completion. Non-terminating inputs that
have complex non-halting behaviors are outside of its domain.
> "Simulating termination analyzer" probably just means halt decider. We
> all know there's no such thing.
>
The difference is that as long as a STA gets one input that halts
correctly and one input that fails to halt correctly then it is a
STA. An actual halt decider is required to be ALL knowing.
>> --
>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-05-02 21:51 +0000 |
| Message-ID | <v111t6$2tdp6$1@i2pn2.org> |
| In reply to | #104219 |
Am Thu, 02 May 2024 12:45:44 -0500 schrieb olcott: > On 5/2/2024 4:07 AM, Alan Mackenzie wrote: >> olcott <polcott333@gmail.com> wrote: >>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote: >> I think it much more likely that there's no such thing as a "simulating >> termination analyzer". > When a simulating termination analyzer matches one of three non-halting > behavior patterns (a) Simple Infinite loop (b) Simple Infinite Recursion > (c) Simple Recursive Simulation > > It aborts it simulation and reports that the input specifies a > non-halting sequence of configurations. Otherwise it continues to > simulate the input to completion. Non-terminating inputs that have > complex non-halting behaviors are outside of its domain. > > The difference is that as long as a STA gets one input that halts > correctly and one input that fails to halt correctly then it is a STA. > An actual halt decider is required to be ALL knowing. Oh hey, your halt decider doesn't actually decide halting for all inputs! Now we know why it is impossible. With that, greetings to all other comp.theorists. --joes
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-02 16:55 -0500 |
| Message-ID | <v1123n$36h4$1@dont-email.me> |
| In reply to | #104207 |
On 5/2/2024 4:07 AM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>>> olcott <polcott333@gmail.com> wrote:
>>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>
> [ .... ]
>
>>>> A simulating termination analyzer is not the same thing as a UTM.
>
>>> At the moment, on this newsgroup, it's a meaningless term. You seem to
>>> have used it merely as a synonym for halting decider in the past. Yet
>>> you fail to say what you mean by it, if you mean something different.
>
>>>> Within my brand new idea of a {simulating termination analyzer}
>>>> there is the idea of abnormal termination.
>
>>> It's unlikely to be a brand new idea, whatever it might be, since you
>>> aren't familiar with the literature and so most likely have come up with
>>> somebody else's old idea.
>
> [ .... ]
>
>>> You've failed, repeatedly, to address the points I've been making in my
>>> last few posts, so it seems that you have accepted them. In particular,
>>> you have accepted that "having been aborted" is indeed a final state for
>>> a turing machine or a program.
>
>> All of the "points" that you have been making were entirely anchored in
>> your ignorance about what "simulating termination analyzer" are and how
>> they work.
>
> I think it much more likely that there's no such thing as a "simulating
> termination analyzer". I.e. there's no theory about it, no interesting
> results, no use for it, or anything like that. I've asked you several
> times to define this object, other people have asked you too, yet you
> fail to do so. Producing a few lines of scrappy C code is not anything
> like producing a definition.
>
*It has been a fully operational software system for a few years now*
Universal Turing Machine (UTM) having the x86 language as its Machine
description language. https://github.com/plolcott/x86utm
> "Simulating termination analyzer" probably just means halt decider. We
> all know there's no such thing.
>
*This is probably the best simulating termination analyzer available*
*AProVE: Non-Termination Witnesses for C Programs*
To prove (non-)termination of a C program, AProVE
uses the Clang compiler [7] to translate it to the
intermediate representation of the LLVM framework [15].
Then AProVE symbolically executes the LLVM program ...
https://verify.rwth-aachen.de/giesl/papers/TACAS22.pdf
>> --
>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-02 21:48 -0400 |
| Message-ID | <v11fq2$2tlr1$4@i2pn2.org> |
| In reply to | #104230 |
On 5/2/24 5:55 PM, olcott wrote:
> On 5/2/2024 4:07 AM, Alan Mackenzie wrote:
>> olcott <polcott333@gmail.com> wrote:
>>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>>>> olcott <polcott333@gmail.com> wrote:
>>>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>>
>> [ .... ]
>>
>>>>> A simulating termination analyzer is not the same thing as a UTM.
>>
>>>> At the moment, on this newsgroup, it's a meaningless term. You seem to
>>>> have used it merely as a synonym for halting decider in the past. Yet
>>>> you fail to say what you mean by it, if you mean something different.
>>
>>>>> Within my brand new idea of a {simulating termination analyzer}
>>>>> there is the idea of abnormal termination.
>>
>>>> It's unlikely to be a brand new idea, whatever it might be, since you
>>>> aren't familiar with the literature and so most likely have come up
>>>> with
>>>> somebody else's old idea.
>>
>> [ .... ]
>>
>>>> You've failed, repeatedly, to address the points I've been making in my
>>>> last few posts, so it seems that you have accepted them. In
>>>> particular,
>>>> you have accepted that "having been aborted" is indeed a final state
>>>> for
>>>> a turing machine or a program.
>>
>>> All of the "points" that you have been making were entirely anchored in
>>> your ignorance about what "simulating termination analyzer" are and how
>>> they work.
>>
>> I think it much more likely that there's no such thing as a "simulating
>> termination analyzer". I.e. there's no theory about it, no interesting
>> results, no use for it, or anything like that. I've asked you several
>> times to define this object, other people have asked you too, yet you
>> fail to do so. Producing a few lines of scrappy C code is not anything
>> like producing a definition.
>>
>
> *It has been a fully operational software system for a few years now*
No, as it gives the wrong answer to the problem that it was written to
solve.
Since that that time, your claim WAS that you were working on the actual
Halting Problem, but claimed that H(D,D) could be correct saying its
input represents a non-halting pattern, even though, by DEFINITION,
since D(D) halt it is an incorret answer.
You gave all sorts of LIES about why a wrong answer could be right.
Now, you just obfuscate what you are actually doing by changing some of
the terms, without actually defining them, but still making you proven
incorrect claims.
>
> Universal Turing Machine (UTM) having the x86 language as its Machine
> description language. https://github.com/plolcott/x86utm
And thus you are STILL indicting that this is about the actual Halting
Problem and claims that these are "Turing Equivalents" (except they
aren't) so your claims are still proven to be lies.
The biggest part is the code you say is the description of the machine
D, isn't, as just that piece of code isn't a "program" but a "program
fragment" and thus everything after that is just a lie.
>
>> "Simulating termination analyzer" probably just means halt decider. We
>> all know there's no such thing.
>>
>
> *This is probably the best simulating termination analyzer available*
>
> *AProVE: Non-Termination Witnesses for C Programs*
> To prove (non-)termination of a C program, AProVE
> uses the Clang compiler [7] to translate it to the
> intermediate representation of the LLVM framework [15].
> Then AProVE symbolically executes the LLVM program ...
> https://verify.rwth-aachen.de/giesl/papers/TACAS22.pdf
Right, and look at what they actually claim.
>
>>> --
>>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>>> hits a target no one else can see." Arthur Schopenhauer
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-03 07:27 -0500 |
| Message-ID | <v12l6m$hk7o$5@dont-email.me> |
| In reply to | #104240 |
On 5/2/2024 8:48 PM, Richard Damon wrote:
> On 5/2/24 5:55 PM, olcott wrote:
>> On 5/2/2024 4:07 AM, Alan Mackenzie wrote:
>>> olcott <polcott333@gmail.com> wrote:
>>>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>>>
>>> [ .... ]
>>>
>>>>>> A simulating termination analyzer is not the same thing as a UTM.
>>>
>>>>> At the moment, on this newsgroup, it's a meaningless term. You
>>>>> seem to
>>>>> have used it merely as a synonym for halting decider in the past. Yet
>>>>> you fail to say what you mean by it, if you mean something different.
>>>
>>>>>> Within my brand new idea of a {simulating termination analyzer}
>>>>>> there is the idea of abnormal termination.
>>>
>>>>> It's unlikely to be a brand new idea, whatever it might be, since you
>>>>> aren't familiar with the literature and so most likely have come up
>>>>> with
>>>>> somebody else's old idea.
>>>
>>> [ .... ]
>>>
>>>>> You've failed, repeatedly, to address the points I've been making
>>>>> in my
>>>>> last few posts, so it seems that you have accepted them. In
>>>>> particular,
>>>>> you have accepted that "having been aborted" is indeed a final
>>>>> state for
>>>>> a turing machine or a program.
>>>
>>>> All of the "points" that you have been making were entirely anchored in
>>>> your ignorance about what "simulating termination analyzer" are and how
>>>> they work.
>>>
>>> I think it much more likely that there's no such thing as a "simulating
>>> termination analyzer". I.e. there's no theory about it, no interesting
>>> results, no use for it, or anything like that. I've asked you several
>>> times to define this object, other people have asked you too, yet you
>>> fail to do so. Producing a few lines of scrappy C code is not anything
>>> like producing a definition.
>>>
>>
>> *It has been a fully operational software system for a few years now*
>
> No, as it gives the wrong answer to the problem that it was written to
> solve.
>
> Since that that time, your claim WAS that you were working on the actual
> Halting Problem, but claimed that H(D,D) could be correct saying its
> input represents a non-halting pattern, even though, by DEFINITION,
> since D(D) halt it is an incorret answer.
>
> You gave all sorts of LIES about why a wrong answer could be right.
>
> Now, you just obfuscate what you are actually doing by changing some of
> the terms, without actually defining them, but still making you proven
> incorrect claims.
>
>>
>> Universal Turing Machine (UTM) having the x86 language as its Machine
>> description language. https://github.com/plolcott/x86utm
>
>
> And thus you are STILL indicting that this is about the actual Halting
> Problem and claims that these are "Turing Equivalents" (except they
> aren't) so your claims are still proven to be lies.
>
> The biggest part is the code you say is the description of the machine
> D, isn't, as just that piece of code isn't a "program" but a "program
> fragment" and thus everything after that is just a lie.
>
YOU TRIED TO CHANGE THE SUBJECT AWAY FROM THIS.
I ONLY GLANCED AT A FEW OF YOUR WORDS TO TELL THAT YOU
TRIED TO CHANGE THE SUBJECT. ONCE I CAN TELL THAT YOU
ARE TRYING TO CHANGE THE SUBJECT I QUIT READING.
(a) It is a verified fact that D(D) simulated by H cannot
possibly reach past line 03 of D(D) simulated by H whether
H aborts its simulation or not.
>>
>>> "Simulating termination analyzer" probably just means halt decider. We
>>> all know there's no such thing.
>>>
>>
>> *This is probably the best simulating termination analyzer available*
>>
>> *AProVE: Non-Termination Witnesses for C Programs*
>> To prove (non-)termination of a C program, AProVE
>> uses the Clang compiler [7] to translate it to the
>> intermediate representation of the LLVM framework [15].
>> Then AProVE symbolically executes the LLVM program ...
>> https://verify.rwth-aachen.de/giesl/papers/TACAS22.pdf
>
> Right, and look at what they actually claim.
>
>>
>>>> --
>>>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>>>> hits a target no one else can see." Arthur Schopenhauer
>>>
>>
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-03 22:42 -0400 |
| Message-ID | <v147be$c31$8@i2pn2.org> |
| In reply to | #104257 |
On 5/3/24 8:27 AM, olcott wrote:
> On 5/2/2024 8:48 PM, Richard Damon wrote:
>> On 5/2/24 5:55 PM, olcott wrote:
>>> On 5/2/2024 4:07 AM, Alan Mackenzie wrote:
>>>> olcott <polcott333@gmail.com> wrote:
>>>>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>>>>
>>>> [ .... ]
>>>>
>>>>>>> A simulating termination analyzer is not the same thing as a UTM.
>>>>
>>>>>> At the moment, on this newsgroup, it's a meaningless term. You
>>>>>> seem to
>>>>>> have used it merely as a synonym for halting decider in the past.
>>>>>> Yet
>>>>>> you fail to say what you mean by it, if you mean something different.
>>>>
>>>>>>> Within my brand new idea of a {simulating termination analyzer}
>>>>>>> there is the idea of abnormal termination.
>>>>
>>>>>> It's unlikely to be a brand new idea, whatever it might be, since you
>>>>>> aren't familiar with the literature and so most likely have come
>>>>>> up with
>>>>>> somebody else's old idea.
>>>>
>>>> [ .... ]
>>>>
>>>>>> You've failed, repeatedly, to address the points I've been making
>>>>>> in my
>>>>>> last few posts, so it seems that you have accepted them. In
>>>>>> particular,
>>>>>> you have accepted that "having been aborted" is indeed a final
>>>>>> state for
>>>>>> a turing machine or a program.
>>>>
>>>>> All of the "points" that you have been making were entirely
>>>>> anchored in
>>>>> your ignorance about what "simulating termination analyzer" are and
>>>>> how
>>>>> they work.
>>>>
>>>> I think it much more likely that there's no such thing as a "simulating
>>>> termination analyzer". I.e. there's no theory about it, no interesting
>>>> results, no use for it, or anything like that. I've asked you several
>>>> times to define this object, other people have asked you too, yet you
>>>> fail to do so. Producing a few lines of scrappy C code is not anything
>>>> like producing a definition.
>>>>
>>>
>>> *It has been a fully operational software system for a few years now*
>>
>> No, as it gives the wrong answer to the problem that it was written to
>> solve.
>>
>> Since that that time, your claim WAS that you were working on the
>> actual Halting Problem, but claimed that H(D,D) could be correct
>> saying its input represents a non-halting pattern, even though, by
>> DEFINITION, since D(D) halt it is an incorret answer.
>>
>> You gave all sorts of LIES about why a wrong answer could be right.
>>
>> Now, you just obfuscate what you are actually doing by changing some
>> of the terms, without actually defining them, but still making you
>> proven incorrect claims.
>>
>>>
>>> Universal Turing Machine (UTM) having the x86 language as its Machine
>>> description language. https://github.com/plolcott/x86utm
>>
>>
>> And thus you are STILL indicting that this is about the actual Halting
>> Problem and claims that these are "Turing Equivalents" (except they
>> aren't) so your claims are still proven to be lies.
>>
>> The biggest part is the code you say is the description of the machine
>> D, isn't, as just that piece of code isn't a "program" but a "program
>> fragment" and thus everything after that is just a lie.
>>
>
> YOU TRIED TO CHANGE THE SUBJECT AWAY FROM THIS.
> I ONLY GLANCED AT A FEW OF YOUR WORDS TO TELL THAT YOU
> TRIED TO CHANGE THE SUBJECT. ONCE I CAN TELL THAT YOU
> ARE TRYING TO CHANGE THE SUBJECT I QUIT READING.
>
> (a) It is a verified fact that D(D) simulated by H cannot
> possibly reach past line 03 of D(D) simulated by H whether
> H aborts its simulation or not.
Proven wrong and not refuted, so you accepted it as a disproven
statement, and thus a LIE to restate.
>
>>>
>>>> "Simulating termination analyzer" probably just means halt decider. We
>>>> all know there's no such thing.
>>>>
>>>
>>> *This is probably the best simulating termination analyzer available*
>>>
>>> *AProVE: Non-Termination Witnesses for C Programs*
>>> To prove (non-)termination of a C program, AProVE
>>> uses the Clang compiler [7] to translate it to the
>>> intermediate representation of the LLVM framework [15].
>>> Then AProVE symbolically executes the LLVM program ...
>>> https://verify.rwth-aachen.de/giesl/papers/TACAS22.pdf
>>
>> Right, and look at what they actually claim.
>>
>>>
>>>>> --
>>>>> Copyright 2024 Olcott "Talent hits a target no one else can hit;
>>>>> Genius
>>>>> hits a target no one else can see." Arthur Schopenhauer
>>>>
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-02 17:10 -0500 |
| Message-ID | <v11300$3au9$1@dont-email.me> |
| In reply to | #104207 |
On 5/2/2024 4:07 AM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
>>> olcott <polcott333@gmail.com> wrote:
>>>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>
> [ .... ]
>
>>>> A simulating termination analyzer is not the same thing as a UTM.
>
>>> At the moment, on this newsgroup, it's a meaningless term. You seem to
>>> have used it merely as a synonym for halting decider in the past. Yet
>>> you fail to say what you mean by it, if you mean something different.
>
>>>> Within my brand new idea of a {simulating termination analyzer}
>>>> there is the idea of abnormal termination.
>
>>> It's unlikely to be a brand new idea, whatever it might be, since you
>>> aren't familiar with the literature and so most likely have come up with
>>> somebody else's old idea.
>
> [ .... ]
>
>>> You've failed, repeatedly, to address the points I've been making in my
>>> last few posts, so it seems that you have accepted them. In particular,
>>> you have accepted that "having been aborted" is indeed a final state for
>>> a turing machine or a program.
>
>> All of the "points" that you have been making were entirely anchored in
>> your ignorance about what "simulating termination analyzer" are and how
>> they work.
>
> I think it much more likely that there's no such thing as a "simulating
> termination analyzer". I.e. there's no theory about it, no interesting
> results, no use for it, or anything like that. I've asked you several
> times to define this object, other people have asked you too, yet you
> fail to do so. Producing a few lines of scrappy C code is not anything
> like producing a definition.
>
> "Simulating termination analyzer" probably just means halt decider. We
> all know there's no such thing.
>
*Symbolic execution as a basis for termination analysis*
https://www.sciencedirect.com/science/article/pii/S0167642315000271
>> --
>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-04-29 14:31 -0500 |
| Message-ID | <v0osj1$1u1uc$1@dont-email.me> |
| In reply to | #104081 |
On 4/29/2024 1:19 PM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 4/29/2024 11:17 AM, Alan Mackenzie wrote:
>>> olcott <polcott333@gmail.com> wrote:
>>>> On 4/29/2024 10:23 AM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 4/29/2024 9:37 AM, Alan Mackenzie wrote:
>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 4/28/2024 1:39 PM, Richard Damon wrote:
>>>>>>>>> On 4/28/24 2:19 PM, olcott wrote:
>
>>>>>>> [ .... ]
>
>>>>>>>>>> Even the term "halting" is problematic.
>>>>>>>>>> For 15 years I thought it means stops running for any reason.
>
>>>>> [ .... ]
>
>>>>>>> Having been aborted (if such were possible) is merely another final
>>>>>>> state for a TM.
>
>>>>>> No it definitely is not.
>
>>>>> In a TM, each state is either a final state or a non-final state. Are
>>>>> you arguing for a third alternative, or do you think that "having been
>>>>> aborted" is a non-final state? If the latter, what state does the TM
>>>>> change to next?
>
>>>> Aborted means completely dead as if you pulled the power cord
>>>> on your computer.
>
>>> A turing machine has no power cord to pull. You didn't answer my point;
>>> you evaded it.
>
>>>>>> When the payroll system crashes 10% of the way through calculating
>>>>>> payroll we cannot say that everyone has been paid.
>
>>>>> Of course not, but it has nevertheless reached a final state, an
>>>>> unsatisfactory one, since it is no longer running on the computer.
>
>>>> That is not what "theory of computation" {final state} means.
>
>>> I think it is. What do you think "final state" means, and how is "having
>>> been aborted" not one?
>
>>>> Core dump abnormal termination does not count as the program
>>>> correctly finished its processing.
>
>>> There is no notion of "correct" in a turing machine.
>
>> In other words when a TM computes the sum of 2 + 3 and derives
>> 999999999999999999999999999 then that is just fine.
>
> Don't be idiotic. A TM that gets that answer from those starting
> conditions isn't calculating their sum; it's doing something else.
>
>>> It is either
>>> running, or has reached a final state. In the TM equivalent of "core
>>> dump", a final state has most definitely been reached.
>
>>>>>>>> Yet again only rhetoric with no actual reasoning.
>>>>>>>> Do you believe:
>>>>>>>> (a) Halting means stopping for any reason.
>>>>>>>> (b) Halting means reaching a final state.
>
>>>>>>> (a) and (b) are identical. A TM having stopped means it has reached a
>>>>>>> final state, and vice versa.
>
>>>>>> No that is incorrect.
>
>>>>> Perhaps, then, you could explain the difference between (a) and (b).
>
>>> No answer?
>
>>>>>> In software engineering terms halting means reaching a final
>>>>>> state and terminating normally.
>
>>>>> "Halting" is about turing machines.
>
>>>> Yet any C function that implements a computable function is
>>>> isomorphic to some TM.
>
>>> Yes. There is no such thing as a core dump in a computable function.
>
>>>>> I don't think you've ever said what you mean by "terminating
>>>>> normally".
>
>>>> Standard term of the art from software engineering.
>
>>> That's an evasion, not an answer. We're talking about the theory of
>>> turnig machines here. What do _you_ mean for a turing machine to
>>> terminate "normally"? I put it to you it has no meaning at all.
>
>>>>> A turing machine either reaches a final state or it doesn't. There is
>>>>> no concept of "normal termination" in a TM.
>
>>> No answer?
>
>>>> A Google search of: "simulating termination analyzer"
>>>> or "simulating halt decider" only brings up me.
>
>>> That surprises nobody. There's no such thing as a halt decider,
>>> simulating or otherwise. As for a "termination analyzer", I don't think
>>> you've ever made clear what you mean by this.
>
>>>> Within this brand new idea then there is such an idea of
>>>> abnormal termination.
>
>>> It's not a brand new idea. Just ask those who teach the theory, and
>>> they'll tell you that this idea comes up continually, year after year.
>>> And at the risk of repeating myself, there is no notion of "abnormal
>>> termination" on a turing machine.
>
>
>> A simulating termination analyzer is not the same thing as a UTM.
>
> At the moment, on this newsgroup, it's a meaningless term. You seem to
There are at least 1244 messages by me about this subject in
this group since 2020.
> have used it merely as a synonym for halting decider in the past. Yet
> you fail to say what you mean by it, if you mean something different.
>
>> Within my brand new idea of a {simulating termination analyzer}
>> there is the idea of abnormal termination.
>
> It's unlikely to be a brand new idea, whatever it might be, since you
> aren't familiar with the literature and so most likely have come up with
> somebody else's old idea.
>
> You've failed, repeatedly, to address the points I've been making in my
> last few posts, so it seems that you have accepted them. In particular,
> you have accepted that "having been aborted" is indeed a final state for
> a turing machine or a program.
>
>> --
>> Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 15 of 18 — ← Prev page 1 … 13 14 [15] 16 17 18 Next page →
Back to top | Article view | comp.theory
csiph-web